1pub const _STDINT_H: u32 = 1;
4pub const _FEATURES_H: u32 = 1;
5pub const _DEFAULT_SOURCE: u32 = 1;
6pub const __GLIBC_USE_ISOC2X: u32 = 0;
7pub const __USE_ISOC11: u32 = 1;
8pub const __USE_ISOC99: u32 = 1;
9pub const __USE_ISOC95: u32 = 1;
10pub const __USE_POSIX_IMPLICITLY: u32 = 1;
11pub const _POSIX_SOURCE: u32 = 1;
12pub const _POSIX_C_SOURCE: u32 = 200809;
13pub const __USE_POSIX: u32 = 1;
14pub const __USE_POSIX2: u32 = 1;
15pub const __USE_POSIX199309: u32 = 1;
16pub const __USE_POSIX199506: u32 = 1;
17pub const __USE_XOPEN2K: u32 = 1;
18pub const __USE_XOPEN2K8: u32 = 1;
19pub const _ATFILE_SOURCE: u32 = 1;
20pub const __WORDSIZE: u32 = 64;
21pub const __WORDSIZE_TIME64_COMPAT32: u32 = 1;
22pub const __SYSCALL_WORDSIZE: u32 = 64;
23pub const __TIMESIZE: u32 = 64;
24pub const __USE_MISC: u32 = 1;
25pub const __USE_ATFILE: u32 = 1;
26pub const __USE_FORTIFY_LEVEL: u32 = 0;
27pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 0;
28pub const __GLIBC_USE_DEPRECATED_SCANF: u32 = 0;
29pub const __GLIBC_USE_C2X_STRTOL: u32 = 0;
30pub const _STDC_PREDEF_H: u32 = 1;
31pub const __STDC_IEC_559__: u32 = 1;
32pub const __STDC_IEC_60559_BFP__: u32 = 201404;
33pub const __STDC_IEC_559_COMPLEX__: u32 = 1;
34pub const __STDC_IEC_60559_COMPLEX__: u32 = 201404;
35pub const __STDC_ISO_10646__: u32 = 201706;
36pub const __GNU_LIBRARY__: u32 = 6;
37pub const __GLIBC__: u32 = 2;
38pub const __GLIBC_MINOR__: u32 = 39;
39pub const _SYS_CDEFS_H: u32 = 1;
40pub const __glibc_c99_flexarr_available: u32 = 1;
41pub const __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI: u32 = 0;
42pub const __HAVE_GENERIC_SELECTION: u32 = 1;
43pub const __GLIBC_USE_LIB_EXT2: u32 = 0;
44pub const __GLIBC_USE_IEC_60559_BFP_EXT: u32 = 0;
45pub const __GLIBC_USE_IEC_60559_BFP_EXT_C2X: u32 = 0;
46pub const __GLIBC_USE_IEC_60559_EXT: u32 = 0;
47pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: u32 = 0;
48pub const __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X: u32 = 0;
49pub const __GLIBC_USE_IEC_60559_TYPES_EXT: u32 = 0;
50pub const _BITS_TYPES_H: u32 = 1;
51pub const _BITS_TYPESIZES_H: u32 = 1;
52pub const __OFF_T_MATCHES_OFF64_T: u32 = 1;
53pub const __INO_T_MATCHES_INO64_T: u32 = 1;
54pub const __RLIM_T_MATCHES_RLIM64_T: u32 = 1;
55pub const __STATFS_MATCHES_STATFS64: u32 = 1;
56pub const __KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64: u32 = 1;
57pub const __FD_SETSIZE: u32 = 1024;
58pub const _BITS_TIME64_H: u32 = 1;
59pub const _BITS_WCHAR_H: u32 = 1;
60pub const _BITS_STDINT_INTN_H: u32 = 1;
61pub const _BITS_STDINT_UINTN_H: u32 = 1;
62pub const _BITS_STDINT_LEAST_H: u32 = 1;
63pub const INT8_MIN: i32 = -128;
64pub const INT16_MIN: i32 = -32768;
65pub const INT32_MIN: i32 = -2147483648;
66pub const INT8_MAX: u32 = 127;
67pub const INT16_MAX: u32 = 32767;
68pub const INT32_MAX: u32 = 2147483647;
69pub const UINT8_MAX: u32 = 255;
70pub const UINT16_MAX: u32 = 65535;
71pub const UINT32_MAX: u32 = 4294967295;
72pub const INT_LEAST8_MIN: i32 = -128;
73pub const INT_LEAST16_MIN: i32 = -32768;
74pub const INT_LEAST32_MIN: i32 = -2147483648;
75pub const INT_LEAST8_MAX: u32 = 127;
76pub const INT_LEAST16_MAX: u32 = 32767;
77pub const INT_LEAST32_MAX: u32 = 2147483647;
78pub const UINT_LEAST8_MAX: u32 = 255;
79pub const UINT_LEAST16_MAX: u32 = 65535;
80pub const UINT_LEAST32_MAX: u32 = 4294967295;
81pub const INT_FAST8_MIN: i32 = -128;
82pub const INT_FAST16_MIN: i64 = -9223372036854775808;
83pub const INT_FAST32_MIN: i64 = -9223372036854775808;
84pub const INT_FAST8_MAX: u32 = 127;
85pub const INT_FAST16_MAX: u64 = 9223372036854775807;
86pub const INT_FAST32_MAX: u64 = 9223372036854775807;
87pub const UINT_FAST8_MAX: u32 = 255;
88pub const UINT_FAST16_MAX: i32 = -1;
89pub const UINT_FAST32_MAX: i32 = -1;
90pub const INTPTR_MIN: i64 = -9223372036854775808;
91pub const INTPTR_MAX: u64 = 9223372036854775807;
92pub const UINTPTR_MAX: i32 = -1;
93pub const PTRDIFF_MIN: i64 = -9223372036854775808;
94pub const PTRDIFF_MAX: u64 = 9223372036854775807;
95pub const SIG_ATOMIC_MIN: i32 = -2147483648;
96pub const SIG_ATOMIC_MAX: u32 = 2147483647;
97pub const SIZE_MAX: i32 = -1;
98pub const WINT_MIN: u32 = 0;
99pub const WINT_MAX: u32 = 4294967295;
100pub const _STDLIB_H: u32 = 1;
101pub const WNOHANG: u32 = 1;
102pub const WUNTRACED: u32 = 2;
103pub const WSTOPPED: u32 = 2;
104pub const WEXITED: u32 = 4;
105pub const WCONTINUED: u32 = 8;
106pub const WNOWAIT: u32 = 16777216;
107pub const __WNOTHREAD: u32 = 536870912;
108pub const __WALL: u32 = 1073741824;
109pub const __WCLONE: u32 = 2147483648;
110pub const __W_CONTINUED: u32 = 65535;
111pub const __WCOREFLAG: u32 = 128;
112pub const __HAVE_FLOAT128: u32 = 0;
113pub const __HAVE_DISTINCT_FLOAT128: u32 = 0;
114pub const __HAVE_FLOAT64X: u32 = 1;
115pub const __HAVE_FLOAT64X_LONG_DOUBLE: u32 = 1;
116pub const __HAVE_FLOAT16: u32 = 0;
117pub const __HAVE_FLOAT32: u32 = 1;
118pub const __HAVE_FLOAT64: u32 = 1;
119pub const __HAVE_FLOAT32X: u32 = 1;
120pub const __HAVE_FLOAT128X: u32 = 0;
121pub const __HAVE_DISTINCT_FLOAT16: u32 = 0;
122pub const __HAVE_DISTINCT_FLOAT32: u32 = 0;
123pub const __HAVE_DISTINCT_FLOAT64: u32 = 0;
124pub const __HAVE_DISTINCT_FLOAT32X: u32 = 0;
125pub const __HAVE_DISTINCT_FLOAT64X: u32 = 0;
126pub const __HAVE_DISTINCT_FLOAT128X: u32 = 0;
127pub const __HAVE_FLOATN_NOT_TYPEDEF: u32 = 0;
128pub const __ldiv_t_defined: u32 = 1;
129pub const __lldiv_t_defined: u32 = 1;
130pub const RAND_MAX: u32 = 2147483647;
131pub const EXIT_FAILURE: u32 = 1;
132pub const EXIT_SUCCESS: u32 = 0;
133pub const _SYS_TYPES_H: u32 = 1;
134pub const __clock_t_defined: u32 = 1;
135pub const __clockid_t_defined: u32 = 1;
136pub const __time_t_defined: u32 = 1;
137pub const __timer_t_defined: u32 = 1;
138pub const __BIT_TYPES_DEFINED__: u32 = 1;
139pub const _ENDIAN_H: u32 = 1;
140pub const _BITS_ENDIAN_H: u32 = 1;
141pub const __LITTLE_ENDIAN: u32 = 1234;
142pub const __BIG_ENDIAN: u32 = 4321;
143pub const __PDP_ENDIAN: u32 = 3412;
144pub const _BITS_ENDIANNESS_H: u32 = 1;
145pub const __BYTE_ORDER: u32 = 1234;
146pub const __FLOAT_WORD_ORDER: u32 = 1234;
147pub const LITTLE_ENDIAN: u32 = 1234;
148pub const BIG_ENDIAN: u32 = 4321;
149pub const PDP_ENDIAN: u32 = 3412;
150pub const BYTE_ORDER: u32 = 1234;
151pub const _BITS_BYTESWAP_H: u32 = 1;
152pub const _BITS_UINTN_IDENTITY_H: u32 = 1;
153pub const _SYS_SELECT_H: u32 = 1;
154pub const __sigset_t_defined: u32 = 1;
155pub const __timeval_defined: u32 = 1;
156pub const _STRUCT_TIMESPEC: u32 = 1;
157pub const FD_SETSIZE: u32 = 1024;
158pub const _BITS_PTHREADTYPES_COMMON_H: u32 = 1;
159pub const _THREAD_SHARED_TYPES_H: u32 = 1;
160pub const _BITS_PTHREADTYPES_ARCH_H: u32 = 1;
161pub const __SIZEOF_PTHREAD_MUTEX_T: u32 = 40;
162pub const __SIZEOF_PTHREAD_ATTR_T: u32 = 56;
163pub const __SIZEOF_PTHREAD_RWLOCK_T: u32 = 56;
164pub const __SIZEOF_PTHREAD_BARRIER_T: u32 = 32;
165pub const __SIZEOF_PTHREAD_MUTEXATTR_T: u32 = 4;
166pub const __SIZEOF_PTHREAD_COND_T: u32 = 48;
167pub const __SIZEOF_PTHREAD_CONDATTR_T: u32 = 4;
168pub const __SIZEOF_PTHREAD_RWLOCKATTR_T: u32 = 8;
169pub const __SIZEOF_PTHREAD_BARRIERATTR_T: u32 = 4;
170pub const _THREAD_MUTEX_INTERNAL_H: u32 = 1;
171pub const __PTHREAD_MUTEX_HAVE_PREV: u32 = 1;
172pub const __have_pthread_attr_t: u32 = 1;
173pub const _ALLOCA_H: u32 = 1;
174pub type __u_char = libc::c_uchar;
175pub type __u_short = libc::c_ushort;
176pub type __u_int = libc::c_uint;
177pub type __u_long = libc::c_ulong;
178pub type __int8_t = libc::c_schar;
179pub type __uint8_t = libc::c_uchar;
180pub type __int16_t = libc::c_short;
181pub type __uint16_t = libc::c_ushort;
182pub type __int32_t = libc::c_int;
183pub type __uint32_t = libc::c_uint;
184pub type __int64_t = libc::c_long;
185pub type __uint64_t = libc::c_ulong;
186pub type __int_least8_t = __int8_t;
187pub type __uint_least8_t = __uint8_t;
188pub type __int_least16_t = __int16_t;
189pub type __uint_least16_t = __uint16_t;
190pub type __int_least32_t = __int32_t;
191pub type __uint_least32_t = __uint32_t;
192pub type __int_least64_t = __int64_t;
193pub type __uint_least64_t = __uint64_t;
194pub type __quad_t = libc::c_long;
195pub type __u_quad_t = libc::c_ulong;
196pub type __intmax_t = libc::c_long;
197pub type __uintmax_t = libc::c_ulong;
198pub type __dev_t = libc::c_ulong;
199pub type __uid_t = libc::c_uint;
200pub type __gid_t = libc::c_uint;
201pub type __ino_t = libc::c_ulong;
202pub type __ino64_t = libc::c_ulong;
203pub type __mode_t = libc::c_uint;
204pub type __nlink_t = libc::c_ulong;
205pub type __off_t = libc::c_long;
206pub type __off64_t = libc::c_long;
207pub type __pid_t = libc::c_int;
208#[repr(C)]
209#[derive(Debug, Copy, Clone)]
210pub struct __fsid_t {
211 pub __val: [libc::c_int; 2usize],
212}
213#[test]
214fn bindgen_test_layout___fsid_t() {
215 const UNINIT: ::std::mem::MaybeUninit<__fsid_t> = ::std::mem::MaybeUninit::uninit();
216 let ptr = UNINIT.as_ptr();
217 assert_eq!(
218 ::std::mem::size_of::<__fsid_t>(),
219 8usize,
220 concat!("Size of: ", stringify!(__fsid_t))
221 );
222 assert_eq!(
223 ::std::mem::align_of::<__fsid_t>(),
224 4usize,
225 concat!("Alignment of ", stringify!(__fsid_t))
226 );
227 assert_eq!(
228 unsafe { ::std::ptr::addr_of!((*ptr).__val) as usize - ptr as usize },
229 0usize,
230 concat!(
231 "Offset of field: ",
232 stringify!(__fsid_t),
233 "::",
234 stringify!(__val)
235 )
236 );
237}
238pub type __clock_t = libc::c_long;
239pub type __rlim_t = libc::c_ulong;
240pub type __rlim64_t = libc::c_ulong;
241pub type __id_t = libc::c_uint;
242pub type __time_t = libc::c_long;
243pub type __useconds_t = libc::c_uint;
244pub type __suseconds_t = libc::c_long;
245pub type __suseconds64_t = libc::c_long;
246pub type __daddr_t = libc::c_int;
247pub type __key_t = libc::c_int;
248pub type __clockid_t = libc::c_int;
249pub type __timer_t = *mut libc::c_void;
250pub type __blksize_t = libc::c_long;
251pub type __blkcnt_t = libc::c_long;
252pub type __blkcnt64_t = libc::c_long;
253pub type __fsblkcnt_t = libc::c_ulong;
254pub type __fsblkcnt64_t = libc::c_ulong;
255pub type __fsfilcnt_t = libc::c_ulong;
256pub type __fsfilcnt64_t = libc::c_ulong;
257pub type __fsword_t = libc::c_long;
258pub type __ssize_t = libc::c_long;
259pub type __syscall_slong_t = libc::c_long;
260pub type __syscall_ulong_t = libc::c_ulong;
261pub type __loff_t = __off64_t;
262pub type __caddr_t = *mut libc::c_char;
263pub type __intptr_t = libc::c_long;
264pub type __socklen_t = libc::c_uint;
265pub type __sig_atomic_t = libc::c_int;
266pub type int_least8_t = __int_least8_t;
267pub type int_least16_t = __int_least16_t;
268pub type int_least32_t = __int_least32_t;
269pub type int_least64_t = __int_least64_t;
270pub type uint_least8_t = __uint_least8_t;
271pub type uint_least16_t = __uint_least16_t;
272pub type uint_least32_t = __uint_least32_t;
273pub type uint_least64_t = __uint_least64_t;
274pub type int_fast8_t = libc::c_schar;
275pub type int_fast16_t = libc::c_long;
276pub type int_fast32_t = libc::c_long;
277pub type int_fast64_t = libc::c_long;
278pub type uint_fast8_t = libc::c_uchar;
279pub type uint_fast16_t = libc::c_ulong;
280pub type uint_fast32_t = libc::c_ulong;
281pub type uint_fast64_t = libc::c_ulong;
282pub type intmax_t = __intmax_t;
283pub type uintmax_t = __uintmax_t;
284pub type wchar_t = libc::c_int;
285#[repr(C)]
286#[repr(align(16))]
287#[derive(Debug, Copy, Clone)]
288pub struct max_align_t {
289 pub __clang_max_align_nonce1: libc::c_longlong,
290 pub __bindgen_padding_0: u64,
291 pub __clang_max_align_nonce2: u128,
292}
293#[test]
294fn bindgen_test_layout_max_align_t() {
295 const UNINIT: ::std::mem::MaybeUninit<max_align_t> = ::std::mem::MaybeUninit::uninit();
296 let ptr = UNINIT.as_ptr();
297 assert_eq!(
298 ::std::mem::size_of::<max_align_t>(),
299 32usize,
300 concat!("Size of: ", stringify!(max_align_t))
301 );
302 assert_eq!(
303 ::std::mem::align_of::<max_align_t>(),
304 16usize,
305 concat!("Alignment of ", stringify!(max_align_t))
306 );
307 assert_eq!(
308 unsafe { ::std::ptr::addr_of!((*ptr).__clang_max_align_nonce1) as usize - ptr as usize },
309 0usize,
310 concat!(
311 "Offset of field: ",
312 stringify!(max_align_t),
313 "::",
314 stringify!(__clang_max_align_nonce1)
315 )
316 );
317 assert_eq!(
318 unsafe { ::std::ptr::addr_of!((*ptr).__clang_max_align_nonce2) as usize - ptr as usize },
319 16usize,
320 concat!(
321 "Offset of field: ",
322 stringify!(max_align_t),
323 "::",
324 stringify!(__clang_max_align_nonce2)
325 )
326 );
327}
328pub type _Float32 = f32;
329pub type _Float64 = f64;
330pub type _Float32x = f64;
331pub type _Float64x = u128;
332#[repr(C)]
333#[derive(Debug, Copy, Clone)]
334pub struct div_t {
335 pub quot: libc::c_int,
336 pub rem: libc::c_int,
337}
338#[test]
339fn bindgen_test_layout_div_t() {
340 const UNINIT: ::std::mem::MaybeUninit<div_t> = ::std::mem::MaybeUninit::uninit();
341 let ptr = UNINIT.as_ptr();
342 assert_eq!(
343 ::std::mem::size_of::<div_t>(),
344 8usize,
345 concat!("Size of: ", stringify!(div_t))
346 );
347 assert_eq!(
348 ::std::mem::align_of::<div_t>(),
349 4usize,
350 concat!("Alignment of ", stringify!(div_t))
351 );
352 assert_eq!(
353 unsafe { ::std::ptr::addr_of!((*ptr).quot) as usize - ptr as usize },
354 0usize,
355 concat!(
356 "Offset of field: ",
357 stringify!(div_t),
358 "::",
359 stringify!(quot)
360 )
361 );
362 assert_eq!(
363 unsafe { ::std::ptr::addr_of!((*ptr).rem) as usize - ptr as usize },
364 4usize,
365 concat!(
366 "Offset of field: ",
367 stringify!(div_t),
368 "::",
369 stringify!(rem)
370 )
371 );
372}
373#[repr(C)]
374#[derive(Debug, Copy, Clone)]
375pub struct ldiv_t {
376 pub quot: libc::c_long,
377 pub rem: libc::c_long,
378}
379#[test]
380fn bindgen_test_layout_ldiv_t() {
381 const UNINIT: ::std::mem::MaybeUninit<ldiv_t> = ::std::mem::MaybeUninit::uninit();
382 let ptr = UNINIT.as_ptr();
383 assert_eq!(
384 ::std::mem::size_of::<ldiv_t>(),
385 16usize,
386 concat!("Size of: ", stringify!(ldiv_t))
387 );
388 assert_eq!(
389 ::std::mem::align_of::<ldiv_t>(),
390 8usize,
391 concat!("Alignment of ", stringify!(ldiv_t))
392 );
393 assert_eq!(
394 unsafe { ::std::ptr::addr_of!((*ptr).quot) as usize - ptr as usize },
395 0usize,
396 concat!(
397 "Offset of field: ",
398 stringify!(ldiv_t),
399 "::",
400 stringify!(quot)
401 )
402 );
403 assert_eq!(
404 unsafe { ::std::ptr::addr_of!((*ptr).rem) as usize - ptr as usize },
405 8usize,
406 concat!(
407 "Offset of field: ",
408 stringify!(ldiv_t),
409 "::",
410 stringify!(rem)
411 )
412 );
413}
414#[repr(C)]
415#[derive(Debug, Copy, Clone)]
416pub struct lldiv_t {
417 pub quot: libc::c_longlong,
418 pub rem: libc::c_longlong,
419}
420#[test]
421fn bindgen_test_layout_lldiv_t() {
422 const UNINIT: ::std::mem::MaybeUninit<lldiv_t> = ::std::mem::MaybeUninit::uninit();
423 let ptr = UNINIT.as_ptr();
424 assert_eq!(
425 ::std::mem::size_of::<lldiv_t>(),
426 16usize,
427 concat!("Size of: ", stringify!(lldiv_t))
428 );
429 assert_eq!(
430 ::std::mem::align_of::<lldiv_t>(),
431 8usize,
432 concat!("Alignment of ", stringify!(lldiv_t))
433 );
434 assert_eq!(
435 unsafe { ::std::ptr::addr_of!((*ptr).quot) as usize - ptr as usize },
436 0usize,
437 concat!(
438 "Offset of field: ",
439 stringify!(lldiv_t),
440 "::",
441 stringify!(quot)
442 )
443 );
444 assert_eq!(
445 unsafe { ::std::ptr::addr_of!((*ptr).rem) as usize - ptr as usize },
446 8usize,
447 concat!(
448 "Offset of field: ",
449 stringify!(lldiv_t),
450 "::",
451 stringify!(rem)
452 )
453 );
454}
455extern "C" {
456 pub fn __ctype_get_mb_cur_max() -> usize;
457}
458extern "C" {
459 pub fn atof(__nptr: *const libc::c_char) -> f64;
460}
461extern "C" {
462 pub fn atoi(__nptr: *const libc::c_char) -> libc::c_int;
463}
464extern "C" {
465 pub fn atol(__nptr: *const libc::c_char) -> libc::c_long;
466}
467extern "C" {
468 pub fn atoll(__nptr: *const libc::c_char) -> libc::c_longlong;
469}
470extern "C" {
471 pub fn strtod(__nptr: *const libc::c_char, __endptr: *mut *mut libc::c_char) -> f64;
472}
473extern "C" {
474 pub fn strtof(__nptr: *const libc::c_char, __endptr: *mut *mut libc::c_char) -> f32;
475}
476extern "C" {
477 pub fn strtold(__nptr: *const libc::c_char, __endptr: *mut *mut libc::c_char) -> u128;
478}
479extern "C" {
480 pub fn strtol(
481 __nptr: *const libc::c_char,
482 __endptr: *mut *mut libc::c_char,
483 __base: libc::c_int,
484 ) -> libc::c_long;
485}
486extern "C" {
487 pub fn strtoul(
488 __nptr: *const libc::c_char,
489 __endptr: *mut *mut libc::c_char,
490 __base: libc::c_int,
491 ) -> libc::c_ulong;
492}
493extern "C" {
494 pub fn strtoq(
495 __nptr: *const libc::c_char,
496 __endptr: *mut *mut libc::c_char,
497 __base: libc::c_int,
498 ) -> libc::c_longlong;
499}
500extern "C" {
501 pub fn strtouq(
502 __nptr: *const libc::c_char,
503 __endptr: *mut *mut libc::c_char,
504 __base: libc::c_int,
505 ) -> libc::c_ulonglong;
506}
507extern "C" {
508 pub fn strtoll(
509 __nptr: *const libc::c_char,
510 __endptr: *mut *mut libc::c_char,
511 __base: libc::c_int,
512 ) -> libc::c_longlong;
513}
514extern "C" {
515 pub fn strtoull(
516 __nptr: *const libc::c_char,
517 __endptr: *mut *mut libc::c_char,
518 __base: libc::c_int,
519 ) -> libc::c_ulonglong;
520}
521extern "C" {
522 pub fn l64a(__n: libc::c_long) -> *mut libc::c_char;
523}
524extern "C" {
525 pub fn a64l(__s: *const libc::c_char) -> libc::c_long;
526}
527pub type u_char = __u_char;
528pub type u_short = __u_short;
529pub type u_int = __u_int;
530pub type u_long = __u_long;
531pub type quad_t = __quad_t;
532pub type u_quad_t = __u_quad_t;
533pub type fsid_t = __fsid_t;
534pub type loff_t = __loff_t;
535pub type ino_t = __ino_t;
536pub type dev_t = __dev_t;
537pub type gid_t = __gid_t;
538pub type mode_t = __mode_t;
539pub type nlink_t = __nlink_t;
540pub type uid_t = __uid_t;
541pub type off_t = __off_t;
542pub type pid_t = __pid_t;
543pub type id_t = __id_t;
544pub type daddr_t = __daddr_t;
545pub type caddr_t = __caddr_t;
546pub type key_t = __key_t;
547pub type clock_t = __clock_t;
548pub type clockid_t = __clockid_t;
549pub type time_t = __time_t;
550pub type timer_t = __timer_t;
551pub type ulong = libc::c_ulong;
552pub type ushort = libc::c_ushort;
553pub type uint = libc::c_uint;
554pub type u_int8_t = __uint8_t;
555pub type u_int16_t = __uint16_t;
556pub type u_int32_t = __uint32_t;
557pub type u_int64_t = __uint64_t;
558pub type register_t = libc::c_long;
559#[repr(C)]
560#[derive(Debug, Copy, Clone)]
561pub struct __sigset_t {
562 pub __val: [libc::c_ulong; 16usize],
563}
564#[test]
565fn bindgen_test_layout___sigset_t() {
566 const UNINIT: ::std::mem::MaybeUninit<__sigset_t> = ::std::mem::MaybeUninit::uninit();
567 let ptr = UNINIT.as_ptr();
568 assert_eq!(
569 ::std::mem::size_of::<__sigset_t>(),
570 128usize,
571 concat!("Size of: ", stringify!(__sigset_t))
572 );
573 assert_eq!(
574 ::std::mem::align_of::<__sigset_t>(),
575 8usize,
576 concat!("Alignment of ", stringify!(__sigset_t))
577 );
578 assert_eq!(
579 unsafe { ::std::ptr::addr_of!((*ptr).__val) as usize - ptr as usize },
580 0usize,
581 concat!(
582 "Offset of field: ",
583 stringify!(__sigset_t),
584 "::",
585 stringify!(__val)
586 )
587 );
588}
589pub type sigset_t = __sigset_t;
590#[repr(C)]
591#[derive(Debug, Copy, Clone)]
592pub struct timeval {
593 pub tv_sec: __time_t,
594 pub tv_usec: __suseconds_t,
595}
596#[test]
597fn bindgen_test_layout_timeval() {
598 const UNINIT: ::std::mem::MaybeUninit<timeval> = ::std::mem::MaybeUninit::uninit();
599 let ptr = UNINIT.as_ptr();
600 assert_eq!(
601 ::std::mem::size_of::<timeval>(),
602 16usize,
603 concat!("Size of: ", stringify!(timeval))
604 );
605 assert_eq!(
606 ::std::mem::align_of::<timeval>(),
607 8usize,
608 concat!("Alignment of ", stringify!(timeval))
609 );
610 assert_eq!(
611 unsafe { ::std::ptr::addr_of!((*ptr).tv_sec) as usize - ptr as usize },
612 0usize,
613 concat!(
614 "Offset of field: ",
615 stringify!(timeval),
616 "::",
617 stringify!(tv_sec)
618 )
619 );
620 assert_eq!(
621 unsafe { ::std::ptr::addr_of!((*ptr).tv_usec) as usize - ptr as usize },
622 8usize,
623 concat!(
624 "Offset of field: ",
625 stringify!(timeval),
626 "::",
627 stringify!(tv_usec)
628 )
629 );
630}
631#[repr(C)]
632#[derive(Debug, Copy, Clone)]
633pub struct timespec {
634 pub tv_sec: __time_t,
635 pub tv_nsec: __syscall_slong_t,
636}
637#[test]
638fn bindgen_test_layout_timespec() {
639 const UNINIT: ::std::mem::MaybeUninit<timespec> = ::std::mem::MaybeUninit::uninit();
640 let ptr = UNINIT.as_ptr();
641 assert_eq!(
642 ::std::mem::size_of::<timespec>(),
643 16usize,
644 concat!("Size of: ", stringify!(timespec))
645 );
646 assert_eq!(
647 ::std::mem::align_of::<timespec>(),
648 8usize,
649 concat!("Alignment of ", stringify!(timespec))
650 );
651 assert_eq!(
652 unsafe { ::std::ptr::addr_of!((*ptr).tv_sec) as usize - ptr as usize },
653 0usize,
654 concat!(
655 "Offset of field: ",
656 stringify!(timespec),
657 "::",
658 stringify!(tv_sec)
659 )
660 );
661 assert_eq!(
662 unsafe { ::std::ptr::addr_of!((*ptr).tv_nsec) as usize - ptr as usize },
663 8usize,
664 concat!(
665 "Offset of field: ",
666 stringify!(timespec),
667 "::",
668 stringify!(tv_nsec)
669 )
670 );
671}
672pub type suseconds_t = __suseconds_t;
673pub type __fd_mask = libc::c_long;
674#[repr(C)]
675#[derive(Debug, Copy, Clone)]
676pub struct fd_set {
677 pub __fds_bits: [__fd_mask; 16usize],
678}
679#[test]
680fn bindgen_test_layout_fd_set() {
681 const UNINIT: ::std::mem::MaybeUninit<fd_set> = ::std::mem::MaybeUninit::uninit();
682 let ptr = UNINIT.as_ptr();
683 assert_eq!(
684 ::std::mem::size_of::<fd_set>(),
685 128usize,
686 concat!("Size of: ", stringify!(fd_set))
687 );
688 assert_eq!(
689 ::std::mem::align_of::<fd_set>(),
690 8usize,
691 concat!("Alignment of ", stringify!(fd_set))
692 );
693 assert_eq!(
694 unsafe { ::std::ptr::addr_of!((*ptr).__fds_bits) as usize - ptr as usize },
695 0usize,
696 concat!(
697 "Offset of field: ",
698 stringify!(fd_set),
699 "::",
700 stringify!(__fds_bits)
701 )
702 );
703}
704pub type fd_mask = __fd_mask;
705extern "C" {
706 pub fn select(
707 __nfds: libc::c_int,
708 __readfds: *mut fd_set,
709 __writefds: *mut fd_set,
710 __exceptfds: *mut fd_set,
711 __timeout: *mut timeval,
712 ) -> libc::c_int;
713}
714extern "C" {
715 pub fn pselect(
716 __nfds: libc::c_int,
717 __readfds: *mut fd_set,
718 __writefds: *mut fd_set,
719 __exceptfds: *mut fd_set,
720 __timeout: *const timespec,
721 __sigmask: *const __sigset_t,
722 ) -> libc::c_int;
723}
724pub type blksize_t = __blksize_t;
725pub type blkcnt_t = __blkcnt_t;
726pub type fsblkcnt_t = __fsblkcnt_t;
727pub type fsfilcnt_t = __fsfilcnt_t;
728#[repr(C)]
729#[derive(Copy, Clone)]
730pub union __atomic_wide_counter {
731 pub __value64: libc::c_ulonglong,
732 pub __value32: __atomic_wide_counter__bindgen_ty_1,
733}
734#[repr(C)]
735#[derive(Debug, Copy, Clone)]
736pub struct __atomic_wide_counter__bindgen_ty_1 {
737 pub __low: libc::c_uint,
738 pub __high: libc::c_uint,
739}
740#[test]
741fn bindgen_test_layout___atomic_wide_counter__bindgen_ty_1() {
742 const UNINIT: ::std::mem::MaybeUninit<__atomic_wide_counter__bindgen_ty_1> =
743 ::std::mem::MaybeUninit::uninit();
744 let ptr = UNINIT.as_ptr();
745 assert_eq!(
746 ::std::mem::size_of::<__atomic_wide_counter__bindgen_ty_1>(),
747 8usize,
748 concat!("Size of: ", stringify!(__atomic_wide_counter__bindgen_ty_1))
749 );
750 assert_eq!(
751 ::std::mem::align_of::<__atomic_wide_counter__bindgen_ty_1>(),
752 4usize,
753 concat!(
754 "Alignment of ",
755 stringify!(__atomic_wide_counter__bindgen_ty_1)
756 )
757 );
758 assert_eq!(
759 unsafe { ::std::ptr::addr_of!((*ptr).__low) as usize - ptr as usize },
760 0usize,
761 concat!(
762 "Offset of field: ",
763 stringify!(__atomic_wide_counter__bindgen_ty_1),
764 "::",
765 stringify!(__low)
766 )
767 );
768 assert_eq!(
769 unsafe { ::std::ptr::addr_of!((*ptr).__high) as usize - ptr as usize },
770 4usize,
771 concat!(
772 "Offset of field: ",
773 stringify!(__atomic_wide_counter__bindgen_ty_1),
774 "::",
775 stringify!(__high)
776 )
777 );
778}
779#[test]
780fn bindgen_test_layout___atomic_wide_counter() {
781 const UNINIT: ::std::mem::MaybeUninit<__atomic_wide_counter> =
782 ::std::mem::MaybeUninit::uninit();
783 let ptr = UNINIT.as_ptr();
784 assert_eq!(
785 ::std::mem::size_of::<__atomic_wide_counter>(),
786 8usize,
787 concat!("Size of: ", stringify!(__atomic_wide_counter))
788 );
789 assert_eq!(
790 ::std::mem::align_of::<__atomic_wide_counter>(),
791 8usize,
792 concat!("Alignment of ", stringify!(__atomic_wide_counter))
793 );
794 assert_eq!(
795 unsafe { ::std::ptr::addr_of!((*ptr).__value64) as usize - ptr as usize },
796 0usize,
797 concat!(
798 "Offset of field: ",
799 stringify!(__atomic_wide_counter),
800 "::",
801 stringify!(__value64)
802 )
803 );
804 assert_eq!(
805 unsafe { ::std::ptr::addr_of!((*ptr).__value32) as usize - ptr as usize },
806 0usize,
807 concat!(
808 "Offset of field: ",
809 stringify!(__atomic_wide_counter),
810 "::",
811 stringify!(__value32)
812 )
813 );
814}
815#[repr(C)]
816#[derive(Debug, Copy, Clone)]
817pub struct __pthread_internal_list {
818 pub __prev: *mut __pthread_internal_list,
819 pub __next: *mut __pthread_internal_list,
820}
821#[test]
822fn bindgen_test_layout___pthread_internal_list() {
823 const UNINIT: ::std::mem::MaybeUninit<__pthread_internal_list> =
824 ::std::mem::MaybeUninit::uninit();
825 let ptr = UNINIT.as_ptr();
826 assert_eq!(
827 ::std::mem::size_of::<__pthread_internal_list>(),
828 16usize,
829 concat!("Size of: ", stringify!(__pthread_internal_list))
830 );
831 assert_eq!(
832 ::std::mem::align_of::<__pthread_internal_list>(),
833 8usize,
834 concat!("Alignment of ", stringify!(__pthread_internal_list))
835 );
836 assert_eq!(
837 unsafe { ::std::ptr::addr_of!((*ptr).__prev) as usize - ptr as usize },
838 0usize,
839 concat!(
840 "Offset of field: ",
841 stringify!(__pthread_internal_list),
842 "::",
843 stringify!(__prev)
844 )
845 );
846 assert_eq!(
847 unsafe { ::std::ptr::addr_of!((*ptr).__next) as usize - ptr as usize },
848 8usize,
849 concat!(
850 "Offset of field: ",
851 stringify!(__pthread_internal_list),
852 "::",
853 stringify!(__next)
854 )
855 );
856}
857pub type __pthread_list_t = __pthread_internal_list;
858#[repr(C)]
859#[derive(Debug, Copy, Clone)]
860pub struct __pthread_internal_slist {
861 pub __next: *mut __pthread_internal_slist,
862}
863#[test]
864fn bindgen_test_layout___pthread_internal_slist() {
865 const UNINIT: ::std::mem::MaybeUninit<__pthread_internal_slist> =
866 ::std::mem::MaybeUninit::uninit();
867 let ptr = UNINIT.as_ptr();
868 assert_eq!(
869 ::std::mem::size_of::<__pthread_internal_slist>(),
870 8usize,
871 concat!("Size of: ", stringify!(__pthread_internal_slist))
872 );
873 assert_eq!(
874 ::std::mem::align_of::<__pthread_internal_slist>(),
875 8usize,
876 concat!("Alignment of ", stringify!(__pthread_internal_slist))
877 );
878 assert_eq!(
879 unsafe { ::std::ptr::addr_of!((*ptr).__next) as usize - ptr as usize },
880 0usize,
881 concat!(
882 "Offset of field: ",
883 stringify!(__pthread_internal_slist),
884 "::",
885 stringify!(__next)
886 )
887 );
888}
889pub type __pthread_slist_t = __pthread_internal_slist;
890#[repr(C)]
891#[derive(Debug, Copy, Clone)]
892pub struct __pthread_mutex_s {
893 pub __lock: libc::c_int,
894 pub __count: libc::c_uint,
895 pub __owner: libc::c_int,
896 pub __nusers: libc::c_uint,
897 pub __kind: libc::c_int,
898 pub __spins: libc::c_short,
899 pub __elision: libc::c_short,
900 pub __list: __pthread_list_t,
901}
902#[test]
903fn bindgen_test_layout___pthread_mutex_s() {
904 const UNINIT: ::std::mem::MaybeUninit<__pthread_mutex_s> = ::std::mem::MaybeUninit::uninit();
905 let ptr = UNINIT.as_ptr();
906 assert_eq!(
907 ::std::mem::size_of::<__pthread_mutex_s>(),
908 40usize,
909 concat!("Size of: ", stringify!(__pthread_mutex_s))
910 );
911 assert_eq!(
912 ::std::mem::align_of::<__pthread_mutex_s>(),
913 8usize,
914 concat!("Alignment of ", stringify!(__pthread_mutex_s))
915 );
916 assert_eq!(
917 unsafe { ::std::ptr::addr_of!((*ptr).__lock) as usize - ptr as usize },
918 0usize,
919 concat!(
920 "Offset of field: ",
921 stringify!(__pthread_mutex_s),
922 "::",
923 stringify!(__lock)
924 )
925 );
926 assert_eq!(
927 unsafe { ::std::ptr::addr_of!((*ptr).__count) as usize - ptr as usize },
928 4usize,
929 concat!(
930 "Offset of field: ",
931 stringify!(__pthread_mutex_s),
932 "::",
933 stringify!(__count)
934 )
935 );
936 assert_eq!(
937 unsafe { ::std::ptr::addr_of!((*ptr).__owner) as usize - ptr as usize },
938 8usize,
939 concat!(
940 "Offset of field: ",
941 stringify!(__pthread_mutex_s),
942 "::",
943 stringify!(__owner)
944 )
945 );
946 assert_eq!(
947 unsafe { ::std::ptr::addr_of!((*ptr).__nusers) as usize - ptr as usize },
948 12usize,
949 concat!(
950 "Offset of field: ",
951 stringify!(__pthread_mutex_s),
952 "::",
953 stringify!(__nusers)
954 )
955 );
956 assert_eq!(
957 unsafe { ::std::ptr::addr_of!((*ptr).__kind) as usize - ptr as usize },
958 16usize,
959 concat!(
960 "Offset of field: ",
961 stringify!(__pthread_mutex_s),
962 "::",
963 stringify!(__kind)
964 )
965 );
966 assert_eq!(
967 unsafe { ::std::ptr::addr_of!((*ptr).__spins) as usize - ptr as usize },
968 20usize,
969 concat!(
970 "Offset of field: ",
971 stringify!(__pthread_mutex_s),
972 "::",
973 stringify!(__spins)
974 )
975 );
976 assert_eq!(
977 unsafe { ::std::ptr::addr_of!((*ptr).__elision) as usize - ptr as usize },
978 22usize,
979 concat!(
980 "Offset of field: ",
981 stringify!(__pthread_mutex_s),
982 "::",
983 stringify!(__elision)
984 )
985 );
986 assert_eq!(
987 unsafe { ::std::ptr::addr_of!((*ptr).__list) as usize - ptr as usize },
988 24usize,
989 concat!(
990 "Offset of field: ",
991 stringify!(__pthread_mutex_s),
992 "::",
993 stringify!(__list)
994 )
995 );
996}
997#[repr(C)]
998#[derive(Debug, Copy, Clone)]
999pub struct __pthread_rwlock_arch_t {
1000 pub __readers: libc::c_uint,
1001 pub __writers: libc::c_uint,
1002 pub __wrphase_futex: libc::c_uint,
1003 pub __writers_futex: libc::c_uint,
1004 pub __pad3: libc::c_uint,
1005 pub __pad4: libc::c_uint,
1006 pub __cur_writer: libc::c_int,
1007 pub __shared: libc::c_int,
1008 pub __rwelision: libc::c_schar,
1009 pub __pad1: [libc::c_uchar; 7usize],
1010 pub __pad2: libc::c_ulong,
1011 pub __flags: libc::c_uint,
1012}
1013#[test]
1014fn bindgen_test_layout___pthread_rwlock_arch_t() {
1015 const UNINIT: ::std::mem::MaybeUninit<__pthread_rwlock_arch_t> =
1016 ::std::mem::MaybeUninit::uninit();
1017 let ptr = UNINIT.as_ptr();
1018 assert_eq!(
1019 ::std::mem::size_of::<__pthread_rwlock_arch_t>(),
1020 56usize,
1021 concat!("Size of: ", stringify!(__pthread_rwlock_arch_t))
1022 );
1023 assert_eq!(
1024 ::std::mem::align_of::<__pthread_rwlock_arch_t>(),
1025 8usize,
1026 concat!("Alignment of ", stringify!(__pthread_rwlock_arch_t))
1027 );
1028 assert_eq!(
1029 unsafe { ::std::ptr::addr_of!((*ptr).__readers) as usize - ptr as usize },
1030 0usize,
1031 concat!(
1032 "Offset of field: ",
1033 stringify!(__pthread_rwlock_arch_t),
1034 "::",
1035 stringify!(__readers)
1036 )
1037 );
1038 assert_eq!(
1039 unsafe { ::std::ptr::addr_of!((*ptr).__writers) as usize - ptr as usize },
1040 4usize,
1041 concat!(
1042 "Offset of field: ",
1043 stringify!(__pthread_rwlock_arch_t),
1044 "::",
1045 stringify!(__writers)
1046 )
1047 );
1048 assert_eq!(
1049 unsafe { ::std::ptr::addr_of!((*ptr).__wrphase_futex) as usize - ptr as usize },
1050 8usize,
1051 concat!(
1052 "Offset of field: ",
1053 stringify!(__pthread_rwlock_arch_t),
1054 "::",
1055 stringify!(__wrphase_futex)
1056 )
1057 );
1058 assert_eq!(
1059 unsafe { ::std::ptr::addr_of!((*ptr).__writers_futex) as usize - ptr as usize },
1060 12usize,
1061 concat!(
1062 "Offset of field: ",
1063 stringify!(__pthread_rwlock_arch_t),
1064 "::",
1065 stringify!(__writers_futex)
1066 )
1067 );
1068 assert_eq!(
1069 unsafe { ::std::ptr::addr_of!((*ptr).__pad3) as usize - ptr as usize },
1070 16usize,
1071 concat!(
1072 "Offset of field: ",
1073 stringify!(__pthread_rwlock_arch_t),
1074 "::",
1075 stringify!(__pad3)
1076 )
1077 );
1078 assert_eq!(
1079 unsafe { ::std::ptr::addr_of!((*ptr).__pad4) as usize - ptr as usize },
1080 20usize,
1081 concat!(
1082 "Offset of field: ",
1083 stringify!(__pthread_rwlock_arch_t),
1084 "::",
1085 stringify!(__pad4)
1086 )
1087 );
1088 assert_eq!(
1089 unsafe { ::std::ptr::addr_of!((*ptr).__cur_writer) as usize - ptr as usize },
1090 24usize,
1091 concat!(
1092 "Offset of field: ",
1093 stringify!(__pthread_rwlock_arch_t),
1094 "::",
1095 stringify!(__cur_writer)
1096 )
1097 );
1098 assert_eq!(
1099 unsafe { ::std::ptr::addr_of!((*ptr).__shared) as usize - ptr as usize },
1100 28usize,
1101 concat!(
1102 "Offset of field: ",
1103 stringify!(__pthread_rwlock_arch_t),
1104 "::",
1105 stringify!(__shared)
1106 )
1107 );
1108 assert_eq!(
1109 unsafe { ::std::ptr::addr_of!((*ptr).__rwelision) as usize - ptr as usize },
1110 32usize,
1111 concat!(
1112 "Offset of field: ",
1113 stringify!(__pthread_rwlock_arch_t),
1114 "::",
1115 stringify!(__rwelision)
1116 )
1117 );
1118 assert_eq!(
1119 unsafe { ::std::ptr::addr_of!((*ptr).__pad1) as usize - ptr as usize },
1120 33usize,
1121 concat!(
1122 "Offset of field: ",
1123 stringify!(__pthread_rwlock_arch_t),
1124 "::",
1125 stringify!(__pad1)
1126 )
1127 );
1128 assert_eq!(
1129 unsafe { ::std::ptr::addr_of!((*ptr).__pad2) as usize - ptr as usize },
1130 40usize,
1131 concat!(
1132 "Offset of field: ",
1133 stringify!(__pthread_rwlock_arch_t),
1134 "::",
1135 stringify!(__pad2)
1136 )
1137 );
1138 assert_eq!(
1139 unsafe { ::std::ptr::addr_of!((*ptr).__flags) as usize - ptr as usize },
1140 48usize,
1141 concat!(
1142 "Offset of field: ",
1143 stringify!(__pthread_rwlock_arch_t),
1144 "::",
1145 stringify!(__flags)
1146 )
1147 );
1148}
1149#[repr(C)]
1150#[derive(Copy, Clone)]
1151pub struct __pthread_cond_s {
1152 pub __wseq: __atomic_wide_counter,
1153 pub __g1_start: __atomic_wide_counter,
1154 pub __g_refs: [libc::c_uint; 2usize],
1155 pub __g_size: [libc::c_uint; 2usize],
1156 pub __g1_orig_size: libc::c_uint,
1157 pub __wrefs: libc::c_uint,
1158 pub __g_signals: [libc::c_uint; 2usize],
1159}
1160#[test]
1161fn bindgen_test_layout___pthread_cond_s() {
1162 const UNINIT: ::std::mem::MaybeUninit<__pthread_cond_s> = ::std::mem::MaybeUninit::uninit();
1163 let ptr = UNINIT.as_ptr();
1164 assert_eq!(
1165 ::std::mem::size_of::<__pthread_cond_s>(),
1166 48usize,
1167 concat!("Size of: ", stringify!(__pthread_cond_s))
1168 );
1169 assert_eq!(
1170 ::std::mem::align_of::<__pthread_cond_s>(),
1171 8usize,
1172 concat!("Alignment of ", stringify!(__pthread_cond_s))
1173 );
1174 assert_eq!(
1175 unsafe { ::std::ptr::addr_of!((*ptr).__wseq) as usize - ptr as usize },
1176 0usize,
1177 concat!(
1178 "Offset of field: ",
1179 stringify!(__pthread_cond_s),
1180 "::",
1181 stringify!(__wseq)
1182 )
1183 );
1184 assert_eq!(
1185 unsafe { ::std::ptr::addr_of!((*ptr).__g1_start) as usize - ptr as usize },
1186 8usize,
1187 concat!(
1188 "Offset of field: ",
1189 stringify!(__pthread_cond_s),
1190 "::",
1191 stringify!(__g1_start)
1192 )
1193 );
1194 assert_eq!(
1195 unsafe { ::std::ptr::addr_of!((*ptr).__g_refs) as usize - ptr as usize },
1196 16usize,
1197 concat!(
1198 "Offset of field: ",
1199 stringify!(__pthread_cond_s),
1200 "::",
1201 stringify!(__g_refs)
1202 )
1203 );
1204 assert_eq!(
1205 unsafe { ::std::ptr::addr_of!((*ptr).__g_size) as usize - ptr as usize },
1206 24usize,
1207 concat!(
1208 "Offset of field: ",
1209 stringify!(__pthread_cond_s),
1210 "::",
1211 stringify!(__g_size)
1212 )
1213 );
1214 assert_eq!(
1215 unsafe { ::std::ptr::addr_of!((*ptr).__g1_orig_size) as usize - ptr as usize },
1216 32usize,
1217 concat!(
1218 "Offset of field: ",
1219 stringify!(__pthread_cond_s),
1220 "::",
1221 stringify!(__g1_orig_size)
1222 )
1223 );
1224 assert_eq!(
1225 unsafe { ::std::ptr::addr_of!((*ptr).__wrefs) as usize - ptr as usize },
1226 36usize,
1227 concat!(
1228 "Offset of field: ",
1229 stringify!(__pthread_cond_s),
1230 "::",
1231 stringify!(__wrefs)
1232 )
1233 );
1234 assert_eq!(
1235 unsafe { ::std::ptr::addr_of!((*ptr).__g_signals) as usize - ptr as usize },
1236 40usize,
1237 concat!(
1238 "Offset of field: ",
1239 stringify!(__pthread_cond_s),
1240 "::",
1241 stringify!(__g_signals)
1242 )
1243 );
1244}
1245pub type __tss_t = libc::c_uint;
1246pub type __thrd_t = libc::c_ulong;
1247#[repr(C)]
1248#[derive(Debug, Copy, Clone)]
1249pub struct __once_flag {
1250 pub __data: libc::c_int,
1251}
1252#[test]
1253fn bindgen_test_layout___once_flag() {
1254 const UNINIT: ::std::mem::MaybeUninit<__once_flag> = ::std::mem::MaybeUninit::uninit();
1255 let ptr = UNINIT.as_ptr();
1256 assert_eq!(
1257 ::std::mem::size_of::<__once_flag>(),
1258 4usize,
1259 concat!("Size of: ", stringify!(__once_flag))
1260 );
1261 assert_eq!(
1262 ::std::mem::align_of::<__once_flag>(),
1263 4usize,
1264 concat!("Alignment of ", stringify!(__once_flag))
1265 );
1266 assert_eq!(
1267 unsafe { ::std::ptr::addr_of!((*ptr).__data) as usize - ptr as usize },
1268 0usize,
1269 concat!(
1270 "Offset of field: ",
1271 stringify!(__once_flag),
1272 "::",
1273 stringify!(__data)
1274 )
1275 );
1276}
1277pub type pthread_t = libc::c_ulong;
1278#[repr(C)]
1279#[derive(Copy, Clone)]
1280pub union pthread_mutexattr_t {
1281 pub __size: [libc::c_char; 4usize],
1282 pub __align: libc::c_int,
1283}
1284#[test]
1285fn bindgen_test_layout_pthread_mutexattr_t() {
1286 const UNINIT: ::std::mem::MaybeUninit<pthread_mutexattr_t> = ::std::mem::MaybeUninit::uninit();
1287 let ptr = UNINIT.as_ptr();
1288 assert_eq!(
1289 ::std::mem::size_of::<pthread_mutexattr_t>(),
1290 4usize,
1291 concat!("Size of: ", stringify!(pthread_mutexattr_t))
1292 );
1293 assert_eq!(
1294 ::std::mem::align_of::<pthread_mutexattr_t>(),
1295 4usize,
1296 concat!("Alignment of ", stringify!(pthread_mutexattr_t))
1297 );
1298 assert_eq!(
1299 unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
1300 0usize,
1301 concat!(
1302 "Offset of field: ",
1303 stringify!(pthread_mutexattr_t),
1304 "::",
1305 stringify!(__size)
1306 )
1307 );
1308 assert_eq!(
1309 unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
1310 0usize,
1311 concat!(
1312 "Offset of field: ",
1313 stringify!(pthread_mutexattr_t),
1314 "::",
1315 stringify!(__align)
1316 )
1317 );
1318}
1319#[repr(C)]
1320#[derive(Copy, Clone)]
1321pub union pthread_condattr_t {
1322 pub __size: [libc::c_char; 4usize],
1323 pub __align: libc::c_int,
1324}
1325#[test]
1326fn bindgen_test_layout_pthread_condattr_t() {
1327 const UNINIT: ::std::mem::MaybeUninit<pthread_condattr_t> = ::std::mem::MaybeUninit::uninit();
1328 let ptr = UNINIT.as_ptr();
1329 assert_eq!(
1330 ::std::mem::size_of::<pthread_condattr_t>(),
1331 4usize,
1332 concat!("Size of: ", stringify!(pthread_condattr_t))
1333 );
1334 assert_eq!(
1335 ::std::mem::align_of::<pthread_condattr_t>(),
1336 4usize,
1337 concat!("Alignment of ", stringify!(pthread_condattr_t))
1338 );
1339 assert_eq!(
1340 unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
1341 0usize,
1342 concat!(
1343 "Offset of field: ",
1344 stringify!(pthread_condattr_t),
1345 "::",
1346 stringify!(__size)
1347 )
1348 );
1349 assert_eq!(
1350 unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
1351 0usize,
1352 concat!(
1353 "Offset of field: ",
1354 stringify!(pthread_condattr_t),
1355 "::",
1356 stringify!(__align)
1357 )
1358 );
1359}
1360pub type pthread_key_t = libc::c_uint;
1361pub type pthread_once_t = libc::c_int;
1362#[repr(C)]
1363#[derive(Copy, Clone)]
1364pub union pthread_attr_t {
1365 pub __size: [libc::c_char; 56usize],
1366 pub __align: libc::c_long,
1367}
1368#[test]
1369fn bindgen_test_layout_pthread_attr_t() {
1370 const UNINIT: ::std::mem::MaybeUninit<pthread_attr_t> = ::std::mem::MaybeUninit::uninit();
1371 let ptr = UNINIT.as_ptr();
1372 assert_eq!(
1373 ::std::mem::size_of::<pthread_attr_t>(),
1374 56usize,
1375 concat!("Size of: ", stringify!(pthread_attr_t))
1376 );
1377 assert_eq!(
1378 ::std::mem::align_of::<pthread_attr_t>(),
1379 8usize,
1380 concat!("Alignment of ", stringify!(pthread_attr_t))
1381 );
1382 assert_eq!(
1383 unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
1384 0usize,
1385 concat!(
1386 "Offset of field: ",
1387 stringify!(pthread_attr_t),
1388 "::",
1389 stringify!(__size)
1390 )
1391 );
1392 assert_eq!(
1393 unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
1394 0usize,
1395 concat!(
1396 "Offset of field: ",
1397 stringify!(pthread_attr_t),
1398 "::",
1399 stringify!(__align)
1400 )
1401 );
1402}
1403#[repr(C)]
1404#[derive(Copy, Clone)]
1405pub union pthread_mutex_t {
1406 pub __data: __pthread_mutex_s,
1407 pub __size: [libc::c_char; 40usize],
1408 pub __align: libc::c_long,
1409}
1410#[test]
1411fn bindgen_test_layout_pthread_mutex_t() {
1412 const UNINIT: ::std::mem::MaybeUninit<pthread_mutex_t> = ::std::mem::MaybeUninit::uninit();
1413 let ptr = UNINIT.as_ptr();
1414 assert_eq!(
1415 ::std::mem::size_of::<pthread_mutex_t>(),
1416 40usize,
1417 concat!("Size of: ", stringify!(pthread_mutex_t))
1418 );
1419 assert_eq!(
1420 ::std::mem::align_of::<pthread_mutex_t>(),
1421 8usize,
1422 concat!("Alignment of ", stringify!(pthread_mutex_t))
1423 );
1424 assert_eq!(
1425 unsafe { ::std::ptr::addr_of!((*ptr).__data) as usize - ptr as usize },
1426 0usize,
1427 concat!(
1428 "Offset of field: ",
1429 stringify!(pthread_mutex_t),
1430 "::",
1431 stringify!(__data)
1432 )
1433 );
1434 assert_eq!(
1435 unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
1436 0usize,
1437 concat!(
1438 "Offset of field: ",
1439 stringify!(pthread_mutex_t),
1440 "::",
1441 stringify!(__size)
1442 )
1443 );
1444 assert_eq!(
1445 unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
1446 0usize,
1447 concat!(
1448 "Offset of field: ",
1449 stringify!(pthread_mutex_t),
1450 "::",
1451 stringify!(__align)
1452 )
1453 );
1454}
1455#[repr(C)]
1456#[derive(Copy, Clone)]
1457pub union pthread_cond_t {
1458 pub __data: __pthread_cond_s,
1459 pub __size: [libc::c_char; 48usize],
1460 pub __align: libc::c_longlong,
1461}
1462#[test]
1463fn bindgen_test_layout_pthread_cond_t() {
1464 const UNINIT: ::std::mem::MaybeUninit<pthread_cond_t> = ::std::mem::MaybeUninit::uninit();
1465 let ptr = UNINIT.as_ptr();
1466 assert_eq!(
1467 ::std::mem::size_of::<pthread_cond_t>(),
1468 48usize,
1469 concat!("Size of: ", stringify!(pthread_cond_t))
1470 );
1471 assert_eq!(
1472 ::std::mem::align_of::<pthread_cond_t>(),
1473 8usize,
1474 concat!("Alignment of ", stringify!(pthread_cond_t))
1475 );
1476 assert_eq!(
1477 unsafe { ::std::ptr::addr_of!((*ptr).__data) as usize - ptr as usize },
1478 0usize,
1479 concat!(
1480 "Offset of field: ",
1481 stringify!(pthread_cond_t),
1482 "::",
1483 stringify!(__data)
1484 )
1485 );
1486 assert_eq!(
1487 unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
1488 0usize,
1489 concat!(
1490 "Offset of field: ",
1491 stringify!(pthread_cond_t),
1492 "::",
1493 stringify!(__size)
1494 )
1495 );
1496 assert_eq!(
1497 unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
1498 0usize,
1499 concat!(
1500 "Offset of field: ",
1501 stringify!(pthread_cond_t),
1502 "::",
1503 stringify!(__align)
1504 )
1505 );
1506}
1507#[repr(C)]
1508#[derive(Copy, Clone)]
1509pub union pthread_rwlock_t {
1510 pub __data: __pthread_rwlock_arch_t,
1511 pub __size: [libc::c_char; 56usize],
1512 pub __align: libc::c_long,
1513}
1514#[test]
1515fn bindgen_test_layout_pthread_rwlock_t() {
1516 const UNINIT: ::std::mem::MaybeUninit<pthread_rwlock_t> = ::std::mem::MaybeUninit::uninit();
1517 let ptr = UNINIT.as_ptr();
1518 assert_eq!(
1519 ::std::mem::size_of::<pthread_rwlock_t>(),
1520 56usize,
1521 concat!("Size of: ", stringify!(pthread_rwlock_t))
1522 );
1523 assert_eq!(
1524 ::std::mem::align_of::<pthread_rwlock_t>(),
1525 8usize,
1526 concat!("Alignment of ", stringify!(pthread_rwlock_t))
1527 );
1528 assert_eq!(
1529 unsafe { ::std::ptr::addr_of!((*ptr).__data) as usize - ptr as usize },
1530 0usize,
1531 concat!(
1532 "Offset of field: ",
1533 stringify!(pthread_rwlock_t),
1534 "::",
1535 stringify!(__data)
1536 )
1537 );
1538 assert_eq!(
1539 unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
1540 0usize,
1541 concat!(
1542 "Offset of field: ",
1543 stringify!(pthread_rwlock_t),
1544 "::",
1545 stringify!(__size)
1546 )
1547 );
1548 assert_eq!(
1549 unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
1550 0usize,
1551 concat!(
1552 "Offset of field: ",
1553 stringify!(pthread_rwlock_t),
1554 "::",
1555 stringify!(__align)
1556 )
1557 );
1558}
1559#[repr(C)]
1560#[derive(Copy, Clone)]
1561pub union pthread_rwlockattr_t {
1562 pub __size: [libc::c_char; 8usize],
1563 pub __align: libc::c_long,
1564}
1565#[test]
1566fn bindgen_test_layout_pthread_rwlockattr_t() {
1567 const UNINIT: ::std::mem::MaybeUninit<pthread_rwlockattr_t> = ::std::mem::MaybeUninit::uninit();
1568 let ptr = UNINIT.as_ptr();
1569 assert_eq!(
1570 ::std::mem::size_of::<pthread_rwlockattr_t>(),
1571 8usize,
1572 concat!("Size of: ", stringify!(pthread_rwlockattr_t))
1573 );
1574 assert_eq!(
1575 ::std::mem::align_of::<pthread_rwlockattr_t>(),
1576 8usize,
1577 concat!("Alignment of ", stringify!(pthread_rwlockattr_t))
1578 );
1579 assert_eq!(
1580 unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
1581 0usize,
1582 concat!(
1583 "Offset of field: ",
1584 stringify!(pthread_rwlockattr_t),
1585 "::",
1586 stringify!(__size)
1587 )
1588 );
1589 assert_eq!(
1590 unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
1591 0usize,
1592 concat!(
1593 "Offset of field: ",
1594 stringify!(pthread_rwlockattr_t),
1595 "::",
1596 stringify!(__align)
1597 )
1598 );
1599}
1600pub type pthread_spinlock_t = libc::c_int;
1601#[repr(C)]
1602#[derive(Copy, Clone)]
1603pub union pthread_barrier_t {
1604 pub __size: [libc::c_char; 32usize],
1605 pub __align: libc::c_long,
1606}
1607#[test]
1608fn bindgen_test_layout_pthread_barrier_t() {
1609 const UNINIT: ::std::mem::MaybeUninit<pthread_barrier_t> = ::std::mem::MaybeUninit::uninit();
1610 let ptr = UNINIT.as_ptr();
1611 assert_eq!(
1612 ::std::mem::size_of::<pthread_barrier_t>(),
1613 32usize,
1614 concat!("Size of: ", stringify!(pthread_barrier_t))
1615 );
1616 assert_eq!(
1617 ::std::mem::align_of::<pthread_barrier_t>(),
1618 8usize,
1619 concat!("Alignment of ", stringify!(pthread_barrier_t))
1620 );
1621 assert_eq!(
1622 unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
1623 0usize,
1624 concat!(
1625 "Offset of field: ",
1626 stringify!(pthread_barrier_t),
1627 "::",
1628 stringify!(__size)
1629 )
1630 );
1631 assert_eq!(
1632 unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
1633 0usize,
1634 concat!(
1635 "Offset of field: ",
1636 stringify!(pthread_barrier_t),
1637 "::",
1638 stringify!(__align)
1639 )
1640 );
1641}
1642#[repr(C)]
1643#[derive(Copy, Clone)]
1644pub union pthread_barrierattr_t {
1645 pub __size: [libc::c_char; 4usize],
1646 pub __align: libc::c_int,
1647}
1648#[test]
1649fn bindgen_test_layout_pthread_barrierattr_t() {
1650 const UNINIT: ::std::mem::MaybeUninit<pthread_barrierattr_t> =
1651 ::std::mem::MaybeUninit::uninit();
1652 let ptr = UNINIT.as_ptr();
1653 assert_eq!(
1654 ::std::mem::size_of::<pthread_barrierattr_t>(),
1655 4usize,
1656 concat!("Size of: ", stringify!(pthread_barrierattr_t))
1657 );
1658 assert_eq!(
1659 ::std::mem::align_of::<pthread_barrierattr_t>(),
1660 4usize,
1661 concat!("Alignment of ", stringify!(pthread_barrierattr_t))
1662 );
1663 assert_eq!(
1664 unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
1665 0usize,
1666 concat!(
1667 "Offset of field: ",
1668 stringify!(pthread_barrierattr_t),
1669 "::",
1670 stringify!(__size)
1671 )
1672 );
1673 assert_eq!(
1674 unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
1675 0usize,
1676 concat!(
1677 "Offset of field: ",
1678 stringify!(pthread_barrierattr_t),
1679 "::",
1680 stringify!(__align)
1681 )
1682 );
1683}
1684extern "C" {
1685 pub fn random() -> libc::c_long;
1686}
1687extern "C" {
1688 pub fn srandom(__seed: libc::c_uint);
1689}
1690extern "C" {
1691 pub fn initstate(
1692 __seed: libc::c_uint,
1693 __statebuf: *mut libc::c_char,
1694 __statelen: usize,
1695 ) -> *mut libc::c_char;
1696}
1697extern "C" {
1698 pub fn setstate(__statebuf: *mut libc::c_char) -> *mut libc::c_char;
1699}
1700#[repr(C)]
1701#[derive(Debug, Copy, Clone)]
1702pub struct random_data {
1703 pub fptr: *mut i32,
1704 pub rptr: *mut i32,
1705 pub state: *mut i32,
1706 pub rand_type: libc::c_int,
1707 pub rand_deg: libc::c_int,
1708 pub rand_sep: libc::c_int,
1709 pub end_ptr: *mut i32,
1710}
1711#[test]
1712fn bindgen_test_layout_random_data() {
1713 const UNINIT: ::std::mem::MaybeUninit<random_data> = ::std::mem::MaybeUninit::uninit();
1714 let ptr = UNINIT.as_ptr();
1715 assert_eq!(
1716 ::std::mem::size_of::<random_data>(),
1717 48usize,
1718 concat!("Size of: ", stringify!(random_data))
1719 );
1720 assert_eq!(
1721 ::std::mem::align_of::<random_data>(),
1722 8usize,
1723 concat!("Alignment of ", stringify!(random_data))
1724 );
1725 assert_eq!(
1726 unsafe { ::std::ptr::addr_of!((*ptr).fptr) as usize - ptr as usize },
1727 0usize,
1728 concat!(
1729 "Offset of field: ",
1730 stringify!(random_data),
1731 "::",
1732 stringify!(fptr)
1733 )
1734 );
1735 assert_eq!(
1736 unsafe { ::std::ptr::addr_of!((*ptr).rptr) as usize - ptr as usize },
1737 8usize,
1738 concat!(
1739 "Offset of field: ",
1740 stringify!(random_data),
1741 "::",
1742 stringify!(rptr)
1743 )
1744 );
1745 assert_eq!(
1746 unsafe { ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize },
1747 16usize,
1748 concat!(
1749 "Offset of field: ",
1750 stringify!(random_data),
1751 "::",
1752 stringify!(state)
1753 )
1754 );
1755 assert_eq!(
1756 unsafe { ::std::ptr::addr_of!((*ptr).rand_type) as usize - ptr as usize },
1757 24usize,
1758 concat!(
1759 "Offset of field: ",
1760 stringify!(random_data),
1761 "::",
1762 stringify!(rand_type)
1763 )
1764 );
1765 assert_eq!(
1766 unsafe { ::std::ptr::addr_of!((*ptr).rand_deg) as usize - ptr as usize },
1767 28usize,
1768 concat!(
1769 "Offset of field: ",
1770 stringify!(random_data),
1771 "::",
1772 stringify!(rand_deg)
1773 )
1774 );
1775 assert_eq!(
1776 unsafe { ::std::ptr::addr_of!((*ptr).rand_sep) as usize - ptr as usize },
1777 32usize,
1778 concat!(
1779 "Offset of field: ",
1780 stringify!(random_data),
1781 "::",
1782 stringify!(rand_sep)
1783 )
1784 );
1785 assert_eq!(
1786 unsafe { ::std::ptr::addr_of!((*ptr).end_ptr) as usize - ptr as usize },
1787 40usize,
1788 concat!(
1789 "Offset of field: ",
1790 stringify!(random_data),
1791 "::",
1792 stringify!(end_ptr)
1793 )
1794 );
1795}
1796extern "C" {
1797 pub fn random_r(__buf: *mut random_data, __result: *mut i32) -> libc::c_int;
1798}
1799extern "C" {
1800 pub fn srandom_r(__seed: libc::c_uint, __buf: *mut random_data) -> libc::c_int;
1801}
1802extern "C" {
1803 pub fn initstate_r(
1804 __seed: libc::c_uint,
1805 __statebuf: *mut libc::c_char,
1806 __statelen: usize,
1807 __buf: *mut random_data,
1808 ) -> libc::c_int;
1809}
1810extern "C" {
1811 pub fn setstate_r(__statebuf: *mut libc::c_char, __buf: *mut random_data) -> libc::c_int;
1812}
1813extern "C" {
1814 pub fn rand() -> libc::c_int;
1815}
1816extern "C" {
1817 pub fn srand(__seed: libc::c_uint);
1818}
1819extern "C" {
1820 pub fn rand_r(__seed: *mut libc::c_uint) -> libc::c_int;
1821}
1822extern "C" {
1823 pub fn drand48() -> f64;
1824}
1825extern "C" {
1826 pub fn erand48(__xsubi: *mut libc::c_ushort) -> f64;
1827}
1828extern "C" {
1829 pub fn lrand48() -> libc::c_long;
1830}
1831extern "C" {
1832 pub fn nrand48(__xsubi: *mut libc::c_ushort) -> libc::c_long;
1833}
1834extern "C" {
1835 pub fn mrand48() -> libc::c_long;
1836}
1837extern "C" {
1838 pub fn jrand48(__xsubi: *mut libc::c_ushort) -> libc::c_long;
1839}
1840extern "C" {
1841 pub fn srand48(__seedval: libc::c_long);
1842}
1843extern "C" {
1844 pub fn seed48(__seed16v: *mut libc::c_ushort) -> *mut libc::c_ushort;
1845}
1846extern "C" {
1847 pub fn lcong48(__param: *mut libc::c_ushort);
1848}
1849#[repr(C)]
1850#[derive(Debug, Copy, Clone)]
1851pub struct drand48_data {
1852 pub __x: [libc::c_ushort; 3usize],
1853 pub __old_x: [libc::c_ushort; 3usize],
1854 pub __c: libc::c_ushort,
1855 pub __init: libc::c_ushort,
1856 pub __a: libc::c_ulonglong,
1857}
1858#[test]
1859fn bindgen_test_layout_drand48_data() {
1860 const UNINIT: ::std::mem::MaybeUninit<drand48_data> = ::std::mem::MaybeUninit::uninit();
1861 let ptr = UNINIT.as_ptr();
1862 assert_eq!(
1863 ::std::mem::size_of::<drand48_data>(),
1864 24usize,
1865 concat!("Size of: ", stringify!(drand48_data))
1866 );
1867 assert_eq!(
1868 ::std::mem::align_of::<drand48_data>(),
1869 8usize,
1870 concat!("Alignment of ", stringify!(drand48_data))
1871 );
1872 assert_eq!(
1873 unsafe { ::std::ptr::addr_of!((*ptr).__x) as usize - ptr as usize },
1874 0usize,
1875 concat!(
1876 "Offset of field: ",
1877 stringify!(drand48_data),
1878 "::",
1879 stringify!(__x)
1880 )
1881 );
1882 assert_eq!(
1883 unsafe { ::std::ptr::addr_of!((*ptr).__old_x) as usize - ptr as usize },
1884 6usize,
1885 concat!(
1886 "Offset of field: ",
1887 stringify!(drand48_data),
1888 "::",
1889 stringify!(__old_x)
1890 )
1891 );
1892 assert_eq!(
1893 unsafe { ::std::ptr::addr_of!((*ptr).__c) as usize - ptr as usize },
1894 12usize,
1895 concat!(
1896 "Offset of field: ",
1897 stringify!(drand48_data),
1898 "::",
1899 stringify!(__c)
1900 )
1901 );
1902 assert_eq!(
1903 unsafe { ::std::ptr::addr_of!((*ptr).__init) as usize - ptr as usize },
1904 14usize,
1905 concat!(
1906 "Offset of field: ",
1907 stringify!(drand48_data),
1908 "::",
1909 stringify!(__init)
1910 )
1911 );
1912 assert_eq!(
1913 unsafe { ::std::ptr::addr_of!((*ptr).__a) as usize - ptr as usize },
1914 16usize,
1915 concat!(
1916 "Offset of field: ",
1917 stringify!(drand48_data),
1918 "::",
1919 stringify!(__a)
1920 )
1921 );
1922}
1923extern "C" {
1924 pub fn drand48_r(__buffer: *mut drand48_data, __result: *mut f64) -> libc::c_int;
1925}
1926extern "C" {
1927 pub fn erand48_r(
1928 __xsubi: *mut libc::c_ushort,
1929 __buffer: *mut drand48_data,
1930 __result: *mut f64,
1931 ) -> libc::c_int;
1932}
1933extern "C" {
1934 pub fn lrand48_r(__buffer: *mut drand48_data, __result: *mut libc::c_long) -> libc::c_int;
1935}
1936extern "C" {
1937 pub fn nrand48_r(
1938 __xsubi: *mut libc::c_ushort,
1939 __buffer: *mut drand48_data,
1940 __result: *mut libc::c_long,
1941 ) -> libc::c_int;
1942}
1943extern "C" {
1944 pub fn mrand48_r(__buffer: *mut drand48_data, __result: *mut libc::c_long) -> libc::c_int;
1945}
1946extern "C" {
1947 pub fn jrand48_r(
1948 __xsubi: *mut libc::c_ushort,
1949 __buffer: *mut drand48_data,
1950 __result: *mut libc::c_long,
1951 ) -> libc::c_int;
1952}
1953extern "C" {
1954 pub fn srand48_r(__seedval: libc::c_long, __buffer: *mut drand48_data) -> libc::c_int;
1955}
1956extern "C" {
1957 pub fn seed48_r(__seed16v: *mut libc::c_ushort, __buffer: *mut drand48_data) -> libc::c_int;
1958}
1959extern "C" {
1960 pub fn lcong48_r(__param: *mut libc::c_ushort, __buffer: *mut drand48_data) -> libc::c_int;
1961}
1962extern "C" {
1963 pub fn arc4random() -> __uint32_t;
1964}
1965extern "C" {
1966 pub fn arc4random_buf(__buf: *mut libc::c_void, __size: usize);
1967}
1968extern "C" {
1969 pub fn arc4random_uniform(__upper_bound: __uint32_t) -> __uint32_t;
1970}
1971extern "C" {
1972 pub fn malloc(__size: libc::c_ulong) -> *mut libc::c_void;
1973}
1974extern "C" {
1975 pub fn calloc(__nmemb: libc::c_ulong, __size: libc::c_ulong) -> *mut libc::c_void;
1976}
1977extern "C" {
1978 pub fn realloc(__ptr: *mut libc::c_void, __size: libc::c_ulong) -> *mut libc::c_void;
1979}
1980extern "C" {
1981 pub fn free(__ptr: *mut libc::c_void);
1982}
1983extern "C" {
1984 pub fn reallocarray(
1985 __ptr: *mut libc::c_void,
1986 __nmemb: usize,
1987 __size: usize,
1988 ) -> *mut libc::c_void;
1989}
1990extern "C" {
1991 pub fn alloca(__size: libc::c_ulong) -> *mut libc::c_void;
1992}
1993extern "C" {
1994 pub fn valloc(__size: usize) -> *mut libc::c_void;
1995}
1996extern "C" {
1997 pub fn posix_memalign(
1998 __memptr: *mut *mut libc::c_void,
1999 __alignment: usize,
2000 __size: usize,
2001 ) -> libc::c_int;
2002}
2003extern "C" {
2004 pub fn aligned_alloc(__alignment: libc::c_ulong, __size: libc::c_ulong) -> *mut libc::c_void;
2005}
2006extern "C" {
2007 pub fn abort() -> !;
2008}
2009extern "C" {
2010 pub fn atexit(__func: ::std::option::Option<unsafe extern "C" fn()>) -> libc::c_int;
2011}
2012extern "C" {
2013 pub fn at_quick_exit(__func: ::std::option::Option<unsafe extern "C" fn()>) -> libc::c_int;
2014}
2015extern "C" {
2016 pub fn on_exit(
2017 __func: ::std::option::Option<
2018 unsafe extern "C" fn(__status: libc::c_int, __arg: *mut libc::c_void),
2019 >,
2020 __arg: *mut libc::c_void,
2021 ) -> libc::c_int;
2022}
2023extern "C" {
2024 pub fn exit(__status: libc::c_int) -> !;
2025}
2026extern "C" {
2027 pub fn quick_exit(__status: libc::c_int) -> !;
2028}
2029extern "C" {
2030 pub fn _Exit(__status: libc::c_int) -> !;
2031}
2032extern "C" {
2033 pub fn getenv(__name: *const libc::c_char) -> *mut libc::c_char;
2034}
2035extern "C" {
2036 pub fn putenv(__string: *mut libc::c_char) -> libc::c_int;
2037}
2038extern "C" {
2039 pub fn setenv(
2040 __name: *const libc::c_char,
2041 __value: *const libc::c_char,
2042 __replace: libc::c_int,
2043 ) -> libc::c_int;
2044}
2045extern "C" {
2046 pub fn unsetenv(__name: *const libc::c_char) -> libc::c_int;
2047}
2048extern "C" {
2049 pub fn clearenv() -> libc::c_int;
2050}
2051extern "C" {
2052 pub fn mktemp(__template: *mut libc::c_char) -> *mut libc::c_char;
2053}
2054extern "C" {
2055 pub fn mkstemp(__template: *mut libc::c_char) -> libc::c_int;
2056}
2057extern "C" {
2058 pub fn mkstemps(__template: *mut libc::c_char, __suffixlen: libc::c_int) -> libc::c_int;
2059}
2060extern "C" {
2061 pub fn mkdtemp(__template: *mut libc::c_char) -> *mut libc::c_char;
2062}
2063extern "C" {
2064 pub fn system(__command: *const libc::c_char) -> libc::c_int;
2065}
2066extern "C" {
2067 pub fn realpath(
2068 __name: *const libc::c_char,
2069 __resolved: *mut libc::c_char,
2070 ) -> *mut libc::c_char;
2071}
2072pub type __compar_fn_t = ::std::option::Option<
2073 unsafe extern "C" fn(arg1: *const libc::c_void, arg2: *const libc::c_void) -> libc::c_int,
2074>;
2075extern "C" {
2076 pub fn bsearch(
2077 __key: *const libc::c_void,
2078 __base: *const libc::c_void,
2079 __nmemb: usize,
2080 __size: usize,
2081 __compar: __compar_fn_t,
2082 ) -> *mut libc::c_void;
2083}
2084extern "C" {
2085 pub fn qsort(__base: *mut libc::c_void, __nmemb: usize, __size: usize, __compar: __compar_fn_t);
2086}
2087extern "C" {
2088 pub fn abs(__x: libc::c_int) -> libc::c_int;
2089}
2090extern "C" {
2091 pub fn labs(__x: libc::c_long) -> libc::c_long;
2092}
2093extern "C" {
2094 pub fn llabs(__x: libc::c_longlong) -> libc::c_longlong;
2095}
2096extern "C" {
2097 pub fn div(__numer: libc::c_int, __denom: libc::c_int) -> div_t;
2098}
2099extern "C" {
2100 pub fn ldiv(__numer: libc::c_long, __denom: libc::c_long) -> ldiv_t;
2101}
2102extern "C" {
2103 pub fn lldiv(__numer: libc::c_longlong, __denom: libc::c_longlong) -> lldiv_t;
2104}
2105extern "C" {
2106 pub fn ecvt(
2107 __value: f64,
2108 __ndigit: libc::c_int,
2109 __decpt: *mut libc::c_int,
2110 __sign: *mut libc::c_int,
2111 ) -> *mut libc::c_char;
2112}
2113extern "C" {
2114 pub fn fcvt(
2115 __value: f64,
2116 __ndigit: libc::c_int,
2117 __decpt: *mut libc::c_int,
2118 __sign: *mut libc::c_int,
2119 ) -> *mut libc::c_char;
2120}
2121extern "C" {
2122 pub fn gcvt(__value: f64, __ndigit: libc::c_int, __buf: *mut libc::c_char)
2123 -> *mut libc::c_char;
2124}
2125extern "C" {
2126 pub fn qecvt(
2127 __value: u128,
2128 __ndigit: libc::c_int,
2129 __decpt: *mut libc::c_int,
2130 __sign: *mut libc::c_int,
2131 ) -> *mut libc::c_char;
2132}
2133extern "C" {
2134 pub fn qfcvt(
2135 __value: u128,
2136 __ndigit: libc::c_int,
2137 __decpt: *mut libc::c_int,
2138 __sign: *mut libc::c_int,
2139 ) -> *mut libc::c_char;
2140}
2141extern "C" {
2142 pub fn qgcvt(
2143 __value: u128,
2144 __ndigit: libc::c_int,
2145 __buf: *mut libc::c_char,
2146 ) -> *mut libc::c_char;
2147}
2148extern "C" {
2149 pub fn ecvt_r(
2150 __value: f64,
2151 __ndigit: libc::c_int,
2152 __decpt: *mut libc::c_int,
2153 __sign: *mut libc::c_int,
2154 __buf: *mut libc::c_char,
2155 __len: usize,
2156 ) -> libc::c_int;
2157}
2158extern "C" {
2159 pub fn fcvt_r(
2160 __value: f64,
2161 __ndigit: libc::c_int,
2162 __decpt: *mut libc::c_int,
2163 __sign: *mut libc::c_int,
2164 __buf: *mut libc::c_char,
2165 __len: usize,
2166 ) -> libc::c_int;
2167}
2168extern "C" {
2169 pub fn qecvt_r(
2170 __value: u128,
2171 __ndigit: libc::c_int,
2172 __decpt: *mut libc::c_int,
2173 __sign: *mut libc::c_int,
2174 __buf: *mut libc::c_char,
2175 __len: usize,
2176 ) -> libc::c_int;
2177}
2178extern "C" {
2179 pub fn qfcvt_r(
2180 __value: u128,
2181 __ndigit: libc::c_int,
2182 __decpt: *mut libc::c_int,
2183 __sign: *mut libc::c_int,
2184 __buf: *mut libc::c_char,
2185 __len: usize,
2186 ) -> libc::c_int;
2187}
2188extern "C" {
2189 pub fn mblen(__s: *const libc::c_char, __n: usize) -> libc::c_int;
2190}
2191extern "C" {
2192 pub fn mbtowc(__pwc: *mut wchar_t, __s: *const libc::c_char, __n: usize) -> libc::c_int;
2193}
2194extern "C" {
2195 pub fn wctomb(__s: *mut libc::c_char, __wchar: wchar_t) -> libc::c_int;
2196}
2197extern "C" {
2198 pub fn mbstowcs(__pwcs: *mut wchar_t, __s: *const libc::c_char, __n: usize) -> usize;
2199}
2200extern "C" {
2201 pub fn wcstombs(__s: *mut libc::c_char, __pwcs: *const wchar_t, __n: usize) -> usize;
2202}
2203extern "C" {
2204 pub fn rpmatch(__response: *const libc::c_char) -> libc::c_int;
2205}
2206extern "C" {
2207 pub fn getsubopt(
2208 __optionp: *mut *mut libc::c_char,
2209 __tokens: *const *mut libc::c_char,
2210 __valuep: *mut *mut libc::c_char,
2211 ) -> libc::c_int;
2212}
2213extern "C" {
2214 pub fn getloadavg(__loadavg: *mut f64, __nelem: libc::c_int) -> libc::c_int;
2215}
2216#[doc = " Auto–index for NULL keys. When enabled, passing NULL\n as the key to qmap_put generates auto-incrementing IDs."]
2217pub const qmap_flags_QM_AINDEX: qmap_flags = 1;
2218#[doc = " Create reverse-lookup (secondary) map. The mirror map\n handle is always primary_hd + 1 and swaps keys/values.\n\n QM_MIRROR is useful when you need bidirectional lookup (key→value\n and value→key) and is commonly used with file persistence.\n\n The mirror map is automatically closed when you close the primary\n map via qmap_close(hd)."]
2219pub const qmap_flags_QM_MIRROR: qmap_flags = 2;
2220#[doc = " For associated maps: default to obtaining primary keys\n instead of values. Used internally for mirror maps and\n essential for creating value→key secondary indexes.\n\n When a secondary map has QM_PGET, qmap_get() returns\n the primary key instead of the primary value. This allows\n secondary indexes to map from values back to keys."]
2221pub const qmap_flags_QM_PGET: qmap_flags = 4;
2222#[doc = " Enable sorted index support (B-tree search). Enables\n ordered iteration. Index is automatically rebuilt on\n modifications (put/del operations mark it dirty).\n\n Performance Note: The sorted index is rebuilt from scratch\n whenever it's marked dirty and iteration is requested.\n This makes the first iteration after modifications O(n log n)\n instead of O(n)."]
2223pub const qmap_flags_QM_SORTED: qmap_flags = 8;
2224#[doc = " Allow duplicate keys in sorted maps. Enables multi-value\n lookups where multiple entries can share the same key.\n\n REQUIRES QM_SORTED: This flag cannot be used without QM_SORTED.\n qmap_open() will return QM_MISS if QM_MULTIVALUE is set without\n QM_SORTED.\n\n Behavior:\n - qmap_put() with an existing key ADDS a new entry (does not replace)\n - qmap_get() returns the FIRST matching value\n - qmap_get_multi() returns cursor to iterate over ALL matching values\n - qmap_count() returns the number of entries for a key\n - qmap_del() deletes only the FIRST matching entry\n - qmap_del_all() deletes ALL entries with the specified key\n\n Use Case: Secondary indexes via qmap_assoc() where multiple primary\n entries map to the same secondary key."]
2225pub const qmap_flags_QM_MULTIVALUE: qmap_flags = 16;
2226#[doc = " Disable auto-grow. When set and the map reaches capacity,\n inserts return QM_MISS instead of growing the table.\n Use for memory-constrained environments or fixed-size tables."]
2227pub const qmap_flags_QM_NOGROW: qmap_flags = 32;
2228#[doc = " @brief QMap flags."]
2229pub type qmap_flags = libc::c_uint;
2230#[doc = " Pointer (hashed)."]
2231pub const qmap_tbi_QM_PTR: qmap_tbi = 0;
2232#[doc = " Opaque handle. Uses value directly as hash (no transformation)."]
2233pub const qmap_tbi_QM_HNDL: qmap_tbi = 1;
2234#[doc = " String contents hash and compare."]
2235pub const qmap_tbi_QM_STR: qmap_tbi = 2;
2236#[doc = " 32-bit unsigned integer (hash and mask)."]
2237pub const qmap_tbi_QM_U32: qmap_tbi = 3;
2238#[doc = " @brief Built-in type identifiers."]
2239pub type qmap_tbi = libc::c_uint;
2240#[doc = " Continue iteration even if key differs from the initial.\n Behavior depends on whether QM_SORTED was set on the map:\n - With QM_SORTED: performs ordered range scan from the\n starting key onwards (B-tree ordered iteration)\n - Without QM_SORTED: performs linear scan through the\n hash table, comparing keys with the initial key using\n the type's comparison function"]
2241pub const qmap_if_QM_RANGE: qmap_if = 1;
2242#[doc = " @brief Iterator flags."]
2243pub type qmap_if = libc::c_uint;
2244extern "C" {
2245 #[doc = " @brief Open a database.\n\n Creates an in-memory map and registers its handle\n with the internal file cache, linking it to\n 'filename'. If a file exists, it loads the map\n data for the specified 'database'.\n\n @param[in] filename Path to file or cache key.\n NULL → in-memory only.\n @param[in] database Logical name within file.\n NULL → skip file association.\n @param[in] ktype Built-in or registered key\n type.\n @param[in] vtype Built-in or registered value\n type.\n @param[in] mask Must be 2ⁿ − 1; table size is\n (mask + 1).\n @param[in] flags Bitwise OR of QM_AINDEX,\n QM_MIRROR, QM_SORTED, etc.\n @return Map handle (hd).\n\n @note File Persistence: File-backed maps automatically load\n data from disk when opened, regardless of flags. The\n QM_MIRROR flag enables bidirectional lookup (creating a\n reverse map at handle hd + 1) which is useful for many\n persistence scenarios. The mirror map is automatically\n closed when closing the primary map.\n\n @note Multiple databases can share a single file. Each database\n is identified by a hash of its name (XXH32). Data is saved\n and loaded based on this database ID."]
2246 pub fn qmap_open(
2247 filename: *const libc::c_char,
2248 database: *const libc::c_char,
2249 ktype: u32,
2250 vtype: u32,
2251 mask: u32,
2252 flags: u32,
2253 ) -> u32;
2254}
2255extern "C" {
2256 #[doc = " @brief Write all file-backed maps to disk.\n\n Walks the internal cache, computes file sizes,\n and performs mmap/memcpy writes for maps\n associated with a file.\n\n @note This is automatically called at process exit.\n Explicit calls are only needed for mid-execution\n checkpointing or when you want to ensure data\n is persisted before continuing."]
2257 pub fn qmap_save();
2258}
2259extern "C" {
2260 #[doc = " @brief Close a map and free its resources.\n\n Deletes all entries, closes associated secondary maps,\n and frees internal structures. All open maps are\n automatically closed at process exit by the library\n destructor, but you can call this explicitly to free\n resources earlier.\n\n @param[in] hd Handle to close."]
2261 pub fn qmap_close(hd: u32);
2262}
2263extern "C" {
2264 #[doc = " @brief Retrieve a value by key.\n\n For maps with QM_MULTIVALUE flag, this returns the FIRST\n matching value only. To retrieve all values for a key, use\n qmap_get_multi() instead.\n\n @param[in] hd Map handle.\n @param[in] key Key to look up.\n @return Pointer to value or NULL if not found.\n For QM_MULTIVALUE maps, returns first match.\n See qmap_common for pointer ownership rules."]
2265 pub fn qmap_get(hd: u32, key: *const libc::c_void) -> *const libc::c_void;
2266}
2267extern "C" {
2268 #[doc = " @brief Insert or update a pair.\n\n Behavior depends on the QM_MULTIVALUE flag:\n - Without QM_MULTIVALUE: Replaces existing value if key exists\n - With QM_MULTIVALUE: Always adds a new entry (duplicates allowed)\n\n @param[in] hd Map handle.\n @param[in] key Key (NULL if QM_AINDEX).\n @param[in] value Value to store.\n @return Internal index for the entry. With QM_AINDEX,\n this is the generated key ID."]
2269 pub fn qmap_put(hd: u32, key: *const libc::c_void, value: *const libc::c_void) -> u32;
2270}
2271extern "C" {
2272 #[doc = " @brief Delete an entry by key.\n\n For maps with QM_MULTIVALUE flag, this only deletes the FIRST\n occurrence of the key. To delete all duplicates, call this\n function multiple times until the key no longer exists.\n\n @param[in] hd Map handle.\n @param[in] key Key to delete."]
2273 pub fn qmap_del(hd: u32, key: *const libc::c_void);
2274}
2275extern "C" {
2276 #[doc = " @brief Delete all entries with the specified key.\n\n For QM_MULTIVALUE maps, removes all duplicate entries. For regular maps,\n behaves identically to qmap_del().\n\n @param[in] hd Map handle.\n @param[in] key Key of entries to delete.\n\n @see qmap_del\n @see qmap_get_multi"]
2277 pub fn qmap_del_all(hd: u32, key: *const libc::c_void);
2278}
2279extern "C" {
2280 #[doc = " @brief Remove all entries from a map.\n\n @param[in] hd Map handle."]
2281 pub fn qmap_drop(hd: u32);
2282}
2283#[doc = " @brief Association callback type.\n\n After association, future puts/dels on the\n primary will update the secondary.\n Deletes on the primary remove corresponding\n entries from the secondary.\n\n @param[out] skey Pointer to set secondary key.\n @param[in] pkey Primary key.\n @param[in] value Primary value."]
2284pub type qmap_assoc_t = ::std::option::Option<
2285 unsafe extern "C" fn(
2286 skey: *mut *const libc::c_void,
2287 pkey: *const libc::c_void,
2288 value: *const libc::c_void,
2289 ),
2290>;
2291extern "C" {
2292 #[doc = " @brief Make an association between tables.\n\n Links a secondary (index) map to a primary map so that\n put/delete operations on the primary automatically update\n the secondary. The callback determines the secondary key.\n\n @param[in] hd Secondary (index) map handle.\n @param[in] link Primary (source) map handle.\n @param[in] cb Callback to produce secondary\n keys. NULL → use primary value.\n\n @note The secondary map stores (secondary_key, primary_value).\n To retrieve the primary KEY instead of the primary VALUE,\n the secondary map must be created with the QM_PGET flag.\n This is essential for creating value→key indexes.\n\n @code\n // Example: Create a secondary index from username -> user_id\n // Primary: user_id -> username\n uint32_t users = qmap_open(NULL, NULL, QM_U32, QM_STR, 0xFF, 0);\n\n // Secondary: username -> user_id\n // QM_PGET makes qmap_get return the primary key instead of value\n uint32_t by_name = qmap_open(NULL, NULL, QM_STR, QM_U32, 0xFF, QM_PGET);\n\n // Callback: use primary value (username) as secondary key\n static void value_to_key(const void **skey,\n const void *pkey,\n const void *value) {\n (void) pkey;\n *skey = value; // Use username as key\n }\n\n qmap_assoc(by_name, users, value_to_key);\n\n // Now puts to 'users' automatically update 'by_name'\n qmap_put(users, &(uint32_t){100}, \"alice\");\n // by_name now contains: \"alice\" -> 100\n @endcode"]
2293 pub fn qmap_assoc(hd: u32, link: u32, cb: qmap_assoc_t);
2294}
2295extern "C" {
2296 #[doc = " @brief Start iteration.\n\n Creates a cursor for iterating over map entries.\n Ordered ranges require QM_SORTED flag on the map.\n\n @param[in] hd Map handle.\n @param[in] key Starting key or NULL for all entries.\n @param[in] flags Iterator flags (QM_RANGE valid).\n - QM_RANGE with QM_SORTED: ordered scan\n - QM_RANGE without QM_SORTED: linear scan\n - No flags: iterate single key (or all if key is NULL)\n @return Cursor handle for use with qmap_next."]
2297 pub fn qmap_iter(hd: u32, key: *const libc::c_void, flags: u32) -> u32;
2298}
2299extern "C" {
2300 #[doc = " @brief Fetch next key/value.\n\n @param[out] key Pointer to key.\n @param[out] value Pointer to value.\n @param[in] cur_id Cursor handle.\n @return 1 if valid, 0 if done.\n See qmap_common for pointer ownership rules."]
2301 pub fn qmap_next(
2302 key: *mut *const libc::c_void,
2303 value: *mut *const libc::c_void,
2304 cur_id: u32,
2305 ) -> libc::c_int;
2306}
2307extern "C" {
2308 #[doc = " @brief End iteration early.\n\n @param[in] cur_id Cursor handle."]
2309 pub fn qmap_fin(cur_id: u32);
2310}
2311extern "C" {
2312 #[doc = " @brief Start iteration over all values for a key.\n\n For maps with QM_MULTIVALUE flag, this returns a cursor that\n iterates over ALL values associated with the given key in\n sorted order. For maps without QM_MULTIVALUE, this behaves\n like a single-value iterator.\n\n @param[in] hd Map handle.\n @param[in] key Key to look up.\n @return Cursor handle for use with qmap_next(), or\n QM_MISS if key not found.\n\n Example:\n @code\n uint32_t cur = qmap_get_multi(hd, &key);\n if (cur != QM_MISS) {\n const void *k, *v;\n while (qmap_next(&k, &v, cur)) {\n // Process each value for this key\n }\n qmap_fin(cur);\n }\n @endcode\n\n @note Internally, this is equivalent to: qmap_iter(hd, key, 0)\n @note For single-value lookups, qmap_get() is more efficient\n @see qmap_del_all for deleting all duplicates at once\n @see qmap_count for counting entries without iteration"]
2313 pub fn qmap_get_multi(hd: u32, key: *const libc::c_void) -> u32;
2314}
2315extern "C" {
2316 #[doc = " @brief Count entries matching a key.\n\n @param[in] hd Map handle.\n @param[in] key Key to count. NULL counts total entries in map.\n @return Number of matching entries.\n\n @note For QM_MULTIVALUE maps, returns count of all duplicate values\n @note For normal maps, returns 0 or 1"]
2317 pub fn qmap_count(hd: u32, key: *const libc::c_void) -> u32;
2318}
2319#[doc = " @brief Callback to measure variable-size keys.\n\n Keys of dynamic length need measurement when\n hashing/comparing beyond pointer equality.\n\n @param[in] data Pointer to key.\n @return Key size in bytes."]
2320pub type qmap_measure_t =
2321 ::std::option::Option<unsafe extern "C" fn(data: *const libc::c_void) -> usize>;
2322extern "C" {
2323 #[doc = " @brief Register a fixed-length type.\n\n Registers a new custom type with a fixed byte length.\n The type will use the default hash (XXH32) and\n comparison (memcmp) functions.\n\n @param[in] len Length in bytes.\n @return Type ID for use in qmap_open, or\n QM_MISS if type limit is reached."]
2324 pub fn qmap_reg(len: usize) -> u32;
2325}
2326#[doc = " @brief Comparison callback type.\n\n @param[in] a First object.\n @param[in] b Second object.\n @param[in] len Length in bytes.\n @return <0, 0, or >0."]
2327pub type qmap_cmp_t = ::std::option::Option<
2328 unsafe extern "C" fn(a: *const libc::c_void, b: *const libc::c_void, len: usize) -> libc::c_int,
2329>;
2330extern "C" {
2331 #[doc = " @brief Assign comparison function to a type.\n\n @param[in] ref Type ID.\n @param[in] cmp Comparison callback."]
2332 pub fn qmap_cmp_set(ref_: u32, cmp: qmap_cmp_t);
2333}
2334extern "C" {
2335 #[doc = " @brief Register a variable-length type.\n\n Registers a new custom type with variable length.\n A measurement callback is required to determine the\n size of each element. The type will use the default\n hash (XXH32) and comparison (memcmp) functions.\n\n @param[in] measure Size-measuring callback.\n @return Type ID for use in qmap_open, or\n QM_MISS if type limit is reached."]
2336 pub fn qmap_mreg(measure: qmap_measure_t) -> u32;
2337}
2338extern "C" {
2339 #[doc = " @brief Get the byte length of an element.\n\n @param[in] type_id Type ID.\n @param[in] data Element pointer.\n @return Size in bytes."]
2340 pub fn qmap_len(type_id: u32, data: *const libc::c_void) -> usize;
2341}