pub const __STDC_FORMAT_MACROS: u32 = 1;
pub const _POSIX_C_SOURCE: u32 = 200809;
pub const _XOPEN_SOURCE: u32 = 700;
pub const true_: u32 = 1;
pub const false_: u32 = 0;
pub const __bool_true_false_are_defined: u32 = 1;
pub const _STDINT_H: u32 = 1;
pub const _FEATURES_H: u32 = 1;
pub const _ISOC95_SOURCE: u32 = 1;
pub const _ISOC99_SOURCE: u32 = 1;
pub const _ISOC11_SOURCE: u32 = 1;
pub const _ISOC2X_SOURCE: u32 = 1;
pub const _POSIX_SOURCE: u32 = 1;
pub const _XOPEN_SOURCE_EXTENDED: u32 = 1;
pub const _LARGEFILE64_SOURCE: u32 = 1;
pub const _DEFAULT_SOURCE: u32 = 1;
pub const _ATFILE_SOURCE: u32 = 1;
pub const __GLIBC_USE_ISOC2X: u32 = 1;
pub const __USE_ISOC11: u32 = 1;
pub const __USE_ISOC99: u32 = 1;
pub const __USE_ISOC95: u32 = 1;
pub const __USE_POSIX: u32 = 1;
pub const __USE_POSIX2: u32 = 1;
pub const __USE_POSIX199309: u32 = 1;
pub const __USE_POSIX199506: u32 = 1;
pub const __USE_XOPEN2K: u32 = 1;
pub const __USE_XOPEN2K8: u32 = 1;
pub const __USE_XOPEN: u32 = 1;
pub const __USE_XOPEN_EXTENDED: u32 = 1;
pub const __USE_UNIX98: u32 = 1;
pub const _LARGEFILE_SOURCE: u32 = 1;
pub const __USE_XOPEN2K8XSI: u32 = 1;
pub const __USE_XOPEN2KXSI: u32 = 1;
pub const __USE_LARGEFILE: u32 = 1;
pub const __USE_LARGEFILE64: u32 = 1;
pub const __USE_MISC: u32 = 1;
pub const __USE_ATFILE: u32 = 1;
pub const __USE_GNU: u32 = 1;
pub const __USE_FORTIFY_LEVEL: u32 = 0;
pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 0;
pub const __GLIBC_USE_DEPRECATED_SCANF: u32 = 0;
pub const _STDC_PREDEF_H: u32 = 1;
pub const __STDC_IEC_559__: u32 = 1;
pub const __STDC_IEC_559_COMPLEX__: u32 = 1;
pub const __STDC_ISO_10646__: u32 = 201706;
pub const __GNU_LIBRARY__: u32 = 6;
pub const __GLIBC__: u32 = 2;
pub const __GLIBC_MINOR__: u32 = 31;
pub const _SYS_CDEFS_H: u32 = 1;
pub const __glibc_c99_flexarr_available: u32 = 1;
pub const __WORDSIZE: u32 = 64;
pub const __WORDSIZE_TIME64_COMPAT32: u32 = 1;
pub const __SYSCALL_WORDSIZE: u32 = 64;
pub const __LONG_DOUBLE_USES_FLOAT128: u32 = 0;
pub const __HAVE_GENERIC_SELECTION: u32 = 1;
pub const __GLIBC_USE_LIB_EXT2: u32 = 1;
pub const __GLIBC_USE_IEC_60559_BFP_EXT: u32 = 1;
pub const __GLIBC_USE_IEC_60559_BFP_EXT_C2X: u32 = 1;
pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: u32 = 1;
pub const __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X: u32 = 1;
pub const __GLIBC_USE_IEC_60559_TYPES_EXT: u32 = 1;
pub const _BITS_TYPES_H: u32 = 1;
pub const __TIMESIZE: u32 = 64;
pub const _BITS_TYPESIZES_H: u32 = 1;
pub const __OFF_T_MATCHES_OFF64_T: u32 = 1;
pub const __INO_T_MATCHES_INO64_T: u32 = 1;
pub const __RLIM_T_MATCHES_RLIM64_T: u32 = 1;
pub const __STATFS_MATCHES_STATFS64: u32 = 1;
pub const __FD_SETSIZE: u32 = 1024;
pub const _BITS_TIME64_H: u32 = 1;
pub const _BITS_WCHAR_H: u32 = 1;
pub const _BITS_STDINT_INTN_H: u32 = 1;
pub const _BITS_STDINT_UINTN_H: u32 = 1;
pub const INT8_MIN: i32 = -128;
pub const INT16_MIN: i32 = -32768;
pub const INT32_MIN: i32 = -2147483648;
pub const INT8_MAX: u32 = 127;
pub const INT16_MAX: u32 = 32767;
pub const INT32_MAX: u32 = 2147483647;
pub const UINT8_MAX: u32 = 255;
pub const UINT16_MAX: u32 = 65535;
pub const UINT32_MAX: u32 = 4294967295;
pub const INT_LEAST8_MIN: i32 = -128;
pub const INT_LEAST16_MIN: i32 = -32768;
pub const INT_LEAST32_MIN: i32 = -2147483648;
pub const INT_LEAST8_MAX: u32 = 127;
pub const INT_LEAST16_MAX: u32 = 32767;
pub const INT_LEAST32_MAX: u32 = 2147483647;
pub const UINT_LEAST8_MAX: u32 = 255;
pub const UINT_LEAST16_MAX: u32 = 65535;
pub const UINT_LEAST32_MAX: u32 = 4294967295;
pub const INT_FAST8_MIN: i32 = -128;
pub const INT_FAST16_MIN: i64 = -9223372036854775808;
pub const INT_FAST32_MIN: i64 = -9223372036854775808;
pub const INT_FAST8_MAX: u32 = 127;
pub const INT_FAST16_MAX: u64 = 9223372036854775807;
pub const INT_FAST32_MAX: u64 = 9223372036854775807;
pub const UINT_FAST8_MAX: u32 = 255;
pub const UINT_FAST16_MAX: i32 = -1;
pub const UINT_FAST32_MAX: i32 = -1;
pub const INTPTR_MIN: i64 = -9223372036854775808;
pub const INTPTR_MAX: u64 = 9223372036854775807;
pub const UINTPTR_MAX: i32 = -1;
pub const PTRDIFF_MIN: i64 = -9223372036854775808;
pub const PTRDIFF_MAX: u64 = 9223372036854775807;
pub const SIG_ATOMIC_MIN: i32 = -2147483648;
pub const SIG_ATOMIC_MAX: u32 = 2147483647;
pub const SIZE_MAX: i32 = -1;
pub const WINT_MIN: u32 = 0;
pub const WINT_MAX: u32 = 4294967295;
pub const INT8_WIDTH: u32 = 8;
pub const UINT8_WIDTH: u32 = 8;
pub const INT16_WIDTH: u32 = 16;
pub const UINT16_WIDTH: u32 = 16;
pub const INT32_WIDTH: u32 = 32;
pub const UINT32_WIDTH: u32 = 32;
pub const INT64_WIDTH: u32 = 64;
pub const UINT64_WIDTH: u32 = 64;
pub const INT_LEAST8_WIDTH: u32 = 8;
pub const UINT_LEAST8_WIDTH: u32 = 8;
pub const INT_LEAST16_WIDTH: u32 = 16;
pub const UINT_LEAST16_WIDTH: u32 = 16;
pub const INT_LEAST32_WIDTH: u32 = 32;
pub const UINT_LEAST32_WIDTH: u32 = 32;
pub const INT_LEAST64_WIDTH: u32 = 64;
pub const UINT_LEAST64_WIDTH: u32 = 64;
pub const INT_FAST8_WIDTH: u32 = 8;
pub const UINT_FAST8_WIDTH: u32 = 8;
pub const INT_FAST16_WIDTH: u32 = 64;
pub const UINT_FAST16_WIDTH: u32 = 64;
pub const INT_FAST32_WIDTH: u32 = 64;
pub const UINT_FAST32_WIDTH: u32 = 64;
pub const INT_FAST64_WIDTH: u32 = 64;
pub const UINT_FAST64_WIDTH: u32 = 64;
pub const INTPTR_WIDTH: u32 = 64;
pub const UINTPTR_WIDTH: u32 = 64;
pub const INTMAX_WIDTH: u32 = 64;
pub const UINTMAX_WIDTH: u32 = 64;
pub const PTRDIFF_WIDTH: u32 = 64;
pub const SIG_ATOMIC_WIDTH: u32 = 32;
pub const SIZE_WIDTH: u32 = 64;
pub const WCHAR_WIDTH: u32 = 32;
pub const WINT_WIDTH: u32 = 32;
pub const _STDLIB_H: u32 = 1;
pub const WNOHANG: u32 = 1;
pub const WUNTRACED: u32 = 2;
pub const WSTOPPED: u32 = 2;
pub const WEXITED: u32 = 4;
pub const WCONTINUED: u32 = 8;
pub const WNOWAIT: u32 = 16777216;
pub const __WNOTHREAD: u32 = 536870912;
pub const __WALL: u32 = 1073741824;
pub const __WCLONE: u32 = 2147483648;
pub const __ENUM_IDTYPE_T: u32 = 1;
pub const __W_CONTINUED: u32 = 65535;
pub const __WCOREFLAG: u32 = 128;
pub const __HAVE_FLOAT128: u32 = 0;
pub const __HAVE_DISTINCT_FLOAT128: u32 = 0;
pub const __HAVE_FLOAT64X: u32 = 1;
pub const __HAVE_FLOAT64X_LONG_DOUBLE: u32 = 1;
pub const __HAVE_FLOAT16: u32 = 0;
pub const __HAVE_FLOAT32: u32 = 1;
pub const __HAVE_FLOAT64: u32 = 1;
pub const __HAVE_FLOAT32X: u32 = 1;
pub const __HAVE_FLOAT128X: u32 = 0;
pub const __HAVE_DISTINCT_FLOAT16: u32 = 0;
pub const __HAVE_DISTINCT_FLOAT32: u32 = 0;
pub const __HAVE_DISTINCT_FLOAT64: u32 = 0;
pub const __HAVE_DISTINCT_FLOAT32X: u32 = 0;
pub const __HAVE_DISTINCT_FLOAT64X: u32 = 0;
pub const __HAVE_DISTINCT_FLOAT128X: u32 = 0;
pub const __HAVE_FLOATN_NOT_TYPEDEF: u32 = 0;
pub const __ldiv_t_defined: u32 = 1;
pub const __lldiv_t_defined: u32 = 1;
pub const RAND_MAX: u32 = 2147483647;
pub const EXIT_FAILURE: u32 = 1;
pub const EXIT_SUCCESS: u32 = 0;
pub const _BITS_TYPES_LOCALE_T_H: u32 = 1;
pub const _BITS_TYPES___LOCALE_T_H: u32 = 1;
pub const _SYS_TYPES_H: u32 = 1;
pub const __clock_t_defined: u32 = 1;
pub const __clockid_t_defined: u32 = 1;
pub const __time_t_defined: u32 = 1;
pub const __timer_t_defined: u32 = 1;
pub const __BIT_TYPES_DEFINED__: u32 = 1;
pub const _ENDIAN_H: u32 = 1;
pub const _BITS_ENDIAN_H: u32 = 1;
pub const __LITTLE_ENDIAN: u32 = 1234;
pub const __BIG_ENDIAN: u32 = 4321;
pub const __PDP_ENDIAN: u32 = 3412;
pub const _BITS_ENDIANNESS_H: u32 = 1;
pub const __BYTE_ORDER: u32 = 1234;
pub const __FLOAT_WORD_ORDER: u32 = 1234;
pub const LITTLE_ENDIAN: u32 = 1234;
pub const BIG_ENDIAN: u32 = 4321;
pub const PDP_ENDIAN: u32 = 3412;
pub const BYTE_ORDER: u32 = 1234;
pub const _BITS_BYTESWAP_H: u32 = 1;
pub const _BITS_UINTN_IDENTITY_H: u32 = 1;
pub const _SYS_SELECT_H: u32 = 1;
pub const __FD_ZERO_STOS: &'static [u8; 6usize] = b"stosq\0";
pub const __sigset_t_defined: u32 = 1;
pub const __timeval_defined: u32 = 1;
pub const _STRUCT_TIMESPEC: u32 = 1;
pub const FD_SETSIZE: u32 = 1024;
pub const _BITS_PTHREADTYPES_COMMON_H: u32 = 1;
pub const _THREAD_SHARED_TYPES_H: u32 = 1;
pub const _BITS_PTHREADTYPES_ARCH_H: u32 = 1;
pub const __SIZEOF_PTHREAD_MUTEX_T: u32 = 40;
pub const __SIZEOF_PTHREAD_ATTR_T: u32 = 56;
pub const __SIZEOF_PTHREAD_RWLOCK_T: u32 = 56;
pub const __SIZEOF_PTHREAD_BARRIER_T: u32 = 32;
pub const __SIZEOF_PTHREAD_MUTEXATTR_T: u32 = 4;
pub const __SIZEOF_PTHREAD_COND_T: u32 = 48;
pub const __SIZEOF_PTHREAD_CONDATTR_T: u32 = 4;
pub const __SIZEOF_PTHREAD_RWLOCKATTR_T: u32 = 8;
pub const __SIZEOF_PTHREAD_BARRIERATTR_T: u32 = 4;
pub const _THREAD_MUTEX_INTERNAL_H: u32 = 1;
pub const __PTHREAD_MUTEX_HAVE_PREV: u32 = 1;
pub const __have_pthread_attr_t: u32 = 1;
pub const _ALLOCA_H: u32 = 1;
pub const _MALLOC_H: u32 = 1;
pub const _STDIO_H: u32 = 1;
pub const __GNUC_VA_LIST: u32 = 1;
pub const _____fpos_t_defined: u32 = 1;
pub const ____mbstate_t_defined: u32 = 1;
pub const _____fpos64_t_defined: u32 = 1;
pub const ____FILE_defined: u32 = 1;
pub const __FILE_defined: u32 = 1;
pub const __struct_FILE_defined: u32 = 1;
pub const _IO_EOF_SEEN: u32 = 16;
pub const _IO_ERR_SEEN: u32 = 32;
pub const _IO_USER_LOCK: u32 = 32768;
pub const __cookie_io_functions_t_defined: u32 = 1;
pub const _IOFBF: u32 = 0;
pub const _IOLBF: u32 = 1;
pub const _IONBF: u32 = 2;
pub const BUFSIZ: u32 = 8192;
pub const EOF: i32 = -1;
pub const SEEK_SET: u32 = 0;
pub const SEEK_CUR: u32 = 1;
pub const SEEK_END: u32 = 2;
pub const SEEK_DATA: u32 = 3;
pub const SEEK_HOLE: u32 = 4;
pub const P_tmpdir: &'static [u8; 5usize] = b"/tmp\0";
pub const _BITS_STDIO_LIM_H: u32 = 1;
pub const L_tmpnam: u32 = 20;
pub const TMP_MAX: u32 = 238328;
pub const FILENAME_MAX: u32 = 4096;
pub const L_ctermid: u32 = 9;
pub const L_cuserid: u32 = 9;
pub const FOPEN_MAX: u32 = 16;
pub const RENAME_NOREPLACE: u32 = 1;
pub const RENAME_EXCHANGE: u32 = 2;
pub const RENAME_WHITEOUT: u32 = 4;
pub const M_MXFAST: u32 = 1;
pub const M_NLBLKS: u32 = 2;
pub const M_GRAIN: u32 = 3;
pub const M_KEEP: u32 = 4;
pub const M_TRIM_THRESHOLD: i32 = -1;
pub const M_TOP_PAD: i32 = -2;
pub const M_MMAP_THRESHOLD: i32 = -3;
pub const M_MMAP_MAX: i32 = -4;
pub const M_CHECK_ACTION: i32 = -5;
pub const M_PERTURB: i32 = -6;
pub const M_ARENA_TEST: i32 = -7;
pub const M_ARENA_MAX: i32 = -8;
pub const _MM_HINT_ET0: u32 = 7;
pub const _MM_HINT_ET1: u32 = 6;
pub const _MM_HINT_T0: u32 = 3;
pub const _MM_HINT_T1: u32 = 2;
pub const _MM_HINT_T2: u32 = 1;
pub const _MM_HINT_NTA: u32 = 0;
pub const _MM_EXCEPT_INVALID: u32 = 1;
pub const _MM_EXCEPT_DENORM: u32 = 2;
pub const _MM_EXCEPT_DIV_ZERO: u32 = 4;
pub const _MM_EXCEPT_OVERFLOW: u32 = 8;
pub const _MM_EXCEPT_UNDERFLOW: u32 = 16;
pub const _MM_EXCEPT_INEXACT: u32 = 32;
pub const _MM_EXCEPT_MASK: u32 = 63;
pub const _MM_MASK_INVALID: u32 = 128;
pub const _MM_MASK_DENORM: u32 = 256;
pub const _MM_MASK_DIV_ZERO: u32 = 512;
pub const _MM_MASK_OVERFLOW: u32 = 1024;
pub const _MM_MASK_UNDERFLOW: u32 = 2048;
pub const _MM_MASK_INEXACT: u32 = 4096;
pub const _MM_MASK_MASK: u32 = 8064;
pub const _MM_ROUND_NEAREST: u32 = 0;
pub const _MM_ROUND_DOWN: u32 = 8192;
pub const _MM_ROUND_UP: u32 = 16384;
pub const _MM_ROUND_TOWARD_ZERO: u32 = 24576;
pub const _MM_ROUND_MASK: u32 = 24576;
pub const _MM_FLUSH_ZERO_MASK: u32 = 32768;
pub const _MM_FLUSH_ZERO_ON: u32 = 32768;
pub const _MM_FLUSH_ZERO_OFF: u32 = 0;
pub const _MM_DENORMALS_ZERO_ON: u32 = 64;
pub const _MM_DENORMALS_ZERO_OFF: u32 = 0;
pub const _MM_DENORMALS_ZERO_MASK: u32 = 64;
pub const _MM_FROUND_TO_NEAREST_INT: u32 = 0;
pub const _MM_FROUND_TO_NEG_INF: u32 = 1;
pub const _MM_FROUND_TO_POS_INF: u32 = 2;
pub const _MM_FROUND_TO_ZERO: u32 = 3;
pub const _MM_FROUND_CUR_DIRECTION: u32 = 4;
pub const _MM_FROUND_RAISE_EXC: u32 = 0;
pub const _MM_FROUND_NO_EXC: u32 = 8;
pub const _MM_FROUND_NINT: u32 = 0;
pub const _MM_FROUND_FLOOR: u32 = 1;
pub const _MM_FROUND_CEIL: u32 = 2;
pub const _MM_FROUND_TRUNC: u32 = 3;
pub const _MM_FROUND_RINT: u32 = 4;
pub const _MM_FROUND_NEARBYINT: u32 = 12;
pub const _SIDD_UBYTE_OPS: u32 = 0;
pub const _SIDD_UWORD_OPS: u32 = 1;
pub const _SIDD_SBYTE_OPS: u32 = 2;
pub const _SIDD_SWORD_OPS: u32 = 3;
pub const _SIDD_CMP_EQUAL_ANY: u32 = 0;
pub const _SIDD_CMP_RANGES: u32 = 4;
pub const _SIDD_CMP_EQUAL_EACH: u32 = 8;
pub const _SIDD_CMP_EQUAL_ORDERED: u32 = 12;
pub const _SIDD_POSITIVE_POLARITY: u32 = 0;
pub const _SIDD_NEGATIVE_POLARITY: u32 = 16;
pub const _SIDD_MASKED_POSITIVE_POLARITY: u32 = 32;
pub const _SIDD_MASKED_NEGATIVE_POLARITY: u32 = 48;
pub const _SIDD_LEAST_SIGNIFICANT: u32 = 0;
pub const _SIDD_MOST_SIGNIFICANT: u32 = 64;
pub const _SIDD_BIT_MASK: u32 = 0;
pub const _SIDD_UNIT_MASK: u32 = 64;
pub const _CMP_EQ_OQ: u32 = 0;
pub const _CMP_LT_OS: u32 = 1;
pub const _CMP_LE_OS: u32 = 2;
pub const _CMP_UNORD_Q: u32 = 3;
pub const _CMP_NEQ_UQ: u32 = 4;
pub const _CMP_NLT_US: u32 = 5;
pub const _CMP_NLE_US: u32 = 6;
pub const _CMP_ORD_Q: u32 = 7;
pub const _CMP_EQ_UQ: u32 = 8;
pub const _CMP_NGE_US: u32 = 9;
pub const _CMP_NGT_US: u32 = 10;
pub const _CMP_FALSE_OQ: u32 = 11;
pub const _CMP_NEQ_OQ: u32 = 12;
pub const _CMP_GE_OS: u32 = 13;
pub const _CMP_GT_OS: u32 = 14;
pub const _CMP_TRUE_UQ: u32 = 15;
pub const _CMP_EQ_OS: u32 = 16;
pub const _CMP_LT_OQ: u32 = 17;
pub const _CMP_LE_OQ: u32 = 18;
pub const _CMP_UNORD_S: u32 = 19;
pub const _CMP_NEQ_US: u32 = 20;
pub const _CMP_NLT_UQ: u32 = 21;
pub const _CMP_NLE_UQ: u32 = 22;
pub const _CMP_ORD_S: u32 = 23;
pub const _CMP_EQ_US: u32 = 24;
pub const _CMP_NGE_UQ: u32 = 25;
pub const _CMP_NGT_UQ: u32 = 26;
pub const _CMP_FALSE_OS: u32 = 27;
pub const _CMP_NEQ_OS: u32 = 28;
pub const _CMP_GE_OQ: u32 = 29;
pub const _CMP_GT_OQ: u32 = 30;
pub const _CMP_TRUE_US: u32 = 31;
pub const _XBEGIN_STARTED: i32 = -1;
pub const _XABORT_EXPLICIT: u32 = 1;
pub const _XABORT_RETRY: u32 = 2;
pub const _XABORT_CONFLICT: u32 = 4;
pub const _XABORT_CAPACITY: u32 = 8;
pub const _XABORT_DEBUG: u32 = 16;
pub const _XABORT_NESTED: u32 = 32;
pub const __PCONFIG_KEY_PROGRAM: u32 = 1;
pub const _MM_PCOMCTRL_LT: u32 = 0;
pub const _MM_PCOMCTRL_LE: u32 = 1;
pub const _MM_PCOMCTRL_GT: u32 = 2;
pub const _MM_PCOMCTRL_GE: u32 = 3;
pub const _MM_PCOMCTRL_EQ: u32 = 4;
pub const _MM_PCOMCTRL_NEQ: u32 = 5;
pub const _MM_PCOMCTRL_FALSE: u32 = 6;
pub const _MM_PCOMCTRL_TRUE: u32 = 7;
pub const LAZY_OR_BITSET_CONVERSION: u32 = 1;
pub const LAZY_OR_BITSET_CONVERSION_TO_FULL: u32 = 1;
pub const OR_BITSET_CONVERSION_TO_FULL: u32 = 1;
pub const _STRING_H: u32 = 1;
pub const _STRINGS_H: u32 = 1;
pub const _ASSERT_H: u32 = 1;
pub const BITSET_CONTAINER_TYPE_CODE: u32 = 1;
pub const ARRAY_CONTAINER_TYPE_CODE: u32 = 2;
pub const RUN_CONTAINER_TYPE_CODE: u32 = 3;
pub const SHARED_CONTAINER_TYPE_CODE: u32 = 4;
pub const MAX_CONTAINERS: u32 = 65536;
pub const SERIALIZATION_ARRAY_UINT32: u32 = 1;
pub const SERIALIZATION_CONTAINER: u32 = 2;
pub const ROARING_VERSION_MAJOR: ::std::os::raw::c_uint = 0;
pub const ROARING_VERSION_MINOR: ::std::os::raw::c_uint = 2;
pub const ROARING_VERSION_REVISION: ::std::os::raw::c_uint = 66;
pub type _bindgen_ty_1 = ::std::os::raw::c_uint;
pub type __u_char = ::std::os::raw::c_uchar;
pub type __u_short = ::std::os::raw::c_ushort;
pub type __u_int = ::std::os::raw::c_uint;
pub type __u_long = ::std::os::raw::c_ulong;
pub type __int8_t = ::std::os::raw::c_schar;
pub type __uint8_t = ::std::os::raw::c_uchar;
pub type __int16_t = ::std::os::raw::c_short;
pub type __uint16_t = ::std::os::raw::c_ushort;
pub type __int32_t = ::std::os::raw::c_int;
pub type __uint32_t = ::std::os::raw::c_uint;
pub type __int64_t = ::std::os::raw::c_long;
pub type __uint64_t = ::std::os::raw::c_ulong;
pub type __int_least8_t = __int8_t;
pub type __uint_least8_t = __uint8_t;
pub type __int_least16_t = __int16_t;
pub type __uint_least16_t = __uint16_t;
pub type __int_least32_t = __int32_t;
pub type __uint_least32_t = __uint32_t;
pub type __int_least64_t = __int64_t;
pub type __uint_least64_t = __uint64_t;
pub type __quad_t = ::std::os::raw::c_long;
pub type __u_quad_t = ::std::os::raw::c_ulong;
pub type __intmax_t = ::std::os::raw::c_long;
pub type __uintmax_t = ::std::os::raw::c_ulong;
pub type __dev_t = ::std::os::raw::c_ulong;
pub type __uid_t = ::std::os::raw::c_uint;
pub type __gid_t = ::std::os::raw::c_uint;
pub type __ino_t = ::std::os::raw::c_ulong;
pub type __ino64_t = ::std::os::raw::c_ulong;
pub type __mode_t = ::std::os::raw::c_uint;
pub type __nlink_t = ::std::os::raw::c_ulong;
pub type __off_t = ::std::os::raw::c_long;
pub type __off64_t = ::std::os::raw::c_long;
pub type __pid_t = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __fsid_t {
pub __val: [::std::os::raw::c_int; 2usize],
}
#[test]
fn bindgen_test_layout___fsid_t() {
assert_eq!(
::std::mem::size_of::<__fsid_t>(),
8usize,
concat!("Size of: ", stringify!(__fsid_t))
);
assert_eq!(
::std::mem::align_of::<__fsid_t>(),
4usize,
concat!("Alignment of ", stringify!(__fsid_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__fsid_t>())).__val as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__fsid_t),
"::",
stringify!(__val)
)
);
}
pub type __clock_t = ::std::os::raw::c_long;
pub type __rlim_t = ::std::os::raw::c_ulong;
pub type __rlim64_t = ::std::os::raw::c_ulong;
pub type __id_t = ::std::os::raw::c_uint;
pub type __time_t = ::std::os::raw::c_long;
pub type __useconds_t = ::std::os::raw::c_uint;
pub type __suseconds_t = ::std::os::raw::c_long;
pub type __daddr_t = ::std::os::raw::c_int;
pub type __key_t = ::std::os::raw::c_int;
pub type __clockid_t = ::std::os::raw::c_int;
pub type __timer_t = *mut ::std::os::raw::c_void;
pub type __blksize_t = ::std::os::raw::c_long;
pub type __blkcnt_t = ::std::os::raw::c_long;
pub type __blkcnt64_t = ::std::os::raw::c_long;
pub type __fsblkcnt_t = ::std::os::raw::c_ulong;
pub type __fsblkcnt64_t = ::std::os::raw::c_ulong;
pub type __fsfilcnt_t = ::std::os::raw::c_ulong;
pub type __fsfilcnt64_t = ::std::os::raw::c_ulong;
pub type __fsword_t = ::std::os::raw::c_long;
pub type __ssize_t = ::std::os::raw::c_long;
pub type __syscall_slong_t = ::std::os::raw::c_long;
pub type __syscall_ulong_t = ::std::os::raw::c_ulong;
pub type __loff_t = __off64_t;
pub type __caddr_t = *mut ::std::os::raw::c_char;
pub type __intptr_t = ::std::os::raw::c_long;
pub type __socklen_t = ::std::os::raw::c_uint;
pub type __sig_atomic_t = ::std::os::raw::c_int;
pub type int_least8_t = __int_least8_t;
pub type int_least16_t = __int_least16_t;
pub type int_least32_t = __int_least32_t;
pub type int_least64_t = __int_least64_t;
pub type uint_least8_t = __uint_least8_t;
pub type uint_least16_t = __uint_least16_t;
pub type uint_least32_t = __uint_least32_t;
pub type uint_least64_t = __uint_least64_t;
pub type int_fast8_t = ::std::os::raw::c_schar;
pub type int_fast16_t = ::std::os::raw::c_long;
pub type int_fast32_t = ::std::os::raw::c_long;
pub type int_fast64_t = ::std::os::raw::c_long;
pub type uint_fast8_t = ::std::os::raw::c_uchar;
pub type uint_fast16_t = ::std::os::raw::c_ulong;
pub type uint_fast32_t = ::std::os::raw::c_ulong;
pub type uint_fast64_t = ::std::os::raw::c_ulong;
pub type intmax_t = __intmax_t;
pub type uintmax_t = __uintmax_t;
pub type size_t = ::std::os::raw::c_ulong;
pub type wchar_t = ::std::os::raw::c_int;
pub const idtype_t_P_ALL: idtype_t = 0;
pub const idtype_t_P_PID: idtype_t = 1;
pub const idtype_t_P_PGID: idtype_t = 2;
pub type idtype_t = ::std::os::raw::c_uint;
pub type _Float32 = f32;
pub type _Float64 = f64;
pub type _Float32x = f64;
pub type _Float64x = u128;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct div_t {
pub quot: ::std::os::raw::c_int,
pub rem: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_div_t() {
assert_eq!(
::std::mem::size_of::<div_t>(),
8usize,
concat!("Size of: ", stringify!(div_t))
);
assert_eq!(
::std::mem::align_of::<div_t>(),
4usize,
concat!("Alignment of ", stringify!(div_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<div_t>())).quot as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(div_t),
"::",
stringify!(quot)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<div_t>())).rem as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(div_t),
"::",
stringify!(rem)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ldiv_t {
pub quot: ::std::os::raw::c_long,
pub rem: ::std::os::raw::c_long,
}
#[test]
fn bindgen_test_layout_ldiv_t() {
assert_eq!(
::std::mem::size_of::<ldiv_t>(),
16usize,
concat!("Size of: ", stringify!(ldiv_t))
);
assert_eq!(
::std::mem::align_of::<ldiv_t>(),
8usize,
concat!("Alignment of ", stringify!(ldiv_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ldiv_t>())).quot as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ldiv_t),
"::",
stringify!(quot)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ldiv_t>())).rem as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ldiv_t),
"::",
stringify!(rem)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lldiv_t {
pub quot: ::std::os::raw::c_longlong,
pub rem: ::std::os::raw::c_longlong,
}
#[test]
fn bindgen_test_layout_lldiv_t() {
assert_eq!(
::std::mem::size_of::<lldiv_t>(),
16usize,
concat!("Size of: ", stringify!(lldiv_t))
);
assert_eq!(
::std::mem::align_of::<lldiv_t>(),
8usize,
concat!("Alignment of ", stringify!(lldiv_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lldiv_t>())).quot as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lldiv_t),
"::",
stringify!(quot)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lldiv_t>())).rem as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lldiv_t),
"::",
stringify!(rem)
)
);
}
extern "C" {
pub fn __ctype_get_mb_cur_max() -> size_t;
}
extern "C" {
pub fn atof(__nptr: *const ::std::os::raw::c_char) -> f64;
}
extern "C" {
pub fn atoi(__nptr: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn atol(__nptr: *const ::std::os::raw::c_char) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn atoll(__nptr: *const ::std::os::raw::c_char) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn strtod(
__nptr: *const ::std::os::raw::c_char,
__endptr: *mut *mut ::std::os::raw::c_char,
) -> f64;
}
extern "C" {
pub fn strtof(
__nptr: *const ::std::os::raw::c_char,
__endptr: *mut *mut ::std::os::raw::c_char,
) -> f32;
}
extern "C" {
pub fn strtold(
__nptr: *const ::std::os::raw::c_char,
__endptr: *mut *mut ::std::os::raw::c_char,
) -> u128;
}
extern "C" {
pub fn strtof32(
__nptr: *const ::std::os::raw::c_char,
__endptr: *mut *mut ::std::os::raw::c_char,
) -> _Float32;
}
extern "C" {
pub fn strtof64(
__nptr: *const ::std::os::raw::c_char,
__endptr: *mut *mut ::std::os::raw::c_char,
) -> _Float64;
}
extern "C" {
pub fn strtof32x(
__nptr: *const ::std::os::raw::c_char,
__endptr: *mut *mut ::std::os::raw::c_char,
) -> _Float32x;
}
extern "C" {
pub fn strtof64x(
__nptr: *const ::std::os::raw::c_char,
__endptr: *mut *mut ::std::os::raw::c_char,
) -> _Float64x;
}
extern "C" {
pub fn strtol(
__nptr: *const ::std::os::raw::c_char,
__endptr: *mut *mut ::std::os::raw::c_char,
__base: ::std::os::raw::c_int,
) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn strtoul(
__nptr: *const ::std::os::raw::c_char,
__endptr: *mut *mut ::std::os::raw::c_char,
__base: ::std::os::raw::c_int,
) -> ::std::os::raw::c_ulong;
}
extern "C" {
pub fn strtoq(
__nptr: *const ::std::os::raw::c_char,
__endptr: *mut *mut ::std::os::raw::c_char,
__base: ::std::os::raw::c_int,
) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn strtouq(
__nptr: *const ::std::os::raw::c_char,
__endptr: *mut *mut ::std::os::raw::c_char,
__base: ::std::os::raw::c_int,
) -> ::std::os::raw::c_ulonglong;
}
extern "C" {
pub fn strtoll(
__nptr: *const ::std::os::raw::c_char,
__endptr: *mut *mut ::std::os::raw::c_char,
__base: ::std::os::raw::c_int,
) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn strtoull(
__nptr: *const ::std::os::raw::c_char,
__endptr: *mut *mut ::std::os::raw::c_char,
__base: ::std::os::raw::c_int,
) -> ::std::os::raw::c_ulonglong;
}
extern "C" {
pub fn strfromd(
__dest: *mut ::std::os::raw::c_char,
__size: size_t,
__format: *const ::std::os::raw::c_char,
__f: f64,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn strfromf(
__dest: *mut ::std::os::raw::c_char,
__size: size_t,
__format: *const ::std::os::raw::c_char,
__f: f32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn strfroml(
__dest: *mut ::std::os::raw::c_char,
__size: size_t,
__format: *const ::std::os::raw::c_char,
__f: u128,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn strfromf32(
__dest: *mut ::std::os::raw::c_char,
__size: size_t,
__format: *const ::std::os::raw::c_char,
__f: _Float32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn strfromf64(
__dest: *mut ::std::os::raw::c_char,
__size: size_t,
__format: *const ::std::os::raw::c_char,
__f: _Float64,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn strfromf32x(
__dest: *mut ::std::os::raw::c_char,
__size: size_t,
__format: *const ::std::os::raw::c_char,
__f: _Float32x,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn strfromf64x(
__dest: *mut ::std::os::raw::c_char,
__size: size_t,
__format: *const ::std::os::raw::c_char,
__f: _Float64x,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __locale_struct {
pub __locales: [*mut __locale_data; 13usize],
pub __ctype_b: *const ::std::os::raw::c_ushort,
pub __ctype_tolower: *const ::std::os::raw::c_int,
pub __ctype_toupper: *const ::std::os::raw::c_int,
pub __names: [*const ::std::os::raw::c_char; 13usize],
}
#[test]
fn bindgen_test_layout___locale_struct() {
assert_eq!(
::std::mem::size_of::<__locale_struct>(),
232usize,
concat!("Size of: ", stringify!(__locale_struct))
);
assert_eq!(
::std::mem::align_of::<__locale_struct>(),
8usize,
concat!("Alignment of ", stringify!(__locale_struct))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__locale_struct>())).__locales as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__locale_struct),
"::",
stringify!(__locales)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__locale_struct>())).__ctype_b as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(__locale_struct),
"::",
stringify!(__ctype_b)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__locale_struct>())).__ctype_tolower as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(__locale_struct),
"::",
stringify!(__ctype_tolower)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__locale_struct>())).__ctype_toupper as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(__locale_struct),
"::",
stringify!(__ctype_toupper)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__locale_struct>())).__names as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(__locale_struct),
"::",
stringify!(__names)
)
);
}
pub type __locale_t = *mut __locale_struct;
pub type locale_t = __locale_t;
extern "C" {
pub fn strtol_l(
__nptr: *const ::std::os::raw::c_char,
__endptr: *mut *mut ::std::os::raw::c_char,
__base: ::std::os::raw::c_int,
__loc: locale_t,
) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn strtoul_l(
__nptr: *const ::std::os::raw::c_char,
__endptr: *mut *mut ::std::os::raw::c_char,
__base: ::std::os::raw::c_int,
__loc: locale_t,
) -> ::std::os::raw::c_ulong;
}
extern "C" {
pub fn strtoll_l(
__nptr: *const ::std::os::raw::c_char,
__endptr: *mut *mut ::std::os::raw::c_char,
__base: ::std::os::raw::c_int,
__loc: locale_t,
) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn strtoull_l(
__nptr: *const ::std::os::raw::c_char,
__endptr: *mut *mut ::std::os::raw::c_char,
__base: ::std::os::raw::c_int,
__loc: locale_t,
) -> ::std::os::raw::c_ulonglong;
}
extern "C" {
pub fn strtod_l(
__nptr: *const ::std::os::raw::c_char,
__endptr: *mut *mut ::std::os::raw::c_char,
__loc: locale_t,
) -> f64;
}
extern "C" {
pub fn strtof_l(
__nptr: *const ::std::os::raw::c_char,
__endptr: *mut *mut ::std::os::raw::c_char,
__loc: locale_t,
) -> f32;
}
extern "C" {
pub fn strtold_l(
__nptr: *const ::std::os::raw::c_char,
__endptr: *mut *mut ::std::os::raw::c_char,
__loc: locale_t,
) -> u128;
}
extern "C" {
pub fn strtof32_l(
__nptr: *const ::std::os::raw::c_char,
__endptr: *mut *mut ::std::os::raw::c_char,
__loc: locale_t,
) -> _Float32;
}
extern "C" {
pub fn strtof64_l(
__nptr: *const ::std::os::raw::c_char,
__endptr: *mut *mut ::std::os::raw::c_char,
__loc: locale_t,
) -> _Float64;
}
extern "C" {
pub fn strtof32x_l(
__nptr: *const ::std::os::raw::c_char,
__endptr: *mut *mut ::std::os::raw::c_char,
__loc: locale_t,
) -> _Float32x;
}
extern "C" {
pub fn strtof64x_l(
__nptr: *const ::std::os::raw::c_char,
__endptr: *mut *mut ::std::os::raw::c_char,
__loc: locale_t,
) -> _Float64x;
}
extern "C" {
pub fn l64a(__n: ::std::os::raw::c_long) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn a64l(__s: *const ::std::os::raw::c_char) -> ::std::os::raw::c_long;
}
pub type u_char = __u_char;
pub type u_short = __u_short;
pub type u_int = __u_int;
pub type u_long = __u_long;
pub type quad_t = __quad_t;
pub type u_quad_t = __u_quad_t;
pub type fsid_t = __fsid_t;
pub type loff_t = __loff_t;
pub type ino_t = __ino_t;
pub type ino64_t = __ino64_t;
pub type dev_t = __dev_t;
pub type gid_t = __gid_t;
pub type mode_t = __mode_t;
pub type nlink_t = __nlink_t;
pub type uid_t = __uid_t;
pub type off_t = __off_t;
pub type off64_t = __off64_t;
pub type pid_t = __pid_t;
pub type id_t = __id_t;
pub type ssize_t = __ssize_t;
pub type daddr_t = __daddr_t;
pub type caddr_t = __caddr_t;
pub type key_t = __key_t;
pub type clock_t = __clock_t;
pub type clockid_t = __clockid_t;
pub type time_t = __time_t;
pub type timer_t = __timer_t;
pub type useconds_t = __useconds_t;
pub type suseconds_t = __suseconds_t;
pub type ulong = ::std::os::raw::c_ulong;
pub type ushort = ::std::os::raw::c_ushort;
pub type uint = ::std::os::raw::c_uint;
pub type u_int8_t = __uint8_t;
pub type u_int16_t = __uint16_t;
pub type u_int32_t = __uint32_t;
pub type u_int64_t = __uint64_t;
pub type register_t = ::std::os::raw::c_long;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __sigset_t {
pub __val: [::std::os::raw::c_ulong; 16usize],
}
#[test]
fn bindgen_test_layout___sigset_t() {
assert_eq!(
::std::mem::size_of::<__sigset_t>(),
128usize,
concat!("Size of: ", stringify!(__sigset_t))
);
assert_eq!(
::std::mem::align_of::<__sigset_t>(),
8usize,
concat!("Alignment of ", stringify!(__sigset_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__sigset_t>())).__val as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__sigset_t),
"::",
stringify!(__val)
)
);
}
pub type sigset_t = __sigset_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct timeval {
pub tv_sec: __time_t,
pub tv_usec: __suseconds_t,
}
#[test]
fn bindgen_test_layout_timeval() {
assert_eq!(
::std::mem::size_of::<timeval>(),
16usize,
concat!("Size of: ", stringify!(timeval))
);
assert_eq!(
::std::mem::align_of::<timeval>(),
8usize,
concat!("Alignment of ", stringify!(timeval))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<timeval>())).tv_sec as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(timeval),
"::",
stringify!(tv_sec)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<timeval>())).tv_usec as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(timeval),
"::",
stringify!(tv_usec)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct timespec {
pub tv_sec: __time_t,
pub tv_nsec: __syscall_slong_t,
}
#[test]
fn bindgen_test_layout_timespec() {
assert_eq!(
::std::mem::size_of::<timespec>(),
16usize,
concat!("Size of: ", stringify!(timespec))
);
assert_eq!(
::std::mem::align_of::<timespec>(),
8usize,
concat!("Alignment of ", stringify!(timespec))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<timespec>())).tv_sec as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(timespec),
"::",
stringify!(tv_sec)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<timespec>())).tv_nsec as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(timespec),
"::",
stringify!(tv_nsec)
)
);
}
pub type __fd_mask = ::std::os::raw::c_long;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct fd_set {
pub fds_bits: [__fd_mask; 16usize],
}
#[test]
fn bindgen_test_layout_fd_set() {
assert_eq!(
::std::mem::size_of::<fd_set>(),
128usize,
concat!("Size of: ", stringify!(fd_set))
);
assert_eq!(
::std::mem::align_of::<fd_set>(),
8usize,
concat!("Alignment of ", stringify!(fd_set))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<fd_set>())).fds_bits as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(fd_set),
"::",
stringify!(fds_bits)
)
);
}
pub type fd_mask = __fd_mask;
extern "C" {
pub fn select(
__nfds: ::std::os::raw::c_int,
__readfds: *mut fd_set,
__writefds: *mut fd_set,
__exceptfds: *mut fd_set,
__timeout: *mut timeval,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn pselect(
__nfds: ::std::os::raw::c_int,
__readfds: *mut fd_set,
__writefds: *mut fd_set,
__exceptfds: *mut fd_set,
__timeout: *const timespec,
__sigmask: *const __sigset_t,
) -> ::std::os::raw::c_int;
}
pub type blksize_t = __blksize_t;
pub type blkcnt_t = __blkcnt_t;
pub type fsblkcnt_t = __fsblkcnt_t;
pub type fsfilcnt_t = __fsfilcnt_t;
pub type blkcnt64_t = __blkcnt64_t;
pub type fsblkcnt64_t = __fsblkcnt64_t;
pub type fsfilcnt64_t = __fsfilcnt64_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_internal_list {
pub __prev: *mut __pthread_internal_list,
pub __next: *mut __pthread_internal_list,
}
#[test]
fn bindgen_test_layout___pthread_internal_list() {
assert_eq!(
::std::mem::size_of::<__pthread_internal_list>(),
16usize,
concat!("Size of: ", stringify!(__pthread_internal_list))
);
assert_eq!(
::std::mem::align_of::<__pthread_internal_list>(),
8usize,
concat!("Alignment of ", stringify!(__pthread_internal_list))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_internal_list>())).__prev as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_internal_list),
"::",
stringify!(__prev)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_internal_list>())).__next as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__pthread_internal_list),
"::",
stringify!(__next)
)
);
}
pub type __pthread_list_t = __pthread_internal_list;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_internal_slist {
pub __next: *mut __pthread_internal_slist,
}
#[test]
fn bindgen_test_layout___pthread_internal_slist() {
assert_eq!(
::std::mem::size_of::<__pthread_internal_slist>(),
8usize,
concat!("Size of: ", stringify!(__pthread_internal_slist))
);
assert_eq!(
::std::mem::align_of::<__pthread_internal_slist>(),
8usize,
concat!("Alignment of ", stringify!(__pthread_internal_slist))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_internal_slist>())).__next as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_internal_slist),
"::",
stringify!(__next)
)
);
}
pub type __pthread_slist_t = __pthread_internal_slist;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_mutex_s {
pub __lock: ::std::os::raw::c_int,
pub __count: ::std::os::raw::c_uint,
pub __owner: ::std::os::raw::c_int,
pub __nusers: ::std::os::raw::c_uint,
pub __kind: ::std::os::raw::c_int,
pub __spins: ::std::os::raw::c_short,
pub __elision: ::std::os::raw::c_short,
pub __list: __pthread_list_t,
}
#[test]
fn bindgen_test_layout___pthread_mutex_s() {
assert_eq!(
::std::mem::size_of::<__pthread_mutex_s>(),
40usize,
concat!("Size of: ", stringify!(__pthread_mutex_s))
);
assert_eq!(
::std::mem::align_of::<__pthread_mutex_s>(),
8usize,
concat!("Alignment of ", stringify!(__pthread_mutex_s))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__lock as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__lock)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__count as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__owner as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__owner)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__nusers as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__nusers)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__kind as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__kind)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__spins as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__spins)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__elision as *const _ as usize },
22usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__elision)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__list as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__list)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_rwlock_arch_t {
pub __readers: ::std::os::raw::c_uint,
pub __writers: ::std::os::raw::c_uint,
pub __wrphase_futex: ::std::os::raw::c_uint,
pub __writers_futex: ::std::os::raw::c_uint,
pub __pad3: ::std::os::raw::c_uint,
pub __pad4: ::std::os::raw::c_uint,
pub __cur_writer: ::std::os::raw::c_int,
pub __shared: ::std::os::raw::c_int,
pub __rwelision: ::std::os::raw::c_schar,
pub __pad1: [::std::os::raw::c_uchar; 7usize],
pub __pad2: ::std::os::raw::c_ulong,
pub __flags: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout___pthread_rwlock_arch_t() {
assert_eq!(
::std::mem::size_of::<__pthread_rwlock_arch_t>(),
56usize,
concat!("Size of: ", stringify!(__pthread_rwlock_arch_t))
);
assert_eq!(
::std::mem::align_of::<__pthread_rwlock_arch_t>(),
8usize,
concat!("Alignment of ", stringify!(__pthread_rwlock_arch_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__readers as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__readers)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__writers as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__writers)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__wrphase_futex as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__wrphase_futex)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__writers_futex as *const _ as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__writers_futex)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__pad3 as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__pad3)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__pad4 as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__pad4)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__cur_writer as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__cur_writer)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__shared as *const _ as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__shared)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__rwelision as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__rwelision)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__pad1 as *const _ as usize },
33usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__pad1)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__pad2 as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__pad2)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__flags as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__flags)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct __pthread_cond_s {
pub __bindgen_anon_1: __pthread_cond_s__bindgen_ty_1,
pub __bindgen_anon_2: __pthread_cond_s__bindgen_ty_2,
pub __g_refs: [::std::os::raw::c_uint; 2usize],
pub __g_size: [::std::os::raw::c_uint; 2usize],
pub __g1_orig_size: ::std::os::raw::c_uint,
pub __wrefs: ::std::os::raw::c_uint,
pub __g_signals: [::std::os::raw::c_uint; 2usize],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __pthread_cond_s__bindgen_ty_1 {
pub __wseq: ::std::os::raw::c_ulonglong,
pub __wseq32: __pthread_cond_s__bindgen_ty_1__bindgen_ty_1,
_bindgen_union_align: u64,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_cond_s__bindgen_ty_1__bindgen_ty_1 {
pub __low: ::std::os::raw::c_uint,
pub __high: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout___pthread_cond_s__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<__pthread_cond_s__bindgen_ty_1__bindgen_ty_1>(),
8usize,
concat!(
"Size of: ",
stringify!(__pthread_cond_s__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<__pthread_cond_s__bindgen_ty_1__bindgen_ty_1>(),
4usize,
concat!(
"Alignment of ",
stringify!(__pthread_cond_s__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_cond_s__bindgen_ty_1__bindgen_ty_1>())).__low
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(__low)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_cond_s__bindgen_ty_1__bindgen_ty_1>())).__high
as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(__high)
)
);
}
#[test]
fn bindgen_test_layout___pthread_cond_s__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<__pthread_cond_s__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(__pthread_cond_s__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<__pthread_cond_s__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(__pthread_cond_s__bindgen_ty_1))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_cond_s__bindgen_ty_1>())).__wseq as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s__bindgen_ty_1),
"::",
stringify!(__wseq)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_cond_s__bindgen_ty_1>())).__wseq32 as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s__bindgen_ty_1),
"::",
stringify!(__wseq32)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __pthread_cond_s__bindgen_ty_2 {
pub __g1_start: ::std::os::raw::c_ulonglong,
pub __g1_start32: __pthread_cond_s__bindgen_ty_2__bindgen_ty_1,
_bindgen_union_align: u64,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_cond_s__bindgen_ty_2__bindgen_ty_1 {
pub __low: ::std::os::raw::c_uint,
pub __high: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout___pthread_cond_s__bindgen_ty_2__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<__pthread_cond_s__bindgen_ty_2__bindgen_ty_1>(),
8usize,
concat!(
"Size of: ",
stringify!(__pthread_cond_s__bindgen_ty_2__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<__pthread_cond_s__bindgen_ty_2__bindgen_ty_1>(),
4usize,
concat!(
"Alignment of ",
stringify!(__pthread_cond_s__bindgen_ty_2__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_cond_s__bindgen_ty_2__bindgen_ty_1>())).__low
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s__bindgen_ty_2__bindgen_ty_1),
"::",
stringify!(__low)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_cond_s__bindgen_ty_2__bindgen_ty_1>())).__high
as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s__bindgen_ty_2__bindgen_ty_1),
"::",
stringify!(__high)
)
);
}
#[test]
fn bindgen_test_layout___pthread_cond_s__bindgen_ty_2() {
assert_eq!(
::std::mem::size_of::<__pthread_cond_s__bindgen_ty_2>(),
8usize,
concat!("Size of: ", stringify!(__pthread_cond_s__bindgen_ty_2))
);
assert_eq!(
::std::mem::align_of::<__pthread_cond_s__bindgen_ty_2>(),
8usize,
concat!("Alignment of ", stringify!(__pthread_cond_s__bindgen_ty_2))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_cond_s__bindgen_ty_2>())).__g1_start as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s__bindgen_ty_2),
"::",
stringify!(__g1_start)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_cond_s__bindgen_ty_2>())).__g1_start32 as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s__bindgen_ty_2),
"::",
stringify!(__g1_start32)
)
);
}
#[test]
fn bindgen_test_layout___pthread_cond_s() {
assert_eq!(
::std::mem::size_of::<__pthread_cond_s>(),
48usize,
concat!("Size of: ", stringify!(__pthread_cond_s))
);
assert_eq!(
::std::mem::align_of::<__pthread_cond_s>(),
8usize,
concat!("Alignment of ", stringify!(__pthread_cond_s))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_cond_s>())).__g_refs as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__g_refs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_cond_s>())).__g_size as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__g_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_cond_s>())).__g1_orig_size as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__g1_orig_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_cond_s>())).__wrefs as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__wrefs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_cond_s>())).__g_signals as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__g_signals)
)
);
}
pub type pthread_t = ::std::os::raw::c_ulong;
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_mutexattr_t {
pub __size: [::std::os::raw::c_char; 4usize],
pub __align: ::std::os::raw::c_int,
_bindgen_union_align: u32,
}
#[test]
fn bindgen_test_layout_pthread_mutexattr_t() {
assert_eq!(
::std::mem::size_of::<pthread_mutexattr_t>(),
4usize,
concat!("Size of: ", stringify!(pthread_mutexattr_t))
);
assert_eq!(
::std::mem::align_of::<pthread_mutexattr_t>(),
4usize,
concat!("Alignment of ", stringify!(pthread_mutexattr_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_mutexattr_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_mutexattr_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_mutexattr_t>())).__align as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_mutexattr_t),
"::",
stringify!(__align)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_condattr_t {
pub __size: [::std::os::raw::c_char; 4usize],
pub __align: ::std::os::raw::c_int,
_bindgen_union_align: u32,
}
#[test]
fn bindgen_test_layout_pthread_condattr_t() {
assert_eq!(
::std::mem::size_of::<pthread_condattr_t>(),
4usize,
concat!("Size of: ", stringify!(pthread_condattr_t))
);
assert_eq!(
::std::mem::align_of::<pthread_condattr_t>(),
4usize,
concat!("Alignment of ", stringify!(pthread_condattr_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_condattr_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_condattr_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_condattr_t>())).__align as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_condattr_t),
"::",
stringify!(__align)
)
);
}
pub type pthread_key_t = ::std::os::raw::c_uint;
pub type pthread_once_t = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_attr_t {
pub __size: [::std::os::raw::c_char; 56usize],
pub __align: ::std::os::raw::c_long,
_bindgen_union_align: [u64; 7usize],
}
#[test]
fn bindgen_test_layout_pthread_attr_t() {
assert_eq!(
::std::mem::size_of::<pthread_attr_t>(),
56usize,
concat!("Size of: ", stringify!(pthread_attr_t))
);
assert_eq!(
::std::mem::align_of::<pthread_attr_t>(),
8usize,
concat!("Alignment of ", stringify!(pthread_attr_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_attr_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_attr_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_attr_t>())).__align as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_attr_t),
"::",
stringify!(__align)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_mutex_t {
pub __data: __pthread_mutex_s,
pub __size: [::std::os::raw::c_char; 40usize],
pub __align: ::std::os::raw::c_long,
_bindgen_union_align: [u64; 5usize],
}
#[test]
fn bindgen_test_layout_pthread_mutex_t() {
assert_eq!(
::std::mem::size_of::<pthread_mutex_t>(),
40usize,
concat!("Size of: ", stringify!(pthread_mutex_t))
);
assert_eq!(
::std::mem::align_of::<pthread_mutex_t>(),
8usize,
concat!("Alignment of ", stringify!(pthread_mutex_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_mutex_t>())).__data as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_mutex_t),
"::",
stringify!(__data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_mutex_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_mutex_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_mutex_t>())).__align as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_mutex_t),
"::",
stringify!(__align)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_cond_t {
pub __data: __pthread_cond_s,
pub __size: [::std::os::raw::c_char; 48usize],
pub __align: ::std::os::raw::c_longlong,
_bindgen_union_align: [u64; 6usize],
}
#[test]
fn bindgen_test_layout_pthread_cond_t() {
assert_eq!(
::std::mem::size_of::<pthread_cond_t>(),
48usize,
concat!("Size of: ", stringify!(pthread_cond_t))
);
assert_eq!(
::std::mem::align_of::<pthread_cond_t>(),
8usize,
concat!("Alignment of ", stringify!(pthread_cond_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_cond_t>())).__data as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_cond_t),
"::",
stringify!(__data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_cond_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_cond_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_cond_t>())).__align as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_cond_t),
"::",
stringify!(__align)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_rwlock_t {
pub __data: __pthread_rwlock_arch_t,
pub __size: [::std::os::raw::c_char; 56usize],
pub __align: ::std::os::raw::c_long,
_bindgen_union_align: [u64; 7usize],
}
#[test]
fn bindgen_test_layout_pthread_rwlock_t() {
assert_eq!(
::std::mem::size_of::<pthread_rwlock_t>(),
56usize,
concat!("Size of: ", stringify!(pthread_rwlock_t))
);
assert_eq!(
::std::mem::align_of::<pthread_rwlock_t>(),
8usize,
concat!("Alignment of ", stringify!(pthread_rwlock_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_rwlock_t>())).__data as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_rwlock_t),
"::",
stringify!(__data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_rwlock_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_rwlock_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_rwlock_t>())).__align as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_rwlock_t),
"::",
stringify!(__align)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_rwlockattr_t {
pub __size: [::std::os::raw::c_char; 8usize],
pub __align: ::std::os::raw::c_long,
_bindgen_union_align: u64,
}
#[test]
fn bindgen_test_layout_pthread_rwlockattr_t() {
assert_eq!(
::std::mem::size_of::<pthread_rwlockattr_t>(),
8usize,
concat!("Size of: ", stringify!(pthread_rwlockattr_t))
);
assert_eq!(
::std::mem::align_of::<pthread_rwlockattr_t>(),
8usize,
concat!("Alignment of ", stringify!(pthread_rwlockattr_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_rwlockattr_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_rwlockattr_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_rwlockattr_t>())).__align as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_rwlockattr_t),
"::",
stringify!(__align)
)
);
}
pub type pthread_spinlock_t = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_barrier_t {
pub __size: [::std::os::raw::c_char; 32usize],
pub __align: ::std::os::raw::c_long,
_bindgen_union_align: [u64; 4usize],
}
#[test]
fn bindgen_test_layout_pthread_barrier_t() {
assert_eq!(
::std::mem::size_of::<pthread_barrier_t>(),
32usize,
concat!("Size of: ", stringify!(pthread_barrier_t))
);
assert_eq!(
::std::mem::align_of::<pthread_barrier_t>(),
8usize,
concat!("Alignment of ", stringify!(pthread_barrier_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_barrier_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_barrier_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_barrier_t>())).__align as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_barrier_t),
"::",
stringify!(__align)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_barrierattr_t {
pub __size: [::std::os::raw::c_char; 4usize],
pub __align: ::std::os::raw::c_int,
_bindgen_union_align: u32,
}
#[test]
fn bindgen_test_layout_pthread_barrierattr_t() {
assert_eq!(
::std::mem::size_of::<pthread_barrierattr_t>(),
4usize,
concat!("Size of: ", stringify!(pthread_barrierattr_t))
);
assert_eq!(
::std::mem::align_of::<pthread_barrierattr_t>(),
4usize,
concat!("Alignment of ", stringify!(pthread_barrierattr_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_barrierattr_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_barrierattr_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_barrierattr_t>())).__align as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_barrierattr_t),
"::",
stringify!(__align)
)
);
}
extern "C" {
pub fn random() -> ::std::os::raw::c_long;
}
extern "C" {
pub fn srandom(__seed: ::std::os::raw::c_uint);
}
extern "C" {
pub fn initstate(
__seed: ::std::os::raw::c_uint,
__statebuf: *mut ::std::os::raw::c_char,
__statelen: size_t,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn setstate(__statebuf: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct random_data {
pub fptr: *mut i32,
pub rptr: *mut i32,
pub state: *mut i32,
pub rand_type: ::std::os::raw::c_int,
pub rand_deg: ::std::os::raw::c_int,
pub rand_sep: ::std::os::raw::c_int,
pub end_ptr: *mut i32,
}
#[test]
fn bindgen_test_layout_random_data() {
assert_eq!(
::std::mem::size_of::<random_data>(),
48usize,
concat!("Size of: ", stringify!(random_data))
);
assert_eq!(
::std::mem::align_of::<random_data>(),
8usize,
concat!("Alignment of ", stringify!(random_data))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<random_data>())).fptr as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(random_data),
"::",
stringify!(fptr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<random_data>())).rptr as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(random_data),
"::",
stringify!(rptr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<random_data>())).state as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(random_data),
"::",
stringify!(state)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<random_data>())).rand_type as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(random_data),
"::",
stringify!(rand_type)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<random_data>())).rand_deg as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(random_data),
"::",
stringify!(rand_deg)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<random_data>())).rand_sep as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(random_data),
"::",
stringify!(rand_sep)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<random_data>())).end_ptr as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(random_data),
"::",
stringify!(end_ptr)
)
);
}
extern "C" {
pub fn random_r(__buf: *mut random_data, __result: *mut i32) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn srandom_r(
__seed: ::std::os::raw::c_uint,
__buf: *mut random_data,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn initstate_r(
__seed: ::std::os::raw::c_uint,
__statebuf: *mut ::std::os::raw::c_char,
__statelen: size_t,
__buf: *mut random_data,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn setstate_r(
__statebuf: *mut ::std::os::raw::c_char,
__buf: *mut random_data,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rand() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn srand(__seed: ::std::os::raw::c_uint);
}
extern "C" {
pub fn rand_r(__seed: *mut ::std::os::raw::c_uint) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn drand48() -> f64;
}
extern "C" {
pub fn erand48(__xsubi: *mut ::std::os::raw::c_ushort) -> f64;
}
extern "C" {
pub fn lrand48() -> ::std::os::raw::c_long;
}
extern "C" {
pub fn nrand48(__xsubi: *mut ::std::os::raw::c_ushort) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn mrand48() -> ::std::os::raw::c_long;
}
extern "C" {
pub fn jrand48(__xsubi: *mut ::std::os::raw::c_ushort) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn srand48(__seedval: ::std::os::raw::c_long);
}
extern "C" {
pub fn seed48(__seed16v: *mut ::std::os::raw::c_ushort) -> *mut ::std::os::raw::c_ushort;
}
extern "C" {
pub fn lcong48(__param: *mut ::std::os::raw::c_ushort);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct drand48_data {
pub __x: [::std::os::raw::c_ushort; 3usize],
pub __old_x: [::std::os::raw::c_ushort; 3usize],
pub __c: ::std::os::raw::c_ushort,
pub __init: ::std::os::raw::c_ushort,
pub __a: ::std::os::raw::c_ulonglong,
}
#[test]
fn bindgen_test_layout_drand48_data() {
assert_eq!(
::std::mem::size_of::<drand48_data>(),
24usize,
concat!("Size of: ", stringify!(drand48_data))
);
assert_eq!(
::std::mem::align_of::<drand48_data>(),
8usize,
concat!("Alignment of ", stringify!(drand48_data))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<drand48_data>())).__x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(drand48_data),
"::",
stringify!(__x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<drand48_data>())).__old_x as *const _ as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(drand48_data),
"::",
stringify!(__old_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<drand48_data>())).__c as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(drand48_data),
"::",
stringify!(__c)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<drand48_data>())).__init as *const _ as usize },
14usize,
concat!(
"Offset of field: ",
stringify!(drand48_data),
"::",
stringify!(__init)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<drand48_data>())).__a as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(drand48_data),
"::",
stringify!(__a)
)
);
}
extern "C" {
pub fn drand48_r(__buffer: *mut drand48_data, __result: *mut f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn erand48_r(
__xsubi: *mut ::std::os::raw::c_ushort,
__buffer: *mut drand48_data,
__result: *mut f64,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn lrand48_r(
__buffer: *mut drand48_data,
__result: *mut ::std::os::raw::c_long,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nrand48_r(
__xsubi: *mut ::std::os::raw::c_ushort,
__buffer: *mut drand48_data,
__result: *mut ::std::os::raw::c_long,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mrand48_r(
__buffer: *mut drand48_data,
__result: *mut ::std::os::raw::c_long,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn jrand48_r(
__xsubi: *mut ::std::os::raw::c_ushort,
__buffer: *mut drand48_data,
__result: *mut ::std::os::raw::c_long,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn srand48_r(
__seedval: ::std::os::raw::c_long,
__buffer: *mut drand48_data,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn seed48_r(
__seed16v: *mut ::std::os::raw::c_ushort,
__buffer: *mut drand48_data,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn lcong48_r(
__param: *mut ::std::os::raw::c_ushort,
__buffer: *mut drand48_data,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn malloc(__size: ::std::os::raw::c_ulong) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn calloc(
__nmemb: ::std::os::raw::c_ulong,
__size: ::std::os::raw::c_ulong,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn realloc(
__ptr: *mut ::std::os::raw::c_void,
__size: ::std::os::raw::c_ulong,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn reallocarray(
__ptr: *mut ::std::os::raw::c_void,
__nmemb: size_t,
__size: size_t,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn free(__ptr: *mut ::std::os::raw::c_void);
}
extern "C" {
pub fn alloca(__size: ::std::os::raw::c_ulong) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn valloc(__size: size_t) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn posix_memalign(
__memptr: *mut *mut ::std::os::raw::c_void,
__alignment: size_t,
__size: size_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn aligned_alloc(__alignment: size_t, __size: size_t) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn abort();
}
extern "C" {
pub fn atexit(__func: ::std::option::Option<unsafe extern "C" fn()>) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn at_quick_exit(
__func: ::std::option::Option<unsafe extern "C" fn()>,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn on_exit(
__func: ::std::option::Option<
unsafe extern "C" fn(
__status: ::std::os::raw::c_int,
__arg: *mut ::std::os::raw::c_void,
),
>,
__arg: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn exit(__status: ::std::os::raw::c_int);
}
extern "C" {
pub fn quick_exit(__status: ::std::os::raw::c_int);
}
extern "C" {
pub fn _Exit(__status: ::std::os::raw::c_int);
}
extern "C" {
pub fn getenv(__name: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn secure_getenv(__name: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn putenv(__string: *mut ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn setenv(
__name: *const ::std::os::raw::c_char,
__value: *const ::std::os::raw::c_char,
__replace: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn unsetenv(__name: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn clearenv() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mktemp(__template: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn mkstemp(__template: *mut ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mkstemp64(__template: *mut ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mkstemps(
__template: *mut ::std::os::raw::c_char,
__suffixlen: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mkstemps64(
__template: *mut ::std::os::raw::c_char,
__suffixlen: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mkdtemp(__template: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn mkostemp(
__template: *mut ::std::os::raw::c_char,
__flags: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mkostemp64(
__template: *mut ::std::os::raw::c_char,
__flags: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mkostemps(
__template: *mut ::std::os::raw::c_char,
__suffixlen: ::std::os::raw::c_int,
__flags: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mkostemps64(
__template: *mut ::std::os::raw::c_char,
__suffixlen: ::std::os::raw::c_int,
__flags: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn system(__command: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn canonicalize_file_name(
__name: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn realpath(
__name: *const ::std::os::raw::c_char,
__resolved: *mut ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
pub type __compar_fn_t = ::std::option::Option<
unsafe extern "C" fn(
arg1: *const ::std::os::raw::c_void,
arg2: *const ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>;
pub type comparison_fn_t = __compar_fn_t;
pub type __compar_d_fn_t = ::std::option::Option<
unsafe extern "C" fn(
arg1: *const ::std::os::raw::c_void,
arg2: *const ::std::os::raw::c_void,
arg3: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>;
extern "C" {
pub fn bsearch(
__key: *const ::std::os::raw::c_void,
__base: *const ::std::os::raw::c_void,
__nmemb: size_t,
__size: size_t,
__compar: __compar_fn_t,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn qsort(
__base: *mut ::std::os::raw::c_void,
__nmemb: size_t,
__size: size_t,
__compar: __compar_fn_t,
);
}
extern "C" {
pub fn qsort_r(
__base: *mut ::std::os::raw::c_void,
__nmemb: size_t,
__size: size_t,
__compar: __compar_d_fn_t,
__arg: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn abs(__x: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn labs(__x: ::std::os::raw::c_long) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn llabs(__x: ::std::os::raw::c_longlong) -> ::std::os::raw::c_longlong;
}
extern "C" {
pub fn div(__numer: ::std::os::raw::c_int, __denom: ::std::os::raw::c_int) -> div_t;
}
extern "C" {
pub fn ldiv(__numer: ::std::os::raw::c_long, __denom: ::std::os::raw::c_long) -> ldiv_t;
}
extern "C" {
pub fn lldiv(
__numer: ::std::os::raw::c_longlong,
__denom: ::std::os::raw::c_longlong,
) -> lldiv_t;
}
extern "C" {
pub fn ecvt(
__value: f64,
__ndigit: ::std::os::raw::c_int,
__decpt: *mut ::std::os::raw::c_int,
__sign: *mut ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn fcvt(
__value: f64,
__ndigit: ::std::os::raw::c_int,
__decpt: *mut ::std::os::raw::c_int,
__sign: *mut ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn gcvt(
__value: f64,
__ndigit: ::std::os::raw::c_int,
__buf: *mut ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn qecvt(
__value: u128,
__ndigit: ::std::os::raw::c_int,
__decpt: *mut ::std::os::raw::c_int,
__sign: *mut ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn qfcvt(
__value: u128,
__ndigit: ::std::os::raw::c_int,
__decpt: *mut ::std::os::raw::c_int,
__sign: *mut ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn qgcvt(
__value: u128,
__ndigit: ::std::os::raw::c_int,
__buf: *mut ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn ecvt_r(
__value: f64,
__ndigit: ::std::os::raw::c_int,
__decpt: *mut ::std::os::raw::c_int,
__sign: *mut ::std::os::raw::c_int,
__buf: *mut ::std::os::raw::c_char,
__len: size_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fcvt_r(
__value: f64,
__ndigit: ::std::os::raw::c_int,
__decpt: *mut ::std::os::raw::c_int,
__sign: *mut ::std::os::raw::c_int,
__buf: *mut ::std::os::raw::c_char,
__len: size_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn qecvt_r(
__value: u128,
__ndigit: ::std::os::raw::c_int,
__decpt: *mut ::std::os::raw::c_int,
__sign: *mut ::std::os::raw::c_int,
__buf: *mut ::std::os::raw::c_char,
__len: size_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn qfcvt_r(
__value: u128,
__ndigit: ::std::os::raw::c_int,
__decpt: *mut ::std::os::raw::c_int,
__sign: *mut ::std::os::raw::c_int,
__buf: *mut ::std::os::raw::c_char,
__len: size_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mblen(__s: *const ::std::os::raw::c_char, __n: size_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mbtowc(
__pwc: *mut wchar_t,
__s: *const ::std::os::raw::c_char,
__n: size_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn wctomb(__s: *mut ::std::os::raw::c_char, __wchar: wchar_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mbstowcs(
__pwcs: *mut wchar_t,
__s: *const ::std::os::raw::c_char,
__n: size_t,
) -> size_t;
}
extern "C" {
pub fn wcstombs(
__s: *mut ::std::os::raw::c_char,
__pwcs: *const wchar_t,
__n: size_t,
) -> size_t;
}
extern "C" {
pub fn rpmatch(__response: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn getsubopt(
__optionp: *mut *mut ::std::os::raw::c_char,
__tokens: *const *mut ::std::os::raw::c_char,
__valuep: *mut *mut ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn posix_openpt(__oflag: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn grantpt(__fd: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn unlockpt(__fd: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ptsname(__fd: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn ptsname_r(
__fd: ::std::os::raw::c_int,
__buf: *mut ::std::os::raw::c_char,
__buflen: size_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn getpt() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn getloadavg(__loadavg: *mut f64, __nelem: ::std::os::raw::c_int)
-> ::std::os::raw::c_int;
}
pub type va_list = __builtin_va_list;
pub type __gnuc_va_list = __builtin_va_list;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct __mbstate_t {
pub __count: ::std::os::raw::c_int,
pub __value: __mbstate_t__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __mbstate_t__bindgen_ty_1 {
pub __wch: ::std::os::raw::c_uint,
pub __wchb: [::std::os::raw::c_char; 4usize],
_bindgen_union_align: u32,
}
#[test]
fn bindgen_test_layout___mbstate_t__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<__mbstate_t__bindgen_ty_1>(),
4usize,
concat!("Size of: ", stringify!(__mbstate_t__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<__mbstate_t__bindgen_ty_1>(),
4usize,
concat!("Alignment of ", stringify!(__mbstate_t__bindgen_ty_1))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__mbstate_t__bindgen_ty_1>())).__wch as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__mbstate_t__bindgen_ty_1),
"::",
stringify!(__wch)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__mbstate_t__bindgen_ty_1>())).__wchb as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(__mbstate_t__bindgen_ty_1),
"::",
stringify!(__wchb)
)
);
}
#[test]
fn bindgen_test_layout___mbstate_t() {
assert_eq!(
::std::mem::size_of::<__mbstate_t>(),
8usize,
concat!("Size of: ", stringify!(__mbstate_t))
);
assert_eq!(
::std::mem::align_of::<__mbstate_t>(),
4usize,
concat!("Alignment of ", stringify!(__mbstate_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__mbstate_t>())).__count as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__mbstate_t),
"::",
stringify!(__count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__mbstate_t>())).__value as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(__mbstate_t),
"::",
stringify!(__value)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _G_fpos_t {
pub __pos: __off_t,
pub __state: __mbstate_t,
}
#[test]
fn bindgen_test_layout__G_fpos_t() {
assert_eq!(
::std::mem::size_of::<_G_fpos_t>(),
16usize,
concat!("Size of: ", stringify!(_G_fpos_t))
);
assert_eq!(
::std::mem::align_of::<_G_fpos_t>(),
8usize,
concat!("Alignment of ", stringify!(_G_fpos_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_G_fpos_t>())).__pos as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_G_fpos_t),
"::",
stringify!(__pos)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_G_fpos_t>())).__state as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_G_fpos_t),
"::",
stringify!(__state)
)
);
}
pub type __fpos_t = _G_fpos_t;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _G_fpos64_t {
pub __pos: __off64_t,
pub __state: __mbstate_t,
}
#[test]
fn bindgen_test_layout__G_fpos64_t() {
assert_eq!(
::std::mem::size_of::<_G_fpos64_t>(),
16usize,
concat!("Size of: ", stringify!(_G_fpos64_t))
);
assert_eq!(
::std::mem::align_of::<_G_fpos64_t>(),
8usize,
concat!("Alignment of ", stringify!(_G_fpos64_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_G_fpos64_t>())).__pos as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_G_fpos64_t),
"::",
stringify!(__pos)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_G_fpos64_t>())).__state as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_G_fpos64_t),
"::",
stringify!(__state)
)
);
}
pub type __fpos64_t = _G_fpos64_t;
pub type __FILE = _IO_FILE;
pub type FILE = _IO_FILE;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_marker {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_codecvt {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_wide_data {
_unused: [u8; 0],
}
pub type _IO_lock_t = ::std::os::raw::c_void;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_FILE {
pub _flags: ::std::os::raw::c_int,
pub _IO_read_ptr: *mut ::std::os::raw::c_char,
pub _IO_read_end: *mut ::std::os::raw::c_char,
pub _IO_read_base: *mut ::std::os::raw::c_char,
pub _IO_write_base: *mut ::std::os::raw::c_char,
pub _IO_write_ptr: *mut ::std::os::raw::c_char,
pub _IO_write_end: *mut ::std::os::raw::c_char,
pub _IO_buf_base: *mut ::std::os::raw::c_char,
pub _IO_buf_end: *mut ::std::os::raw::c_char,
pub _IO_save_base: *mut ::std::os::raw::c_char,
pub _IO_backup_base: *mut ::std::os::raw::c_char,
pub _IO_save_end: *mut ::std::os::raw::c_char,
pub _markers: *mut _IO_marker,
pub _chain: *mut _IO_FILE,
pub _fileno: ::std::os::raw::c_int,
pub _flags2: ::std::os::raw::c_int,
pub _old_offset: __off_t,
pub _cur_column: ::std::os::raw::c_ushort,
pub _vtable_offset: ::std::os::raw::c_schar,
pub _shortbuf: [::std::os::raw::c_char; 1usize],
pub _lock: *mut _IO_lock_t,
pub _offset: __off64_t,
pub _codecvt: *mut _IO_codecvt,
pub _wide_data: *mut _IO_wide_data,
pub _freeres_list: *mut _IO_FILE,
pub _freeres_buf: *mut ::std::os::raw::c_void,
pub __pad5: size_t,
pub _mode: ::std::os::raw::c_int,
pub _unused2: [::std::os::raw::c_char; 20usize],
}
#[test]
fn bindgen_test_layout__IO_FILE() {
assert_eq!(
::std::mem::size_of::<_IO_FILE>(),
216usize,
concat!("Size of: ", stringify!(_IO_FILE))
);
assert_eq!(
::std::mem::align_of::<_IO_FILE>(),
8usize,
concat!("Alignment of ", stringify!(_IO_FILE))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._flags as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_read_ptr as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_read_ptr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_read_end as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_read_end)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_read_base as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_read_base)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_write_base as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_write_base)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_write_ptr as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_write_ptr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_write_end as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_write_end)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_buf_base as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_buf_base)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_buf_end as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_buf_end)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_save_base as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_save_base)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_backup_base as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_backup_base)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_save_end as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_save_end)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._markers as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_markers)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._chain as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_chain)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._fileno as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_fileno)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._flags2 as *const _ as usize },
116usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_flags2)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._old_offset as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_old_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._cur_column as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_cur_column)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._vtable_offset as *const _ as usize },
130usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_vtable_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._shortbuf as *const _ as usize },
131usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_shortbuf)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._lock as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_lock)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._offset as *const _ as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._codecvt as *const _ as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_codecvt)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._wide_data as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_wide_data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._freeres_list as *const _ as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_freeres_list)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._freeres_buf as *const _ as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_freeres_buf)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>())).__pad5 as *const _ as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(__pad5)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._mode as *const _ as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_mode)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._unused2 as *const _ as usize },
196usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_unused2)
)
);
}
pub type cookie_read_function_t = ::std::option::Option<
unsafe extern "C" fn(
__cookie: *mut ::std::os::raw::c_void,
__buf: *mut ::std::os::raw::c_char,
__nbytes: size_t,
) -> __ssize_t,
>;
pub type cookie_write_function_t = ::std::option::Option<
unsafe extern "C" fn(
__cookie: *mut ::std::os::raw::c_void,
__buf: *const ::std::os::raw::c_char,
__nbytes: size_t,
) -> __ssize_t,
>;
pub type cookie_seek_function_t = ::std::option::Option<
unsafe extern "C" fn(
__cookie: *mut ::std::os::raw::c_void,
__pos: *mut __off64_t,
__w: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int,
>;
pub type cookie_close_function_t = ::std::option::Option<
unsafe extern "C" fn(__cookie: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_cookie_io_functions_t {
pub read: cookie_read_function_t,
pub write: cookie_write_function_t,
pub seek: cookie_seek_function_t,
pub close: cookie_close_function_t,
}
#[test]
fn bindgen_test_layout__IO_cookie_io_functions_t() {
assert_eq!(
::std::mem::size_of::<_IO_cookie_io_functions_t>(),
32usize,
concat!("Size of: ", stringify!(_IO_cookie_io_functions_t))
);
assert_eq!(
::std::mem::align_of::<_IO_cookie_io_functions_t>(),
8usize,
concat!("Alignment of ", stringify!(_IO_cookie_io_functions_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_cookie_io_functions_t>())).read as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_IO_cookie_io_functions_t),
"::",
stringify!(read)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_cookie_io_functions_t>())).write as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_IO_cookie_io_functions_t),
"::",
stringify!(write)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_cookie_io_functions_t>())).seek as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_IO_cookie_io_functions_t),
"::",
stringify!(seek)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_cookie_io_functions_t>())).close as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_IO_cookie_io_functions_t),
"::",
stringify!(close)
)
);
}
pub type cookie_io_functions_t = _IO_cookie_io_functions_t;
pub type fpos_t = __fpos_t;
pub type fpos64_t = __fpos64_t;
extern "C" {
pub static mut stdin: *mut FILE;
}
extern "C" {
pub static mut stdout: *mut FILE;
}
extern "C" {
pub static mut stderr: *mut FILE;
}
extern "C" {
pub fn remove(__filename: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rename(
__old: *const ::std::os::raw::c_char,
__new: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn renameat(
__oldfd: ::std::os::raw::c_int,
__old: *const ::std::os::raw::c_char,
__newfd: ::std::os::raw::c_int,
__new: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn renameat2(
__oldfd: ::std::os::raw::c_int,
__old: *const ::std::os::raw::c_char,
__newfd: ::std::os::raw::c_int,
__new: *const ::std::os::raw::c_char,
__flags: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn tmpfile() -> *mut FILE;
}
extern "C" {
pub fn tmpfile64() -> *mut FILE;
}
extern "C" {
pub fn tmpnam(__s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn tmpnam_r(__s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn tempnam(
__dir: *const ::std::os::raw::c_char,
__pfx: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn fclose(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fflush(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fflush_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fcloseall() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fopen(
__filename: *const ::std::os::raw::c_char,
__modes: *const ::std::os::raw::c_char,
) -> *mut FILE;
}
extern "C" {
pub fn freopen(
__filename: *const ::std::os::raw::c_char,
__modes: *const ::std::os::raw::c_char,
__stream: *mut FILE,
) -> *mut FILE;
}
extern "C" {
pub fn fopen64(
__filename: *const ::std::os::raw::c_char,
__modes: *const ::std::os::raw::c_char,
) -> *mut FILE;
}
extern "C" {
pub fn freopen64(
__filename: *const ::std::os::raw::c_char,
__modes: *const ::std::os::raw::c_char,
__stream: *mut FILE,
) -> *mut FILE;
}
extern "C" {
pub fn fdopen(__fd: ::std::os::raw::c_int, __modes: *const ::std::os::raw::c_char)
-> *mut FILE;
}
extern "C" {
pub fn fopencookie(
__magic_cookie: *mut ::std::os::raw::c_void,
__modes: *const ::std::os::raw::c_char,
__io_funcs: cookie_io_functions_t,
) -> *mut FILE;
}
extern "C" {
pub fn fmemopen(
__s: *mut ::std::os::raw::c_void,
__len: size_t,
__modes: *const ::std::os::raw::c_char,
) -> *mut FILE;
}
extern "C" {
pub fn open_memstream(
__bufloc: *mut *mut ::std::os::raw::c_char,
__sizeloc: *mut size_t,
) -> *mut FILE;
}
extern "C" {
pub fn setbuf(__stream: *mut FILE, __buf: *mut ::std::os::raw::c_char);
}
extern "C" {
pub fn setvbuf(
__stream: *mut FILE,
__buf: *mut ::std::os::raw::c_char,
__modes: ::std::os::raw::c_int,
__n: size_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn setbuffer(__stream: *mut FILE, __buf: *mut ::std::os::raw::c_char, __size: size_t);
}
extern "C" {
pub fn setlinebuf(__stream: *mut FILE);
}
extern "C" {
pub fn fprintf(
__stream: *mut FILE,
__format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn printf(__format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sprintf(
__s: *mut ::std::os::raw::c_char,
__format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn vfprintf(
__s: *mut FILE,
__format: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn vprintf(
__format: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn vsprintf(
__s: *mut ::std::os::raw::c_char,
__format: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn snprintf(
__s: *mut ::std::os::raw::c_char,
__maxlen: ::std::os::raw::c_ulong,
__format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn vsnprintf(
__s: *mut ::std::os::raw::c_char,
__maxlen: ::std::os::raw::c_ulong,
__format: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn vasprintf(
__ptr: *mut *mut ::std::os::raw::c_char,
__f: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __asprintf(
__ptr: *mut *mut ::std::os::raw::c_char,
__fmt: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn asprintf(
__ptr: *mut *mut ::std::os::raw::c_char,
__fmt: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn vdprintf(
__fd: ::std::os::raw::c_int,
__fmt: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dprintf(
__fd: ::std::os::raw::c_int,
__fmt: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fscanf(
__stream: *mut FILE,
__format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn scanf(__format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sscanf(
__s: *const ::std::os::raw::c_char,
__format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}__isoc99_fscanf"]
pub fn fscanf1(
__stream: *mut FILE,
__format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}__isoc99_scanf"]
pub fn scanf1(__format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}__isoc99_sscanf"]
pub fn sscanf1(
__s: *const ::std::os::raw::c_char,
__format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn vfscanf(
__s: *mut FILE,
__format: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn vscanf(
__format: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn vsscanf(
__s: *const ::std::os::raw::c_char,
__format: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}__isoc99_vfscanf"]
pub fn vfscanf1(
__s: *mut FILE,
__format: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}__isoc99_vscanf"]
pub fn vscanf1(
__format: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}__isoc99_vsscanf"]
pub fn vsscanf1(
__s: *const ::std::os::raw::c_char,
__format: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fgetc(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn getc(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn getchar() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn getc_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn getchar_unlocked() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fgetc_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fputc(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn putc(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn putchar(__c: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fputc_unlocked(__c: ::std::os::raw::c_int, __stream: *mut FILE)
-> ::std::os::raw::c_int;
}
extern "C" {
pub fn putc_unlocked(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn putchar_unlocked(__c: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn getw(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn putw(__w: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fgets(
__s: *mut ::std::os::raw::c_char,
__n: ::std::os::raw::c_int,
__stream: *mut FILE,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn fgets_unlocked(
__s: *mut ::std::os::raw::c_char,
__n: ::std::os::raw::c_int,
__stream: *mut FILE,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn __getdelim(
__lineptr: *mut *mut ::std::os::raw::c_char,
__n: *mut size_t,
__delimiter: ::std::os::raw::c_int,
__stream: *mut FILE,
) -> __ssize_t;
}
extern "C" {
pub fn getdelim(
__lineptr: *mut *mut ::std::os::raw::c_char,
__n: *mut size_t,
__delimiter: ::std::os::raw::c_int,
__stream: *mut FILE,
) -> __ssize_t;
}
extern "C" {
pub fn getline(
__lineptr: *mut *mut ::std::os::raw::c_char,
__n: *mut size_t,
__stream: *mut FILE,
) -> __ssize_t;
}
extern "C" {
pub fn fputs(__s: *const ::std::os::raw::c_char, __stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn puts(__s: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ungetc(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fread(
__ptr: *mut ::std::os::raw::c_void,
__size: ::std::os::raw::c_ulong,
__n: ::std::os::raw::c_ulong,
__stream: *mut FILE,
) -> ::std::os::raw::c_ulong;
}
extern "C" {
pub fn fwrite(
__ptr: *const ::std::os::raw::c_void,
__size: ::std::os::raw::c_ulong,
__n: ::std::os::raw::c_ulong,
__s: *mut FILE,
) -> ::std::os::raw::c_ulong;
}
extern "C" {
pub fn fputs_unlocked(
__s: *const ::std::os::raw::c_char,
__stream: *mut FILE,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fread_unlocked(
__ptr: *mut ::std::os::raw::c_void,
__size: size_t,
__n: size_t,
__stream: *mut FILE,
) -> size_t;
}
extern "C" {
pub fn fwrite_unlocked(
__ptr: *const ::std::os::raw::c_void,
__size: size_t,
__n: size_t,
__stream: *mut FILE,
) -> size_t;
}
extern "C" {
pub fn fseek(
__stream: *mut FILE,
__off: ::std::os::raw::c_long,
__whence: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ftell(__stream: *mut FILE) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn rewind(__stream: *mut FILE);
}
extern "C" {
pub fn fseeko(
__stream: *mut FILE,
__off: __off_t,
__whence: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ftello(__stream: *mut FILE) -> __off_t;
}
extern "C" {
pub fn fgetpos(__stream: *mut FILE, __pos: *mut fpos_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fsetpos(__stream: *mut FILE, __pos: *const fpos_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fseeko64(
__stream: *mut FILE,
__off: __off64_t,
__whence: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ftello64(__stream: *mut FILE) -> __off64_t;
}
extern "C" {
pub fn fgetpos64(__stream: *mut FILE, __pos: *mut fpos64_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fsetpos64(__stream: *mut FILE, __pos: *const fpos64_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn clearerr(__stream: *mut FILE);
}
extern "C" {
pub fn feof(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ferror(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn clearerr_unlocked(__stream: *mut FILE);
}
extern "C" {
pub fn feof_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ferror_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn perror(__s: *const ::std::os::raw::c_char);
}
extern "C" {
pub static mut sys_nerr: ::std::os::raw::c_int;
}
extern "C" {
pub static mut sys_errlist: [*const ::std::os::raw::c_char; 0usize];
}
extern "C" {
pub static mut _sys_nerr: ::std::os::raw::c_int;
}
extern "C" {
pub static mut _sys_errlist: [*const ::std::os::raw::c_char; 0usize];
}
extern "C" {
pub fn fileno(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fileno_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn popen(
__command: *const ::std::os::raw::c_char,
__modes: *const ::std::os::raw::c_char,
) -> *mut FILE;
}
extern "C" {
pub fn pclose(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ctermid(__s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn cuserid(__s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct obstack {
_unused: [u8; 0],
}
extern "C" {
pub fn obstack_printf(
__obstack: *mut obstack,
__format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn obstack_vprintf(
__obstack: *mut obstack,
__format: *const ::std::os::raw::c_char,
__args: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn flockfile(__stream: *mut FILE);
}
extern "C" {
pub fn ftrylockfile(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn funlockfile(__stream: *mut FILE);
}
extern "C" {
pub fn __uflow(arg1: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __overflow(arg1: *mut FILE, arg2: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn memalign(__alignment: size_t, __size: size_t) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn pvalloc(__size: size_t) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub static mut __morecore:
::std::option::Option<unsafe extern "C" fn(__size: isize) -> *mut ::std::os::raw::c_void>;
}
extern "C" {
pub fn __default_morecore(__size: isize) -> *mut ::std::os::raw::c_void;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mallinfo {
pub arena: ::std::os::raw::c_int,
pub ordblks: ::std::os::raw::c_int,
pub smblks: ::std::os::raw::c_int,
pub hblks: ::std::os::raw::c_int,
pub hblkhd: ::std::os::raw::c_int,
pub usmblks: ::std::os::raw::c_int,
pub fsmblks: ::std::os::raw::c_int,
pub uordblks: ::std::os::raw::c_int,
pub fordblks: ::std::os::raw::c_int,
pub keepcost: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_mallinfo() {
assert_eq!(
::std::mem::size_of::<mallinfo>(),
40usize,
concat!("Size of: ", stringify!(mallinfo))
);
assert_eq!(
::std::mem::align_of::<mallinfo>(),
4usize,
concat!("Alignment of ", stringify!(mallinfo))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<mallinfo>())).arena as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(mallinfo),
"::",
stringify!(arena)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<mallinfo>())).ordblks as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(mallinfo),
"::",
stringify!(ordblks)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<mallinfo>())).smblks as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(mallinfo),
"::",
stringify!(smblks)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<mallinfo>())).hblks as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(mallinfo),
"::",
stringify!(hblks)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<mallinfo>())).hblkhd as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(mallinfo),
"::",
stringify!(hblkhd)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<mallinfo>())).usmblks as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(mallinfo),
"::",
stringify!(usmblks)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<mallinfo>())).fsmblks as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(mallinfo),
"::",
stringify!(fsmblks)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<mallinfo>())).uordblks as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(mallinfo),
"::",
stringify!(uordblks)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<mallinfo>())).fordblks as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(mallinfo),
"::",
stringify!(fordblks)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<mallinfo>())).keepcost as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(mallinfo),
"::",
stringify!(keepcost)
)
);
}
extern "C" {
pub fn mallinfo() -> mallinfo;
}
extern "C" {
pub fn mallopt(
__param: ::std::os::raw::c_int,
__val: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn malloc_trim(__pad: size_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn malloc_usable_size(__ptr: *mut ::std::os::raw::c_void) -> size_t;
}
extern "C" {
pub fn malloc_stats();
}
extern "C" {
pub fn malloc_info(__options: ::std::os::raw::c_int, __fp: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub static mut __free_hook: ::std::option::Option<
unsafe extern "C" fn(
__ptr: *mut ::std::os::raw::c_void,
arg1: *const ::std::os::raw::c_void,
),
>;
}
extern "C" {
pub static mut __malloc_hook: ::std::option::Option<
unsafe extern "C" fn(
__size: size_t,
arg1: *const ::std::os::raw::c_void,
) -> *mut ::std::os::raw::c_void,
>;
}
extern "C" {
pub static mut __realloc_hook: ::std::option::Option<
unsafe extern "C" fn(
__ptr: *mut ::std::os::raw::c_void,
__size: size_t,
arg1: *const ::std::os::raw::c_void,
) -> *mut ::std::os::raw::c_void,
>;
}
extern "C" {
pub static mut __memalign_hook: ::std::option::Option<
unsafe extern "C" fn(
__alignment: size_t,
__size: size_t,
arg1: *const ::std::os::raw::c_void,
) -> *mut ::std::os::raw::c_void,
>;
}
extern "C" {
pub static mut __after_morecore_hook: ::std::option::Option<unsafe extern "C" fn()>;
}
pub type __m64 = [::std::os::raw::c_longlong; 1usize];
pub type __v1di = [::std::os::raw::c_longlong; 1usize];
pub type __v2si = [::std::os::raw::c_int; 2usize];
pub type __v4hi = [::std::os::raw::c_short; 4usize];
pub type __v8qi = [::std::os::raw::c_char; 8usize];
pub type __v4si = [::std::os::raw::c_int; 4usize];
pub type __v4sf = [f32; 4usize];
pub type __m128 = [f32; 4usize];
pub type __m128_u = [f32; 4usize];
pub type __v4su = [::std::os::raw::c_uint; 4usize];
extern "C" {
pub fn _mm_sfence();
}
extern "C" {
pub fn _mm_getcsr() -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn _mm_setcsr(__i: ::std::os::raw::c_uint);
}
pub type __m128d = [f64; 2usize];
pub type __m128i = [::std::os::raw::c_longlong; 2usize];
pub type __m128d_u = [f64; 2usize];
pub type __m128i_u = [::std::os::raw::c_longlong; 2usize];
pub type __v2df = [f64; 2usize];
pub type __v2di = [::std::os::raw::c_longlong; 2usize];
pub type __v8hi = [::std::os::raw::c_short; 8usize];
pub type __v16qi = [::std::os::raw::c_char; 16usize];
pub type __v2du = [::std::os::raw::c_ulonglong; 2usize];
pub type __v8hu = [::std::os::raw::c_ushort; 8usize];
pub type __v16qu = [::std::os::raw::c_uchar; 16usize];
pub type __v16qs = [::std::os::raw::c_schar; 16usize];
extern "C" {
pub fn _mm_clflush(__p: *const ::std::os::raw::c_void);
}
extern "C" {
pub fn _mm_lfence();
}
extern "C" {
pub fn _mm_mfence();
}
extern "C" {
pub fn _mm_pause();
}
pub type __v4df = [f64; 4usize];
pub type __v8sf = [f32; 8usize];
pub type __v4di = [::std::os::raw::c_longlong; 4usize];
pub type __v8si = [::std::os::raw::c_int; 8usize];
pub type __v16hi = [::std::os::raw::c_short; 16usize];
pub type __v32qi = [::std::os::raw::c_char; 32usize];
pub type __v4du = [::std::os::raw::c_ulonglong; 4usize];
pub type __v8su = [::std::os::raw::c_uint; 8usize];
pub type __v16hu = [::std::os::raw::c_ushort; 16usize];
pub type __v32qu = [::std::os::raw::c_uchar; 32usize];
pub type __v32qs = [::std::os::raw::c_schar; 32usize];
pub type __m256 = [f32; 8usize];
pub type __m256d = [f64; 4usize];
pub type __m256i = [::std::os::raw::c_longlong; 4usize];
pub type __m256_u = [f32; 8usize];
pub type __m256d_u = [f64; 4usize];
pub type __m256i_u = [::std::os::raw::c_longlong; 4usize];
pub type __v64qi = [::std::os::raw::c_char; 64usize];
pub type __v32hi = [::std::os::raw::c_short; 32usize];
pub type __v8df = [f64; 8usize];
pub type __v16sf = [f32; 16usize];
pub type __v8di = [::std::os::raw::c_longlong; 8usize];
pub type __v16si = [::std::os::raw::c_int; 16usize];
pub type __v64qu = [::std::os::raw::c_uchar; 64usize];
pub type __v32hu = [::std::os::raw::c_ushort; 32usize];
pub type __v8du = [::std::os::raw::c_ulonglong; 8usize];
pub type __v16su = [::std::os::raw::c_uint; 16usize];
pub type __m512 = [f32; 16usize];
pub type __m512d = [f64; 8usize];
pub type __m512i = [::std::os::raw::c_longlong; 8usize];
pub type __m512_u = [f32; 16usize];
pub type __m512d_u = [f64; 8usize];
pub type __m512i_u = [::std::os::raw::c_longlong; 8usize];
pub type __mmask8 = ::std::os::raw::c_uchar;
pub type __mmask16 = ::std::os::raw::c_ushort;
pub const _MM_CMPINT_ENUM__MM_CMPINT_EQ: _MM_CMPINT_ENUM = 0;
pub const _MM_CMPINT_ENUM__MM_CMPINT_LT: _MM_CMPINT_ENUM = 1;
pub const _MM_CMPINT_ENUM__MM_CMPINT_LE: _MM_CMPINT_ENUM = 2;
pub const _MM_CMPINT_ENUM__MM_CMPINT_UNUSED: _MM_CMPINT_ENUM = 3;
pub const _MM_CMPINT_ENUM__MM_CMPINT_NE: _MM_CMPINT_ENUM = 4;
pub const _MM_CMPINT_ENUM__MM_CMPINT_NLT: _MM_CMPINT_ENUM = 5;
pub const _MM_CMPINT_ENUM__MM_CMPINT_NLE: _MM_CMPINT_ENUM = 6;
pub type _MM_CMPINT_ENUM = ::std::os::raw::c_uint;
pub const _MM_PERM_ENUM__MM_PERM_AAAA: _MM_PERM_ENUM = 0;
pub const _MM_PERM_ENUM__MM_PERM_AAAB: _MM_PERM_ENUM = 1;
pub const _MM_PERM_ENUM__MM_PERM_AAAC: _MM_PERM_ENUM = 2;
pub const _MM_PERM_ENUM__MM_PERM_AAAD: _MM_PERM_ENUM = 3;
pub const _MM_PERM_ENUM__MM_PERM_AABA: _MM_PERM_ENUM = 4;
pub const _MM_PERM_ENUM__MM_PERM_AABB: _MM_PERM_ENUM = 5;
pub const _MM_PERM_ENUM__MM_PERM_AABC: _MM_PERM_ENUM = 6;
pub const _MM_PERM_ENUM__MM_PERM_AABD: _MM_PERM_ENUM = 7;
pub const _MM_PERM_ENUM__MM_PERM_AACA: _MM_PERM_ENUM = 8;
pub const _MM_PERM_ENUM__MM_PERM_AACB: _MM_PERM_ENUM = 9;
pub const _MM_PERM_ENUM__MM_PERM_AACC: _MM_PERM_ENUM = 10;
pub const _MM_PERM_ENUM__MM_PERM_AACD: _MM_PERM_ENUM = 11;
pub const _MM_PERM_ENUM__MM_PERM_AADA: _MM_PERM_ENUM = 12;
pub const _MM_PERM_ENUM__MM_PERM_AADB: _MM_PERM_ENUM = 13;
pub const _MM_PERM_ENUM__MM_PERM_AADC: _MM_PERM_ENUM = 14;
pub const _MM_PERM_ENUM__MM_PERM_AADD: _MM_PERM_ENUM = 15;
pub const _MM_PERM_ENUM__MM_PERM_ABAA: _MM_PERM_ENUM = 16;
pub const _MM_PERM_ENUM__MM_PERM_ABAB: _MM_PERM_ENUM = 17;
pub const _MM_PERM_ENUM__MM_PERM_ABAC: _MM_PERM_ENUM = 18;
pub const _MM_PERM_ENUM__MM_PERM_ABAD: _MM_PERM_ENUM = 19;
pub const _MM_PERM_ENUM__MM_PERM_ABBA: _MM_PERM_ENUM = 20;
pub const _MM_PERM_ENUM__MM_PERM_ABBB: _MM_PERM_ENUM = 21;
pub const _MM_PERM_ENUM__MM_PERM_ABBC: _MM_PERM_ENUM = 22;
pub const _MM_PERM_ENUM__MM_PERM_ABBD: _MM_PERM_ENUM = 23;
pub const _MM_PERM_ENUM__MM_PERM_ABCA: _MM_PERM_ENUM = 24;
pub const _MM_PERM_ENUM__MM_PERM_ABCB: _MM_PERM_ENUM = 25;
pub const _MM_PERM_ENUM__MM_PERM_ABCC: _MM_PERM_ENUM = 26;
pub const _MM_PERM_ENUM__MM_PERM_ABCD: _MM_PERM_ENUM = 27;
pub const _MM_PERM_ENUM__MM_PERM_ABDA: _MM_PERM_ENUM = 28;
pub const _MM_PERM_ENUM__MM_PERM_ABDB: _MM_PERM_ENUM = 29;
pub const _MM_PERM_ENUM__MM_PERM_ABDC: _MM_PERM_ENUM = 30;
pub const _MM_PERM_ENUM__MM_PERM_ABDD: _MM_PERM_ENUM = 31;
pub const _MM_PERM_ENUM__MM_PERM_ACAA: _MM_PERM_ENUM = 32;
pub const _MM_PERM_ENUM__MM_PERM_ACAB: _MM_PERM_ENUM = 33;
pub const _MM_PERM_ENUM__MM_PERM_ACAC: _MM_PERM_ENUM = 34;
pub const _MM_PERM_ENUM__MM_PERM_ACAD: _MM_PERM_ENUM = 35;
pub const _MM_PERM_ENUM__MM_PERM_ACBA: _MM_PERM_ENUM = 36;
pub const _MM_PERM_ENUM__MM_PERM_ACBB: _MM_PERM_ENUM = 37;
pub const _MM_PERM_ENUM__MM_PERM_ACBC: _MM_PERM_ENUM = 38;
pub const _MM_PERM_ENUM__MM_PERM_ACBD: _MM_PERM_ENUM = 39;
pub const _MM_PERM_ENUM__MM_PERM_ACCA: _MM_PERM_ENUM = 40;
pub const _MM_PERM_ENUM__MM_PERM_ACCB: _MM_PERM_ENUM = 41;
pub const _MM_PERM_ENUM__MM_PERM_ACCC: _MM_PERM_ENUM = 42;
pub const _MM_PERM_ENUM__MM_PERM_ACCD: _MM_PERM_ENUM = 43;
pub const _MM_PERM_ENUM__MM_PERM_ACDA: _MM_PERM_ENUM = 44;
pub const _MM_PERM_ENUM__MM_PERM_ACDB: _MM_PERM_ENUM = 45;
pub const _MM_PERM_ENUM__MM_PERM_ACDC: _MM_PERM_ENUM = 46;
pub const _MM_PERM_ENUM__MM_PERM_ACDD: _MM_PERM_ENUM = 47;
pub const _MM_PERM_ENUM__MM_PERM_ADAA: _MM_PERM_ENUM = 48;
pub const _MM_PERM_ENUM__MM_PERM_ADAB: _MM_PERM_ENUM = 49;
pub const _MM_PERM_ENUM__MM_PERM_ADAC: _MM_PERM_ENUM = 50;
pub const _MM_PERM_ENUM__MM_PERM_ADAD: _MM_PERM_ENUM = 51;
pub const _MM_PERM_ENUM__MM_PERM_ADBA: _MM_PERM_ENUM = 52;
pub const _MM_PERM_ENUM__MM_PERM_ADBB: _MM_PERM_ENUM = 53;
pub const _MM_PERM_ENUM__MM_PERM_ADBC: _MM_PERM_ENUM = 54;
pub const _MM_PERM_ENUM__MM_PERM_ADBD: _MM_PERM_ENUM = 55;
pub const _MM_PERM_ENUM__MM_PERM_ADCA: _MM_PERM_ENUM = 56;
pub const _MM_PERM_ENUM__MM_PERM_ADCB: _MM_PERM_ENUM = 57;
pub const _MM_PERM_ENUM__MM_PERM_ADCC: _MM_PERM_ENUM = 58;
pub const _MM_PERM_ENUM__MM_PERM_ADCD: _MM_PERM_ENUM = 59;
pub const _MM_PERM_ENUM__MM_PERM_ADDA: _MM_PERM_ENUM = 60;
pub const _MM_PERM_ENUM__MM_PERM_ADDB: _MM_PERM_ENUM = 61;
pub const _MM_PERM_ENUM__MM_PERM_ADDC: _MM_PERM_ENUM = 62;
pub const _MM_PERM_ENUM__MM_PERM_ADDD: _MM_PERM_ENUM = 63;
pub const _MM_PERM_ENUM__MM_PERM_BAAA: _MM_PERM_ENUM = 64;
pub const _MM_PERM_ENUM__MM_PERM_BAAB: _MM_PERM_ENUM = 65;
pub const _MM_PERM_ENUM__MM_PERM_BAAC: _MM_PERM_ENUM = 66;
pub const _MM_PERM_ENUM__MM_PERM_BAAD: _MM_PERM_ENUM = 67;
pub const _MM_PERM_ENUM__MM_PERM_BABA: _MM_PERM_ENUM = 68;
pub const _MM_PERM_ENUM__MM_PERM_BABB: _MM_PERM_ENUM = 69;
pub const _MM_PERM_ENUM__MM_PERM_BABC: _MM_PERM_ENUM = 70;
pub const _MM_PERM_ENUM__MM_PERM_BABD: _MM_PERM_ENUM = 71;
pub const _MM_PERM_ENUM__MM_PERM_BACA: _MM_PERM_ENUM = 72;
pub const _MM_PERM_ENUM__MM_PERM_BACB: _MM_PERM_ENUM = 73;
pub const _MM_PERM_ENUM__MM_PERM_BACC: _MM_PERM_ENUM = 74;
pub const _MM_PERM_ENUM__MM_PERM_BACD: _MM_PERM_ENUM = 75;
pub const _MM_PERM_ENUM__MM_PERM_BADA: _MM_PERM_ENUM = 76;
pub const _MM_PERM_ENUM__MM_PERM_BADB: _MM_PERM_ENUM = 77;
pub const _MM_PERM_ENUM__MM_PERM_BADC: _MM_PERM_ENUM = 78;
pub const _MM_PERM_ENUM__MM_PERM_BADD: _MM_PERM_ENUM = 79;
pub const _MM_PERM_ENUM__MM_PERM_BBAA: _MM_PERM_ENUM = 80;
pub const _MM_PERM_ENUM__MM_PERM_BBAB: _MM_PERM_ENUM = 81;
pub const _MM_PERM_ENUM__MM_PERM_BBAC: _MM_PERM_ENUM = 82;
pub const _MM_PERM_ENUM__MM_PERM_BBAD: _MM_PERM_ENUM = 83;
pub const _MM_PERM_ENUM__MM_PERM_BBBA: _MM_PERM_ENUM = 84;
pub const _MM_PERM_ENUM__MM_PERM_BBBB: _MM_PERM_ENUM = 85;
pub const _MM_PERM_ENUM__MM_PERM_BBBC: _MM_PERM_ENUM = 86;
pub const _MM_PERM_ENUM__MM_PERM_BBBD: _MM_PERM_ENUM = 87;
pub const _MM_PERM_ENUM__MM_PERM_BBCA: _MM_PERM_ENUM = 88;
pub const _MM_PERM_ENUM__MM_PERM_BBCB: _MM_PERM_ENUM = 89;
pub const _MM_PERM_ENUM__MM_PERM_BBCC: _MM_PERM_ENUM = 90;
pub const _MM_PERM_ENUM__MM_PERM_BBCD: _MM_PERM_ENUM = 91;
pub const _MM_PERM_ENUM__MM_PERM_BBDA: _MM_PERM_ENUM = 92;
pub const _MM_PERM_ENUM__MM_PERM_BBDB: _MM_PERM_ENUM = 93;
pub const _MM_PERM_ENUM__MM_PERM_BBDC: _MM_PERM_ENUM = 94;
pub const _MM_PERM_ENUM__MM_PERM_BBDD: _MM_PERM_ENUM = 95;
pub const _MM_PERM_ENUM__MM_PERM_BCAA: _MM_PERM_ENUM = 96;
pub const _MM_PERM_ENUM__MM_PERM_BCAB: _MM_PERM_ENUM = 97;
pub const _MM_PERM_ENUM__MM_PERM_BCAC: _MM_PERM_ENUM = 98;
pub const _MM_PERM_ENUM__MM_PERM_BCAD: _MM_PERM_ENUM = 99;
pub const _MM_PERM_ENUM__MM_PERM_BCBA: _MM_PERM_ENUM = 100;
pub const _MM_PERM_ENUM__MM_PERM_BCBB: _MM_PERM_ENUM = 101;
pub const _MM_PERM_ENUM__MM_PERM_BCBC: _MM_PERM_ENUM = 102;
pub const _MM_PERM_ENUM__MM_PERM_BCBD: _MM_PERM_ENUM = 103;
pub const _MM_PERM_ENUM__MM_PERM_BCCA: _MM_PERM_ENUM = 104;
pub const _MM_PERM_ENUM__MM_PERM_BCCB: _MM_PERM_ENUM = 105;
pub const _MM_PERM_ENUM__MM_PERM_BCCC: _MM_PERM_ENUM = 106;
pub const _MM_PERM_ENUM__MM_PERM_BCCD: _MM_PERM_ENUM = 107;
pub const _MM_PERM_ENUM__MM_PERM_BCDA: _MM_PERM_ENUM = 108;
pub const _MM_PERM_ENUM__MM_PERM_BCDB: _MM_PERM_ENUM = 109;
pub const _MM_PERM_ENUM__MM_PERM_BCDC: _MM_PERM_ENUM = 110;
pub const _MM_PERM_ENUM__MM_PERM_BCDD: _MM_PERM_ENUM = 111;
pub const _MM_PERM_ENUM__MM_PERM_BDAA: _MM_PERM_ENUM = 112;
pub const _MM_PERM_ENUM__MM_PERM_BDAB: _MM_PERM_ENUM = 113;
pub const _MM_PERM_ENUM__MM_PERM_BDAC: _MM_PERM_ENUM = 114;
pub const _MM_PERM_ENUM__MM_PERM_BDAD: _MM_PERM_ENUM = 115;
pub const _MM_PERM_ENUM__MM_PERM_BDBA: _MM_PERM_ENUM = 116;
pub const _MM_PERM_ENUM__MM_PERM_BDBB: _MM_PERM_ENUM = 117;
pub const _MM_PERM_ENUM__MM_PERM_BDBC: _MM_PERM_ENUM = 118;
pub const _MM_PERM_ENUM__MM_PERM_BDBD: _MM_PERM_ENUM = 119;
pub const _MM_PERM_ENUM__MM_PERM_BDCA: _MM_PERM_ENUM = 120;
pub const _MM_PERM_ENUM__MM_PERM_BDCB: _MM_PERM_ENUM = 121;
pub const _MM_PERM_ENUM__MM_PERM_BDCC: _MM_PERM_ENUM = 122;
pub const _MM_PERM_ENUM__MM_PERM_BDCD: _MM_PERM_ENUM = 123;
pub const _MM_PERM_ENUM__MM_PERM_BDDA: _MM_PERM_ENUM = 124;
pub const _MM_PERM_ENUM__MM_PERM_BDDB: _MM_PERM_ENUM = 125;
pub const _MM_PERM_ENUM__MM_PERM_BDDC: _MM_PERM_ENUM = 126;
pub const _MM_PERM_ENUM__MM_PERM_BDDD: _MM_PERM_ENUM = 127;
pub const _MM_PERM_ENUM__MM_PERM_CAAA: _MM_PERM_ENUM = 128;
pub const _MM_PERM_ENUM__MM_PERM_CAAB: _MM_PERM_ENUM = 129;
pub const _MM_PERM_ENUM__MM_PERM_CAAC: _MM_PERM_ENUM = 130;
pub const _MM_PERM_ENUM__MM_PERM_CAAD: _MM_PERM_ENUM = 131;
pub const _MM_PERM_ENUM__MM_PERM_CABA: _MM_PERM_ENUM = 132;
pub const _MM_PERM_ENUM__MM_PERM_CABB: _MM_PERM_ENUM = 133;
pub const _MM_PERM_ENUM__MM_PERM_CABC: _MM_PERM_ENUM = 134;
pub const _MM_PERM_ENUM__MM_PERM_CABD: _MM_PERM_ENUM = 135;
pub const _MM_PERM_ENUM__MM_PERM_CACA: _MM_PERM_ENUM = 136;
pub const _MM_PERM_ENUM__MM_PERM_CACB: _MM_PERM_ENUM = 137;
pub const _MM_PERM_ENUM__MM_PERM_CACC: _MM_PERM_ENUM = 138;
pub const _MM_PERM_ENUM__MM_PERM_CACD: _MM_PERM_ENUM = 139;
pub const _MM_PERM_ENUM__MM_PERM_CADA: _MM_PERM_ENUM = 140;
pub const _MM_PERM_ENUM__MM_PERM_CADB: _MM_PERM_ENUM = 141;
pub const _MM_PERM_ENUM__MM_PERM_CADC: _MM_PERM_ENUM = 142;
pub const _MM_PERM_ENUM__MM_PERM_CADD: _MM_PERM_ENUM = 143;
pub const _MM_PERM_ENUM__MM_PERM_CBAA: _MM_PERM_ENUM = 144;
pub const _MM_PERM_ENUM__MM_PERM_CBAB: _MM_PERM_ENUM = 145;
pub const _MM_PERM_ENUM__MM_PERM_CBAC: _MM_PERM_ENUM = 146;
pub const _MM_PERM_ENUM__MM_PERM_CBAD: _MM_PERM_ENUM = 147;
pub const _MM_PERM_ENUM__MM_PERM_CBBA: _MM_PERM_ENUM = 148;
pub const _MM_PERM_ENUM__MM_PERM_CBBB: _MM_PERM_ENUM = 149;
pub const _MM_PERM_ENUM__MM_PERM_CBBC: _MM_PERM_ENUM = 150;
pub const _MM_PERM_ENUM__MM_PERM_CBBD: _MM_PERM_ENUM = 151;
pub const _MM_PERM_ENUM__MM_PERM_CBCA: _MM_PERM_ENUM = 152;
pub const _MM_PERM_ENUM__MM_PERM_CBCB: _MM_PERM_ENUM = 153;
pub const _MM_PERM_ENUM__MM_PERM_CBCC: _MM_PERM_ENUM = 154;
pub const _MM_PERM_ENUM__MM_PERM_CBCD: _MM_PERM_ENUM = 155;
pub const _MM_PERM_ENUM__MM_PERM_CBDA: _MM_PERM_ENUM = 156;
pub const _MM_PERM_ENUM__MM_PERM_CBDB: _MM_PERM_ENUM = 157;
pub const _MM_PERM_ENUM__MM_PERM_CBDC: _MM_PERM_ENUM = 158;
pub const _MM_PERM_ENUM__MM_PERM_CBDD: _MM_PERM_ENUM = 159;
pub const _MM_PERM_ENUM__MM_PERM_CCAA: _MM_PERM_ENUM = 160;
pub const _MM_PERM_ENUM__MM_PERM_CCAB: _MM_PERM_ENUM = 161;
pub const _MM_PERM_ENUM__MM_PERM_CCAC: _MM_PERM_ENUM = 162;
pub const _MM_PERM_ENUM__MM_PERM_CCAD: _MM_PERM_ENUM = 163;
pub const _MM_PERM_ENUM__MM_PERM_CCBA: _MM_PERM_ENUM = 164;
pub const _MM_PERM_ENUM__MM_PERM_CCBB: _MM_PERM_ENUM = 165;
pub const _MM_PERM_ENUM__MM_PERM_CCBC: _MM_PERM_ENUM = 166;
pub const _MM_PERM_ENUM__MM_PERM_CCBD: _MM_PERM_ENUM = 167;
pub const _MM_PERM_ENUM__MM_PERM_CCCA: _MM_PERM_ENUM = 168;
pub const _MM_PERM_ENUM__MM_PERM_CCCB: _MM_PERM_ENUM = 169;
pub const _MM_PERM_ENUM__MM_PERM_CCCC: _MM_PERM_ENUM = 170;
pub const _MM_PERM_ENUM__MM_PERM_CCCD: _MM_PERM_ENUM = 171;
pub const _MM_PERM_ENUM__MM_PERM_CCDA: _MM_PERM_ENUM = 172;
pub const _MM_PERM_ENUM__MM_PERM_CCDB: _MM_PERM_ENUM = 173;
pub const _MM_PERM_ENUM__MM_PERM_CCDC: _MM_PERM_ENUM = 174;
pub const _MM_PERM_ENUM__MM_PERM_CCDD: _MM_PERM_ENUM = 175;
pub const _MM_PERM_ENUM__MM_PERM_CDAA: _MM_PERM_ENUM = 176;
pub const _MM_PERM_ENUM__MM_PERM_CDAB: _MM_PERM_ENUM = 177;
pub const _MM_PERM_ENUM__MM_PERM_CDAC: _MM_PERM_ENUM = 178;
pub const _MM_PERM_ENUM__MM_PERM_CDAD: _MM_PERM_ENUM = 179;
pub const _MM_PERM_ENUM__MM_PERM_CDBA: _MM_PERM_ENUM = 180;
pub const _MM_PERM_ENUM__MM_PERM_CDBB: _MM_PERM_ENUM = 181;
pub const _MM_PERM_ENUM__MM_PERM_CDBC: _MM_PERM_ENUM = 182;
pub const _MM_PERM_ENUM__MM_PERM_CDBD: _MM_PERM_ENUM = 183;
pub const _MM_PERM_ENUM__MM_PERM_CDCA: _MM_PERM_ENUM = 184;
pub const _MM_PERM_ENUM__MM_PERM_CDCB: _MM_PERM_ENUM = 185;
pub const _MM_PERM_ENUM__MM_PERM_CDCC: _MM_PERM_ENUM = 186;
pub const _MM_PERM_ENUM__MM_PERM_CDCD: _MM_PERM_ENUM = 187;
pub const _MM_PERM_ENUM__MM_PERM_CDDA: _MM_PERM_ENUM = 188;
pub const _MM_PERM_ENUM__MM_PERM_CDDB: _MM_PERM_ENUM = 189;
pub const _MM_PERM_ENUM__MM_PERM_CDDC: _MM_PERM_ENUM = 190;
pub const _MM_PERM_ENUM__MM_PERM_CDDD: _MM_PERM_ENUM = 191;
pub const _MM_PERM_ENUM__MM_PERM_DAAA: _MM_PERM_ENUM = 192;
pub const _MM_PERM_ENUM__MM_PERM_DAAB: _MM_PERM_ENUM = 193;
pub const _MM_PERM_ENUM__MM_PERM_DAAC: _MM_PERM_ENUM = 194;
pub const _MM_PERM_ENUM__MM_PERM_DAAD: _MM_PERM_ENUM = 195;
pub const _MM_PERM_ENUM__MM_PERM_DABA: _MM_PERM_ENUM = 196;
pub const _MM_PERM_ENUM__MM_PERM_DABB: _MM_PERM_ENUM = 197;
pub const _MM_PERM_ENUM__MM_PERM_DABC: _MM_PERM_ENUM = 198;
pub const _MM_PERM_ENUM__MM_PERM_DABD: _MM_PERM_ENUM = 199;
pub const _MM_PERM_ENUM__MM_PERM_DACA: _MM_PERM_ENUM = 200;
pub const _MM_PERM_ENUM__MM_PERM_DACB: _MM_PERM_ENUM = 201;
pub const _MM_PERM_ENUM__MM_PERM_DACC: _MM_PERM_ENUM = 202;
pub const _MM_PERM_ENUM__MM_PERM_DACD: _MM_PERM_ENUM = 203;
pub const _MM_PERM_ENUM__MM_PERM_DADA: _MM_PERM_ENUM = 204;
pub const _MM_PERM_ENUM__MM_PERM_DADB: _MM_PERM_ENUM = 205;
pub const _MM_PERM_ENUM__MM_PERM_DADC: _MM_PERM_ENUM = 206;
pub const _MM_PERM_ENUM__MM_PERM_DADD: _MM_PERM_ENUM = 207;
pub const _MM_PERM_ENUM__MM_PERM_DBAA: _MM_PERM_ENUM = 208;
pub const _MM_PERM_ENUM__MM_PERM_DBAB: _MM_PERM_ENUM = 209;
pub const _MM_PERM_ENUM__MM_PERM_DBAC: _MM_PERM_ENUM = 210;
pub const _MM_PERM_ENUM__MM_PERM_DBAD: _MM_PERM_ENUM = 211;
pub const _MM_PERM_ENUM__MM_PERM_DBBA: _MM_PERM_ENUM = 212;
pub const _MM_PERM_ENUM__MM_PERM_DBBB: _MM_PERM_ENUM = 213;
pub const _MM_PERM_ENUM__MM_PERM_DBBC: _MM_PERM_ENUM = 214;
pub const _MM_PERM_ENUM__MM_PERM_DBBD: _MM_PERM_ENUM = 215;
pub const _MM_PERM_ENUM__MM_PERM_DBCA: _MM_PERM_ENUM = 216;
pub const _MM_PERM_ENUM__MM_PERM_DBCB: _MM_PERM_ENUM = 217;
pub const _MM_PERM_ENUM__MM_PERM_DBCC: _MM_PERM_ENUM = 218;
pub const _MM_PERM_ENUM__MM_PERM_DBCD: _MM_PERM_ENUM = 219;
pub const _MM_PERM_ENUM__MM_PERM_DBDA: _MM_PERM_ENUM = 220;
pub const _MM_PERM_ENUM__MM_PERM_DBDB: _MM_PERM_ENUM = 221;
pub const _MM_PERM_ENUM__MM_PERM_DBDC: _MM_PERM_ENUM = 222;
pub const _MM_PERM_ENUM__MM_PERM_DBDD: _MM_PERM_ENUM = 223;
pub const _MM_PERM_ENUM__MM_PERM_DCAA: _MM_PERM_ENUM = 224;
pub const _MM_PERM_ENUM__MM_PERM_DCAB: _MM_PERM_ENUM = 225;
pub const _MM_PERM_ENUM__MM_PERM_DCAC: _MM_PERM_ENUM = 226;
pub const _MM_PERM_ENUM__MM_PERM_DCAD: _MM_PERM_ENUM = 227;
pub const _MM_PERM_ENUM__MM_PERM_DCBA: _MM_PERM_ENUM = 228;
pub const _MM_PERM_ENUM__MM_PERM_DCBB: _MM_PERM_ENUM = 229;
pub const _MM_PERM_ENUM__MM_PERM_DCBC: _MM_PERM_ENUM = 230;
pub const _MM_PERM_ENUM__MM_PERM_DCBD: _MM_PERM_ENUM = 231;
pub const _MM_PERM_ENUM__MM_PERM_DCCA: _MM_PERM_ENUM = 232;
pub const _MM_PERM_ENUM__MM_PERM_DCCB: _MM_PERM_ENUM = 233;
pub const _MM_PERM_ENUM__MM_PERM_DCCC: _MM_PERM_ENUM = 234;
pub const _MM_PERM_ENUM__MM_PERM_DCCD: _MM_PERM_ENUM = 235;
pub const _MM_PERM_ENUM__MM_PERM_DCDA: _MM_PERM_ENUM = 236;
pub const _MM_PERM_ENUM__MM_PERM_DCDB: _MM_PERM_ENUM = 237;
pub const _MM_PERM_ENUM__MM_PERM_DCDC: _MM_PERM_ENUM = 238;
pub const _MM_PERM_ENUM__MM_PERM_DCDD: _MM_PERM_ENUM = 239;
pub const _MM_PERM_ENUM__MM_PERM_DDAA: _MM_PERM_ENUM = 240;
pub const _MM_PERM_ENUM__MM_PERM_DDAB: _MM_PERM_ENUM = 241;
pub const _MM_PERM_ENUM__MM_PERM_DDAC: _MM_PERM_ENUM = 242;
pub const _MM_PERM_ENUM__MM_PERM_DDAD: _MM_PERM_ENUM = 243;
pub const _MM_PERM_ENUM__MM_PERM_DDBA: _MM_PERM_ENUM = 244;
pub const _MM_PERM_ENUM__MM_PERM_DDBB: _MM_PERM_ENUM = 245;
pub const _MM_PERM_ENUM__MM_PERM_DDBC: _MM_PERM_ENUM = 246;
pub const _MM_PERM_ENUM__MM_PERM_DDBD: _MM_PERM_ENUM = 247;
pub const _MM_PERM_ENUM__MM_PERM_DDCA: _MM_PERM_ENUM = 248;
pub const _MM_PERM_ENUM__MM_PERM_DDCB: _MM_PERM_ENUM = 249;
pub const _MM_PERM_ENUM__MM_PERM_DDCC: _MM_PERM_ENUM = 250;
pub const _MM_PERM_ENUM__MM_PERM_DDCD: _MM_PERM_ENUM = 251;
pub const _MM_PERM_ENUM__MM_PERM_DDDA: _MM_PERM_ENUM = 252;
pub const _MM_PERM_ENUM__MM_PERM_DDDB: _MM_PERM_ENUM = 253;
pub const _MM_PERM_ENUM__MM_PERM_DDDC: _MM_PERM_ENUM = 254;
pub const _MM_PERM_ENUM__MM_PERM_DDDD: _MM_PERM_ENUM = 255;
pub type _MM_PERM_ENUM = ::std::os::raw::c_uint;
pub const _MM_MANTISSA_NORM_ENUM__MM_MANT_NORM_1_2: _MM_MANTISSA_NORM_ENUM = 0;
pub const _MM_MANTISSA_NORM_ENUM__MM_MANT_NORM_p5_2: _MM_MANTISSA_NORM_ENUM = 1;
pub const _MM_MANTISSA_NORM_ENUM__MM_MANT_NORM_p5_1: _MM_MANTISSA_NORM_ENUM = 2;
pub const _MM_MANTISSA_NORM_ENUM__MM_MANT_NORM_p75_1p5: _MM_MANTISSA_NORM_ENUM = 3;
pub type _MM_MANTISSA_NORM_ENUM = ::std::os::raw::c_uint;
pub const _MM_MANTISSA_SIGN_ENUM__MM_MANT_SIGN_src: _MM_MANTISSA_SIGN_ENUM = 0;
pub const _MM_MANTISSA_SIGN_ENUM__MM_MANT_SIGN_zero: _MM_MANTISSA_SIGN_ENUM = 1;
pub const _MM_MANTISSA_SIGN_ENUM__MM_MANT_SIGN_nan: _MM_MANTISSA_SIGN_ENUM = 2;
pub type _MM_MANTISSA_SIGN_ENUM = ::std::os::raw::c_uint;
pub type __v2hi = [::std::os::raw::c_short; 2usize];
pub type __v4qi = [::std::os::raw::c_char; 4usize];
pub type __v2qi = [::std::os::raw::c_char; 2usize];
pub type __mmask32 = ::std::os::raw::c_uint;
pub type __mmask64 = ::std::os::raw::c_ulonglong;
pub type __m512bh = [::std::os::raw::c_short; 32usize];
pub type __m256bh = [::std::os::raw::c_short; 16usize];
pub type __bfloat16 = ::std::os::raw::c_ushort;
pub type __m128bh = [::std::os::raw::c_short; 8usize];
pub type __v2sf = [f32; 2usize];
pub const ARRAY_LAZY_LOWERBOUND: ::std::os::raw::c_uint = 1024;
#[doc = "During lazy computations, we can transform array containers into bitset"]
#[doc = "containers as"]
#[doc = "long as we can expect them to have ARRAY_LAZY_LOWERBOUND values."]
pub type _bindgen_ty_2 = ::std::os::raw::c_uint;
pub const RUN_DEFAULT_INIT_SIZE: ::std::os::raw::c_uint = 0;
pub type _bindgen_ty_3 = ::std::os::raw::c_uint;
pub const ARRAY_DEFAULT_INIT_SIZE: ::std::os::raw::c_uint = 0;
pub type _bindgen_ty_4 = ::std::os::raw::c_uint;
extern "C" {
pub fn binarySearch(array: *const u16, lenarray: i32, ikey: u16) -> i32;
}
extern "C" {
#[doc = " From Schlegel et al., Fast Sorted-Set Intersection using SIMD Instructions"]
#[doc = " Optimized by D. Lemire on May 3rd 2013"]
#[doc = ""]
#[doc = " C should have capacity greater than the minimum of s_1 and s_b + 8"]
#[doc = " where 8 is sizeof(__m128i)/sizeof(uint16_t)."]
pub fn intersect_vector16(
A: *const u16,
s_a: size_t,
B: *const u16,
s_b: size_t,
C: *mut u16,
) -> i32;
}
extern "C" {
#[doc = " Compute the cardinality of the intersection using SSE4 instructions"]
pub fn intersect_vector16_cardinality(
A: *const u16,
s_a: size_t,
B: *const u16,
s_b: size_t,
) -> i32;
}
extern "C" {
pub fn intersect_skewed_uint16(
smallarray: *const u16,
size_s: size_t,
largearray: *const u16,
size_l: size_t,
buffer: *mut u16,
) -> i32;
}
extern "C" {
pub fn intersect_skewed_uint16_cardinality(
smallarray: *const u16,
size_s: size_t,
largearray: *const u16,
size_l: size_t,
) -> i32;
}
extern "C" {
pub fn intersect_skewed_uint16_nonempty(
smallarray: *const u16,
size_s: size_t,
largearray: *const u16,
size_l: size_t,
) -> bool;
}
extern "C" {
#[doc = " Generic intersection function."]
pub fn intersect_uint16(
A: *const u16,
lenA: size_t,
B: *const u16,
lenB: size_t,
out: *mut u16,
) -> i32;
}
extern "C" {
#[doc = " Compute the size of the intersection (generic)."]
pub fn intersect_uint16_cardinality(
A: *const u16,
lenA: size_t,
B: *const u16,
lenB: size_t,
) -> i32;
}
extern "C" {
#[doc = " Checking whether the size of the intersection is non-zero."]
pub fn intersect_uint16_nonempty(
A: *const u16,
lenA: size_t,
B: *const u16,
lenB: size_t,
) -> bool;
}
extern "C" {
#[doc = " Generic union function."]
pub fn union_uint16(
set_1: *const u16,
size_1: size_t,
set_2: *const u16,
size_2: size_t,
buffer: *mut u16,
) -> size_t;
}
extern "C" {
#[doc = " Generic XOR function."]
pub fn xor_uint16(
array_1: *const u16,
card_1: i32,
array_2: *const u16,
card_2: i32,
out: *mut u16,
) -> i32;
}
extern "C" {
#[doc = " Generic difference function (ANDNOT)."]
pub fn difference_uint16(
a1: *const u16,
length1: ::std::os::raw::c_int,
a2: *const u16,
length2: ::std::os::raw::c_int,
a_out: *mut u16,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Generic intersection function."]
pub fn intersection_uint32(
A: *const u32,
lenA: size_t,
B: *const u32,
lenB: size_t,
out: *mut u32,
) -> size_t;
}
extern "C" {
#[doc = " Generic intersection function, returns just the cardinality."]
pub fn intersection_uint32_card(
A: *const u32,
lenA: size_t,
B: *const u32,
lenB: size_t,
) -> size_t;
}
extern "C" {
#[doc = " Generic union function."]
pub fn union_uint32(
set_1: *const u32,
size_1: size_t,
set_2: *const u32,
size_2: size_t,
buffer: *mut u32,
) -> size_t;
}
extern "C" {
#[doc = " A fast SSE-based union function."]
pub fn union_vector16(
set_1: *const u16,
size_1: u32,
set_2: *const u16,
size_2: u32,
buffer: *mut u16,
) -> u32;
}
extern "C" {
#[doc = " A fast SSE-based XOR function."]
pub fn xor_vector16(
array1: *const u16,
length1: u32,
array2: *const u16,
length2: u32,
output: *mut u16,
) -> u32;
}
extern "C" {
#[doc = " A fast SSE-based difference function."]
pub fn difference_vector16(
A: *const u16,
s_a: size_t,
B: *const u16,
s_b: size_t,
C: *mut u16,
) -> i32;
}
extern "C" {
#[doc = " Generic union function, returns just the cardinality."]
pub fn union_uint32_card(
set_1: *const u32,
size_1: size_t,
set_2: *const u32,
size_2: size_t,
) -> size_t;
}
extern "C" {
#[doc = " combines union_uint16 and union_vector16 optimally"]
pub fn fast_union_uint16(
set_1: *const u16,
size_1: size_t,
set_2: *const u16,
size_2: size_t,
buffer: *mut u16,
) -> size_t;
}
extern "C" {
pub fn memequals(
s1: *const ::std::os::raw::c_void,
s2: *const ::std::os::raw::c_void,
n: size_t,
) -> bool;
}
pub type roaring_iterator = ::std::option::Option<
unsafe extern "C" fn(value: u32, param: *mut ::std::os::raw::c_void) -> bool,
>;
pub type roaring_iterator64 = ::std::option::Option<
unsafe extern "C" fn(value: u64, param: *mut ::std::os::raw::c_void) -> bool,
>;
#[doc = " (For advanced users.)"]
#[doc = " The roaring_statistics_t can be used to collect detailed statistics about"]
#[doc = " the composition of a roaring bitmap."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct roaring_statistics_s {
pub n_containers: u32,
pub n_array_containers: u32,
pub n_run_containers: u32,
pub n_bitset_containers: u32,
pub n_values_array_containers: u32,
pub n_values_run_containers: u32,
pub n_values_bitset_containers: u32,
pub n_bytes_array_containers: u32,
pub n_bytes_run_containers: u32,
pub n_bytes_bitset_containers: u32,
pub max_value: u32,
pub min_value: u32,
pub sum_value: u64,
pub cardinality: u64,
}
#[test]
fn bindgen_test_layout_roaring_statistics_s() {
assert_eq!(
::std::mem::size_of::<roaring_statistics_s>(),
64usize,
concat!("Size of: ", stringify!(roaring_statistics_s))
);
assert_eq!(
::std::mem::align_of::<roaring_statistics_s>(),
8usize,
concat!("Alignment of ", stringify!(roaring_statistics_s))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<roaring_statistics_s>())).n_containers as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(roaring_statistics_s),
"::",
stringify!(n_containers)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<roaring_statistics_s>())).n_array_containers as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(roaring_statistics_s),
"::",
stringify!(n_array_containers)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<roaring_statistics_s>())).n_run_containers as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(roaring_statistics_s),
"::",
stringify!(n_run_containers)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<roaring_statistics_s>())).n_bitset_containers as *const _
as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(roaring_statistics_s),
"::",
stringify!(n_bitset_containers)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<roaring_statistics_s>())).n_values_array_containers as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(roaring_statistics_s),
"::",
stringify!(n_values_array_containers)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<roaring_statistics_s>())).n_values_run_containers as *const _
as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(roaring_statistics_s),
"::",
stringify!(n_values_run_containers)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<roaring_statistics_s>())).n_values_bitset_containers as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(roaring_statistics_s),
"::",
stringify!(n_values_bitset_containers)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<roaring_statistics_s>())).n_bytes_array_containers as *const _
as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(roaring_statistics_s),
"::",
stringify!(n_bytes_array_containers)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<roaring_statistics_s>())).n_bytes_run_containers as *const _
as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(roaring_statistics_s),
"::",
stringify!(n_bytes_run_containers)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<roaring_statistics_s>())).n_bytes_bitset_containers as *const _
as usize
},
36usize,
concat!(
"Offset of field: ",
stringify!(roaring_statistics_s),
"::",
stringify!(n_bytes_bitset_containers)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<roaring_statistics_s>())).max_value as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(roaring_statistics_s),
"::",
stringify!(max_value)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<roaring_statistics_s>())).min_value as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(roaring_statistics_s),
"::",
stringify!(min_value)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<roaring_statistics_s>())).sum_value as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(roaring_statistics_s),
"::",
stringify!(sum_value)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<roaring_statistics_s>())).cardinality as *const _ as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(roaring_statistics_s),
"::",
stringify!(cardinality)
)
);
}
#[doc = " (For advanced users.)"]
#[doc = " The roaring_statistics_t can be used to collect detailed statistics about"]
#[doc = " the composition of a roaring bitmap."]
pub type roaring_statistics_t = roaring_statistics_s;
extern "C" {
pub fn bitset_extract_setbits_avx2(
bitset: *mut u64,
length: size_t,
vout: *mut ::std::os::raw::c_void,
outcapacity: size_t,
base: u32,
) -> size_t;
}
extern "C" {
pub fn bitset_extract_setbits(
bitset: *mut u64,
length: size_t,
vout: *mut ::std::os::raw::c_void,
base: u32,
) -> size_t;
}
extern "C" {
pub fn bitset_extract_setbits_sse_uint16(
bitset: *const u64,
length: size_t,
out: *mut u16,
outcapacity: size_t,
base: u16,
) -> size_t;
}
extern "C" {
pub fn bitset_extract_setbits_uint16(
bitset: *const u64,
length: size_t,
out: *mut u16,
base: u16,
) -> size_t;
}
extern "C" {
pub fn bitset_extract_intersection_setbits_uint16(
bitset1: *const u64,
bitset2: *const u64,
length: size_t,
out: *mut u16,
base: u16,
) -> size_t;
}
extern "C" {
pub fn bitset_set_list_withcard(
bitset: *mut ::std::os::raw::c_void,
card: u64,
list: *const u16,
length: u64,
) -> u64;
}
extern "C" {
pub fn bitset_set_list(bitset: *mut ::std::os::raw::c_void, list: *const u16, length: u64);
}
extern "C" {
pub fn bitset_clear_list(
bitset: *mut ::std::os::raw::c_void,
card: u64,
list: *const u16,
length: u64,
) -> u64;
}
extern "C" {
pub fn bitset_flip_list_withcard(
bitset: *mut ::std::os::raw::c_void,
card: u64,
list: *const u16,
length: u64,
) -> u64;
}
extern "C" {
pub fn bitset_flip_list(bitset: *mut ::std::os::raw::c_void, list: *const u16, length: u64);
}
extern "C" {
pub fn memcpy(
__dest: *mut ::std::os::raw::c_void,
__src: *const ::std::os::raw::c_void,
__n: ::std::os::raw::c_ulong,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn memmove(
__dest: *mut ::std::os::raw::c_void,
__src: *const ::std::os::raw::c_void,
__n: ::std::os::raw::c_ulong,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn memccpy(
__dest: *mut ::std::os::raw::c_void,
__src: *const ::std::os::raw::c_void,
__c: ::std::os::raw::c_int,
__n: ::std::os::raw::c_ulong,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn memset(
__s: *mut ::std::os::raw::c_void,
__c: ::std::os::raw::c_int,
__n: ::std::os::raw::c_ulong,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn memcmp(
__s1: *const ::std::os::raw::c_void,
__s2: *const ::std::os::raw::c_void,
__n: ::std::os::raw::c_ulong,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn memchr(
__s: *const ::std::os::raw::c_void,
__c: ::std::os::raw::c_int,
__n: ::std::os::raw::c_ulong,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn rawmemchr(
__s: *const ::std::os::raw::c_void,
__c: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn memrchr(
__s: *const ::std::os::raw::c_void,
__c: ::std::os::raw::c_int,
__n: size_t,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn strcpy(
__dest: *mut ::std::os::raw::c_char,
__src: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strncpy(
__dest: *mut ::std::os::raw::c_char,
__src: *const ::std::os::raw::c_char,
__n: ::std::os::raw::c_ulong,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strcat(
__dest: *mut ::std::os::raw::c_char,
__src: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strncat(
__dest: *mut ::std::os::raw::c_char,
__src: *const ::std::os::raw::c_char,
__n: ::std::os::raw::c_ulong,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strcmp(
__s1: *const ::std::os::raw::c_char,
__s2: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn strncmp(
__s1: *const ::std::os::raw::c_char,
__s2: *const ::std::os::raw::c_char,
__n: ::std::os::raw::c_ulong,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn strcoll(
__s1: *const ::std::os::raw::c_char,
__s2: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn strxfrm(
__dest: *mut ::std::os::raw::c_char,
__src: *const ::std::os::raw::c_char,
__n: ::std::os::raw::c_ulong,
) -> ::std::os::raw::c_ulong;
}
extern "C" {
pub fn strcoll_l(
__s1: *const ::std::os::raw::c_char,
__s2: *const ::std::os::raw::c_char,
__l: locale_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn strxfrm_l(
__dest: *mut ::std::os::raw::c_char,
__src: *const ::std::os::raw::c_char,
__n: size_t,
__l: locale_t,
) -> size_t;
}
extern "C" {
pub fn strdup(__s: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strndup(
__string: *const ::std::os::raw::c_char,
__n: ::std::os::raw::c_ulong,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strchr(
__s: *const ::std::os::raw::c_char,
__c: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strrchr(
__s: *const ::std::os::raw::c_char,
__c: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strchrnul(
__s: *const ::std::os::raw::c_char,
__c: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strcspn(
__s: *const ::std::os::raw::c_char,
__reject: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_ulong;
}
extern "C" {
pub fn strspn(
__s: *const ::std::os::raw::c_char,
__accept: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_ulong;
}
extern "C" {
pub fn strpbrk(
__s: *const ::std::os::raw::c_char,
__accept: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strstr(
__haystack: *const ::std::os::raw::c_char,
__needle: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strtok(
__s: *mut ::std::os::raw::c_char,
__delim: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn __strtok_r(
__s: *mut ::std::os::raw::c_char,
__delim: *const ::std::os::raw::c_char,
__save_ptr: *mut *mut ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strtok_r(
__s: *mut ::std::os::raw::c_char,
__delim: *const ::std::os::raw::c_char,
__save_ptr: *mut *mut ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strcasestr(
__haystack: *const ::std::os::raw::c_char,
__needle: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn memmem(
__haystack: *const ::std::os::raw::c_void,
__haystacklen: size_t,
__needle: *const ::std::os::raw::c_void,
__needlelen: size_t,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn __mempcpy(
__dest: *mut ::std::os::raw::c_void,
__src: *const ::std::os::raw::c_void,
__n: size_t,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn mempcpy(
__dest: *mut ::std::os::raw::c_void,
__src: *const ::std::os::raw::c_void,
__n: ::std::os::raw::c_ulong,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn strlen(__s: *const ::std::os::raw::c_char) -> ::std::os::raw::c_ulong;
}
extern "C" {
pub fn strnlen(__string: *const ::std::os::raw::c_char, __maxlen: size_t) -> size_t;
}
extern "C" {
pub fn strerror(__errnum: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strerror_r(
__errnum: ::std::os::raw::c_int,
__buf: *mut ::std::os::raw::c_char,
__buflen: size_t,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strerror_l(
__errnum: ::std::os::raw::c_int,
__l: locale_t,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn bcmp(
__s1: *const ::std::os::raw::c_void,
__s2: *const ::std::os::raw::c_void,
__n: ::std::os::raw::c_ulong,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn bcopy(
__src: *const ::std::os::raw::c_void,
__dest: *mut ::std::os::raw::c_void,
__n: size_t,
);
}
extern "C" {
pub fn bzero(__s: *mut ::std::os::raw::c_void, __n: ::std::os::raw::c_ulong);
}
extern "C" {
pub fn index(
__s: *const ::std::os::raw::c_char,
__c: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn rindex(
__s: *const ::std::os::raw::c_char,
__c: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn ffs(__i: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ffsl(__l: ::std::os::raw::c_long) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ffsll(__ll: ::std::os::raw::c_longlong) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn strcasecmp(
__s1: *const ::std::os::raw::c_char,
__s2: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn strncasecmp(
__s1: *const ::std::os::raw::c_char,
__s2: *const ::std::os::raw::c_char,
__n: ::std::os::raw::c_ulong,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn strcasecmp_l(
__s1: *const ::std::os::raw::c_char,
__s2: *const ::std::os::raw::c_char,
__loc: locale_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn strncasecmp_l(
__s1: *const ::std::os::raw::c_char,
__s2: *const ::std::os::raw::c_char,
__n: size_t,
__loc: locale_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn explicit_bzero(__s: *mut ::std::os::raw::c_void, __n: size_t);
}
extern "C" {
pub fn strsep(
__stringp: *mut *mut ::std::os::raw::c_char,
__delim: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strsignal(__sig: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn __stpcpy(
__dest: *mut ::std::os::raw::c_char,
__src: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn stpcpy(
__dest: *mut ::std::os::raw::c_char,
__src: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn __stpncpy(
__dest: *mut ::std::os::raw::c_char,
__src: *const ::std::os::raw::c_char,
__n: size_t,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn stpncpy(
__dest: *mut ::std::os::raw::c_char,
__src: *const ::std::os::raw::c_char,
__n: ::std::os::raw::c_ulong,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strverscmp(
__s1: *const ::std::os::raw::c_char,
__s2: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn strfry(__string: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn memfrob(__s: *mut ::std::os::raw::c_void, __n: size_t) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn basename(__filename: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
pub const DEFAULT_MAX_SIZE: ::std::os::raw::c_uint = 4096;
pub type _bindgen_ty_5 = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct array_container_s {
pub cardinality: i32,
pub capacity: i32,
pub array: *mut u16,
}
#[test]
fn bindgen_test_layout_array_container_s() {
assert_eq!(
::std::mem::size_of::<array_container_s>(),
16usize,
concat!("Size of: ", stringify!(array_container_s))
);
assert_eq!(
::std::mem::align_of::<array_container_s>(),
8usize,
concat!("Alignment of ", stringify!(array_container_s))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<array_container_s>())).cardinality as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(array_container_s),
"::",
stringify!(cardinality)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<array_container_s>())).capacity as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(array_container_s),
"::",
stringify!(capacity)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<array_container_s>())).array as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(array_container_s),
"::",
stringify!(array)
)
);
}
pub type array_container_t = array_container_s;
extern "C" {
pub fn array_container_create() -> *mut array_container_t;
}
extern "C" {
pub fn array_container_create_given_capacity(size: i32) -> *mut array_container_t;
}
extern "C" {
pub fn array_container_create_range(min: u32, max: u32) -> *mut array_container_t;
}
extern "C" {
pub fn array_container_shrink_to_fit(src: *mut array_container_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn array_container_free(array: *mut array_container_t);
}
extern "C" {
pub fn array_container_clone(src: *const array_container_t) -> *mut array_container_t;
}
extern "C" {
pub fn array_container_serialize(
container: *const array_container_t,
buf: *mut ::std::os::raw::c_char,
) -> i32;
}
extern "C" {
pub fn array_container_serialization_len(container: *const array_container_t) -> u32;
}
extern "C" {
pub fn array_container_deserialize(
buf: *const ::std::os::raw::c_char,
buf_len: size_t,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn array_container_copy(src: *const array_container_t, dst: *mut array_container_t);
}
extern "C" {
pub fn array_container_add_from_range(
arr: *mut array_container_t,
min: u32,
max: u32,
step: u16,
);
}
extern "C" {
pub fn array_container_union(
src_1: *const array_container_t,
src_2: *const array_container_t,
dst: *mut array_container_t,
);
}
extern "C" {
pub fn array_container_xor(
array_1: *const array_container_t,
array_2: *const array_container_t,
out: *mut array_container_t,
);
}
extern "C" {
pub fn array_container_intersection(
src_1: *const array_container_t,
src_2: *const array_container_t,
dst: *mut array_container_t,
);
}
extern "C" {
pub fn array_container_intersect(
src_1: *const array_container_t,
src_2: *const array_container_t,
) -> bool;
}
extern "C" {
pub fn array_container_intersection_cardinality(
src_1: *const array_container_t,
src_2: *const array_container_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn array_container_intersection_inplace(
src_1: *mut array_container_t,
src_2: *const array_container_t,
);
}
extern "C" {
pub fn array_container_to_uint32_array(
vout: *mut ::std::os::raw::c_void,
cont: *const array_container_t,
base: u32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn array_container_number_of_runs(a: *const array_container_t) -> i32;
}
extern "C" {
pub fn array_container_printf(v: *const array_container_t);
}
extern "C" {
pub fn array_container_printf_as_uint32_array(v: *const array_container_t, base: u32);
}
extern "C" {
#[doc = " Increase capacity to at least min."]
#[doc = " Whether the existing data needs to be copied over depends on the \"preserve\""]
#[doc = " parameter. If preserve is false, then the new content will be uninitialized,"]
#[doc = " otherwise the old content is copied."]
pub fn array_container_grow(container: *mut array_container_t, min: i32, preserve: bool);
}
extern "C" {
pub fn array_container_iterate(
cont: *const array_container_t,
base: u32,
iterator: roaring_iterator,
ptr: *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn array_container_iterate64(
cont: *const array_container_t,
base: u32,
iterator: roaring_iterator64,
high_bits: u64,
ptr: *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
#[doc = " Writes the underlying array to buf, outputs how many bytes were written."]
#[doc = " This is meant to be byte-by-byte compatible with the Java and Go versions of"]
#[doc = " Roaring."]
#[doc = " The number of bytes written should be"]
#[doc = " array_container_size_in_bytes(container)."]
#[doc = ""]
pub fn array_container_write(
container: *const array_container_t,
buf: *mut ::std::os::raw::c_char,
) -> i32;
}
extern "C" {
#[doc = " Reads the instance from buf, outputs how many bytes were read."]
#[doc = " This is meant to be byte-by-byte compatible with the Java and Go versions of"]
#[doc = " Roaring."]
#[doc = " The number of bytes read should be array_container_size_in_bytes(container)."]
#[doc = " You need to provide the (known) cardinality."]
pub fn array_container_read(
cardinality: i32,
container: *mut array_container_t,
buf: *const ::std::os::raw::c_char,
) -> i32;
}
extern "C" {
#[doc = " Return true if container1 is a subset of container2."]
pub fn array_container_is_subset(
container1: *const array_container_t,
container2: *const array_container_t,
) -> bool;
}
extern "C" {
pub fn array_container_andnot(
array_1: *const array_container_t,
array_2: *const array_container_t,
out: *mut array_container_t,
);
}
extern "C" {
pub fn array_container_contains(arr: *const array_container_t, pos: u16) -> bool;
}
extern "C" {
pub fn array_container_minimum(arr: *const array_container_t) -> u16;
}
extern "C" {
pub fn array_container_maximum(arr: *const array_container_t) -> u16;
}
extern "C" {
pub fn array_container_rank(arr: *const array_container_t, x: u16) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn array_container_index_equalorlarger(
arr: *const array_container_t,
x: u16,
) -> ::std::os::raw::c_int;
}
pub const BITSET_CONTAINER_SIZE_IN_WORDS: ::std::os::raw::c_int = 1024;
pub const BITSET_UNKNOWN_CARDINALITY: ::std::os::raw::c_int = -1;
pub type _bindgen_ty_6 = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bitset_container_s {
pub cardinality: i32,
pub array: *mut u64,
}
#[test]
fn bindgen_test_layout_bitset_container_s() {
assert_eq!(
::std::mem::size_of::<bitset_container_s>(),
16usize,
concat!("Size of: ", stringify!(bitset_container_s))
);
assert_eq!(
::std::mem::align_of::<bitset_container_s>(),
8usize,
concat!("Alignment of ", stringify!(bitset_container_s))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<bitset_container_s>())).cardinality as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(bitset_container_s),
"::",
stringify!(cardinality)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<bitset_container_s>())).array as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(bitset_container_s),
"::",
stringify!(array)
)
);
}
pub type bitset_container_t = bitset_container_s;
extern "C" {
pub fn bitset_container_create() -> *mut bitset_container_t;
}
extern "C" {
pub fn bitset_container_free(bitset: *mut bitset_container_t);
}
extern "C" {
pub fn bitset_container_clear(bitset: *mut bitset_container_t);
}
extern "C" {
pub fn bitset_container_set_all(bitset: *mut bitset_container_t);
}
extern "C" {
pub fn bitset_container_clone(src: *const bitset_container_t) -> *mut bitset_container_t;
}
extern "C" {
pub fn bitset_container_serialize(
container: *const bitset_container_t,
buf: *mut ::std::os::raw::c_char,
) -> i32;
}
extern "C" {
pub fn bitset_container_serialization_len() -> u32;
}
extern "C" {
pub fn bitset_container_deserialize(
buf: *const ::std::os::raw::c_char,
buf_len: size_t,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn bitset_container_set_range(bitset: *mut bitset_container_t, begin: u32, end: u32);
}
extern "C" {
pub fn bitset_container_get(bitset: *const bitset_container_t, pos: u16) -> bool;
}
extern "C" {
pub fn bitset_container_contains(bitset: *const bitset_container_t, pos: u16) -> bool;
}
extern "C" {
pub fn bitset_container_copy(source: *const bitset_container_t, dest: *mut bitset_container_t);
}
extern "C" {
pub fn bitset_container_add_from_range(
bitset: *mut bitset_container_t,
min: u32,
max: u32,
step: u16,
);
}
extern "C" {
pub fn bitset_container_compute_cardinality(
bitset: *const bitset_container_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn bitset_container_intersect(
src_1: *const bitset_container_t,
src_2: *const bitset_container_t,
) -> bool;
}
extern "C" {
pub fn bitset_container_or(
src_1: *const bitset_container_t,
src_2: *const bitset_container_t,
dst: *mut bitset_container_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn bitset_container_or_justcard(
src_1: *const bitset_container_t,
src_2: *const bitset_container_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn bitset_container_union(
src_1: *const bitset_container_t,
src_2: *const bitset_container_t,
dst: *mut bitset_container_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn bitset_container_union_justcard(
src_1: *const bitset_container_t,
src_2: *const bitset_container_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn bitset_container_or_nocard(
src_1: *const bitset_container_t,
src_2: *const bitset_container_t,
dst: *mut bitset_container_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn bitset_container_and(
src_1: *const bitset_container_t,
src_2: *const bitset_container_t,
dst: *mut bitset_container_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn bitset_container_and_justcard(
src_1: *const bitset_container_t,
src_2: *const bitset_container_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn bitset_container_intersection(
src_1: *const bitset_container_t,
src_2: *const bitset_container_t,
dst: *mut bitset_container_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn bitset_container_intersection_justcard(
src_1: *const bitset_container_t,
src_2: *const bitset_container_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn bitset_container_and_nocard(
src_1: *const bitset_container_t,
src_2: *const bitset_container_t,
dst: *mut bitset_container_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn bitset_container_xor(
src_1: *const bitset_container_t,
src_2: *const bitset_container_t,
dst: *mut bitset_container_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn bitset_container_xor_justcard(
src_1: *const bitset_container_t,
src_2: *const bitset_container_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn bitset_container_xor_nocard(
src_1: *const bitset_container_t,
src_2: *const bitset_container_t,
dst: *mut bitset_container_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn bitset_container_andnot(
src_1: *const bitset_container_t,
src_2: *const bitset_container_t,
dst: *mut bitset_container_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn bitset_container_andnot_justcard(
src_1: *const bitset_container_t,
src_2: *const bitset_container_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn bitset_container_andnot_nocard(
src_1: *const bitset_container_t,
src_2: *const bitset_container_t,
dst: *mut bitset_container_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn bitset_container_to_uint32_array(
out: *mut ::std::os::raw::c_void,
cont: *const bitset_container_t,
base: u32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn bitset_container_printf(v: *const bitset_container_t);
}
extern "C" {
pub fn bitset_container_printf_as_uint32_array(v: *const bitset_container_t, base: u32);
}
extern "C" {
#[doc = " Return the the number of runs."]
pub fn bitset_container_number_of_runs(b: *mut bitset_container_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn bitset_container_iterate(
cont: *const bitset_container_t,
base: u32,
iterator: roaring_iterator,
ptr: *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn bitset_container_iterate64(
cont: *const bitset_container_t,
base: u32,
iterator: roaring_iterator64,
high_bits: u64,
ptr: *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
#[doc = " Writes the underlying array to buf, outputs how many bytes were written."]
#[doc = " This is meant to be byte-by-byte compatible with the Java and Go versions of"]
#[doc = " Roaring."]
#[doc = " The number of bytes written should be"]
#[doc = " bitset_container_size_in_bytes(container)."]
pub fn bitset_container_write(
container: *const bitset_container_t,
buf: *mut ::std::os::raw::c_char,
) -> i32;
}
extern "C" {
#[doc = " Reads the instance from buf, outputs how many bytes were read."]
#[doc = " This is meant to be byte-by-byte compatible with the Java and Go versions of"]
#[doc = " Roaring."]
#[doc = " The number of bytes read should be bitset_container_size_in_bytes(container)."]
#[doc = " You need to provide the (known) cardinality."]
pub fn bitset_container_read(
cardinality: i32,
container: *mut bitset_container_t,
buf: *const ::std::os::raw::c_char,
) -> i32;
}
extern "C" {
#[doc = " Return true if the two containers have the same content."]
pub fn bitset_container_equals(
container1: *const bitset_container_t,
container2: *const bitset_container_t,
) -> bool;
}
extern "C" {
#[doc = " Return true if container1 is a subset of container2."]
pub fn bitset_container_is_subset(
container1: *const bitset_container_t,
container2: *const bitset_container_t,
) -> bool;
}
extern "C" {
#[doc = " If the element of given rank is in this container, supposing that the first"]
#[doc = " element has rank start_rank, then the function returns true and sets element"]
#[doc = " accordingly."]
#[doc = " Otherwise, it returns false and update start_rank."]
pub fn bitset_container_select(
container: *const bitset_container_t,
start_rank: *mut u32,
rank: u32,
element: *mut u32,
) -> bool;
}
extern "C" {
pub fn bitset_container_minimum(container: *const bitset_container_t) -> u16;
}
extern "C" {
pub fn bitset_container_maximum(container: *const bitset_container_t) -> u16;
}
extern "C" {
pub fn bitset_container_rank(
container: *const bitset_container_t,
x: u16,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn bitset_container_index_equalorlarger(
container: *const bitset_container_t,
x: u16,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __assert_fail(
__assertion: *const ::std::os::raw::c_char,
__file: *const ::std::os::raw::c_char,
__line: ::std::os::raw::c_uint,
__function: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn __assert_perror_fail(
__errnum: ::std::os::raw::c_int,
__file: *const ::std::os::raw::c_char,
__line: ::std::os::raw::c_uint,
__function: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn __assert(
__assertion: *const ::std::os::raw::c_char,
__file: *const ::std::os::raw::c_char,
__line: ::std::os::raw::c_int,
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rle16_s {
pub value: u16,
pub length: u16,
}
#[test]
fn bindgen_test_layout_rle16_s() {
assert_eq!(
::std::mem::size_of::<rle16_s>(),
4usize,
concat!("Size of: ", stringify!(rle16_s))
);
assert_eq!(
::std::mem::align_of::<rle16_s>(),
2usize,
concat!("Alignment of ", stringify!(rle16_s))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<rle16_s>())).value as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rle16_s),
"::",
stringify!(value)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<rle16_s>())).length as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(rle16_s),
"::",
stringify!(length)
)
);
}
pub type rle16_t = rle16_s;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct run_container_s {
pub n_runs: i32,
pub capacity: i32,
pub runs: *mut rle16_t,
}
#[test]
fn bindgen_test_layout_run_container_s() {
assert_eq!(
::std::mem::size_of::<run_container_s>(),
16usize,
concat!("Size of: ", stringify!(run_container_s))
);
assert_eq!(
::std::mem::align_of::<run_container_s>(),
8usize,
concat!("Alignment of ", stringify!(run_container_s))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<run_container_s>())).n_runs as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(run_container_s),
"::",
stringify!(n_runs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<run_container_s>())).capacity as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(run_container_s),
"::",
stringify!(capacity)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<run_container_s>())).runs as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(run_container_s),
"::",
stringify!(runs)
)
);
}
pub type run_container_t = run_container_s;
extern "C" {
pub fn run_container_create() -> *mut run_container_t;
}
extern "C" {
pub fn run_container_create_given_capacity(size: i32) -> *mut run_container_t;
}
extern "C" {
pub fn run_container_shrink_to_fit(src: *mut run_container_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn run_container_free(run: *mut run_container_t);
}
extern "C" {
pub fn run_container_clone(src: *const run_container_t) -> *mut run_container_t;
}
extern "C" {
pub fn run_container_serialize(
container: *const run_container_t,
buf: *mut ::std::os::raw::c_char,
) -> i32;
}
extern "C" {
pub fn run_container_serialization_len(container: *const run_container_t) -> u32;
}
extern "C" {
pub fn run_container_deserialize(
buf: *const ::std::os::raw::c_char,
buf_len: size_t,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
#[doc = " Good old binary search through rle data"]
pub fn interleavedBinarySearch(array: *const rle16_t, lenarray: i32, ikey: u16) -> i32;
}
extern "C" {
#[doc = " increase capacity to at least min. Whether the"]
#[doc = " existing data needs to be copied over depends on copy. If \"copy\" is false,"]
#[doc = " then the new content will be uninitialized, otherwise a copy is made."]
pub fn run_container_grow(run: *mut run_container_t, min: i32, copy: bool);
}
extern "C" {
pub fn run_container_add(run: *mut run_container_t, pos: u16) -> bool;
}
extern "C" {
pub fn run_container_contains(run: *const run_container_t, pos: u16) -> bool;
}
extern "C" {
pub fn run_container_copy(src: *const run_container_t, dst: *mut run_container_t);
}
extern "C" {
pub fn run_container_union(
src_1: *const run_container_t,
src_2: *const run_container_t,
dst: *mut run_container_t,
);
}
extern "C" {
pub fn run_container_union_inplace(src_1: *mut run_container_t, src_2: *const run_container_t);
}
extern "C" {
pub fn run_container_intersection(
src_1: *const run_container_t,
src_2: *const run_container_t,
dst: *mut run_container_t,
);
}
extern "C" {
pub fn run_container_intersection_cardinality(
src_1: *const run_container_t,
src_2: *const run_container_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn run_container_intersect(
src_1: *const run_container_t,
src_2: *const run_container_t,
) -> bool;
}
extern "C" {
pub fn run_container_xor(
src_1: *const run_container_t,
src_2: *const run_container_t,
dst: *mut run_container_t,
);
}
extern "C" {
pub fn run_container_to_uint32_array(
vout: *mut ::std::os::raw::c_void,
cont: *const run_container_t,
base: u32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn run_container_printf(v: *const run_container_t);
}
extern "C" {
pub fn run_container_printf_as_uint32_array(v: *const run_container_t, base: u32);
}
extern "C" {
pub fn run_container_iterate(
cont: *const run_container_t,
base: u32,
iterator: roaring_iterator,
ptr: *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn run_container_iterate64(
cont: *const run_container_t,
base: u32,
iterator: roaring_iterator64,
high_bits: u64,
ptr: *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
#[doc = " Writes the underlying array to buf, outputs how many bytes were written."]
#[doc = " This is meant to be byte-by-byte compatible with the Java and Go versions of"]
#[doc = " Roaring."]
#[doc = " The number of bytes written should be run_container_size_in_bytes(container)."]
pub fn run_container_write(
container: *const run_container_t,
buf: *mut ::std::os::raw::c_char,
) -> i32;
}
extern "C" {
#[doc = " Reads the instance from buf, outputs how many bytes were read."]
#[doc = " This is meant to be byte-by-byte compatible with the Java and Go versions of"]
#[doc = " Roaring."]
#[doc = " The number of bytes read should be bitset_container_size_in_bytes(container)."]
#[doc = " The cardinality parameter is provided for consistency with other containers,"]
#[doc = " but"]
#[doc = " it might be effectively ignored.."]
pub fn run_container_read(
cardinality: i32,
container: *mut run_container_t,
buf: *const ::std::os::raw::c_char,
) -> i32;
}
extern "C" {
#[doc = " Return true if container1 is a subset of container2."]
pub fn run_container_is_subset(
container1: *const run_container_t,
container2: *const run_container_t,
) -> bool;
}
extern "C" {
#[doc = " Used in a start-finish scan that appends segments, for XOR and NOT"]
pub fn run_container_smart_append_exclusive(src: *mut run_container_t, start: u16, length: u16);
}
extern "C" {
#[doc = " If the element of given rank is in this container, supposing that the first"]
#[doc = " element has rank start_rank, then the function returns true and sets element"]
#[doc = " accordingly."]
#[doc = " Otherwise, it returns false and update start_rank."]
pub fn run_container_select(
container: *const run_container_t,
start_rank: *mut u32,
rank: u32,
element: *mut u32,
) -> bool;
}
extern "C" {
pub fn run_container_andnot(
src_1: *const run_container_t,
src_2: *const run_container_t,
dst: *mut run_container_t,
);
}
extern "C" {
pub fn run_container_minimum(run: *const run_container_t) -> u16;
}
extern "C" {
pub fn run_container_maximum(run: *const run_container_t) -> u16;
}
extern "C" {
pub fn run_container_rank(arr: *const run_container_t, x: u16) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn run_container_index_equalorlarger(
arr: *const run_container_t,
x: u16,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn bitset_container_from_array(arr: *const array_container_t) -> *mut bitset_container_t;
}
extern "C" {
pub fn bitset_container_from_run(arr: *const run_container_t) -> *mut bitset_container_t;
}
extern "C" {
pub fn array_container_from_run(arr: *const run_container_t) -> *mut array_container_t;
}
extern "C" {
pub fn array_container_from_bitset(bits: *const bitset_container_t) -> *mut array_container_t;
}
extern "C" {
pub fn run_container_from_array(c: *const array_container_t) -> *mut run_container_t;
}
extern "C" {
pub fn convert_to_bitset_or_array_container(
r: *mut run_container_t,
card: i32,
resulttype: *mut u8,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn convert_run_optimize(
c: *mut ::std::os::raw::c_void,
typecode_original: u8,
typecode_after: *mut u8,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn convert_run_to_efficient_container(
c: *mut run_container_t,
typecode_after: *mut u8,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn convert_run_to_efficient_container_and_free(
c: *mut run_container_t,
typecode_after: *mut u8,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
#[doc = " Create new bitset container which is a union of run container and"]
#[doc = " range [min, max]. Caller is responsible for freeing run container."]
pub fn bitset_container_from_run_range(
run: *const run_container_t,
min: u32,
max: u32,
) -> *mut bitset_container_t;
}
extern "C" {
#[doc = " Return true if the two containers have the same content."]
pub fn array_container_equal_bitset(
container1: *const array_container_t,
container2: *const bitset_container_t,
) -> bool;
}
extern "C" {
#[doc = " Return true if the two containers have the same content."]
pub fn run_container_equals_array(
container1: *const run_container_t,
container2: *const array_container_t,
) -> bool;
}
extern "C" {
#[doc = " Return true if the two containers have the same content."]
pub fn run_container_equals_bitset(
container1: *const run_container_t,
container2: *const bitset_container_t,
) -> bool;
}
extern "C" {
#[doc = " Return true if container1 is a subset of container2."]
pub fn array_container_is_subset_bitset(
container1: *const array_container_t,
container2: *const bitset_container_t,
) -> bool;
}
extern "C" {
#[doc = " Return true if container1 is a subset of container2."]
pub fn run_container_is_subset_array(
container1: *const run_container_t,
container2: *const array_container_t,
) -> bool;
}
extern "C" {
#[doc = " Return true if container1 is a subset of container2."]
pub fn array_container_is_subset_run(
container1: *const array_container_t,
container2: *const run_container_t,
) -> bool;
}
extern "C" {
#[doc = " Return true if container1 is a subset of container2."]
pub fn run_container_is_subset_bitset(
container1: *const run_container_t,
container2: *const bitset_container_t,
) -> bool;
}
extern "C" {
#[doc = " Return true if container1 is a subset of container2."]
pub fn bitset_container_is_subset_run(
container1: *const bitset_container_t,
container2: *const run_container_t,
) -> bool;
}
extern "C" {
pub fn array_bitset_container_andnot(
src_1: *const array_container_t,
src_2: *const bitset_container_t,
dst: *mut array_container_t,
);
}
extern "C" {
pub fn array_bitset_container_iandnot(
src_1: *mut array_container_t,
src_2: *const bitset_container_t,
);
}
extern "C" {
pub fn bitset_array_container_andnot(
src_1: *const bitset_container_t,
src_2: *const array_container_t,
dst: *mut *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn bitset_array_container_iandnot(
src_1: *mut bitset_container_t,
src_2: *const array_container_t,
dst: *mut *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn run_bitset_container_andnot(
src_1: *const run_container_t,
src_2: *const bitset_container_t,
dst: *mut *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn run_bitset_container_iandnot(
src_1: *mut run_container_t,
src_2: *const bitset_container_t,
dst: *mut *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn bitset_run_container_andnot(
src_1: *const bitset_container_t,
src_2: *const run_container_t,
dst: *mut *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn bitset_run_container_iandnot(
src_1: *mut bitset_container_t,
src_2: *const run_container_t,
dst: *mut *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn run_array_container_andnot(
src_1: *const run_container_t,
src_2: *const array_container_t,
dst: *mut *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn run_array_container_iandnot(
src_1: *mut run_container_t,
src_2: *const array_container_t,
dst: *mut *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn array_run_container_andnot(
src_1: *const array_container_t,
src_2: *const run_container_t,
dst: *mut array_container_t,
);
}
extern "C" {
pub fn array_run_container_iandnot(
src_1: *mut array_container_t,
src_2: *const run_container_t,
);
}
extern "C" {
pub fn run_run_container_andnot(
src_1: *const run_container_t,
src_2: *const run_container_t,
dst: *mut *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn run_run_container_iandnot(
src_1: *mut run_container_t,
src_2: *const run_container_t,
dst: *mut *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn array_array_container_andnot(
src_1: *const array_container_t,
src_2: *const array_container_t,
dst: *mut array_container_t,
);
}
extern "C" {
pub fn array_array_container_iandnot(
src_1: *mut array_container_t,
src_2: *const array_container_t,
);
}
extern "C" {
pub fn bitset_bitset_container_andnot(
src_1: *const bitset_container_t,
src_2: *const bitset_container_t,
dst: *mut *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn bitset_bitset_container_iandnot(
src_1: *mut bitset_container_t,
src_2: *const bitset_container_t,
dst: *mut *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn array_bitset_container_intersection(
src_1: *const array_container_t,
src_2: *const bitset_container_t,
dst: *mut array_container_t,
);
}
extern "C" {
pub fn array_bitset_container_intersection_cardinality(
src_1: *const array_container_t,
src_2: *const bitset_container_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn array_bitset_container_intersect(
src_1: *const array_container_t,
src_2: *const bitset_container_t,
) -> bool;
}
extern "C" {
pub fn bitset_bitset_container_intersection(
src_1: *const bitset_container_t,
src_2: *const bitset_container_t,
dst: *mut *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn array_run_container_intersection(
src_1: *const array_container_t,
src_2: *const run_container_t,
dst: *mut array_container_t,
);
}
extern "C" {
pub fn run_bitset_container_intersection(
src_1: *const run_container_t,
src_2: *const bitset_container_t,
dst: *mut *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn array_run_container_intersection_cardinality(
src_1: *const array_container_t,
src_2: *const run_container_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn run_bitset_container_intersection_cardinality(
src_1: *const run_container_t,
src_2: *const bitset_container_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn array_run_container_intersect(
src_1: *const array_container_t,
src_2: *const run_container_t,
) -> bool;
}
extern "C" {
pub fn run_bitset_container_intersect(
src_1: *const run_container_t,
src_2: *const bitset_container_t,
) -> bool;
}
extern "C" {
pub fn bitset_bitset_container_intersection_inplace(
src_1: *mut bitset_container_t,
src_2: *const bitset_container_t,
dst: *mut *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn array_container_negation(src: *const array_container_t, dst: *mut bitset_container_t);
}
extern "C" {
pub fn bitset_container_negation(
src: *const bitset_container_t,
dst: *mut *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn bitset_container_negation_inplace(
src: *mut bitset_container_t,
dst: *mut *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn run_container_negation(
src: *const run_container_t,
dst: *mut *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn run_container_negation_inplace(
src: *mut run_container_t,
dst: *mut *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn array_container_negation_range(
src: *const array_container_t,
range_start: ::std::os::raw::c_int,
range_end: ::std::os::raw::c_int,
dst: *mut *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn array_container_negation_range_inplace(
src: *mut array_container_t,
range_start: ::std::os::raw::c_int,
range_end: ::std::os::raw::c_int,
dst: *mut *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn bitset_container_negation_range(
src: *const bitset_container_t,
range_start: ::std::os::raw::c_int,
range_end: ::std::os::raw::c_int,
dst: *mut *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn bitset_container_negation_range_inplace(
src: *mut bitset_container_t,
range_start: ::std::os::raw::c_int,
range_end: ::std::os::raw::c_int,
dst: *mut *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn run_container_negation_range(
src: *const run_container_t,
range_start: ::std::os::raw::c_int,
range_end: ::std::os::raw::c_int,
dst: *mut *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn run_container_negation_range_inplace(
src: *mut run_container_t,
range_start: ::std::os::raw::c_int,
range_end: ::std::os::raw::c_int,
dst: *mut *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn array_bitset_container_union(
src_1: *const array_container_t,
src_2: *const bitset_container_t,
dst: *mut bitset_container_t,
);
}
extern "C" {
pub fn array_bitset_container_lazy_union(
src_1: *const array_container_t,
src_2: *const bitset_container_t,
dst: *mut bitset_container_t,
);
}
extern "C" {
pub fn array_array_container_union(
src_1: *const array_container_t,
src_2: *const array_container_t,
dst: *mut *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn array_array_container_inplace_union(
src_1: *mut array_container_t,
src_2: *const array_container_t,
dst: *mut *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn array_array_container_lazy_union(
src_1: *const array_container_t,
src_2: *const array_container_t,
dst: *mut *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn array_array_container_lazy_inplace_union(
src_1: *mut array_container_t,
src_2: *const array_container_t,
dst: *mut *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn array_run_container_union(
src_1: *const array_container_t,
src_2: *const run_container_t,
dst: *mut run_container_t,
);
}
extern "C" {
pub fn array_run_container_inplace_union(
src_1: *const array_container_t,
src_2: *mut run_container_t,
);
}
extern "C" {
pub fn run_bitset_container_union(
src_1: *const run_container_t,
src_2: *const bitset_container_t,
dst: *mut bitset_container_t,
);
}
extern "C" {
pub fn run_bitset_container_lazy_union(
src_1: *const run_container_t,
src_2: *const bitset_container_t,
dst: *mut bitset_container_t,
);
}
extern "C" {
pub fn array_bitset_container_xor(
src_1: *const array_container_t,
src_2: *const bitset_container_t,
dst: *mut *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn array_bitset_container_lazy_xor(
src_1: *const array_container_t,
src_2: *const bitset_container_t,
dst: *mut bitset_container_t,
);
}
extern "C" {
pub fn bitset_bitset_container_xor(
src_1: *const bitset_container_t,
src_2: *const bitset_container_t,
dst: *mut *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn run_bitset_container_xor(
src_1: *const run_container_t,
src_2: *const bitset_container_t,
dst: *mut *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn run_bitset_container_lazy_xor(
src_1: *const run_container_t,
src_2: *const bitset_container_t,
dst: *mut bitset_container_t,
);
}
extern "C" {
pub fn array_run_container_xor(
src_1: *const array_container_t,
src_2: *const run_container_t,
dst: *mut *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn array_array_container_xor(
src_1: *const array_container_t,
src_2: *const array_container_t,
dst: *mut *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn array_array_container_lazy_xor(
src_1: *const array_container_t,
src_2: *const array_container_t,
dst: *mut *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn array_run_container_lazy_xor(
src_1: *const array_container_t,
src_2: *const run_container_t,
dst: *mut run_container_t,
);
}
extern "C" {
pub fn run_run_container_xor(
src_1: *const run_container_t,
src_2: *const run_container_t,
dst: *mut *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn bitset_array_container_ixor(
src_1: *mut bitset_container_t,
src_2: *const array_container_t,
dst: *mut *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn bitset_bitset_container_ixor(
src_1: *mut bitset_container_t,
src_2: *const bitset_container_t,
dst: *mut *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn array_bitset_container_ixor(
src_1: *mut array_container_t,
src_2: *const bitset_container_t,
dst: *mut *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn run_bitset_container_ixor(
src_1: *mut run_container_t,
src_2: *const bitset_container_t,
dst: *mut *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn bitset_run_container_ixor(
src_1: *mut bitset_container_t,
src_2: *const run_container_t,
dst: *mut *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn array_run_container_ixor(
src_1: *mut array_container_t,
src_2: *const run_container_t,
dst: *mut *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn run_array_container_ixor(
src_1: *mut run_container_t,
src_2: *const array_container_t,
dst: *mut *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn array_array_container_ixor(
src_1: *mut array_container_t,
src_2: *const array_container_t,
dst: *mut *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn run_run_container_ixor(
src_1: *mut run_container_t,
src_2: *const run_container_t,
dst: *mut *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
#[doc = " A shared container is a wrapper around a container"]
#[doc = " with reference counting."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct shared_container_s {
pub container: *mut ::std::os::raw::c_void,
pub typecode: u8,
pub counter: u32,
}
#[test]
fn bindgen_test_layout_shared_container_s() {
assert_eq!(
::std::mem::size_of::<shared_container_s>(),
16usize,
concat!("Size of: ", stringify!(shared_container_s))
);
assert_eq!(
::std::mem::align_of::<shared_container_s>(),
8usize,
concat!("Alignment of ", stringify!(shared_container_s))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<shared_container_s>())).container as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(shared_container_s),
"::",
stringify!(container)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<shared_container_s>())).typecode as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(shared_container_s),
"::",
stringify!(typecode)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<shared_container_s>())).counter as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(shared_container_s),
"::",
stringify!(counter)
)
);
}
pub type shared_container_t = shared_container_s;
extern "C" {
pub fn get_copy_of_container(
container: *mut ::std::os::raw::c_void,
typecode: *mut u8,
copy_on_write: bool,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn shared_container_free(container: *mut shared_container_t);
}
extern "C" {
pub fn shared_container_extract_copy(
container: *mut shared_container_t,
typecode: *mut u8,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn container_unwrap_shared(
candidate_shared_container: *const ::std::os::raw::c_void,
type_: *mut u8,
) -> *const ::std::os::raw::c_void;
}
extern "C" {
pub fn container_mutable_unwrap_shared(
candidate_shared_container: *mut ::std::os::raw::c_void,
type_: *mut u8,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
#[doc = " Copies a container, requires a typecode. This allocates new memory, caller"]
#[doc = " is responsible for deallocation. If the container is not shared, then it is"]
#[doc = " physically cloned. Sharable containers are not cloneable."]
pub fn container_clone(
container: *const ::std::os::raw::c_void,
typecode: u8,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub static mut container_names: [*const ::std::os::raw::c_char; 4usize];
}
extern "C" {
pub static mut shared_container_names: [*const ::std::os::raw::c_char; 3usize];
}
extern "C" {
#[doc = " print the container (useful for debugging), requires a typecode"]
pub fn container_printf(container: *const ::std::os::raw::c_void, typecode: u8);
}
extern "C" {
#[doc = " print the content of the container as a comma-separated list of 32-bit values"]
#[doc = " starting at base, requires a typecode"]
pub fn container_printf_as_uint32_array(
container: *const ::std::os::raw::c_void,
typecode: u8,
base: u32,
);
}
extern "C" {
#[doc = " Recover memory from a container, requires a typecode"]
pub fn container_free(container: *mut ::std::os::raw::c_void, typecode: u8);
}
extern "C" {
#[doc = " Check whether a value is in a container, requires a typecode"]
pub fn container_contains(
container: *const ::std::os::raw::c_void,
val: u16,
typecode: u8,
) -> bool;
}
extern "C" {
pub fn container_serialize(
container: *const ::std::os::raw::c_void,
typecode: u8,
buf: *mut ::std::os::raw::c_char,
) -> i32;
}
extern "C" {
pub fn container_serialization_len(
container: *const ::std::os::raw::c_void,
typecode: u8,
) -> u32;
}
extern "C" {
pub fn container_deserialize(
typecode: u8,
buf: *const ::std::os::raw::c_char,
buf_len: size_t,
) -> *mut ::std::os::raw::c_void;
}
pub const SERIAL_COOKIE_NO_RUNCONTAINER: ::std::os::raw::c_uint = 12346;
pub const SERIAL_COOKIE: ::std::os::raw::c_uint = 12347;
pub const FROZEN_COOKIE: ::std::os::raw::c_uint = 13766;
pub const NO_OFFSET_THRESHOLD: ::std::os::raw::c_uint = 4;
pub type _bindgen_ty_7 = ::std::os::raw::c_uint;
#[doc = " Roaring arrays are array-based key-value pairs having containers as values"]
#[doc = " and 16-bit integer keys. A roaring bitmap might be implemented as such."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct roaring_array_s {
pub size: i32,
pub allocation_size: i32,
pub containers: *mut *mut ::std::os::raw::c_void,
pub keys: *mut u16,
pub typecodes: *mut u8,
pub flags: u8,
}
#[test]
fn bindgen_test_layout_roaring_array_s() {
assert_eq!(
::std::mem::size_of::<roaring_array_s>(),
40usize,
concat!("Size of: ", stringify!(roaring_array_s))
);
assert_eq!(
::std::mem::align_of::<roaring_array_s>(),
8usize,
concat!("Alignment of ", stringify!(roaring_array_s))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<roaring_array_s>())).size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(roaring_array_s),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<roaring_array_s>())).allocation_size as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(roaring_array_s),
"::",
stringify!(allocation_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<roaring_array_s>())).containers as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(roaring_array_s),
"::",
stringify!(containers)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<roaring_array_s>())).keys as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(roaring_array_s),
"::",
stringify!(keys)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<roaring_array_s>())).typecodes as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(roaring_array_s),
"::",
stringify!(typecodes)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<roaring_array_s>())).flags as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(roaring_array_s),
"::",
stringify!(flags)
)
);
}
#[doc = " Roaring arrays are array-based key-value pairs having containers as values"]
#[doc = " and 16-bit integer keys. A roaring bitmap might be implemented as such."]
pub type roaring_array_t = roaring_array_s;
extern "C" {
#[doc = " Create a new roaring array"]
pub fn ra_create() -> *mut roaring_array_t;
}
extern "C" {
#[doc = " Initialize an existing roaring array with the specified capacity (in number"]
#[doc = " of containers)"]
pub fn ra_init_with_capacity(new_ra: *mut roaring_array_t, cap: u32) -> bool;
}
extern "C" {
#[doc = " Initialize with zero capacity"]
pub fn ra_init(t: *mut roaring_array_t);
}
extern "C" {
#[doc = " Copies this roaring array, we assume that dest is not initialized"]
pub fn ra_copy(
source: *const roaring_array_t,
dest: *mut roaring_array_t,
copy_on_write: bool,
) -> bool;
}
extern "C" {
pub fn ra_shrink_to_fit(ra: *mut roaring_array_t) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Copies this roaring array, we assume that dest is initialized"]
pub fn ra_overwrite(
source: *const roaring_array_t,
dest: *mut roaring_array_t,
copy_on_write: bool,
) -> bool;
}
extern "C" {
#[doc = " Frees the memory used by a roaring array"]
pub fn ra_clear(r: *mut roaring_array_t);
}
extern "C" {
#[doc = " Frees the memory used by a roaring array, but does not free the containers"]
pub fn ra_clear_without_containers(r: *mut roaring_array_t);
}
extern "C" {
#[doc = " Frees just the containers"]
pub fn ra_clear_containers(ra: *mut roaring_array_t);
}
extern "C" {
#[doc = " Get the index corresponding to a 16-bit key"]
pub fn ra_get_index(ra: *const roaring_array_t, x: u16) -> i32;
}
extern "C" {
#[doc = " Retrieves the container at index i, filling in the typecode"]
pub fn ra_get_container_at_index(
ra: *const roaring_array_t,
i: u16,
typecode: *mut u8,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
#[doc = " Retrieves the key at index i"]
pub fn ra_get_key_at_index(ra: *const roaring_array_t, i: u16) -> u16;
}
extern "C" {
#[doc = " Add a new key-value pair at index i"]
pub fn ra_insert_new_key_value_at(
ra: *mut roaring_array_t,
i: i32,
key: u16,
container: *mut ::std::os::raw::c_void,
typecode: u8,
);
}
extern "C" {
#[doc = " Append a new key-value pair"]
pub fn ra_append(
ra: *mut roaring_array_t,
s: u16,
c: *mut ::std::os::raw::c_void,
typecode: u8,
);
}
extern "C" {
#[doc = " Append a new key-value pair to ra, cloning (in COW sense) a value from sa"]
#[doc = " at index index"]
pub fn ra_append_copy(
ra: *mut roaring_array_t,
sa: *const roaring_array_t,
index: u16,
copy_on_write: bool,
);
}
extern "C" {
#[doc = " Append new key-value pairs to ra, cloning (in COW sense) values from sa"]
#[doc = " at indexes"]
#[doc = " [start_index, end_index)"]
pub fn ra_append_copy_range(
ra: *mut roaring_array_t,
sa: *const roaring_array_t,
start_index: i32,
end_index: i32,
copy_on_write: bool,
);
}
extern "C" {
#[doc = " appends from sa to ra, ending with the greatest key that is"]
#[doc = " is less or equal stopping_key"]
pub fn ra_append_copies_until(
ra: *mut roaring_array_t,
sa: *const roaring_array_t,
stopping_key: u16,
copy_on_write: bool,
);
}
extern "C" {
#[doc = " appends from sa to ra, starting with the smallest key that is"]
#[doc = " is strictly greater than before_start"]
pub fn ra_append_copies_after(
ra: *mut roaring_array_t,
sa: *const roaring_array_t,
before_start: u16,
copy_on_write: bool,
);
}
extern "C" {
#[doc = " Move the key-value pairs to ra from sa at indexes"]
#[doc = " [start_index, end_index), old array should not be freed"]
#[doc = " (use ra_clear_without_containers)"]
pub fn ra_append_move_range(
ra: *mut roaring_array_t,
sa: *mut roaring_array_t,
start_index: i32,
end_index: i32,
);
}
extern "C" {
#[doc = " Append new key-value pairs to ra, from sa at indexes"]
#[doc = " [start_index, end_index)"]
pub fn ra_append_range(
ra: *mut roaring_array_t,
sa: *mut roaring_array_t,
start_index: i32,
end_index: i32,
copy_on_write: bool,
);
}
extern "C" {
#[doc = " Set the container at the corresponding index using the specified"]
#[doc = " typecode."]
pub fn ra_set_container_at_index(
ra: *const roaring_array_t,
i: i32,
c: *mut ::std::os::raw::c_void,
typecode: u8,
);
}
extern "C" {
#[doc = " If needed, increase the capacity of the array so that it can fit k values"]
#[doc = " (at"]
#[doc = " least);"]
pub fn extend_array(ra: *mut roaring_array_t, k: i32) -> bool;
}
extern "C" {
pub fn ra_get_size(ra: *const roaring_array_t) -> i32;
}
extern "C" {
pub fn ra_advance_until_freeing(ra: *mut roaring_array_t, x: u16, pos: i32) -> i32;
}
extern "C" {
pub fn ra_downsize(ra: *mut roaring_array_t, new_length: i32);
}
extern "C" {
pub fn ra_replace_key_and_container_at_index(
ra: *mut roaring_array_t,
i: i32,
key: u16,
c: *mut ::std::os::raw::c_void,
typecode: u8,
);
}
extern "C" {
pub fn ra_to_uint32_array(ra: *const roaring_array_t, ans: *mut u32);
}
extern "C" {
pub fn ra_range_uint32_array(
ra: *const roaring_array_t,
offset: size_t,
limit: size_t,
ans: *mut u32,
) -> bool;
}
extern "C" {
#[doc = " write a bitmap to a buffer. This is meant to be compatible with"]
#[doc = " the"]
#[doc = " Java and Go versions. Return the size in bytes of the serialized"]
#[doc = " output (which should be ra_portable_size_in_bytes(ra))."]
pub fn ra_portable_serialize(
ra: *const roaring_array_t,
buf: *mut ::std::os::raw::c_char,
) -> size_t;
}
extern "C" {
#[doc = " read a bitmap from a serialized version. This is meant to be compatible"]
#[doc = " with the Java and Go versions."]
#[doc = " maxbytes indicates how many bytes available from buf."]
#[doc = " When the function returns true, roaring_array_t is populated with the data"]
#[doc = " and *readbytes indicates how many bytes were read. In all cases, if the function"]
#[doc = " returns true, then maxbytes >= *readbytes."]
pub fn ra_portable_deserialize(
ra: *mut roaring_array_t,
buf: *const ::std::os::raw::c_char,
maxbytes: size_t,
readbytes: *mut size_t,
) -> bool;
}
extern "C" {
#[doc = " Quickly checks whether there is a serialized bitmap at the pointer,"]
#[doc = " not exceeding size \"maxbytes\" in bytes. This function does not allocate"]
#[doc = " memory dynamically."]
#[doc = ""]
#[doc = " This function returns 0 if and only if no valid bitmap is found."]
#[doc = " Otherwise, it returns how many bytes are occupied by the bitmap data."]
pub fn ra_portable_deserialize_size(
buf: *const ::std::os::raw::c_char,
maxbytes: size_t,
) -> size_t;
}
extern "C" {
#[doc = " How many bytes are required to serialize this bitmap (meant to be"]
#[doc = " compatible"]
#[doc = " with Java and Go versions)"]
pub fn ra_portable_size_in_bytes(ra: *const roaring_array_t) -> size_t;
}
extern "C" {
#[doc = " return true if it contains at least one run container."]
pub fn ra_has_run_container(ra: *const roaring_array_t) -> bool;
}
extern "C" {
#[doc = " Size of the header when serializing (meant to be compatible"]
#[doc = " with Java and Go versions)"]
pub fn ra_portable_header_size(ra: *const roaring_array_t) -> u32;
}
extern "C" {
#[doc = " remove at index i, sliding over all entries after i"]
pub fn ra_remove_at_index(ra: *mut roaring_array_t, i: i32);
}
extern "C" {
#[doc = " clears all containers, sets the size at 0 and shrinks the memory usage."]
pub fn ra_reset(ra: *mut roaring_array_t);
}
extern "C" {
#[doc = " remove at index i, sliding over all entries after i. Free removed container."]
pub fn ra_remove_at_index_and_free(ra: *mut roaring_array_t, i: i32);
}
extern "C" {
pub fn ra_copy_range(ra: *mut roaring_array_t, begin: u32, end: u32, new_begin: u32);
}
extern "C" {
#[doc = " Shifts rightmost $count containers to the left (distance < 0) or"]
#[doc = " to the right (distance > 0)."]
#[doc = " Allocates memory if necessary."]
#[doc = " This function doesn't free or create new containers."]
#[doc = " Caller is responsible for that."]
pub fn ra_shift_tail(ra: *mut roaring_array_t, count: i32, distance: i32);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct roaring_bitmap_s {
pub high_low_container: roaring_array_t,
}
#[test]
fn bindgen_test_layout_roaring_bitmap_s() {
assert_eq!(
::std::mem::size_of::<roaring_bitmap_s>(),
40usize,
concat!("Size of: ", stringify!(roaring_bitmap_s))
);
assert_eq!(
::std::mem::align_of::<roaring_bitmap_s>(),
8usize,
concat!("Alignment of ", stringify!(roaring_bitmap_s))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<roaring_bitmap_s>())).high_low_container as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(roaring_bitmap_s),
"::",
stringify!(high_low_container)
)
);
}
pub type roaring_bitmap_t = roaring_bitmap_s;
extern "C" {
#[doc = " Creates a new bitmap (initially empty)"]
pub fn roaring_bitmap_create() -> *mut roaring_bitmap_t;
}
extern "C" {
#[doc = " Add all the values between min (included) and max (excluded) that are at a"]
#[doc = " distance k*step from min."]
pub fn roaring_bitmap_from_range(min: u64, max: u64, step: u32) -> *mut roaring_bitmap_t;
}
extern "C" {
#[doc = " Creates a new bitmap (initially empty) with a provided"]
#[doc = " container-storage capacity (it is a performance hint)."]
pub fn roaring_bitmap_create_with_capacity(cap: u32) -> *mut roaring_bitmap_t;
}
extern "C" {
#[doc = " Creates a new bitmap from a pointer of uint32_t integers"]
pub fn roaring_bitmap_of_ptr(n_args: size_t, vals: *const u32) -> *mut roaring_bitmap_t;
}
extern "C" {
pub fn roaring_bitmap_get_copy_on_write(r: *const roaring_bitmap_t) -> bool;
}
extern "C" {
pub fn roaring_bitmap_set_copy_on_write(r: *mut roaring_bitmap_t, cow: bool);
}
extern "C" {
#[doc = " Describe the inner structure of the bitmap."]
pub fn roaring_bitmap_printf_describe(ra: *const roaring_bitmap_t);
}
extern "C" {
#[doc = " Creates a new bitmap from a list of uint32_t integers"]
pub fn roaring_bitmap_of(n: size_t, ...) -> *mut roaring_bitmap_t;
}
extern "C" {
#[doc = " Copies a bitmap. This does memory allocation. The caller is responsible for"]
#[doc = " memory management."]
#[doc = ""]
pub fn roaring_bitmap_copy(r: *const roaring_bitmap_t) -> *mut roaring_bitmap_t;
}
extern "C" {
#[doc = " Copies a bitmap from src to dest. It is assumed that the pointer dest"]
#[doc = " is to an already allocated bitmap. The content of the dest bitmap is"]
#[doc = " freed/deleted."]
#[doc = ""]
#[doc = " It might be preferable and simpler to call roaring_bitmap_copy except"]
#[doc = " that roaring_bitmap_overwrite can save on memory allocations."]
#[doc = ""]
pub fn roaring_bitmap_overwrite(
dest: *mut roaring_bitmap_t,
src: *const roaring_bitmap_t,
) -> bool;
}
extern "C" {
#[doc = " Print the content of the bitmap."]
pub fn roaring_bitmap_printf(ra: *const roaring_bitmap_t);
}
extern "C" {
#[doc = " Computes the intersection between two bitmaps and returns new bitmap. The"]
#[doc = " caller is"]
#[doc = " responsible for memory management."]
#[doc = ""]
pub fn roaring_bitmap_and(
x1: *const roaring_bitmap_t,
x2: *const roaring_bitmap_t,
) -> *mut roaring_bitmap_t;
}
extern "C" {
#[doc = " Computes the size of the intersection between two bitmaps."]
#[doc = ""]
pub fn roaring_bitmap_and_cardinality(
x1: *const roaring_bitmap_t,
x2: *const roaring_bitmap_t,
) -> u64;
}
extern "C" {
#[doc = " Check whether two bitmaps intersect."]
#[doc = ""]
pub fn roaring_bitmap_intersect(
x1: *const roaring_bitmap_t,
x2: *const roaring_bitmap_t,
) -> bool;
}
extern "C" {
#[doc = " Computes the Jaccard index between two bitmaps. (Also known as the Tanimoto"]
#[doc = " distance,"]
#[doc = " or the Jaccard similarity coefficient)"]
#[doc = ""]
#[doc = " The Jaccard index is undefined if both bitmaps are empty."]
#[doc = ""]
pub fn roaring_bitmap_jaccard_index(
x1: *const roaring_bitmap_t,
x2: *const roaring_bitmap_t,
) -> f64;
}
extern "C" {
#[doc = " Computes the size of the union between two bitmaps."]
#[doc = ""]
pub fn roaring_bitmap_or_cardinality(
x1: *const roaring_bitmap_t,
x2: *const roaring_bitmap_t,
) -> u64;
}
extern "C" {
#[doc = " Computes the size of the difference (andnot) between two bitmaps."]
#[doc = ""]
pub fn roaring_bitmap_andnot_cardinality(
x1: *const roaring_bitmap_t,
x2: *const roaring_bitmap_t,
) -> u64;
}
extern "C" {
#[doc = " Computes the size of the symmetric difference (andnot) between two bitmaps."]
#[doc = ""]
pub fn roaring_bitmap_xor_cardinality(
x1: *const roaring_bitmap_t,
x2: *const roaring_bitmap_t,
) -> u64;
}
extern "C" {
#[doc = " Inplace version modifies x1, x1 == x2 is allowed"]
pub fn roaring_bitmap_and_inplace(x1: *mut roaring_bitmap_t, x2: *const roaring_bitmap_t);
}
extern "C" {
#[doc = " Computes the union between two bitmaps and returns new bitmap. The caller is"]
#[doc = " responsible for memory management."]
pub fn roaring_bitmap_or(
x1: *const roaring_bitmap_t,
x2: *const roaring_bitmap_t,
) -> *mut roaring_bitmap_t;
}
extern "C" {
#[doc = " Inplace version of roaring_bitmap_or, modifies x1. TDOO: decide whether x1 =="]
#[doc = "x2 ok"]
#[doc = ""]
pub fn roaring_bitmap_or_inplace(x1: *mut roaring_bitmap_t, x2: *const roaring_bitmap_t);
}
extern "C" {
#[doc = " Compute the union of 'number' bitmaps. See also roaring_bitmap_or_many_heap."]
#[doc = " Caller is responsible for freeing the"]
#[doc = " result."]
#[doc = ""]
pub fn roaring_bitmap_or_many(
number: size_t,
x: *mut *const roaring_bitmap_t,
) -> *mut roaring_bitmap_t;
}
extern "C" {
#[doc = " Compute the union of 'number' bitmaps using a heap. This can"]
#[doc = " sometimes be faster than roaring_bitmap_or_many which uses"]
#[doc = " a naive algorithm. Caller is responsible for freeing the"]
#[doc = " result."]
#[doc = ""]
pub fn roaring_bitmap_or_many_heap(
number: u32,
x: *mut *const roaring_bitmap_t,
) -> *mut roaring_bitmap_t;
}
extern "C" {
#[doc = " Computes the symmetric difference (xor) between two bitmaps"]
#[doc = " and returns new bitmap. The caller is responsible for memory management."]
pub fn roaring_bitmap_xor(
x1: *const roaring_bitmap_t,
x2: *const roaring_bitmap_t,
) -> *mut roaring_bitmap_t;
}
extern "C" {
#[doc = " Inplace version of roaring_bitmap_xor, modifies x1. x1 != x2."]
#[doc = ""]
pub fn roaring_bitmap_xor_inplace(x1: *mut roaring_bitmap_t, x2: *const roaring_bitmap_t);
}
extern "C" {
#[doc = " Compute the xor of 'number' bitmaps."]
#[doc = " Caller is responsible for freeing the"]
#[doc = " result."]
#[doc = ""]
pub fn roaring_bitmap_xor_many(
number: size_t,
x: *mut *const roaring_bitmap_t,
) -> *mut roaring_bitmap_t;
}
extern "C" {
#[doc = " Computes the difference (andnot) between two bitmaps"]
#[doc = " and returns new bitmap. The caller is responsible for memory management."]
pub fn roaring_bitmap_andnot(
x1: *const roaring_bitmap_t,
x2: *const roaring_bitmap_t,
) -> *mut roaring_bitmap_t;
}
extern "C" {
#[doc = " Inplace version of roaring_bitmap_andnot, modifies x1. x1 != x2."]
#[doc = ""]
pub fn roaring_bitmap_andnot_inplace(x1: *mut roaring_bitmap_t, x2: *const roaring_bitmap_t);
}
extern "C" {
#[doc = " Frees the memory."]
pub fn roaring_bitmap_free(r: *const roaring_bitmap_t);
}
extern "C" {
#[doc = " Add value n_args from pointer vals, faster than repeatedly calling"]
#[doc = " roaring_bitmap_add"]
#[doc = ""]
pub fn roaring_bitmap_add_many(r: *mut roaring_bitmap_t, n_args: size_t, vals: *const u32);
}
extern "C" {
#[doc = " Add value x"]
#[doc = ""]
pub fn roaring_bitmap_add(r: *mut roaring_bitmap_t, x: u32);
}
extern "C" {
#[doc = " Add value x"]
#[doc = " Returns true if a new value was added, false if the value was already existing."]
pub fn roaring_bitmap_add_checked(r: *mut roaring_bitmap_t, x: u32) -> bool;
}
extern "C" {
#[doc = " Add all values in range [min, max]"]
pub fn roaring_bitmap_add_range_closed(ra: *mut roaring_bitmap_t, min: u32, max: u32);
}
extern "C" {
#[doc = " Add all values in range [min, max)"]
pub fn roaring_bitmap_add_range(ra: *mut roaring_bitmap_t, min: u64, max: u64);
}
extern "C" {
#[doc = " Remove value x"]
#[doc = ""]
pub fn roaring_bitmap_remove(r: *mut roaring_bitmap_t, x: u32);
}
extern "C" {
#[doc = " Remove all values in range [min, max]"]
pub fn roaring_bitmap_remove_range_closed(ra: *mut roaring_bitmap_t, min: u32, max: u32);
}
extern "C" {
#[doc = " Remove all values in range [min, max)"]
pub fn roaring_bitmap_remove_range(ra: *mut roaring_bitmap_t, min: u64, max: u64);
}
extern "C" {
#[doc = " Remove multiple values"]
pub fn roaring_bitmap_remove_many(r: *mut roaring_bitmap_t, n_args: size_t, vals: *const u32);
}
extern "C" {
#[doc = " Remove value x"]
#[doc = " Returns true if a new value was removed, false if the value was not existing."]
pub fn roaring_bitmap_remove_checked(r: *mut roaring_bitmap_t, x: u32) -> bool;
}
extern "C" {
#[doc = " Check if value x is present"]
pub fn roaring_bitmap_contains(r: *const roaring_bitmap_t, val: u32) -> bool;
}
extern "C" {
#[doc = " Check whether a range of values from range_start (included) to range_end (excluded) is present"]
pub fn roaring_bitmap_contains_range(
r: *const roaring_bitmap_t,
range_start: u64,
range_end: u64,
) -> bool;
}
extern "C" {
#[doc = " Get the cardinality of the bitmap (number of elements)."]
pub fn roaring_bitmap_get_cardinality(ra: *const roaring_bitmap_t) -> u64;
}
extern "C" {
#[doc = " Returns the number of elements in the range [range_start, range_end)."]
pub fn roaring_bitmap_range_cardinality(
ra: *const roaring_bitmap_t,
range_start: u64,
range_end: u64,
) -> u64;
}
extern "C" {
#[doc = " Returns true if the bitmap is empty (cardinality is zero)."]
pub fn roaring_bitmap_is_empty(ra: *const roaring_bitmap_t) -> bool;
}
extern "C" {
#[doc = " Empties the bitmap"]
pub fn roaring_bitmap_clear(ra: *mut roaring_bitmap_t);
}
extern "C" {
#[doc = " Convert the bitmap to an array. Write the output to \"ans\","]
#[doc = " caller is responsible to ensure that there is enough memory"]
#[doc = " allocated"]
#[doc = " (e.g., ans = malloc(roaring_bitmap_get_cardinality(mybitmap)"]
#[doc = " * sizeof(uint32_t))"]
pub fn roaring_bitmap_to_uint32_array(ra: *const roaring_bitmap_t, ans: *mut u32);
}
extern "C" {
#[doc = " Convert the bitmap to an array from \"offset\" by \"limit\". Write the output to \"ans\"."]
#[doc = " so, you can get data in paging."]
#[doc = " caller is responsible to ensure that there is enough memory"]
#[doc = " allocated"]
#[doc = " (e.g., ans = malloc(roaring_bitmap_get_cardinality(limit)"]
#[doc = " * sizeof(uint32_t))"]
#[doc = " Return false in case of failure (e.g., insufficient memory)"]
pub fn roaring_bitmap_range_uint32_array(
ra: *const roaring_bitmap_t,
offset: size_t,
limit: size_t,
ans: *mut u32,
) -> bool;
}
extern "C" {
#[doc = " Remove run-length encoding even when it is more space efficient"]
#[doc = " return whether a change was applied"]
pub fn roaring_bitmap_remove_run_compression(r: *mut roaring_bitmap_t) -> bool;
}
extern "C" {
#[doc = " convert array and bitmap containers to run containers when it is more"]
#[doc = " efficient;"]
#[doc = " also convert from run containers when more space efficient. Returns"]
#[doc = " true if the result has at least one run container."]
#[doc = " Additional savings might be possible by calling shrinkToFit()."]
pub fn roaring_bitmap_run_optimize(r: *mut roaring_bitmap_t) -> bool;
}
extern "C" {
#[doc = " If needed, reallocate memory to shrink the memory usage. Returns"]
#[doc = " the number of bytes saved."]
pub fn roaring_bitmap_shrink_to_fit(r: *mut roaring_bitmap_t) -> size_t;
}
extern "C" {
#[doc = " write the bitmap to an output pointer, this output buffer should refer to"]
#[doc = " at least roaring_bitmap_size_in_bytes(ra) allocated bytes."]
#[doc = ""]
#[doc = " see roaring_bitmap_portable_serialize if you want a format that's compatible"]
#[doc = " with Java and Go implementations"]
#[doc = ""]
#[doc = " this format has the benefit of being sometimes more space efficient than"]
#[doc = " roaring_bitmap_portable_serialize"]
#[doc = " e.g., when the data is sparse."]
#[doc = ""]
#[doc = " Returns how many bytes were written which should be"]
#[doc = " roaring_bitmap_size_in_bytes(ra)."]
pub fn roaring_bitmap_serialize(
ra: *const roaring_bitmap_t,
buf: *mut ::std::os::raw::c_char,
) -> size_t;
}
extern "C" {
#[doc = " use with roaring_bitmap_serialize"]
#[doc = " see roaring_bitmap_portable_deserialize if you want a format that's"]
#[doc = " compatible with Java and Go implementations"]
pub fn roaring_bitmap_deserialize(buf: *const ::std::os::raw::c_void) -> *mut roaring_bitmap_t;
}
extern "C" {
#[doc = " How many bytes are required to serialize this bitmap (NOT compatible"]
#[doc = " with Java and Go versions)"]
pub fn roaring_bitmap_size_in_bytes(ra: *const roaring_bitmap_t) -> size_t;
}
extern "C" {
#[doc = " read a bitmap from a serialized version. This is meant to be compatible with"]
#[doc = " the Java and Go versions. See format specification at"]
#[doc = " https://github.com/RoaringBitmap/RoaringFormatSpec"]
#[doc = " In case of failure, a null pointer is returned."]
#[doc = " This function is unsafe in the sense that if there is no valid serialized"]
#[doc = " bitmap at the pointer, then many bytes could be read, possibly causing a buffer"]
#[doc = " overflow. For a safer approach,"]
#[doc = " call roaring_bitmap_portable_deserialize_safe."]
pub fn roaring_bitmap_portable_deserialize(
buf: *const ::std::os::raw::c_char,
) -> *mut roaring_bitmap_t;
}
extern "C" {
#[doc = " read a bitmap from a serialized version in a safe manner (reading up to maxbytes)."]
#[doc = " This is meant to be compatible with"]
#[doc = " the Java and Go versions. See format specification at"]
#[doc = " https://github.com/RoaringBitmap/RoaringFormatSpec"]
#[doc = " In case of failure, a null pointer is returned."]
pub fn roaring_bitmap_portable_deserialize_safe(
buf: *const ::std::os::raw::c_char,
maxbytes: size_t,
) -> *mut roaring_bitmap_t;
}
extern "C" {
#[doc = " Check how many bytes would be read (up to maxbytes) at this pointer if there"]
#[doc = " is a bitmap, returns zero if there is no valid bitmap."]
#[doc = " This is meant to be compatible with"]
#[doc = " the Java and Go versions. See format specification at"]
#[doc = " https://github.com/RoaringBitmap/RoaringFormatSpec"]
pub fn roaring_bitmap_portable_deserialize_size(
buf: *const ::std::os::raw::c_char,
maxbytes: size_t,
) -> size_t;
}
extern "C" {
#[doc = " How many bytes are required to serialize this bitmap (meant to be compatible"]
#[doc = " with Java and Go versions). See format specification at"]
#[doc = " https://github.com/RoaringBitmap/RoaringFormatSpec"]
pub fn roaring_bitmap_portable_size_in_bytes(ra: *const roaring_bitmap_t) -> size_t;
}
extern "C" {
#[doc = " write a bitmap to a char buffer. The output buffer should refer to at least"]
#[doc = " roaring_bitmap_portable_size_in_bytes(ra) bytes of allocated memory."]
#[doc = " This is meant to be compatible with"]
#[doc = " the"]
#[doc = " Java and Go versions. Returns how many bytes were written which should be"]
#[doc = " roaring_bitmap_portable_size_in_bytes(ra). See format specification at"]
#[doc = " https://github.com/RoaringBitmap/RoaringFormatSpec"]
pub fn roaring_bitmap_portable_serialize(
ra: *const roaring_bitmap_t,
buf: *mut ::std::os::raw::c_char,
) -> size_t;
}
extern "C" {
#[doc = " Returns number of bytes required to serialize bitmap using frozen format."]
pub fn roaring_bitmap_frozen_size_in_bytes(ra: *const roaring_bitmap_t) -> size_t;
}
extern "C" {
#[doc = " Serializes bitmap using frozen format."]
#[doc = " Buffer size must be at least roaring_bitmap_frozen_size_in_bytes()."]
pub fn roaring_bitmap_frozen_serialize(
ra: *const roaring_bitmap_t,
buf: *mut ::std::os::raw::c_char,
);
}
extern "C" {
#[doc = " Creates constant bitmap that is a view of a given buffer."]
#[doc = " Buffer must contain data previously written by roaring_bitmap_frozen_serialize(),"]
#[doc = " and additionally its beginning must be aligned by 32 bytes."]
#[doc = " Length must be equal exactly to roaring_bitmap_frozen_size_in_bytes()."]
#[doc = ""]
#[doc = " On error, NULL is returned."]
#[doc = ""]
#[doc = " Bitmap returned by this function can be used in all readonly contexts."]
#[doc = " Bitmap must be freed as usual, by calling roaring_bitmap_free()."]
#[doc = " Underlying buffer must not be freed or modified while it backs any bitmaps."]
pub fn roaring_bitmap_frozen_view(
buf: *const ::std::os::raw::c_char,
length: size_t,
) -> *const roaring_bitmap_t;
}
extern "C" {
#[doc = " Iterate over the bitmap elements. The function iterator is called once for"]
#[doc = " all the values with ptr (can be NULL) as the second parameter of each call."]
#[doc = ""]
#[doc = " roaring_iterator is simply a pointer to a function that returns bool"]
#[doc = " (true means that the iteration should continue while false means that it"]
#[doc = " should stop),"]
#[doc = " and takes (uint32_t,void*) as inputs."]
#[doc = ""]
#[doc = " Returns true if the roaring_iterator returned true throughout (so that"]
#[doc = " all data points were necessarily visited)."]
pub fn roaring_iterate(
ra: *const roaring_bitmap_t,
iterator: roaring_iterator,
ptr: *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn roaring_iterate64(
ra: *const roaring_bitmap_t,
iterator: roaring_iterator64,
high_bits: u64,
ptr: *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
#[doc = " Return true if the two bitmaps contain the same elements."]
pub fn roaring_bitmap_equals(
ra1: *const roaring_bitmap_t,
ra2: *const roaring_bitmap_t,
) -> bool;
}
extern "C" {
#[doc = " Return true if all the elements of ra1 are also in ra2."]
pub fn roaring_bitmap_is_subset(
ra1: *const roaring_bitmap_t,
ra2: *const roaring_bitmap_t,
) -> bool;
}
extern "C" {
#[doc = " Return true if all the elements of ra1 are also in ra2 and ra2 is strictly"]
#[doc = " greater"]
#[doc = " than ra1."]
pub fn roaring_bitmap_is_strict_subset(
ra1: *const roaring_bitmap_t,
ra2: *const roaring_bitmap_t,
) -> bool;
}
extern "C" {
#[doc = " (For expert users who seek high performance.)"]
#[doc = ""]
#[doc = " Computes the union between two bitmaps and returns new bitmap. The caller is"]
#[doc = " responsible for memory management."]
#[doc = ""]
#[doc = " The lazy version defers some computations such as the maintenance of the"]
#[doc = " cardinality counts. Thus you need"]
#[doc = " to call roaring_bitmap_repair_after_lazy after executing \"lazy\" computations."]
#[doc = " It is safe to repeatedly call roaring_bitmap_lazy_or_inplace on the result."]
#[doc = " The bitsetconversion conversion is a flag which determines"]
#[doc = " whether container-container operations force a bitset conversion."]
pub fn roaring_bitmap_lazy_or(
x1: *const roaring_bitmap_t,
x2: *const roaring_bitmap_t,
bitsetconversion: bool,
) -> *mut roaring_bitmap_t;
}
extern "C" {
#[doc = " (For expert users who seek high performance.)"]
#[doc = " Inplace version of roaring_bitmap_lazy_or, modifies x1"]
#[doc = " The bitsetconversion conversion is a flag which determines"]
#[doc = " whether container-container operations force a bitset conversion."]
pub fn roaring_bitmap_lazy_or_inplace(
x1: *mut roaring_bitmap_t,
x2: *const roaring_bitmap_t,
bitsetconversion: bool,
);
}
extern "C" {
#[doc = " (For expert users who seek high performance.)"]
#[doc = ""]
#[doc = " Execute maintenance operations on a bitmap created from"]
#[doc = " roaring_bitmap_lazy_or"]
#[doc = " or modified with roaring_bitmap_lazy_or_inplace."]
pub fn roaring_bitmap_repair_after_lazy(x1: *mut roaring_bitmap_t);
}
extern "C" {
#[doc = " Computes the symmetric difference between two bitmaps and returns new bitmap."]
#[doc = "The caller is"]
#[doc = " responsible for memory management."]
#[doc = ""]
#[doc = " The lazy version defers some computations such as the maintenance of the"]
#[doc = " cardinality counts. Thus you need"]
#[doc = " to call roaring_bitmap_repair_after_lazy after executing \"lazy\" computations."]
#[doc = " It is safe to repeatedly call roaring_bitmap_lazy_xor_inplace on the result."]
#[doc = ""]
pub fn roaring_bitmap_lazy_xor(
x1: *const roaring_bitmap_t,
x2: *const roaring_bitmap_t,
) -> *mut roaring_bitmap_t;
}
extern "C" {
#[doc = " (For expert users who seek high performance.)"]
#[doc = " Inplace version of roaring_bitmap_lazy_xor, modifies x1. x1 != x2"]
#[doc = ""]
pub fn roaring_bitmap_lazy_xor_inplace(x1: *mut roaring_bitmap_t, x2: *const roaring_bitmap_t);
}
extern "C" {
#[doc = " compute the negation of the roaring bitmap within a specified"]
#[doc = " interval: [range_start, range_end). The number of negated values is"]
#[doc = " range_end - range_start."]
#[doc = " Areas outside the range are passed through unchanged."]
pub fn roaring_bitmap_flip(
x1: *const roaring_bitmap_t,
range_start: u64,
range_end: u64,
) -> *mut roaring_bitmap_t;
}
extern "C" {
#[doc = " compute (in place) the negation of the roaring bitmap within a specified"]
#[doc = " interval: [range_start, range_end). The number of negated values is"]
#[doc = " range_end - range_start."]
#[doc = " Areas outside the range are passed through unchanged."]
pub fn roaring_bitmap_flip_inplace(x1: *mut roaring_bitmap_t, range_start: u64, range_end: u64);
}
extern "C" {
#[doc = " If the size of the roaring bitmap is strictly greater than rank, then this"]
#[doc = "function returns true and set element to the element of given rank."]
#[doc = "Otherwise, it returns false."]
pub fn roaring_bitmap_select(ra: *const roaring_bitmap_t, rank: u32, element: *mut u32)
-> bool;
}
extern "C" {
#[doc = " roaring_bitmap_rank returns the number of integers that are smaller or equal"]
#[doc = " to x."]
pub fn roaring_bitmap_rank(bm: *const roaring_bitmap_t, x: u32) -> u64;
}
extern "C" {
#[doc = " roaring_bitmap_smallest returns the smallest value in the set."]
#[doc = " Returns UINT32_MAX if the set is empty."]
pub fn roaring_bitmap_minimum(bm: *const roaring_bitmap_t) -> u32;
}
extern "C" {
#[doc = " roaring_bitmap_smallest returns the greatest value in the set."]
#[doc = " Returns 0 if the set is empty."]
pub fn roaring_bitmap_maximum(bm: *const roaring_bitmap_t) -> u32;
}
extern "C" {
#[doc = " (For advanced users.)"]
#[doc = " Collect statistics about the bitmap, see roaring_types.h for"]
#[doc = " a description of roaring_statistics_t"]
pub fn roaring_bitmap_statistics(ra: *const roaring_bitmap_t, stat: *mut roaring_statistics_t);
}
#[doc = " What follows is code use to iterate through values in a roaring bitmap"]
#[doc = ""]
#[doc = "roaring_bitmap_t *ra =..."]
#[doc = "roaring_uint32_iterator_t i;"]
#[doc = "roaring_create_iterator(ra, &i);"]
#[doc = "while(i.has_value) {"]
#[doc = "printf(\"value = %d\\n\", i.current_value);"]
#[doc = "roaring_advance_uint32_iterator(&i);"]
#[doc = "}"]
#[doc = ""]
#[doc = "Obviously, if you modify the underlying bitmap, the iterator"]
#[doc = "becomes invalid. So don't."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct roaring_uint32_iterator_s {
pub parent: *const roaring_bitmap_t,
pub container_index: i32,
pub in_container_index: i32,
pub run_index: i32,
pub current_value: u32,
pub has_value: bool,
pub container: *const ::std::os::raw::c_void,
pub typecode: u8,
pub highbits: u32,
}
#[test]
fn bindgen_test_layout_roaring_uint32_iterator_s() {
assert_eq!(
::std::mem::size_of::<roaring_uint32_iterator_s>(),
48usize,
concat!("Size of: ", stringify!(roaring_uint32_iterator_s))
);
assert_eq!(
::std::mem::align_of::<roaring_uint32_iterator_s>(),
8usize,
concat!("Alignment of ", stringify!(roaring_uint32_iterator_s))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<roaring_uint32_iterator_s>())).parent as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(roaring_uint32_iterator_s),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<roaring_uint32_iterator_s>())).container_index as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(roaring_uint32_iterator_s),
"::",
stringify!(container_index)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<roaring_uint32_iterator_s>())).in_container_index as *const _
as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(roaring_uint32_iterator_s),
"::",
stringify!(in_container_index)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<roaring_uint32_iterator_s>())).run_index as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(roaring_uint32_iterator_s),
"::",
stringify!(run_index)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<roaring_uint32_iterator_s>())).current_value as *const _ as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(roaring_uint32_iterator_s),
"::",
stringify!(current_value)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<roaring_uint32_iterator_s>())).has_value as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(roaring_uint32_iterator_s),
"::",
stringify!(has_value)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<roaring_uint32_iterator_s>())).container as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(roaring_uint32_iterator_s),
"::",
stringify!(container)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<roaring_uint32_iterator_s>())).typecode as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(roaring_uint32_iterator_s),
"::",
stringify!(typecode)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<roaring_uint32_iterator_s>())).highbits as *const _ as usize
},
44usize,
concat!(
"Offset of field: ",
stringify!(roaring_uint32_iterator_s),
"::",
stringify!(highbits)
)
);
}
#[doc = " What follows is code use to iterate through values in a roaring bitmap"]
#[doc = ""]
#[doc = "roaring_bitmap_t *ra =..."]
#[doc = "roaring_uint32_iterator_t i;"]
#[doc = "roaring_create_iterator(ra, &i);"]
#[doc = "while(i.has_value) {"]
#[doc = "printf(\"value = %d\\n\", i.current_value);"]
#[doc = "roaring_advance_uint32_iterator(&i);"]
#[doc = "}"]
#[doc = ""]
#[doc = "Obviously, if you modify the underlying bitmap, the iterator"]
#[doc = "becomes invalid. So don't."]
pub type roaring_uint32_iterator_t = roaring_uint32_iterator_s;
extern "C" {
#[doc = " Initialize an iterator object that can be used to iterate through the"]
#[doc = " values. If there is a value, then this iterator points to the first value"]
#[doc = " and it->has_value is true. The value is in it->current_value."]
pub fn roaring_init_iterator(
ra: *const roaring_bitmap_t,
newit: *mut roaring_uint32_iterator_t,
);
}
extern "C" {
#[doc = " Initialize an iterator object that can be used to iterate through the"]
#[doc = " values. If there is a value, then this iterator points to the last value"]
#[doc = " and it->has_value is true. The value is in it->current_value."]
pub fn roaring_init_iterator_last(
ra: *const roaring_bitmap_t,
newit: *mut roaring_uint32_iterator_t,
);
}
extern "C" {
#[doc = " Create an iterator object that can be used to iterate through the"]
#[doc = " values. Caller is responsible for calling roaring_free_iterator."]
#[doc = " The iterator is initialized. If there is a value, then this iterator"]
#[doc = " points to the first value and it->has_value is true."]
#[doc = " The value is in it->current_value."]
#[doc = ""]
#[doc = " This function calls roaring_init_iterator."]
pub fn roaring_create_iterator(ra: *const roaring_bitmap_t) -> *mut roaring_uint32_iterator_t;
}
extern "C" {
#[doc = " Advance the iterator. If there is a new value, then it->has_value is true."]
#[doc = " The new value is in it->current_value. Values are traversed in increasing"]
#[doc = " orders. For convenience, returns it->has_value."]
pub fn roaring_advance_uint32_iterator(it: *mut roaring_uint32_iterator_t) -> bool;
}
extern "C" {
#[doc = " Decrement the iterator. If there is a new value, then it->has_value is true."]
#[doc = " The new value is in it->current_value. Values are traversed in decreasing"]
#[doc = " orders. For convenience, returns it->has_value."]
pub fn roaring_previous_uint32_iterator(it: *mut roaring_uint32_iterator_t) -> bool;
}
extern "C" {
#[doc = " Move the iterator to the first value >= val. If there is a such a value, then it->has_value is true."]
#[doc = " The new value is in it->current_value. For convenience, returns it->has_value."]
pub fn roaring_move_uint32_iterator_equalorlarger(
it: *mut roaring_uint32_iterator_t,
val: u32,
) -> bool;
}
extern "C" {
#[doc = " Creates a copy of an iterator."]
#[doc = " Caller must free it."]
pub fn roaring_copy_uint32_iterator(
it: *const roaring_uint32_iterator_t,
) -> *mut roaring_uint32_iterator_t;
}
extern "C" {
#[doc = " Free memory following roaring_create_iterator"]
pub fn roaring_free_uint32_iterator(it: *mut roaring_uint32_iterator_t);
}
extern "C" {
pub fn roaring_read_uint32_iterator(
it: *mut roaring_uint32_iterator_t,
buf: *mut u32,
count: u32,
) -> u32;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __locale_data {
pub _address: u8,
}
pub type __builtin_va_list = [__va_list_tag; 1usize];
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __va_list_tag {
pub gp_offset: ::std::os::raw::c_uint,
pub fp_offset: ::std::os::raw::c_uint,
pub overflow_arg_area: *mut ::std::os::raw::c_void,
pub reg_save_area: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout___va_list_tag() {
assert_eq!(
::std::mem::size_of::<__va_list_tag>(),
24usize,
concat!("Size of: ", stringify!(__va_list_tag))
);
assert_eq!(
::std::mem::align_of::<__va_list_tag>(),
8usize,
concat!("Alignment of ", stringify!(__va_list_tag))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__va_list_tag),
"::",
stringify!(gp_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(__va_list_tag),
"::",
stringify!(fp_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__va_list_tag),
"::",
stringify!(overflow_arg_area)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__va_list_tag),
"::",
stringify!(reg_save_area)
)
);
}