darknet-sys 0.4.0

/* automatically generated by rust-bindgen 0.65.1 */

pub const _FEATURES_H: u32 = 1;
pub const _DEFAULT_SOURCE: u32 = 1;
pub const __GLIBC_USE_ISOC2X: u32 = 0;
pub const __USE_ISOC11: u32 = 1;
pub const __USE_ISOC99: u32 = 1;
pub const __USE_ISOC95: u32 = 1;
pub const __USE_POSIX_IMPLICITLY: u32 = 1;
pub const _POSIX_SOURCE: u32 = 1;
pub const _POSIX_C_SOURCE: u32 = 200809;
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 _ATFILE_SOURCE: u32 = 1;
pub const __WORDSIZE: u32 = 64;
pub const __WORDSIZE_TIME64_COMPAT32: u32 = 1;
pub const __SYSCALL_WORDSIZE: u32 = 64;
pub const __TIMESIZE: u32 = 64;
pub const __USE_MISC: u32 = 1;
pub const __USE_ATFILE: 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_60559_BFP__: u32 = 201404;
pub const __STDC_IEC_559_COMPLEX__: u32 = 1;
pub const __STDC_IEC_60559_COMPLEX__: u32 = 201404;
pub const __STDC_ISO_10646__: u32 = 201706;
pub const __GNU_LIBRARY__: u32 = 6;
pub const __GLIBC__: u32 = 2;
pub const __GLIBC_MINOR__: u32 = 37;
pub const _SYS_CDEFS_H: u32 = 1;
pub const __glibc_c99_flexarr_available: u32 = 1;
pub const __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI: u32 = 0;
pub const __HAVE_GENERIC_SELECTION: u32 = 1;
pub const __GLIBC_USE_LIB_EXT2: u32 = 0;
pub const __GLIBC_USE_IEC_60559_BFP_EXT: u32 = 0;
pub const __GLIBC_USE_IEC_60559_BFP_EXT_C2X: u32 = 0;
pub const __GLIBC_USE_IEC_60559_EXT: u32 = 0;
pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: u32 = 0;
pub const __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X: u32 = 0;
pub const __GLIBC_USE_IEC_60559_TYPES_EXT: u32 = 0;
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 __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 _SYS_TYPES_H: u32 = 1;
pub const _BITS_TYPES_H: u32 = 1;
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 __KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64: u32 = 1;
pub const __FD_SETSIZE: u32 = 1024;
pub const _BITS_TIME64_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 _BITS_STDINT_INTN_H: 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 __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 _STDIO_H: 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 _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 P_tmpdir: &[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 FOPEN_MAX: u32 = 16;
pub const _STRING_H: u32 = 1;
pub const _BITS_TYPES_LOCALE_T_H: u32 = 1;
pub const _BITS_TYPES___LOCALE_T_H: u32 = 1;
pub const _STRINGS_H: u32 = 1;
pub const _STDINT_H: u32 = 1;
pub const _BITS_WCHAR_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 _ASSERT_H: u32 = 1;
pub const _PTHREAD_H: u32 = 1;
pub const _SCHED_H: u32 = 1;
pub const _BITS_SCHED_H: u32 = 1;
pub const SCHED_OTHER: u32 = 0;
pub const SCHED_FIFO: u32 = 1;
pub const SCHED_RR: u32 = 2;
pub const _BITS_TYPES_STRUCT_SCHED_PARAM: u32 = 1;
pub const _BITS_CPU_SET_H: u32 = 1;
pub const __CPU_SETSIZE: u32 = 1024;
pub const _TIME_H: u32 = 1;
pub const _BITS_TIME_H: u32 = 1;
pub const CLOCK_REALTIME: u32 = 0;
pub const CLOCK_MONOTONIC: u32 = 1;
pub const CLOCK_PROCESS_CPUTIME_ID: u32 = 2;
pub const CLOCK_THREAD_CPUTIME_ID: u32 = 3;
pub const CLOCK_MONOTONIC_RAW: u32 = 4;
pub const CLOCK_REALTIME_COARSE: u32 = 5;
pub const CLOCK_MONOTONIC_COARSE: u32 = 6;
pub const CLOCK_BOOTTIME: u32 = 7;
pub const CLOCK_REALTIME_ALARM: u32 = 8;
pub const CLOCK_BOOTTIME_ALARM: u32 = 9;
pub const CLOCK_TAI: u32 = 11;
pub const TIMER_ABSTIME: u32 = 1;
pub const __struct_tm_defined: u32 = 1;
pub const __itimerspec_defined: u32 = 1;
pub const TIME_UTC: u32 = 1;
pub const _BITS_SETJMP_H: u32 = 1;
pub const __jmp_buf_tag_defined: u32 = 1;
pub const PTHREAD_STACK_MIN: u32 = 16384;
pub const PTHREAD_ONCE_INIT: u32 = 0;
pub const PTHREAD_BARRIER_SERIAL_THREAD: i32 = -1;
pub const SECRET_NUM: i32 = -1234;
pub type wchar_t = ::std::os::raw::c_int;
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() {
    const UNINIT: ::std::mem::MaybeUninit<div_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    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::addr_of!((*ptr).quot) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(div_t),
        "::",
        stringify!(quot)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rem) as usize - ptr 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() {
    const UNINIT: ::std::mem::MaybeUninit<ldiv_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    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::addr_of!((*ptr).quot) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(ldiv_t),
        "::",
        stringify!(quot)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rem) as usize - ptr 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() {
    const UNINIT: ::std::mem::MaybeUninit<lldiv_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    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::addr_of!((*ptr).quot) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(lldiv_t),
        "::",
        stringify!(quot)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rem) as usize - ptr as usize },
        8usize,
        concat!(
        "Offset of field: ",
        stringify!(lldiv_t),
        "::",
        stringify!(rem)
        )
    );
}
extern "C" {
    pub fn __ctype_get_mb_cur_max() -> usize;
}
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 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 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 = ::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() {
    const UNINIT: ::std::mem::MaybeUninit<__fsid_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    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::addr_of!((*ptr).__val) as usize - ptr 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 __suseconds64_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 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 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 pid_t = __pid_t;
pub type id_t = __id_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 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() {
    const UNINIT: ::std::mem::MaybeUninit<__sigset_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    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::addr_of!((*ptr).__val) as usize - ptr 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() {
    const UNINIT: ::std::mem::MaybeUninit<timeval> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    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::addr_of!((*ptr).tv_sec) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(timeval),
        "::",
        stringify!(tv_sec)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).tv_usec) as usize - ptr 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() {
    const UNINIT: ::std::mem::MaybeUninit<timespec> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    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::addr_of!((*ptr).tv_sec) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(timespec),
        "::",
        stringify!(tv_sec)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).tv_nsec) as usize - ptr as usize },
        8usize,
        concat!(
        "Offset of field: ",
        stringify!(timespec),
        "::",
        stringify!(tv_nsec)
        )
    );
}
pub type suseconds_t = __suseconds_t;
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() {
    const UNINIT: ::std::mem::MaybeUninit<fd_set> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    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::addr_of!((*ptr).__fds_bits) as usize - ptr 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;
#[repr(C)]
#[derive(Copy, Clone)]
pub union __atomic_wide_counter {
    pub __value64: ::std::os::raw::c_ulonglong,
    pub __value32: __atomic_wide_counter__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __atomic_wide_counter__bindgen_ty_1 {
    pub __low: ::std::os::raw::c_uint,
    pub __high: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout___atomic_wide_counter__bindgen_ty_1() {
    const UNINIT: ::std::mem::MaybeUninit<__atomic_wide_counter__bindgen_ty_1> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<__atomic_wide_counter__bindgen_ty_1>(),
        8usize,
        concat!("Size of: ", stringify!(__atomic_wide_counter__bindgen_ty_1))
    );
    assert_eq!(
        ::std::mem::align_of::<__atomic_wide_counter__bindgen_ty_1>(),
        4usize,
        concat!(
        "Alignment of ",
        stringify!(__atomic_wide_counter__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__low) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(__atomic_wide_counter__bindgen_ty_1),
        "::",
        stringify!(__low)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__high) as usize - ptr as usize },
        4usize,
        concat!(
        "Offset of field: ",
        stringify!(__atomic_wide_counter__bindgen_ty_1),
        "::",
        stringify!(__high)
        )
    );
}
#[test]
fn bindgen_test_layout___atomic_wide_counter() {
    const UNINIT: ::std::mem::MaybeUninit<__atomic_wide_counter> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<__atomic_wide_counter>(),
        8usize,
        concat!("Size of: ", stringify!(__atomic_wide_counter))
    );
    assert_eq!(
        ::std::mem::align_of::<__atomic_wide_counter>(),
        8usize,
        concat!("Alignment of ", stringify!(__atomic_wide_counter))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__value64) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(__atomic_wide_counter),
        "::",
        stringify!(__value64)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__value32) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(__atomic_wide_counter),
        "::",
        stringify!(__value32)
        )
    );
}
#[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() {
    const UNINIT: ::std::mem::MaybeUninit<__pthread_internal_list> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    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::addr_of!((*ptr).__prev) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(__pthread_internal_list),
        "::",
        stringify!(__prev)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__next) as usize - ptr 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() {
    const UNINIT: ::std::mem::MaybeUninit<__pthread_internal_slist> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    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::addr_of!((*ptr).__next) as usize - ptr 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() {
    const UNINIT: ::std::mem::MaybeUninit<__pthread_mutex_s> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    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::addr_of!((*ptr).__lock) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(__pthread_mutex_s),
        "::",
        stringify!(__lock)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__count) as usize - ptr as usize },
        4usize,
        concat!(
        "Offset of field: ",
        stringify!(__pthread_mutex_s),
        "::",
        stringify!(__count)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__owner) as usize - ptr as usize },
        8usize,
        concat!(
        "Offset of field: ",
        stringify!(__pthread_mutex_s),
        "::",
        stringify!(__owner)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__nusers) as usize - ptr as usize },
        12usize,
        concat!(
        "Offset of field: ",
        stringify!(__pthread_mutex_s),
        "::",
        stringify!(__nusers)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__kind) as usize - ptr as usize },
        16usize,
        concat!(
        "Offset of field: ",
        stringify!(__pthread_mutex_s),
        "::",
        stringify!(__kind)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__spins) as usize - ptr as usize },
        20usize,
        concat!(
        "Offset of field: ",
        stringify!(__pthread_mutex_s),
        "::",
        stringify!(__spins)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__elision) as usize - ptr as usize },
        22usize,
        concat!(
        "Offset of field: ",
        stringify!(__pthread_mutex_s),
        "::",
        stringify!(__elision)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__list) as usize - ptr 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() {
    const UNINIT: ::std::mem::MaybeUninit<__pthread_rwlock_arch_t> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    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::addr_of!((*ptr).__readers) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(__pthread_rwlock_arch_t),
        "::",
        stringify!(__readers)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__writers) as usize - ptr as usize },
        4usize,
        concat!(
        "Offset of field: ",
        stringify!(__pthread_rwlock_arch_t),
        "::",
        stringify!(__writers)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__wrphase_futex) as usize - ptr as usize },
        8usize,
        concat!(
        "Offset of field: ",
        stringify!(__pthread_rwlock_arch_t),
        "::",
        stringify!(__wrphase_futex)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__writers_futex) as usize - ptr as usize },
        12usize,
        concat!(
        "Offset of field: ",
        stringify!(__pthread_rwlock_arch_t),
        "::",
        stringify!(__writers_futex)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__pad3) as usize - ptr as usize },
        16usize,
        concat!(
        "Offset of field: ",
        stringify!(__pthread_rwlock_arch_t),
        "::",
        stringify!(__pad3)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__pad4) as usize - ptr as usize },
        20usize,
        concat!(
        "Offset of field: ",
        stringify!(__pthread_rwlock_arch_t),
        "::",
        stringify!(__pad4)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__cur_writer) as usize - ptr as usize },
        24usize,
        concat!(
        "Offset of field: ",
        stringify!(__pthread_rwlock_arch_t),
        "::",
        stringify!(__cur_writer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__shared) as usize - ptr as usize },
        28usize,
        concat!(
        "Offset of field: ",
        stringify!(__pthread_rwlock_arch_t),
        "::",
        stringify!(__shared)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__rwelision) as usize - ptr as usize },
        32usize,
        concat!(
        "Offset of field: ",
        stringify!(__pthread_rwlock_arch_t),
        "::",
        stringify!(__rwelision)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__pad1) as usize - ptr as usize },
        33usize,
        concat!(
        "Offset of field: ",
        stringify!(__pthread_rwlock_arch_t),
        "::",
        stringify!(__pad1)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__pad2) as usize - ptr as usize },
        40usize,
        concat!(
        "Offset of field: ",
        stringify!(__pthread_rwlock_arch_t),
        "::",
        stringify!(__pad2)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__flags) as usize - ptr 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 __wseq: __atomic_wide_counter,
    pub __g1_start: __atomic_wide_counter,
    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],
}
#[test]
fn bindgen_test_layout___pthread_cond_s() {
    const UNINIT: ::std::mem::MaybeUninit<__pthread_cond_s> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    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::addr_of!((*ptr).__wseq) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(__pthread_cond_s),
        "::",
        stringify!(__wseq)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__g1_start) as usize - ptr as usize },
        8usize,
        concat!(
        "Offset of field: ",
        stringify!(__pthread_cond_s),
        "::",
        stringify!(__g1_start)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__g_refs) as usize - ptr as usize },
        16usize,
        concat!(
        "Offset of field: ",
        stringify!(__pthread_cond_s),
        "::",
        stringify!(__g_refs)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__g_size) as usize - ptr as usize },
        24usize,
        concat!(
        "Offset of field: ",
        stringify!(__pthread_cond_s),
        "::",
        stringify!(__g_size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__g1_orig_size) as usize - ptr as usize },
        32usize,
        concat!(
        "Offset of field: ",
        stringify!(__pthread_cond_s),
        "::",
        stringify!(__g1_orig_size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__wrefs) as usize - ptr as usize },
        36usize,
        concat!(
        "Offset of field: ",
        stringify!(__pthread_cond_s),
        "::",
        stringify!(__wrefs)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__g_signals) as usize - ptr as usize },
        40usize,
        concat!(
        "Offset of field: ",
        stringify!(__pthread_cond_s),
        "::",
        stringify!(__g_signals)
        )
    );
}
pub type __tss_t = ::std::os::raw::c_uint;
pub type __thrd_t = ::std::os::raw::c_ulong;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __once_flag {
    pub __data: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout___once_flag() {
    const UNINIT: ::std::mem::MaybeUninit<__once_flag> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<__once_flag>(),
        4usize,
        concat!("Size of: ", stringify!(__once_flag))
    );
    assert_eq!(
        ::std::mem::align_of::<__once_flag>(),
        4usize,
        concat!("Alignment of ", stringify!(__once_flag))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__data) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(__once_flag),
        "::",
        stringify!(__data)
        )
    );
}
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,
}
#[test]
fn bindgen_test_layout_pthread_mutexattr_t() {
    const UNINIT: ::std::mem::MaybeUninit<pthread_mutexattr_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    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::addr_of!((*ptr).__size) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(pthread_mutexattr_t),
        "::",
        stringify!(__size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr 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,
}
#[test]
fn bindgen_test_layout_pthread_condattr_t() {
    const UNINIT: ::std::mem::MaybeUninit<pthread_condattr_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    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::addr_of!((*ptr).__size) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(pthread_condattr_t),
        "::",
        stringify!(__size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr 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,
}
#[test]
fn bindgen_test_layout_pthread_attr_t() {
    const UNINIT: ::std::mem::MaybeUninit<pthread_attr_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    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::addr_of!((*ptr).__size) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(pthread_attr_t),
        "::",
        stringify!(__size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr 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,
}
#[test]
fn bindgen_test_layout_pthread_mutex_t() {
    const UNINIT: ::std::mem::MaybeUninit<pthread_mutex_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    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::addr_of!((*ptr).__data) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(pthread_mutex_t),
        "::",
        stringify!(__data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(pthread_mutex_t),
        "::",
        stringify!(__size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr 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,
}
#[test]
fn bindgen_test_layout_pthread_cond_t() {
    const UNINIT: ::std::mem::MaybeUninit<pthread_cond_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    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::addr_of!((*ptr).__data) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(pthread_cond_t),
        "::",
        stringify!(__data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(pthread_cond_t),
        "::",
        stringify!(__size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr 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,
}
#[test]
fn bindgen_test_layout_pthread_rwlock_t() {
    const UNINIT: ::std::mem::MaybeUninit<pthread_rwlock_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    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::addr_of!((*ptr).__data) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(pthread_rwlock_t),
        "::",
        stringify!(__data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(pthread_rwlock_t),
        "::",
        stringify!(__size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr 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,
}
#[test]
fn bindgen_test_layout_pthread_rwlockattr_t() {
    const UNINIT: ::std::mem::MaybeUninit<pthread_rwlockattr_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    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::addr_of!((*ptr).__size) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(pthread_rwlockattr_t),
        "::",
        stringify!(__size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr 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,
}
#[test]
fn bindgen_test_layout_pthread_barrier_t() {
    const UNINIT: ::std::mem::MaybeUninit<pthread_barrier_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    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::addr_of!((*ptr).__size) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(pthread_barrier_t),
        "::",
        stringify!(__size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr 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,
}
#[test]
fn bindgen_test_layout_pthread_barrierattr_t() {
    const UNINIT: ::std::mem::MaybeUninit<pthread_barrierattr_t> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    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::addr_of!((*ptr).__size) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(pthread_barrierattr_t),
        "::",
        stringify!(__size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr 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: usize,
    ) -> *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() {
    const UNINIT: ::std::mem::MaybeUninit<random_data> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    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::addr_of!((*ptr).fptr) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(random_data),
        "::",
        stringify!(fptr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rptr) as usize - ptr as usize },
        8usize,
        concat!(
        "Offset of field: ",
        stringify!(random_data),
        "::",
        stringify!(rptr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize },
        16usize,
        concat!(
        "Offset of field: ",
        stringify!(random_data),
        "::",
        stringify!(state)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rand_type) as usize - ptr as usize },
        24usize,
        concat!(
        "Offset of field: ",
        stringify!(random_data),
        "::",
        stringify!(rand_type)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rand_deg) as usize - ptr as usize },
        28usize,
        concat!(
        "Offset of field: ",
        stringify!(random_data),
        "::",
        stringify!(rand_deg)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rand_sep) as usize - ptr as usize },
        32usize,
        concat!(
        "Offset of field: ",
        stringify!(random_data),
        "::",
        stringify!(rand_sep)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).end_ptr) as usize - ptr 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: usize,
        __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() {
    const UNINIT: ::std::mem::MaybeUninit<drand48_data> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    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::addr_of!((*ptr).__x) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(drand48_data),
        "::",
        stringify!(__x)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__old_x) as usize - ptr as usize },
        6usize,
        concat!(
        "Offset of field: ",
        stringify!(drand48_data),
        "::",
        stringify!(__old_x)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__c) as usize - ptr as usize },
        12usize,
        concat!(
        "Offset of field: ",
        stringify!(drand48_data),
        "::",
        stringify!(__c)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__init) as usize - ptr as usize },
        14usize,
        concat!(
        "Offset of field: ",
        stringify!(drand48_data),
        "::",
        stringify!(__init)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__a) as usize - ptr 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 arc4random() -> __uint32_t;
}
extern "C" {
    pub fn arc4random_buf(__buf: *mut ::std::os::raw::c_void, __size: usize);
}
extern "C" {
    pub fn arc4random_uniform(__upper_bound: __uint32_t) -> __uint32_t;
}
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 free(__ptr: *mut ::std::os::raw::c_void);
}
extern "C" {
    pub fn reallocarray(
        __ptr: *mut ::std::os::raw::c_void,
        __nmemb: usize,
        __size: usize,
    ) -> *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: usize) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn posix_memalign(
        __memptr: *mut *mut ::std::os::raw::c_void,
        __alignment: usize,
        __size: usize,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn aligned_alloc(
        __alignment: ::std::os::raw::c_ulong,
        __size: ::std::os::raw::c_ulong,
    ) -> *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 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 mkstemps(
        __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 system(__command: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
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,
>;
extern "C" {
    pub fn bsearch(
        __key: *const ::std::os::raw::c_void,
        __base: *const ::std::os::raw::c_void,
        __nmemb: usize,
        __size: usize,
        __compar: __compar_fn_t,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn qsort(
        __base: *mut ::std::os::raw::c_void,
        __nmemb: usize,
        __size: usize,
        __compar: __compar_fn_t,
    );
}
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: usize,
    ) -> ::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: usize,
    ) -> ::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: usize,
    ) -> ::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: usize,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mblen(__s: *const ::std::os::raw::c_char, __n: usize) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mbtowc(
        __pwc: *mut wchar_t,
        __s: *const ::std::os::raw::c_char,
        __n: usize,
    ) -> ::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: usize) -> usize;
}
extern "C" {
    pub fn wcstombs(__s: *mut ::std::os::raw::c_char, __pwcs: *const wchar_t, __n: usize) -> usize;
}
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 getloadavg(__loadavg: *mut f64, __nelem: ::std::os::raw::c_int)
                      -> ::std::os::raw::c_int;
}
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],
}
#[test]
fn bindgen_test_layout___mbstate_t__bindgen_ty_1() {
    const UNINIT: ::std::mem::MaybeUninit<__mbstate_t__bindgen_ty_1> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    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::addr_of!((*ptr).__wch) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(__mbstate_t__bindgen_ty_1),
        "::",
        stringify!(__wch)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__wchb) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(__mbstate_t__bindgen_ty_1),
        "::",
        stringify!(__wchb)
        )
    );
}
#[test]
fn bindgen_test_layout___mbstate_t() {
    const UNINIT: ::std::mem::MaybeUninit<__mbstate_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    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::addr_of!((*ptr).__count) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(__mbstate_t),
        "::",
        stringify!(__count)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__value) as usize - ptr 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() {
    const UNINIT: ::std::mem::MaybeUninit<_G_fpos_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    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::addr_of!((*ptr).__pos) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(_G_fpos_t),
        "::",
        stringify!(__pos)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__state) as usize - ptr 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() {
    const UNINIT: ::std::mem::MaybeUninit<_G_fpos64_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    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::addr_of!((*ptr).__pos) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(_G_fpos64_t),
        "::",
        stringify!(__pos)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__state) as usize - ptr 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: usize,
    pub _mode: ::std::os::raw::c_int,
    pub _unused2: [::std::os::raw::c_char; 20usize],
}
#[test]
fn bindgen_test_layout__IO_FILE() {
    const UNINIT: ::std::mem::MaybeUninit<_IO_FILE> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    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::addr_of!((*ptr)._flags) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(_IO_FILE),
        "::",
        stringify!(_flags)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._IO_read_ptr) as usize - ptr as usize },
        8usize,
        concat!(
        "Offset of field: ",
        stringify!(_IO_FILE),
        "::",
        stringify!(_IO_read_ptr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._IO_read_end) as usize - ptr as usize },
        16usize,
        concat!(
        "Offset of field: ",
        stringify!(_IO_FILE),
        "::",
        stringify!(_IO_read_end)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._IO_read_base) as usize - ptr as usize },
        24usize,
        concat!(
        "Offset of field: ",
        stringify!(_IO_FILE),
        "::",
        stringify!(_IO_read_base)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._IO_write_base) as usize - ptr as usize },
        32usize,
        concat!(
        "Offset of field: ",
        stringify!(_IO_FILE),
        "::",
        stringify!(_IO_write_base)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._IO_write_ptr) as usize - ptr as usize },
        40usize,
        concat!(
        "Offset of field: ",
        stringify!(_IO_FILE),
        "::",
        stringify!(_IO_write_ptr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._IO_write_end) as usize - ptr as usize },
        48usize,
        concat!(
        "Offset of field: ",
        stringify!(_IO_FILE),
        "::",
        stringify!(_IO_write_end)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._IO_buf_base) as usize - ptr as usize },
        56usize,
        concat!(
        "Offset of field: ",
        stringify!(_IO_FILE),
        "::",
        stringify!(_IO_buf_base)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._IO_buf_end) as usize - ptr as usize },
        64usize,
        concat!(
        "Offset of field: ",
        stringify!(_IO_FILE),
        "::",
        stringify!(_IO_buf_end)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._IO_save_base) as usize - ptr as usize },
        72usize,
        concat!(
        "Offset of field: ",
        stringify!(_IO_FILE),
        "::",
        stringify!(_IO_save_base)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._IO_backup_base) as usize - ptr as usize },
        80usize,
        concat!(
        "Offset of field: ",
        stringify!(_IO_FILE),
        "::",
        stringify!(_IO_backup_base)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._IO_save_end) as usize - ptr as usize },
        88usize,
        concat!(
        "Offset of field: ",
        stringify!(_IO_FILE),
        "::",
        stringify!(_IO_save_end)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._markers) as usize - ptr as usize },
        96usize,
        concat!(
        "Offset of field: ",
        stringify!(_IO_FILE),
        "::",
        stringify!(_markers)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._chain) as usize - ptr as usize },
        104usize,
        concat!(
        "Offset of field: ",
        stringify!(_IO_FILE),
        "::",
        stringify!(_chain)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._fileno) as usize - ptr as usize },
        112usize,
        concat!(
        "Offset of field: ",
        stringify!(_IO_FILE),
        "::",
        stringify!(_fileno)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._flags2) as usize - ptr as usize },
        116usize,
        concat!(
        "Offset of field: ",
        stringify!(_IO_FILE),
        "::",
        stringify!(_flags2)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._old_offset) as usize - ptr as usize },
        120usize,
        concat!(
        "Offset of field: ",
        stringify!(_IO_FILE),
        "::",
        stringify!(_old_offset)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._cur_column) as usize - ptr as usize },
        128usize,
        concat!(
        "Offset of field: ",
        stringify!(_IO_FILE),
        "::",
        stringify!(_cur_column)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._vtable_offset) as usize - ptr as usize },
        130usize,
        concat!(
        "Offset of field: ",
        stringify!(_IO_FILE),
        "::",
        stringify!(_vtable_offset)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._shortbuf) as usize - ptr as usize },
        131usize,
        concat!(
        "Offset of field: ",
        stringify!(_IO_FILE),
        "::",
        stringify!(_shortbuf)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._lock) as usize - ptr as usize },
        136usize,
        concat!(
        "Offset of field: ",
        stringify!(_IO_FILE),
        "::",
        stringify!(_lock)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._offset) as usize - ptr as usize },
        144usize,
        concat!(
        "Offset of field: ",
        stringify!(_IO_FILE),
        "::",
        stringify!(_offset)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._codecvt) as usize - ptr as usize },
        152usize,
        concat!(
        "Offset of field: ",
        stringify!(_IO_FILE),
        "::",
        stringify!(_codecvt)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._wide_data) as usize - ptr as usize },
        160usize,
        concat!(
        "Offset of field: ",
        stringify!(_IO_FILE),
        "::",
        stringify!(_wide_data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._freeres_list) as usize - ptr as usize },
        168usize,
        concat!(
        "Offset of field: ",
        stringify!(_IO_FILE),
        "::",
        stringify!(_freeres_list)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._freeres_buf) as usize - ptr as usize },
        176usize,
        concat!(
        "Offset of field: ",
        stringify!(_IO_FILE),
        "::",
        stringify!(_freeres_buf)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__pad5) as usize - ptr as usize },
        184usize,
        concat!(
        "Offset of field: ",
        stringify!(_IO_FILE),
        "::",
        stringify!(__pad5)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._mode) as usize - ptr as usize },
        192usize,
        concat!(
        "Offset of field: ",
        stringify!(_IO_FILE),
        "::",
        stringify!(_mode)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._unused2) as usize - ptr as usize },
        196usize,
        concat!(
        "Offset of field: ",
        stringify!(_IO_FILE),
        "::",
        stringify!(_unused2)
        )
    );
}
pub type va_list = __gnuc_va_list;
pub type fpos_t = __fpos_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 fclose(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn tmpfile() -> *mut FILE;
}
extern "C" {
    pub fn tmpnam(arg1: *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 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 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 fdopen(__fd: ::std::os::raw::c_int, __modes: *const ::std::os::raw::c_char)
                  -> *mut FILE;
}
extern "C" {
    pub fn fmemopen(
        __s: *mut ::std::os::raw::c_void,
        __len: usize,
        __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 usize,
    ) -> *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: usize,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn setbuffer(__stream: *mut FILE, __buf: *mut ::std::os::raw::c_char, __size: usize);
}
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 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 __getdelim(
        __lineptr: *mut *mut ::std::os::raw::c_char,
        __n: *mut usize,
        __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 usize,
        __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 usize,
        __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 fread_unlocked(
        __ptr: *mut ::std::os::raw::c_void,
        __size: usize,
        __n: usize,
        __stream: *mut FILE,
    ) -> usize;
}
extern "C" {
    pub fn fwrite_unlocked(
        __ptr: *const ::std::os::raw::c_void,
        __size: usize,
        __n: usize,
        __stream: *mut FILE,
    ) -> usize;
}
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 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 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 pclose(__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 ctermid(__s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
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 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 __memcmpeq(
        __s1: *const ::std::os::raw::c_void,
        __s2: *const ::std::os::raw::c_void,
        __n: usize,
    ) -> ::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 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;
}
#[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() {
    const UNINIT: ::std::mem::MaybeUninit<__locale_struct> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    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::addr_of!((*ptr).__locales) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(__locale_struct),
        "::",
        stringify!(__locales)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__ctype_b) as usize - ptr as usize },
        104usize,
        concat!(
        "Offset of field: ",
        stringify!(__locale_struct),
        "::",
        stringify!(__ctype_b)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__ctype_tolower) as usize - ptr as usize },
        112usize,
        concat!(
        "Offset of field: ",
        stringify!(__locale_struct),
        "::",
        stringify!(__ctype_tolower)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__ctype_toupper) as usize - ptr as usize },
        120usize,
        concat!(
        "Offset of field: ",
        stringify!(__locale_struct),
        "::",
        stringify!(__ctype_toupper)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__names) as usize - ptr 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 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: usize,
        __l: locale_t,
    ) -> usize;
}
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 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 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: usize) -> usize;
}
extern "C" {
    pub fn strerror(__errnum: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    #[link_name = "\u{1}__xpg_strerror_r"]
    pub fn strerror_r(
        __errnum: ::std::os::raw::c_int,
        __buf: *mut ::std::os::raw::c_char,
        __buflen: usize,
    ) -> ::std::os::raw::c_int;
}
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: usize,
    );
}
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: usize,
        __loc: locale_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn explicit_bzero(__s: *mut ::std::os::raw::c_void, __n: usize);
}
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: usize,
    ) -> *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;
}
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;
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 sched_param {
    pub sched_priority: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_sched_param() {
    const UNINIT: ::std::mem::MaybeUninit<sched_param> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sched_param>(),
        4usize,
        concat!("Size of: ", stringify!(sched_param))
    );
    assert_eq!(
        ::std::mem::align_of::<sched_param>(),
        4usize,
        concat!("Alignment of ", stringify!(sched_param))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).sched_priority) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(sched_param),
        "::",
        stringify!(sched_priority)
        )
    );
}
pub type __cpu_mask = ::std::os::raw::c_ulong;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cpu_set_t {
    pub __bits: [__cpu_mask; 16usize],
}
#[test]
fn bindgen_test_layout_cpu_set_t() {
    const UNINIT: ::std::mem::MaybeUninit<cpu_set_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<cpu_set_t>(),
        128usize,
        concat!("Size of: ", stringify!(cpu_set_t))
    );
    assert_eq!(
        ::std::mem::align_of::<cpu_set_t>(),
        8usize,
        concat!("Alignment of ", stringify!(cpu_set_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__bits) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(cpu_set_t),
        "::",
        stringify!(__bits)
        )
    );
}
extern "C" {
    pub fn __sched_cpucount(__setsize: usize, __setp: *const cpu_set_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn __sched_cpualloc(__count: usize) -> *mut cpu_set_t;
}
extern "C" {
    pub fn __sched_cpufree(__set: *mut cpu_set_t);
}
extern "C" {
    pub fn sched_setparam(__pid: __pid_t, __param: *const sched_param) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn sched_getparam(__pid: __pid_t, __param: *mut sched_param) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn sched_setscheduler(
        __pid: __pid_t,
        __policy: ::std::os::raw::c_int,
        __param: *const sched_param,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn sched_getscheduler(__pid: __pid_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn sched_yield() -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn sched_get_priority_max(__algorithm: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn sched_get_priority_min(__algorithm: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn sched_rr_get_interval(__pid: __pid_t, __t: *mut timespec) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct tm {
    pub tm_sec: ::std::os::raw::c_int,
    pub tm_min: ::std::os::raw::c_int,
    pub tm_hour: ::std::os::raw::c_int,
    pub tm_mday: ::std::os::raw::c_int,
    pub tm_mon: ::std::os::raw::c_int,
    pub tm_year: ::std::os::raw::c_int,
    pub tm_wday: ::std::os::raw::c_int,
    pub tm_yday: ::std::os::raw::c_int,
    pub tm_isdst: ::std::os::raw::c_int,
    pub tm_gmtoff: ::std::os::raw::c_long,
    pub tm_zone: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_tm() {
    const UNINIT: ::std::mem::MaybeUninit<tm> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<tm>(),
        56usize,
        concat!("Size of: ", stringify!(tm))
    );
    assert_eq!(
        ::std::mem::align_of::<tm>(),
        8usize,
        concat!("Alignment of ", stringify!(tm))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).tm_sec) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(tm),
        "::",
        stringify!(tm_sec)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).tm_min) as usize - ptr as usize },
        4usize,
        concat!(
        "Offset of field: ",
        stringify!(tm),
        "::",
        stringify!(tm_min)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).tm_hour) as usize - ptr as usize },
        8usize,
        concat!(
        "Offset of field: ",
        stringify!(tm),
        "::",
        stringify!(tm_hour)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).tm_mday) as usize - ptr as usize },
        12usize,
        concat!(
        "Offset of field: ",
        stringify!(tm),
        "::",
        stringify!(tm_mday)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).tm_mon) as usize - ptr as usize },
        16usize,
        concat!(
        "Offset of field: ",
        stringify!(tm),
        "::",
        stringify!(tm_mon)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).tm_year) as usize - ptr as usize },
        20usize,
        concat!(
        "Offset of field: ",
        stringify!(tm),
        "::",
        stringify!(tm_year)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).tm_wday) as usize - ptr as usize },
        24usize,
        concat!(
        "Offset of field: ",
        stringify!(tm),
        "::",
        stringify!(tm_wday)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).tm_yday) as usize - ptr as usize },
        28usize,
        concat!(
        "Offset of field: ",
        stringify!(tm),
        "::",
        stringify!(tm_yday)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).tm_isdst) as usize - ptr as usize },
        32usize,
        concat!(
        "Offset of field: ",
        stringify!(tm),
        "::",
        stringify!(tm_isdst)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).tm_gmtoff) as usize - ptr as usize },
        40usize,
        concat!(
        "Offset of field: ",
        stringify!(tm),
        "::",
        stringify!(tm_gmtoff)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).tm_zone) as usize - ptr as usize },
        48usize,
        concat!(
        "Offset of field: ",
        stringify!(tm),
        "::",
        stringify!(tm_zone)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct itimerspec {
    pub it_interval: timespec,
    pub it_value: timespec,
}
#[test]
fn bindgen_test_layout_itimerspec() {
    const UNINIT: ::std::mem::MaybeUninit<itimerspec> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<itimerspec>(),
        32usize,
        concat!("Size of: ", stringify!(itimerspec))
    );
    assert_eq!(
        ::std::mem::align_of::<itimerspec>(),
        8usize,
        concat!("Alignment of ", stringify!(itimerspec))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).it_interval) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(itimerspec),
        "::",
        stringify!(it_interval)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).it_value) as usize - ptr as usize },
        16usize,
        concat!(
        "Offset of field: ",
        stringify!(itimerspec),
        "::",
        stringify!(it_value)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sigevent {
    _unused: [u8; 0],
}
extern "C" {
    pub fn clock() -> clock_t;
}
extern "C" {
    pub fn time(__timer: *mut time_t) -> time_t;
}
extern "C" {
    pub fn difftime(__time1: time_t, __time0: time_t) -> f64;
}
extern "C" {
    pub fn mktime(__tp: *mut tm) -> time_t;
}
extern "C" {
    pub fn strftime(
        __s: *mut ::std::os::raw::c_char,
        __maxsize: usize,
        __format: *const ::std::os::raw::c_char,
        __tp: *const tm,
    ) -> usize;
}
extern "C" {
    pub fn strftime_l(
        __s: *mut ::std::os::raw::c_char,
        __maxsize: usize,
        __format: *const ::std::os::raw::c_char,
        __tp: *const tm,
        __loc: locale_t,
    ) -> usize;
}
extern "C" {
    pub fn gmtime(__timer: *const time_t) -> *mut tm;
}
extern "C" {
    pub fn localtime(__timer: *const time_t) -> *mut tm;
}
extern "C" {
    pub fn gmtime_r(__timer: *const time_t, __tp: *mut tm) -> *mut tm;
}
extern "C" {
    pub fn localtime_r(__timer: *const time_t, __tp: *mut tm) -> *mut tm;
}
extern "C" {
    pub fn asctime(__tp: *const tm) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn ctime(__timer: *const time_t) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn asctime_r(
        __tp: *const tm,
        __buf: *mut ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn ctime_r(
        __timer: *const time_t,
        __buf: *mut ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub static mut __tzname: [*mut ::std::os::raw::c_char; 2usize];
}
extern "C" {
    pub static mut __daylight: ::std::os::raw::c_int;
}
extern "C" {
    pub static mut __timezone: ::std::os::raw::c_long;
}
extern "C" {
    pub static mut tzname: [*mut ::std::os::raw::c_char; 2usize];
}
extern "C" {
    pub fn tzset();
}
extern "C" {
    pub static mut daylight: ::std::os::raw::c_int;
}
extern "C" {
    pub static mut timezone: ::std::os::raw::c_long;
}
extern "C" {
    pub fn timegm(__tp: *mut tm) -> time_t;
}
extern "C" {
    pub fn timelocal(__tp: *mut tm) -> time_t;
}
extern "C" {
    pub fn dysize(__year: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn nanosleep(
        __requested_time: *const timespec,
        __remaining: *mut timespec,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn clock_getres(__clock_id: clockid_t, __res: *mut timespec) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn clock_gettime(__clock_id: clockid_t, __tp: *mut timespec) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn clock_settime(__clock_id: clockid_t, __tp: *const timespec) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn clock_nanosleep(
        __clock_id: clockid_t,
        __flags: ::std::os::raw::c_int,
        __req: *const timespec,
        __rem: *mut timespec,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn clock_getcpuclockid(__pid: pid_t, __clock_id: *mut clockid_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn timer_create(
        __clock_id: clockid_t,
        __evp: *mut sigevent,
        __timerid: *mut timer_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn timer_delete(__timerid: timer_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn timer_settime(
        __timerid: timer_t,
        __flags: ::std::os::raw::c_int,
        __value: *const itimerspec,
        __ovalue: *mut itimerspec,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn timer_gettime(__timerid: timer_t, __value: *mut itimerspec) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn timer_getoverrun(__timerid: timer_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn timespec_get(
        __ts: *mut timespec,
        __base: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
pub type __jmp_buf = [::std::os::raw::c_long; 8usize];
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __jmp_buf_tag {
    pub __jmpbuf: __jmp_buf,
    pub __mask_was_saved: ::std::os::raw::c_int,
    pub __saved_mask: __sigset_t,
}
#[test]
fn bindgen_test_layout___jmp_buf_tag() {
    const UNINIT: ::std::mem::MaybeUninit<__jmp_buf_tag> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<__jmp_buf_tag>(),
        200usize,
        concat!("Size of: ", stringify!(__jmp_buf_tag))
    );
    assert_eq!(
        ::std::mem::align_of::<__jmp_buf_tag>(),
        8usize,
        concat!("Alignment of ", stringify!(__jmp_buf_tag))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__jmpbuf) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(__jmp_buf_tag),
        "::",
        stringify!(__jmpbuf)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__mask_was_saved) as usize - ptr as usize },
        64usize,
        concat!(
        "Offset of field: ",
        stringify!(__jmp_buf_tag),
        "::",
        stringify!(__mask_was_saved)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__saved_mask) as usize - ptr as usize },
        72usize,
        concat!(
        "Offset of field: ",
        stringify!(__jmp_buf_tag),
        "::",
        stringify!(__saved_mask)
        )
    );
}
pub const PTHREAD_CREATE_JOINABLE: _bindgen_ty_1 = 0;
pub const PTHREAD_CREATE_DETACHED: _bindgen_ty_1 = 1;
pub type _bindgen_ty_1 = ::std::os::raw::c_uint;
pub const PTHREAD_MUTEX_TIMED_NP: _bindgen_ty_2 = 0;
pub const PTHREAD_MUTEX_RECURSIVE_NP: _bindgen_ty_2 = 1;
pub const PTHREAD_MUTEX_ERRORCHECK_NP: _bindgen_ty_2 = 2;
pub const PTHREAD_MUTEX_ADAPTIVE_NP: _bindgen_ty_2 = 3;
pub const PTHREAD_MUTEX_NORMAL: _bindgen_ty_2 = 0;
pub const PTHREAD_MUTEX_RECURSIVE: _bindgen_ty_2 = 1;
pub const PTHREAD_MUTEX_ERRORCHECK: _bindgen_ty_2 = 2;
pub const PTHREAD_MUTEX_DEFAULT: _bindgen_ty_2 = 0;
pub type _bindgen_ty_2 = ::std::os::raw::c_uint;
pub const PTHREAD_MUTEX_STALLED: _bindgen_ty_3 = 0;
pub const PTHREAD_MUTEX_STALLED_NP: _bindgen_ty_3 = 0;
pub const PTHREAD_MUTEX_ROBUST: _bindgen_ty_3 = 1;
pub const PTHREAD_MUTEX_ROBUST_NP: _bindgen_ty_3 = 1;
pub type _bindgen_ty_3 = ::std::os::raw::c_uint;
pub const PTHREAD_PRIO_NONE: _bindgen_ty_4 = 0;
pub const PTHREAD_PRIO_INHERIT: _bindgen_ty_4 = 1;
pub const PTHREAD_PRIO_PROTECT: _bindgen_ty_4 = 2;
pub type _bindgen_ty_4 = ::std::os::raw::c_uint;
pub const PTHREAD_RWLOCK_PREFER_READER_NP: _bindgen_ty_5 = 0;
pub const PTHREAD_RWLOCK_PREFER_WRITER_NP: _bindgen_ty_5 = 1;
pub const PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP: _bindgen_ty_5 = 2;
pub const PTHREAD_RWLOCK_DEFAULT_NP: _bindgen_ty_5 = 0;
pub type _bindgen_ty_5 = ::std::os::raw::c_uint;
pub const PTHREAD_INHERIT_SCHED: _bindgen_ty_6 = 0;
pub const PTHREAD_EXPLICIT_SCHED: _bindgen_ty_6 = 1;
pub type _bindgen_ty_6 = ::std::os::raw::c_uint;
pub const PTHREAD_SCOPE_SYSTEM: _bindgen_ty_7 = 0;
pub const PTHREAD_SCOPE_PROCESS: _bindgen_ty_7 = 1;
pub type _bindgen_ty_7 = ::std::os::raw::c_uint;
pub const PTHREAD_PROCESS_PRIVATE: _bindgen_ty_8 = 0;
pub const PTHREAD_PROCESS_SHARED: _bindgen_ty_8 = 1;
pub type _bindgen_ty_8 = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _pthread_cleanup_buffer {
    pub __routine: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
    pub __arg: *mut ::std::os::raw::c_void,
    pub __canceltype: ::std::os::raw::c_int,
    pub __prev: *mut _pthread_cleanup_buffer,
}
#[test]
fn bindgen_test_layout__pthread_cleanup_buffer() {
    const UNINIT: ::std::mem::MaybeUninit<_pthread_cleanup_buffer> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<_pthread_cleanup_buffer>(),
        32usize,
        concat!("Size of: ", stringify!(_pthread_cleanup_buffer))
    );
    assert_eq!(
        ::std::mem::align_of::<_pthread_cleanup_buffer>(),
        8usize,
        concat!("Alignment of ", stringify!(_pthread_cleanup_buffer))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__routine) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(_pthread_cleanup_buffer),
        "::",
        stringify!(__routine)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__arg) as usize - ptr as usize },
        8usize,
        concat!(
        "Offset of field: ",
        stringify!(_pthread_cleanup_buffer),
        "::",
        stringify!(__arg)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__canceltype) as usize - ptr as usize },
        16usize,
        concat!(
        "Offset of field: ",
        stringify!(_pthread_cleanup_buffer),
        "::",
        stringify!(__canceltype)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__prev) as usize - ptr as usize },
        24usize,
        concat!(
        "Offset of field: ",
        stringify!(_pthread_cleanup_buffer),
        "::",
        stringify!(__prev)
        )
    );
}
pub const PTHREAD_CANCEL_ENABLE: _bindgen_ty_9 = 0;
pub const PTHREAD_CANCEL_DISABLE: _bindgen_ty_9 = 1;
pub type _bindgen_ty_9 = ::std::os::raw::c_uint;
pub const PTHREAD_CANCEL_DEFERRED: _bindgen_ty_10 = 0;
pub const PTHREAD_CANCEL_ASYNCHRONOUS: _bindgen_ty_10 = 1;
pub type _bindgen_ty_10 = ::std::os::raw::c_uint;
extern "C" {
    pub fn pthread_create(
        __newthread: *mut pthread_t,
        __attr: *const pthread_attr_t,
        __start_routine: ::std::option::Option<
            unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> *mut ::std::os::raw::c_void,
        >,
        __arg: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_exit(__retval: *mut ::std::os::raw::c_void) -> !;
}
extern "C" {
    pub fn pthread_join(
        __th: pthread_t,
        __thread_return: *mut *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_detach(__th: pthread_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_self() -> pthread_t;
}
extern "C" {
    pub fn pthread_equal(__thread1: pthread_t, __thread2: pthread_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_attr_init(__attr: *mut pthread_attr_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_attr_destroy(__attr: *mut pthread_attr_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_attr_getdetachstate(
        __attr: *const pthread_attr_t,
        __detachstate: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_attr_setdetachstate(
        __attr: *mut pthread_attr_t,
        __detachstate: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_attr_getguardsize(
        __attr: *const pthread_attr_t,
        __guardsize: *mut usize,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_attr_setguardsize(
        __attr: *mut pthread_attr_t,
        __guardsize: usize,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_attr_getschedparam(
        __attr: *const pthread_attr_t,
        __param: *mut sched_param,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_attr_setschedparam(
        __attr: *mut pthread_attr_t,
        __param: *const sched_param,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_attr_getschedpolicy(
        __attr: *const pthread_attr_t,
        __policy: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_attr_setschedpolicy(
        __attr: *mut pthread_attr_t,
        __policy: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_attr_getinheritsched(
        __attr: *const pthread_attr_t,
        __inherit: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_attr_setinheritsched(
        __attr: *mut pthread_attr_t,
        __inherit: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_attr_getscope(
        __attr: *const pthread_attr_t,
        __scope: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_attr_setscope(
        __attr: *mut pthread_attr_t,
        __scope: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_attr_getstackaddr(
        __attr: *const pthread_attr_t,
        __stackaddr: *mut *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_attr_setstackaddr(
        __attr: *mut pthread_attr_t,
        __stackaddr: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_attr_getstacksize(
        __attr: *const pthread_attr_t,
        __stacksize: *mut usize,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_attr_setstacksize(
        __attr: *mut pthread_attr_t,
        __stacksize: usize,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_attr_getstack(
        __attr: *const pthread_attr_t,
        __stackaddr: *mut *mut ::std::os::raw::c_void,
        __stacksize: *mut usize,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_attr_setstack(
        __attr: *mut pthread_attr_t,
        __stackaddr: *mut ::std::os::raw::c_void,
        __stacksize: usize,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_setschedparam(
        __target_thread: pthread_t,
        __policy: ::std::os::raw::c_int,
        __param: *const sched_param,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_getschedparam(
        __target_thread: pthread_t,
        __policy: *mut ::std::os::raw::c_int,
        __param: *mut sched_param,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_setschedprio(
        __target_thread: pthread_t,
        __prio: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_once(
        __once_control: *mut pthread_once_t,
        __init_routine: ::std::option::Option<unsafe extern "C" fn()>,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_setcancelstate(
        __state: ::std::os::raw::c_int,
        __oldstate: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_setcanceltype(
        __type: ::std::os::raw::c_int,
        __oldtype: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_cancel(__th: pthread_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_testcancel();
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __cancel_jmp_buf_tag {
    pub __cancel_jmp_buf: __jmp_buf,
    pub __mask_was_saved: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout___cancel_jmp_buf_tag() {
    const UNINIT: ::std::mem::MaybeUninit<__cancel_jmp_buf_tag> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<__cancel_jmp_buf_tag>(),
        72usize,
        concat!("Size of: ", stringify!(__cancel_jmp_buf_tag))
    );
    assert_eq!(
        ::std::mem::align_of::<__cancel_jmp_buf_tag>(),
        8usize,
        concat!("Alignment of ", stringify!(__cancel_jmp_buf_tag))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__cancel_jmp_buf) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(__cancel_jmp_buf_tag),
        "::",
        stringify!(__cancel_jmp_buf)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__mask_was_saved) as usize - ptr as usize },
        64usize,
        concat!(
        "Offset of field: ",
        stringify!(__cancel_jmp_buf_tag),
        "::",
        stringify!(__mask_was_saved)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_unwind_buf_t {
    pub __cancel_jmp_buf: [__cancel_jmp_buf_tag; 1usize],
    pub __pad: [*mut ::std::os::raw::c_void; 4usize],
}
#[test]
fn bindgen_test_layout___pthread_unwind_buf_t() {
    const UNINIT: ::std::mem::MaybeUninit<__pthread_unwind_buf_t> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<__pthread_unwind_buf_t>(),
        104usize,
        concat!("Size of: ", stringify!(__pthread_unwind_buf_t))
    );
    assert_eq!(
        ::std::mem::align_of::<__pthread_unwind_buf_t>(),
        8usize,
        concat!("Alignment of ", stringify!(__pthread_unwind_buf_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__cancel_jmp_buf) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(__pthread_unwind_buf_t),
        "::",
        stringify!(__cancel_jmp_buf)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__pad) as usize - ptr as usize },
        72usize,
        concat!(
        "Offset of field: ",
        stringify!(__pthread_unwind_buf_t),
        "::",
        stringify!(__pad)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_cleanup_frame {
    pub __cancel_routine:
    ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
    pub __cancel_arg: *mut ::std::os::raw::c_void,
    pub __do_it: ::std::os::raw::c_int,
    pub __cancel_type: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout___pthread_cleanup_frame() {
    const UNINIT: ::std::mem::MaybeUninit<__pthread_cleanup_frame> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<__pthread_cleanup_frame>(),
        24usize,
        concat!("Size of: ", stringify!(__pthread_cleanup_frame))
    );
    assert_eq!(
        ::std::mem::align_of::<__pthread_cleanup_frame>(),
        8usize,
        concat!("Alignment of ", stringify!(__pthread_cleanup_frame))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__cancel_routine) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(__pthread_cleanup_frame),
        "::",
        stringify!(__cancel_routine)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__cancel_arg) as usize - ptr as usize },
        8usize,
        concat!(
        "Offset of field: ",
        stringify!(__pthread_cleanup_frame),
        "::",
        stringify!(__cancel_arg)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__do_it) as usize - ptr as usize },
        16usize,
        concat!(
        "Offset of field: ",
        stringify!(__pthread_cleanup_frame),
        "::",
        stringify!(__do_it)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__cancel_type) as usize - ptr as usize },
        20usize,
        concat!(
        "Offset of field: ",
        stringify!(__pthread_cleanup_frame),
        "::",
        stringify!(__cancel_type)
        )
    );
}
extern "C" {
    pub fn __pthread_register_cancel(__buf: *mut __pthread_unwind_buf_t);
}
extern "C" {
    pub fn __pthread_unregister_cancel(__buf: *mut __pthread_unwind_buf_t);
}
extern "C" {
    pub fn __pthread_unwind_next(__buf: *mut __pthread_unwind_buf_t) -> !;
}
extern "C" {
    pub fn __sigsetjmp(
        __env: *mut __jmp_buf_tag,
        __savemask: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_mutex_init(
        __mutex: *mut pthread_mutex_t,
        __mutexattr: *const pthread_mutexattr_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_mutex_destroy(__mutex: *mut pthread_mutex_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_mutex_trylock(__mutex: *mut pthread_mutex_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_mutex_lock(__mutex: *mut pthread_mutex_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_mutex_timedlock(
        __mutex: *mut pthread_mutex_t,
        __abstime: *const timespec,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_mutex_unlock(__mutex: *mut pthread_mutex_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_mutex_getprioceiling(
        __mutex: *const pthread_mutex_t,
        __prioceiling: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_mutex_setprioceiling(
        __mutex: *mut pthread_mutex_t,
        __prioceiling: ::std::os::raw::c_int,
        __old_ceiling: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_mutex_consistent(__mutex: *mut pthread_mutex_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_mutexattr_init(__attr: *mut pthread_mutexattr_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_mutexattr_destroy(__attr: *mut pthread_mutexattr_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_mutexattr_getpshared(
        __attr: *const pthread_mutexattr_t,
        __pshared: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_mutexattr_setpshared(
        __attr: *mut pthread_mutexattr_t,
        __pshared: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_mutexattr_gettype(
        __attr: *const pthread_mutexattr_t,
        __kind: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_mutexattr_settype(
        __attr: *mut pthread_mutexattr_t,
        __kind: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_mutexattr_getprotocol(
        __attr: *const pthread_mutexattr_t,
        __protocol: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_mutexattr_setprotocol(
        __attr: *mut pthread_mutexattr_t,
        __protocol: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_mutexattr_getprioceiling(
        __attr: *const pthread_mutexattr_t,
        __prioceiling: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_mutexattr_setprioceiling(
        __attr: *mut pthread_mutexattr_t,
        __prioceiling: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_mutexattr_getrobust(
        __attr: *const pthread_mutexattr_t,
        __robustness: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_mutexattr_setrobust(
        __attr: *mut pthread_mutexattr_t,
        __robustness: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_rwlock_init(
        __rwlock: *mut pthread_rwlock_t,
        __attr: *const pthread_rwlockattr_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_rwlock_destroy(__rwlock: *mut pthread_rwlock_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_rwlock_rdlock(__rwlock: *mut pthread_rwlock_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_rwlock_tryrdlock(__rwlock: *mut pthread_rwlock_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_rwlock_timedrdlock(
        __rwlock: *mut pthread_rwlock_t,
        __abstime: *const timespec,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_rwlock_wrlock(__rwlock: *mut pthread_rwlock_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_rwlock_trywrlock(__rwlock: *mut pthread_rwlock_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_rwlock_timedwrlock(
        __rwlock: *mut pthread_rwlock_t,
        __abstime: *const timespec,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_rwlock_unlock(__rwlock: *mut pthread_rwlock_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_rwlockattr_init(__attr: *mut pthread_rwlockattr_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_rwlockattr_destroy(__attr: *mut pthread_rwlockattr_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_rwlockattr_getpshared(
        __attr: *const pthread_rwlockattr_t,
        __pshared: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_rwlockattr_setpshared(
        __attr: *mut pthread_rwlockattr_t,
        __pshared: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_rwlockattr_getkind_np(
        __attr: *const pthread_rwlockattr_t,
        __pref: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_rwlockattr_setkind_np(
        __attr: *mut pthread_rwlockattr_t,
        __pref: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_cond_init(
        __cond: *mut pthread_cond_t,
        __cond_attr: *const pthread_condattr_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_cond_destroy(__cond: *mut pthread_cond_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_cond_signal(__cond: *mut pthread_cond_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_cond_broadcast(__cond: *mut pthread_cond_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_cond_wait(
        __cond: *mut pthread_cond_t,
        __mutex: *mut pthread_mutex_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_cond_timedwait(
        __cond: *mut pthread_cond_t,
        __mutex: *mut pthread_mutex_t,
        __abstime: *const timespec,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_condattr_init(__attr: *mut pthread_condattr_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_condattr_destroy(__attr: *mut pthread_condattr_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_condattr_getpshared(
        __attr: *const pthread_condattr_t,
        __pshared: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_condattr_setpshared(
        __attr: *mut pthread_condattr_t,
        __pshared: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_condattr_getclock(
        __attr: *const pthread_condattr_t,
        __clock_id: *mut __clockid_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_condattr_setclock(
        __attr: *mut pthread_condattr_t,
        __clock_id: __clockid_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_spin_init(
        __lock: *mut pthread_spinlock_t,
        __pshared: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_spin_destroy(__lock: *mut pthread_spinlock_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_spin_lock(__lock: *mut pthread_spinlock_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_spin_trylock(__lock: *mut pthread_spinlock_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_spin_unlock(__lock: *mut pthread_spinlock_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_barrier_init(
        __barrier: *mut pthread_barrier_t,
        __attr: *const pthread_barrierattr_t,
        __count: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_barrier_destroy(__barrier: *mut pthread_barrier_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_barrier_wait(__barrier: *mut pthread_barrier_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_barrierattr_init(__attr: *mut pthread_barrierattr_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_barrierattr_destroy(__attr: *mut pthread_barrierattr_t)
                                       -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_barrierattr_getpshared(
        __attr: *const pthread_barrierattr_t,
        __pshared: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_barrierattr_setpshared(
        __attr: *mut pthread_barrierattr_t,
        __pshared: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_key_create(
        __key: *mut pthread_key_t,
        __destr_function: ::std::option::Option<
            unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void),
        >,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_key_delete(__key: pthread_key_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_getspecific(__key: pthread_key_t) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn pthread_setspecific(
        __key: pthread_key_t,
        __pointer: *const ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_getcpuclockid(
        __thread_id: pthread_t,
        __clock_id: *mut __clockid_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pthread_atfork(
        __prepare: ::std::option::Option<unsafe extern "C" fn()>,
        __parent: ::std::option::Option<unsafe extern "C" fn()>,
        __child: ::std::option::Option<unsafe extern "C" fn()>,
    ) -> ::std::os::raw::c_int;
}
pub const UNUSED_ENUM_TYPE_UNUSED_DEF_VAL: UNUSED_ENUM_TYPE = 0;
pub type UNUSED_ENUM_TYPE = ::std::os::raw::c_uint;
extern "C" {
    pub static mut gpu_index: ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct metadata {
    pub classes: ::std::os::raw::c_int,
    pub names: *mut *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_metadata() {
    const UNINIT: ::std::mem::MaybeUninit<metadata> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<metadata>(),
        16usize,
        concat!("Size of: ", stringify!(metadata))
    );
    assert_eq!(
        ::std::mem::align_of::<metadata>(),
        8usize,
        concat!("Alignment of ", stringify!(metadata))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).classes) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(metadata),
        "::",
        stringify!(classes)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).names) as usize - ptr as usize },
        8usize,
        concat!(
        "Offset of field: ",
        stringify!(metadata),
        "::",
        stringify!(names)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct tree {
    pub leaf: *mut ::std::os::raw::c_int,
    pub n: ::std::os::raw::c_int,
    pub parent: *mut ::std::os::raw::c_int,
    pub child: *mut ::std::os::raw::c_int,
    pub group: *mut ::std::os::raw::c_int,
    pub name: *mut *mut ::std::os::raw::c_char,
    pub groups: ::std::os::raw::c_int,
    pub group_size: *mut ::std::os::raw::c_int,
    pub group_offset: *mut ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_tree() {
    const UNINIT: ::std::mem::MaybeUninit<tree> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<tree>(),
        72usize,
        concat!("Size of: ", stringify!(tree))
    );
    assert_eq!(
        ::std::mem::align_of::<tree>(),
        8usize,
        concat!("Alignment of ", stringify!(tree))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).leaf) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(tree),
        "::",
        stringify!(leaf)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).n) as usize - ptr as usize },
        8usize,
        concat!("Offset of field: ", stringify!(tree), "::", stringify!(n))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
        16usize,
        concat!(
        "Offset of field: ",
        stringify!(tree),
        "::",
        stringify!(parent)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).child) as usize - ptr as usize },
        24usize,
        concat!(
        "Offset of field: ",
        stringify!(tree),
        "::",
        stringify!(child)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).group) as usize - ptr as usize },
        32usize,
        concat!(
        "Offset of field: ",
        stringify!(tree),
        "::",
        stringify!(group)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
        40usize,
        concat!(
        "Offset of field: ",
        stringify!(tree),
        "::",
        stringify!(name)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).groups) as usize - ptr as usize },
        48usize,
        concat!(
        "Offset of field: ",
        stringify!(tree),
        "::",
        stringify!(groups)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).group_size) as usize - ptr as usize },
        56usize,
        concat!(
        "Offset of field: ",
        stringify!(tree),
        "::",
        stringify!(group_size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).group_offset) as usize - ptr as usize },
        64usize,
        concat!(
        "Offset of field: ",
        stringify!(tree),
        "::",
        stringify!(group_offset)
        )
    );
}
pub const ACTIVATION_LOGISTIC: ACTIVATION = 0;
pub const ACTIVATION_RELU: ACTIVATION = 1;
pub const ACTIVATION_RELU6: ACTIVATION = 2;
pub const ACTIVATION_RELIE: ACTIVATION = 3;
pub const ACTIVATION_LINEAR: ACTIVATION = 4;
pub const ACTIVATION_RAMP: ACTIVATION = 5;
pub const ACTIVATION_TANH: ACTIVATION = 6;
pub const ACTIVATION_PLSE: ACTIVATION = 7;
pub const ACTIVATION_REVLEAKY: ACTIVATION = 8;
pub const ACTIVATION_LEAKY: ACTIVATION = 9;
pub const ACTIVATION_ELU: ACTIVATION = 10;
pub const ACTIVATION_LOGGY: ACTIVATION = 11;
pub const ACTIVATION_STAIR: ACTIVATION = 12;
pub const ACTIVATION_HARDTAN: ACTIVATION = 13;
pub const ACTIVATION_LHTAN: ACTIVATION = 14;
pub const ACTIVATION_SELU: ACTIVATION = 15;
pub const ACTIVATION_GELU: ACTIVATION = 16;
pub const ACTIVATION_SWISH: ACTIVATION = 17;
pub const ACTIVATION_MISH: ACTIVATION = 18;
pub const ACTIVATION_HARD_MISH: ACTIVATION = 19;
pub const ACTIVATION_NORM_CHAN: ACTIVATION = 20;
pub const ACTIVATION_NORM_CHAN_SOFTMAX: ACTIVATION = 21;
pub const ACTIVATION_NORM_CHAN_SOFTMAX_MAXVAL: ACTIVATION = 22;
pub type ACTIVATION = ::std::os::raw::c_uint;
pub const IOU_LOSS_IOU: IOU_LOSS = 0;
pub const IOU_LOSS_GIOU: IOU_LOSS = 1;
pub const IOU_LOSS_MSE: IOU_LOSS = 2;
pub const IOU_LOSS_DIOU: IOU_LOSS = 3;
pub const IOU_LOSS_CIOU: IOU_LOSS = 4;
pub type IOU_LOSS = ::std::os::raw::c_uint;
pub const NMS_KIND_DEFAULT_NMS: NMS_KIND = 0;
pub const NMS_KIND_GREEDY_NMS: NMS_KIND = 1;
pub const NMS_KIND_DIOU_NMS: NMS_KIND = 2;
pub const NMS_KIND_CORNERS_NMS: NMS_KIND = 3;
pub type NMS_KIND = ::std::os::raw::c_uint;
pub const YOLO_POINT_YOLO_CENTER: YOLO_POINT = 1;
pub const YOLO_POINT_YOLO_LEFT_TOP: YOLO_POINT = 2;
pub const YOLO_POINT_YOLO_RIGHT_BOTTOM: YOLO_POINT = 4;
pub type YOLO_POINT = ::std::os::raw::c_uint;
pub const WEIGHTS_TYPE_T_NO_WEIGHTS: WEIGHTS_TYPE_T = 0;
pub const WEIGHTS_TYPE_T_PER_FEATURE: WEIGHTS_TYPE_T = 1;
pub const WEIGHTS_TYPE_T_PER_CHANNEL: WEIGHTS_TYPE_T = 2;
pub type WEIGHTS_TYPE_T = ::std::os::raw::c_uint;
pub const WEIGHTS_NORMALIZATION_T_NO_NORMALIZATION: WEIGHTS_NORMALIZATION_T = 0;
pub const WEIGHTS_NORMALIZATION_T_RELU_NORMALIZATION: WEIGHTS_NORMALIZATION_T = 1;
pub const WEIGHTS_NORMALIZATION_T_SOFTMAX_NORMALIZATION: WEIGHTS_NORMALIZATION_T = 2;
pub type WEIGHTS_NORMALIZATION_T = ::std::os::raw::c_uint;
pub const IMTYPE_PNG: IMTYPE = 0;
pub const IMTYPE_BMP: IMTYPE = 1;
pub const IMTYPE_TGA: IMTYPE = 2;
pub const IMTYPE_JPG: IMTYPE = 3;
pub type IMTYPE = ::std::os::raw::c_uint;
pub const BINARY_ACTIVATION_MULT: BINARY_ACTIVATION = 0;
pub const BINARY_ACTIVATION_ADD: BINARY_ACTIVATION = 1;
pub const BINARY_ACTIVATION_SUB: BINARY_ACTIVATION = 2;
pub const BINARY_ACTIVATION_DIV: BINARY_ACTIVATION = 3;
pub type BINARY_ACTIVATION = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct contrastive_params {
    pub sim: f32,
    pub exp_sim: f32,
    pub P: f32,
    pub i: ::std::os::raw::c_int,
    pub j: ::std::os::raw::c_int,
    pub time_step_i: ::std::os::raw::c_int,
    pub time_step_j: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_contrastive_params() {
    const UNINIT: ::std::mem::MaybeUninit<contrastive_params> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<contrastive_params>(),
        28usize,
        concat!("Size of: ", stringify!(contrastive_params))
    );
    assert_eq!(
        ::std::mem::align_of::<contrastive_params>(),
        4usize,
        concat!("Alignment of ", stringify!(contrastive_params))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).sim) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(contrastive_params),
        "::",
        stringify!(sim)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).exp_sim) as usize - ptr as usize },
        4usize,
        concat!(
        "Offset of field: ",
        stringify!(contrastive_params),
        "::",
        stringify!(exp_sim)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).P) as usize - ptr as usize },
        8usize,
        concat!(
        "Offset of field: ",
        stringify!(contrastive_params),
        "::",
        stringify!(P)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).i) as usize - ptr as usize },
        12usize,
        concat!(
        "Offset of field: ",
        stringify!(contrastive_params),
        "::",
        stringify!(i)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).j) as usize - ptr as usize },
        16usize,
        concat!(
        "Offset of field: ",
        stringify!(contrastive_params),
        "::",
        stringify!(j)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).time_step_i) as usize - ptr as usize },
        20usize,
        concat!(
        "Offset of field: ",
        stringify!(contrastive_params),
        "::",
        stringify!(time_step_i)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).time_step_j) as usize - ptr as usize },
        24usize,
        concat!(
        "Offset of field: ",
        stringify!(contrastive_params),
        "::",
        stringify!(time_step_j)
        )
    );
}
pub const LAYER_TYPE_CONVOLUTIONAL: LAYER_TYPE = 0;
pub const LAYER_TYPE_DECONVOLUTIONAL: LAYER_TYPE = 1;
pub const LAYER_TYPE_CONNECTED: LAYER_TYPE = 2;
pub const LAYER_TYPE_MAXPOOL: LAYER_TYPE = 3;
pub const LAYER_TYPE_LOCAL_AVGPOOL: LAYER_TYPE = 4;
pub const LAYER_TYPE_SOFTMAX: LAYER_TYPE = 5;
pub const LAYER_TYPE_DETECTION: LAYER_TYPE = 6;
pub const LAYER_TYPE_DROPOUT: LAYER_TYPE = 7;
pub const LAYER_TYPE_CROP: LAYER_TYPE = 8;
pub const LAYER_TYPE_ROUTE: LAYER_TYPE = 9;
pub const LAYER_TYPE_COST: LAYER_TYPE = 10;
pub const LAYER_TYPE_NORMALIZATION: LAYER_TYPE = 11;
pub const LAYER_TYPE_AVGPOOL: LAYER_TYPE = 12;
pub const LAYER_TYPE_LOCAL: LAYER_TYPE = 13;
pub const LAYER_TYPE_SHORTCUT: LAYER_TYPE = 14;
pub const LAYER_TYPE_SCALE_CHANNELS: LAYER_TYPE = 15;
pub const LAYER_TYPE_SAM: LAYER_TYPE = 16;
pub const LAYER_TYPE_ACTIVE: LAYER_TYPE = 17;
pub const LAYER_TYPE_RNN: LAYER_TYPE = 18;
pub const LAYER_TYPE_GRU: LAYER_TYPE = 19;
pub const LAYER_TYPE_LSTM: LAYER_TYPE = 20;
pub const LAYER_TYPE_CONV_LSTM: LAYER_TYPE = 21;
pub const LAYER_TYPE_HISTORY: LAYER_TYPE = 22;
pub const LAYER_TYPE_CRNN: LAYER_TYPE = 23;
pub const LAYER_TYPE_BATCHNORM: LAYER_TYPE = 24;
pub const LAYER_TYPE_NETWORK: LAYER_TYPE = 25;
pub const LAYER_TYPE_XNOR: LAYER_TYPE = 26;
pub const LAYER_TYPE_REGION: LAYER_TYPE = 27;
pub const LAYER_TYPE_YOLO: LAYER_TYPE = 28;
pub const LAYER_TYPE_GAUSSIAN_YOLO: LAYER_TYPE = 29;
pub const LAYER_TYPE_ISEG: LAYER_TYPE = 30;
pub const LAYER_TYPE_REORG: LAYER_TYPE = 31;
pub const LAYER_TYPE_REORG_OLD: LAYER_TYPE = 32;
pub const LAYER_TYPE_UPSAMPLE: LAYER_TYPE = 33;
pub const LAYER_TYPE_LOGXENT: LAYER_TYPE = 34;
pub const LAYER_TYPE_L2NORM: LAYER_TYPE = 35;
pub const LAYER_TYPE_EMPTY: LAYER_TYPE = 36;
pub const LAYER_TYPE_BLANK: LAYER_TYPE = 37;
pub const LAYER_TYPE_CONTRASTIVE: LAYER_TYPE = 38;
pub const LAYER_TYPE_IMPLICIT: LAYER_TYPE = 39;
pub type LAYER_TYPE = ::std::os::raw::c_uint;
pub const COST_TYPE_SSE: COST_TYPE = 0;
pub const COST_TYPE_MASKED: COST_TYPE = 1;
pub const COST_TYPE_L1: COST_TYPE = 2;
pub const COST_TYPE_SEG: COST_TYPE = 3;
pub const COST_TYPE_SMOOTH: COST_TYPE = 4;
pub const COST_TYPE_WGAN: COST_TYPE = 5;
pub type COST_TYPE = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct update_args {
    pub batch: ::std::os::raw::c_int,
    pub learning_rate: f32,
    pub momentum: f32,
    pub decay: f32,
    pub adam: ::std::os::raw::c_int,
    pub B1: f32,
    pub B2: f32,
    pub eps: f32,
    pub t: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_update_args() {
    const UNINIT: ::std::mem::MaybeUninit<update_args> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<update_args>(),
        36usize,
        concat!("Size of: ", stringify!(update_args))
    );
    assert_eq!(
        ::std::mem::align_of::<update_args>(),
        4usize,
        concat!("Alignment of ", stringify!(update_args))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).batch) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(update_args),
        "::",
        stringify!(batch)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).learning_rate) as usize - ptr as usize },
        4usize,
        concat!(
        "Offset of field: ",
        stringify!(update_args),
        "::",
        stringify!(learning_rate)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).momentum) as usize - ptr as usize },
        8usize,
        concat!(
        "Offset of field: ",
        stringify!(update_args),
        "::",
        stringify!(momentum)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).decay) as usize - ptr as usize },
        12usize,
        concat!(
        "Offset of field: ",
        stringify!(update_args),
        "::",
        stringify!(decay)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).adam) as usize - ptr as usize },
        16usize,
        concat!(
        "Offset of field: ",
        stringify!(update_args),
        "::",
        stringify!(adam)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).B1) as usize - ptr as usize },
        20usize,
        concat!(
        "Offset of field: ",
        stringify!(update_args),
        "::",
        stringify!(B1)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).B2) as usize - ptr as usize },
        24usize,
        concat!(
        "Offset of field: ",
        stringify!(update_args),
        "::",
        stringify!(B2)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).eps) as usize - ptr as usize },
        28usize,
        concat!(
        "Offset of field: ",
        stringify!(update_args),
        "::",
        stringify!(eps)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).t) as usize - ptr as usize },
        32usize,
        concat!(
        "Offset of field: ",
        stringify!(update_args),
        "::",
        stringify!(t)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct layer {
    pub type_: LAYER_TYPE,
    pub activation: ACTIVATION,
    pub lstm_activation: ACTIVATION,
    pub cost_type: COST_TYPE,
    pub forward: ::std::option::Option<unsafe extern "C" fn(arg1: layer, arg2: network_state)>,
    pub backward: ::std::option::Option<unsafe extern "C" fn(arg1: layer, arg2: network_state)>,
    pub update: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: layer,
            arg2: ::std::os::raw::c_int,
            arg3: f32,
            arg4: f32,
            arg5: f32,
        ),
    >,
    pub forward_gpu: ::std::option::Option<unsafe extern "C" fn(arg1: layer, arg2: network_state)>,
    pub backward_gpu: ::std::option::Option<unsafe extern "C" fn(arg1: layer, arg2: network_state)>,
    pub update_gpu: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: layer,
            arg2: ::std::os::raw::c_int,
            arg3: f32,
            arg4: f32,
            arg5: f32,
            arg6: f32,
        ),
    >,
    pub share_layer: *mut layer,
    pub train: ::std::os::raw::c_int,
    pub avgpool: ::std::os::raw::c_int,
    pub batch_normalize: ::std::os::raw::c_int,
    pub shortcut: ::std::os::raw::c_int,
    pub batch: ::std::os::raw::c_int,
    pub dynamic_minibatch: ::std::os::raw::c_int,
    pub forced: ::std::os::raw::c_int,
    pub flipped: ::std::os::raw::c_int,
    pub inputs: ::std::os::raw::c_int,
    pub outputs: ::std::os::raw::c_int,
    pub mean_alpha: f32,
    pub nweights: ::std::os::raw::c_int,
    pub nbiases: ::std::os::raw::c_int,
    pub extra: ::std::os::raw::c_int,
    pub truths: ::std::os::raw::c_int,
    pub h: ::std::os::raw::c_int,
    pub w: ::std::os::raw::c_int,
    pub c: ::std::os::raw::c_int,
    pub out_h: ::std::os::raw::c_int,
    pub out_w: ::std::os::raw::c_int,
    pub out_c: ::std::os::raw::c_int,
    pub n: ::std::os::raw::c_int,
    pub max_boxes: ::std::os::raw::c_int,
    pub truth_size: ::std::os::raw::c_int,
    pub groups: ::std::os::raw::c_int,
    pub group_id: ::std::os::raw::c_int,
    pub size: ::std::os::raw::c_int,
    pub side: ::std::os::raw::c_int,
    pub stride: ::std::os::raw::c_int,
    pub stride_x: ::std::os::raw::c_int,
    pub stride_y: ::std::os::raw::c_int,
    pub dilation: ::std::os::raw::c_int,
    pub antialiasing: ::std::os::raw::c_int,
    pub maxpool_depth: ::std::os::raw::c_int,
    pub maxpool_zero_nonmax: ::std::os::raw::c_int,
    pub out_channels: ::std::os::raw::c_int,
    pub reverse: f32,
    pub coordconv: ::std::os::raw::c_int,
    pub flatten: ::std::os::raw::c_int,
    pub spatial: ::std::os::raw::c_int,
    pub pad: ::std::os::raw::c_int,
    pub sqrt: ::std::os::raw::c_int,
    pub flip: ::std::os::raw::c_int,
    pub index: ::std::os::raw::c_int,
    pub scale_wh: ::std::os::raw::c_int,
    pub binary: ::std::os::raw::c_int,
    pub xnor: ::std::os::raw::c_int,
    pub peephole: ::std::os::raw::c_int,
    pub use_bin_output: ::std::os::raw::c_int,
    pub keep_delta_gpu: ::std::os::raw::c_int,
    pub optimized_memory: ::std::os::raw::c_int,
    pub steps: ::std::os::raw::c_int,
    pub history_size: ::std::os::raw::c_int,
    pub bottleneck: ::std::os::raw::c_int,
    pub time_normalizer: f32,
    pub state_constrain: ::std::os::raw::c_int,
    pub hidden: ::std::os::raw::c_int,
    pub truth: ::std::os::raw::c_int,
    pub smooth: f32,
    pub dot: f32,
    pub deform: ::std::os::raw::c_int,
    pub grad_centr: ::std::os::raw::c_int,
    pub sway: ::std::os::raw::c_int,
    pub rotate: ::std::os::raw::c_int,
    pub stretch: ::std::os::raw::c_int,
    pub stretch_sway: ::std::os::raw::c_int,
    pub angle: f32,
    pub jitter: f32,
    pub resize: f32,
    pub saturation: f32,
    pub exposure: f32,
    pub shift: f32,
    pub ratio: f32,
    pub learning_rate_scale: f32,
    pub clip: f32,
    pub focal_loss: ::std::os::raw::c_int,
    pub classes_multipliers: *mut f32,
    pub label_smooth_eps: f32,
    pub noloss: ::std::os::raw::c_int,
    pub softmax: ::std::os::raw::c_int,
    pub classes: ::std::os::raw::c_int,
    pub detection: ::std::os::raw::c_int,
    pub embedding_layer_id: ::std::os::raw::c_int,
    pub embedding_output: *mut f32,
    pub embedding_size: ::std::os::raw::c_int,
    pub sim_thresh: f32,
    pub track_history_size: ::std::os::raw::c_int,
    pub dets_for_track: ::std::os::raw::c_int,
    pub dets_for_show: ::std::os::raw::c_int,
    pub track_ciou_norm: f32,
    pub coords: ::std::os::raw::c_int,
    pub background: ::std::os::raw::c_int,
    pub rescore: ::std::os::raw::c_int,
    pub objectness: ::std::os::raw::c_int,
    pub does_cost: ::std::os::raw::c_int,
    pub joint: ::std::os::raw::c_int,
    pub noadjust: ::std::os::raw::c_int,
    pub reorg: ::std::os::raw::c_int,
    pub log: ::std::os::raw::c_int,
    pub tanh: ::std::os::raw::c_int,
    pub mask: *mut ::std::os::raw::c_int,
    pub total: ::std::os::raw::c_int,
    pub bflops: f32,
    pub adam: ::std::os::raw::c_int,
    pub B1: f32,
    pub B2: f32,
    pub eps: f32,
    pub t: ::std::os::raw::c_int,
    pub alpha: f32,
    pub beta: f32,
    pub kappa: f32,
    pub coord_scale: f32,
    pub object_scale: f32,
    pub noobject_scale: f32,
    pub mask_scale: f32,
    pub class_scale: f32,
    pub bias_match: ::std::os::raw::c_int,
    pub random: f32,
    pub ignore_thresh: f32,
    pub truth_thresh: f32,
    pub iou_thresh: f32,
    pub thresh: f32,
    pub focus: f32,
    pub classfix: ::std::os::raw::c_int,
    pub absolute: ::std::os::raw::c_int,
    pub assisted_excitation: ::std::os::raw::c_int,
    pub onlyforward: ::std::os::raw::c_int,
    pub stopbackward: ::std::os::raw::c_int,
    pub train_only_bn: ::std::os::raw::c_int,
    pub dont_update: ::std::os::raw::c_int,
    pub burnin_update: ::std::os::raw::c_int,
    pub dontload: ::std::os::raw::c_int,
    pub dontsave: ::std::os::raw::c_int,
    pub dontloadscales: ::std::os::raw::c_int,
    pub numload: ::std::os::raw::c_int,
    pub temperature: f32,
    pub probability: f32,
    pub dropblock_size_rel: f32,
    pub dropblock_size_abs: ::std::os::raw::c_int,
    pub dropblock: ::std::os::raw::c_int,
    pub scale: f32,
    pub receptive_w: ::std::os::raw::c_int,
    pub receptive_h: ::std::os::raw::c_int,
    pub receptive_w_scale: ::std::os::raw::c_int,
    pub receptive_h_scale: ::std::os::raw::c_int,
    pub cweights: *mut ::std::os::raw::c_char,
    pub indexes: *mut ::std::os::raw::c_int,
    pub input_layers: *mut ::std::os::raw::c_int,
    pub input_sizes: *mut ::std::os::raw::c_int,
    pub layers_output: *mut *mut f32,
    pub layers_delta: *mut *mut f32,
    pub weights_type: WEIGHTS_TYPE_T,
    pub weights_normalization: WEIGHTS_NORMALIZATION_T,
    pub map: *mut ::std::os::raw::c_int,
    pub counts: *mut ::std::os::raw::c_int,
    pub sums: *mut *mut f32,
    pub rand: *mut f32,
    pub cost: *mut f32,
    pub labels: *mut ::std::os::raw::c_int,
    pub class_ids: *mut ::std::os::raw::c_int,
    pub contrastive_neg_max: ::std::os::raw::c_int,
    pub cos_sim: *mut f32,
    pub exp_cos_sim: *mut f32,
    pub p_constrastive: *mut f32,
    pub contrast_p_gpu: *mut contrastive_params,
    pub state: *mut f32,
    pub prev_state: *mut f32,
    pub forgot_state: *mut f32,
    pub forgot_delta: *mut f32,
    pub state_delta: *mut f32,
    pub combine_cpu: *mut f32,
    pub combine_delta_cpu: *mut f32,
    pub concat: *mut f32,
    pub concat_delta: *mut f32,
    pub binary_weights: *mut f32,
    pub biases: *mut f32,
    pub bias_updates: *mut f32,
    pub scales: *mut f32,
    pub scale_updates: *mut f32,
    pub weights_ema: *mut f32,
    pub biases_ema: *mut f32,
    pub scales_ema: *mut f32,
    pub weights: *mut f32,
    pub weight_updates: *mut f32,
    pub scale_x_y: f32,
    pub objectness_smooth: ::std::os::raw::c_int,
    pub new_coords: ::std::os::raw::c_int,
    pub show_details: ::std::os::raw::c_int,
    pub max_delta: f32,
    pub uc_normalizer: f32,
    pub iou_normalizer: f32,
    pub obj_normalizer: f32,
    pub cls_normalizer: f32,
    pub delta_normalizer: f32,
    pub iou_loss: IOU_LOSS,
    pub iou_thresh_kind: IOU_LOSS,
    pub nms_kind: NMS_KIND,
    pub beta_nms: f32,
    pub yolo_point: YOLO_POINT,
    pub align_bit_weights_gpu: *mut ::std::os::raw::c_char,
    pub mean_arr_gpu: *mut f32,
    pub align_workspace_gpu: *mut f32,
    pub transposed_align_workspace_gpu: *mut f32,
    pub align_workspace_size: ::std::os::raw::c_int,
    pub align_bit_weights: *mut ::std::os::raw::c_char,
    pub mean_arr: *mut f32,
    pub align_bit_weights_size: ::std::os::raw::c_int,
    pub lda_align: ::std::os::raw::c_int,
    pub new_lda: ::std::os::raw::c_int,
    pub bit_align: ::std::os::raw::c_int,
    pub col_image: *mut f32,
    pub delta: *mut f32,
    pub output: *mut f32,
    pub activation_input: *mut f32,
    pub delta_pinned: ::std::os::raw::c_int,
    pub output_pinned: ::std::os::raw::c_int,
    pub loss: *mut f32,
    pub squared: *mut f32,
    pub norms: *mut f32,
    pub spatial_mean: *mut f32,
    pub mean: *mut f32,
    pub variance: *mut f32,
    pub mean_delta: *mut f32,
    pub variance_delta: *mut f32,
    pub rolling_mean: *mut f32,
    pub rolling_variance: *mut f32,
    pub x: *mut f32,
    pub x_norm: *mut f32,
    pub m: *mut f32,
    pub v: *mut f32,
    pub bias_m: *mut f32,
    pub bias_v: *mut f32,
    pub scale_m: *mut f32,
    pub scale_v: *mut f32,
    pub z_cpu: *mut f32,
    pub r_cpu: *mut f32,
    pub h_cpu: *mut f32,
    pub stored_h_cpu: *mut f32,
    pub prev_state_cpu: *mut f32,
    pub temp_cpu: *mut f32,
    pub temp2_cpu: *mut f32,
    pub temp3_cpu: *mut f32,
    pub dh_cpu: *mut f32,
    pub hh_cpu: *mut f32,
    pub prev_cell_cpu: *mut f32,
    pub cell_cpu: *mut f32,
    pub f_cpu: *mut f32,
    pub i_cpu: *mut f32,
    pub g_cpu: *mut f32,
    pub o_cpu: *mut f32,
    pub c_cpu: *mut f32,
    pub stored_c_cpu: *mut f32,
    pub dc_cpu: *mut f32,
    pub binary_input: *mut f32,
    pub bin_re_packed_input: *mut u32,
    pub t_bit_input: *mut ::std::os::raw::c_char,
    pub input_layer: *mut layer,
    pub self_layer: *mut layer,
    pub output_layer: *mut layer,
    pub reset_layer: *mut layer,
    pub update_layer: *mut layer,
    pub state_layer: *mut layer,
    pub input_gate_layer: *mut layer,
    pub state_gate_layer: *mut layer,
    pub input_save_layer: *mut layer,
    pub state_save_layer: *mut layer,
    pub input_state_layer: *mut layer,
    pub state_state_layer: *mut layer,
    pub input_z_layer: *mut layer,
    pub state_z_layer: *mut layer,
    pub input_r_layer: *mut layer,
    pub state_r_layer: *mut layer,
    pub input_h_layer: *mut layer,
    pub state_h_layer: *mut layer,
    pub wz: *mut layer,
    pub uz: *mut layer,
    pub wr: *mut layer,
    pub ur: *mut layer,
    pub wh: *mut layer,
    pub uh: *mut layer,
    pub uo: *mut layer,
    pub wo: *mut layer,
    pub vo: *mut layer,
    pub uf: *mut layer,
    pub wf: *mut layer,
    pub vf: *mut layer,
    pub ui: *mut layer,
    pub wi: *mut layer,
    pub vi: *mut layer,
    pub ug: *mut layer,
    pub wg: *mut layer,
    pub softmax_tree: *mut tree,
    pub workspace_size: usize,
    pub indexes_gpu: *mut ::std::os::raw::c_int,
    pub stream: ::std::os::raw::c_int,
    pub wait_stream_id: ::std::os::raw::c_int,
    pub z_gpu: *mut f32,
    pub r_gpu: *mut f32,
    pub h_gpu: *mut f32,
    pub stored_h_gpu: *mut f32,
    pub bottelneck_hi_gpu: *mut f32,
    pub bottelneck_delta_gpu: *mut f32,
    pub temp_gpu: *mut f32,
    pub temp2_gpu: *mut f32,
    pub temp3_gpu: *mut f32,
    pub dh_gpu: *mut f32,
    pub hh_gpu: *mut f32,
    pub prev_cell_gpu: *mut f32,
    pub prev_state_gpu: *mut f32,
    pub last_prev_state_gpu: *mut f32,
    pub last_prev_cell_gpu: *mut f32,
    pub cell_gpu: *mut f32,
    pub f_gpu: *mut f32,
    pub i_gpu: *mut f32,
    pub g_gpu: *mut f32,
    pub o_gpu: *mut f32,
    pub c_gpu: *mut f32,
    pub stored_c_gpu: *mut f32,
    pub dc_gpu: *mut f32,
    pub m_gpu: *mut f32,
    pub v_gpu: *mut f32,
    pub bias_m_gpu: *mut f32,
    pub scale_m_gpu: *mut f32,
    pub bias_v_gpu: *mut f32,
    pub scale_v_gpu: *mut f32,
    pub combine_gpu: *mut f32,
    pub combine_delta_gpu: *mut f32,
    pub forgot_state_gpu: *mut f32,
    pub forgot_delta_gpu: *mut f32,
    pub state_gpu: *mut f32,
    pub state_delta_gpu: *mut f32,
    pub gate_gpu: *mut f32,
    pub gate_delta_gpu: *mut f32,
    pub save_gpu: *mut f32,
    pub save_delta_gpu: *mut f32,
    pub concat_gpu: *mut f32,
    pub concat_delta_gpu: *mut f32,
    pub binary_input_gpu: *mut f32,
    pub binary_weights_gpu: *mut f32,
    pub bin_conv_shortcut_in_gpu: *mut f32,
    pub bin_conv_shortcut_out_gpu: *mut f32,
    pub mean_gpu: *mut f32,
    pub variance_gpu: *mut f32,
    pub m_cbn_avg_gpu: *mut f32,
    pub v_cbn_avg_gpu: *mut f32,
    pub rolling_mean_gpu: *mut f32,
    pub rolling_variance_gpu: *mut f32,
    pub variance_delta_gpu: *mut f32,
    pub mean_delta_gpu: *mut f32,
    pub col_image_gpu: *mut f32,
    pub x_gpu: *mut f32,
    pub x_norm_gpu: *mut f32,
    pub weights_gpu: *mut f32,
    pub weight_updates_gpu: *mut f32,
    pub weight_deform_gpu: *mut f32,
    pub weight_change_gpu: *mut f32,
    pub weights_gpu16: *mut f32,
    pub weight_updates_gpu16: *mut f32,
    pub biases_gpu: *mut f32,
    pub bias_updates_gpu: *mut f32,
    pub bias_change_gpu: *mut f32,
    pub scales_gpu: *mut f32,
    pub scale_updates_gpu: *mut f32,
    pub scale_change_gpu: *mut f32,
    pub input_antialiasing_gpu: *mut f32,
    pub output_gpu: *mut f32,
    pub output_avg_gpu: *mut f32,
    pub activation_input_gpu: *mut f32,
    pub loss_gpu: *mut f32,
    pub delta_gpu: *mut f32,
    pub cos_sim_gpu: *mut f32,
    pub rand_gpu: *mut f32,
    pub drop_blocks_scale: *mut f32,
    pub drop_blocks_scale_gpu: *mut f32,
    pub squared_gpu: *mut f32,
    pub norms_gpu: *mut f32,
    pub gt_gpu: *mut f32,
    pub a_avg_gpu: *mut f32,
    pub input_sizes_gpu: *mut ::std::os::raw::c_int,
    pub layers_output_gpu: *mut *mut f32,
    pub layers_delta_gpu: *mut *mut f32,
    pub srcTensorDesc: *mut ::std::os::raw::c_void,
    pub dstTensorDesc: *mut ::std::os::raw::c_void,
    pub srcTensorDesc16: *mut ::std::os::raw::c_void,
    pub dstTensorDesc16: *mut ::std::os::raw::c_void,
    pub dsrcTensorDesc: *mut ::std::os::raw::c_void,
    pub ddstTensorDesc: *mut ::std::os::raw::c_void,
    pub dsrcTensorDesc16: *mut ::std::os::raw::c_void,
    pub ddstTensorDesc16: *mut ::std::os::raw::c_void,
    pub normTensorDesc: *mut ::std::os::raw::c_void,
    pub normDstTensorDesc: *mut ::std::os::raw::c_void,
    pub normDstTensorDescF16: *mut ::std::os::raw::c_void,
    pub weightDesc: *mut ::std::os::raw::c_void,
    pub weightDesc16: *mut ::std::os::raw::c_void,
    pub dweightDesc: *mut ::std::os::raw::c_void,
    pub dweightDesc16: *mut ::std::os::raw::c_void,
    pub convDesc: *mut ::std::os::raw::c_void,
    pub fw_algo: UNUSED_ENUM_TYPE,
    pub fw_algo16: UNUSED_ENUM_TYPE,
    pub bd_algo: UNUSED_ENUM_TYPE,
    pub bd_algo16: UNUSED_ENUM_TYPE,
    pub bf_algo: UNUSED_ENUM_TYPE,
    pub bf_algo16: UNUSED_ENUM_TYPE,
    pub poolingDesc: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_layer() {
    const UNINIT: ::std::mem::MaybeUninit<layer> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<layer>(),
        2616usize,
        concat!("Size of: ", stringify!(layer))
    );
    assert_eq!(
        ::std::mem::align_of::<layer>(),
        8usize,
        concat!("Alignment of ", stringify!(layer))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(type_)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).activation) as usize - ptr as usize },
        4usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(activation)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).lstm_activation) as usize - ptr as usize },
        8usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(lstm_activation)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).cost_type) as usize - ptr as usize },
        12usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(cost_type)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).forward) as usize - ptr as usize },
        16usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(forward)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).backward) as usize - ptr as usize },
        24usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(backward)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).update) as usize - ptr as usize },
        32usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(update)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).forward_gpu) as usize - ptr as usize },
        40usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(forward_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).backward_gpu) as usize - ptr as usize },
        48usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(backward_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).update_gpu) as usize - ptr as usize },
        56usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(update_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).share_layer) as usize - ptr as usize },
        64usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(share_layer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).train) as usize - ptr as usize },
        72usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(train)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).avgpool) as usize - ptr as usize },
        76usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(avgpool)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).batch_normalize) as usize - ptr as usize },
        80usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(batch_normalize)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).shortcut) as usize - ptr as usize },
        84usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(shortcut)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).batch) as usize - ptr as usize },
        88usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(batch)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dynamic_minibatch) as usize - ptr as usize },
        92usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(dynamic_minibatch)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).forced) as usize - ptr as usize },
        96usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(forced)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).flipped) as usize - ptr as usize },
        100usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(flipped)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).inputs) as usize - ptr as usize },
        104usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(inputs)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).outputs) as usize - ptr as usize },
        108usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(outputs)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mean_alpha) as usize - ptr as usize },
        112usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(mean_alpha)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nweights) as usize - ptr as usize },
        116usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(nweights)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nbiases) as usize - ptr as usize },
        120usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(nbiases)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).extra) as usize - ptr as usize },
        124usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(extra)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).truths) as usize - ptr as usize },
        128usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(truths)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).h) as usize - ptr as usize },
        132usize,
        concat!("Offset of field: ", stringify!(layer), "::", stringify!(h))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).w) as usize - ptr as usize },
        136usize,
        concat!("Offset of field: ", stringify!(layer), "::", stringify!(w))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).c) as usize - ptr as usize },
        140usize,
        concat!("Offset of field: ", stringify!(layer), "::", stringify!(c))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).out_h) as usize - ptr as usize },
        144usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(out_h)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).out_w) as usize - ptr as usize },
        148usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(out_w)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).out_c) as usize - ptr as usize },
        152usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(out_c)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).n) as usize - ptr as usize },
        156usize,
        concat!("Offset of field: ", stringify!(layer), "::", stringify!(n))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).max_boxes) as usize - ptr as usize },
        160usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(max_boxes)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).truth_size) as usize - ptr as usize },
        164usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(truth_size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).groups) as usize - ptr as usize },
        168usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(groups)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).group_id) as usize - ptr as usize },
        172usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(group_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        176usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).side) as usize - ptr as usize },
        180usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(side)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).stride) as usize - ptr as usize },
        184usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(stride)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).stride_x) as usize - ptr as usize },
        188usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(stride_x)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).stride_y) as usize - ptr as usize },
        192usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(stride_y)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dilation) as usize - ptr as usize },
        196usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(dilation)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).antialiasing) as usize - ptr as usize },
        200usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(antialiasing)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).maxpool_depth) as usize - ptr as usize },
        204usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(maxpool_depth)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).maxpool_zero_nonmax) as usize - ptr as usize },
        208usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(maxpool_zero_nonmax)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).out_channels) as usize - ptr as usize },
        212usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(out_channels)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).reverse) as usize - ptr as usize },
        216usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(reverse)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).coordconv) as usize - ptr as usize },
        220usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(coordconv)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).flatten) as usize - ptr as usize },
        224usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(flatten)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).spatial) as usize - ptr as usize },
        228usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(spatial)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pad) as usize - ptr as usize },
        232usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(pad)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).sqrt) as usize - ptr as usize },
        236usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(sqrt)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).flip) as usize - ptr as usize },
        240usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(flip)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).index) as usize - ptr as usize },
        244usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(index)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).scale_wh) as usize - ptr as usize },
        248usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(scale_wh)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).binary) as usize - ptr as usize },
        252usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(binary)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).xnor) as usize - ptr as usize },
        256usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(xnor)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).peephole) as usize - ptr as usize },
        260usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(peephole)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).use_bin_output) as usize - ptr as usize },
        264usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(use_bin_output)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).keep_delta_gpu) as usize - ptr as usize },
        268usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(keep_delta_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).optimized_memory) as usize - ptr as usize },
        272usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(optimized_memory)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).steps) as usize - ptr as usize },
        276usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(steps)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).history_size) as usize - ptr as usize },
        280usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(history_size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bottleneck) as usize - ptr as usize },
        284usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(bottleneck)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).time_normalizer) as usize - ptr as usize },
        288usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(time_normalizer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).state_constrain) as usize - ptr as usize },
        292usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(state_constrain)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hidden) as usize - ptr as usize },
        296usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(hidden)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).truth) as usize - ptr as usize },
        300usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(truth)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).smooth) as usize - ptr as usize },
        304usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(smooth)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dot) as usize - ptr as usize },
        308usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(dot)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).deform) as usize - ptr as usize },
        312usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(deform)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).grad_centr) as usize - ptr as usize },
        316usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(grad_centr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).sway) as usize - ptr as usize },
        320usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(sway)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rotate) as usize - ptr as usize },
        324usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(rotate)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).stretch) as usize - ptr as usize },
        328usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(stretch)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).stretch_sway) as usize - ptr as usize },
        332usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(stretch_sway)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).angle) as usize - ptr as usize },
        336usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(angle)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).jitter) as usize - ptr as usize },
        340usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(jitter)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).resize) as usize - ptr as usize },
        344usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(resize)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).saturation) as usize - ptr as usize },
        348usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(saturation)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).exposure) as usize - ptr as usize },
        352usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(exposure)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).shift) as usize - ptr as usize },
        356usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(shift)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ratio) as usize - ptr as usize },
        360usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(ratio)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).learning_rate_scale) as usize - ptr as usize },
        364usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(learning_rate_scale)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).clip) as usize - ptr as usize },
        368usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(clip)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).focal_loss) as usize - ptr as usize },
        372usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(focal_loss)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).classes_multipliers) as usize - ptr as usize },
        376usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(classes_multipliers)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).label_smooth_eps) as usize - ptr as usize },
        384usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(label_smooth_eps)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).noloss) as usize - ptr as usize },
        388usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(noloss)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).softmax) as usize - ptr as usize },
        392usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(softmax)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).classes) as usize - ptr as usize },
        396usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(classes)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).detection) as usize - ptr as usize },
        400usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(detection)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).embedding_layer_id) as usize - ptr as usize },
        404usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(embedding_layer_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).embedding_output) as usize - ptr as usize },
        408usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(embedding_output)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).embedding_size) as usize - ptr as usize },
        416usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(embedding_size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).sim_thresh) as usize - ptr as usize },
        420usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(sim_thresh)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).track_history_size) as usize - ptr as usize },
        424usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(track_history_size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dets_for_track) as usize - ptr as usize },
        428usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(dets_for_track)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dets_for_show) as usize - ptr as usize },
        432usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(dets_for_show)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).track_ciou_norm) as usize - ptr as usize },
        436usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(track_ciou_norm)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).coords) as usize - ptr as usize },
        440usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(coords)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).background) as usize - ptr as usize },
        444usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(background)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rescore) as usize - ptr as usize },
        448usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(rescore)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).objectness) as usize - ptr as usize },
        452usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(objectness)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).does_cost) as usize - ptr as usize },
        456usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(does_cost)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).joint) as usize - ptr as usize },
        460usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(joint)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).noadjust) as usize - ptr as usize },
        464usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(noadjust)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).reorg) as usize - ptr as usize },
        468usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(reorg)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).log) as usize - ptr as usize },
        472usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(log)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).tanh) as usize - ptr as usize },
        476usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(tanh)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mask) as usize - ptr as usize },
        480usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(mask)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).total) as usize - ptr as usize },
        488usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(total)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bflops) as usize - ptr as usize },
        492usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(bflops)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).adam) as usize - ptr as usize },
        496usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(adam)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).B1) as usize - ptr as usize },
        500usize,
        concat!("Offset of field: ", stringify!(layer), "::", stringify!(B1))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).B2) as usize - ptr as usize },
        504usize,
        concat!("Offset of field: ", stringify!(layer), "::", stringify!(B2))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).eps) as usize - ptr as usize },
        508usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(eps)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).t) as usize - ptr as usize },
        512usize,
        concat!("Offset of field: ", stringify!(layer), "::", stringify!(t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).alpha) as usize - ptr as usize },
        516usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(alpha)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).beta) as usize - ptr as usize },
        520usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(beta)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).kappa) as usize - ptr as usize },
        524usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(kappa)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).coord_scale) as usize - ptr as usize },
        528usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(coord_scale)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).object_scale) as usize - ptr as usize },
        532usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(object_scale)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).noobject_scale) as usize - ptr as usize },
        536usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(noobject_scale)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mask_scale) as usize - ptr as usize },
        540usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(mask_scale)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).class_scale) as usize - ptr as usize },
        544usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(class_scale)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bias_match) as usize - ptr as usize },
        548usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(bias_match)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).random) as usize - ptr as usize },
        552usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(random)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ignore_thresh) as usize - ptr as usize },
        556usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(ignore_thresh)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).truth_thresh) as usize - ptr as usize },
        560usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(truth_thresh)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).iou_thresh) as usize - ptr as usize },
        564usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(iou_thresh)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).thresh) as usize - ptr as usize },
        568usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(thresh)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).focus) as usize - ptr as usize },
        572usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(focus)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).classfix) as usize - ptr as usize },
        576usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(classfix)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).absolute) as usize - ptr as usize },
        580usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(absolute)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).assisted_excitation) as usize - ptr as usize },
        584usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(assisted_excitation)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).onlyforward) as usize - ptr as usize },
        588usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(onlyforward)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).stopbackward) as usize - ptr as usize },
        592usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(stopbackward)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).train_only_bn) as usize - ptr as usize },
        596usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(train_only_bn)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dont_update) as usize - ptr as usize },
        600usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(dont_update)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).burnin_update) as usize - ptr as usize },
        604usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(burnin_update)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dontload) as usize - ptr as usize },
        608usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(dontload)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dontsave) as usize - ptr as usize },
        612usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(dontsave)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dontloadscales) as usize - ptr as usize },
        616usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(dontloadscales)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).numload) as usize - ptr as usize },
        620usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(numload)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).temperature) as usize - ptr as usize },
        624usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(temperature)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).probability) as usize - ptr as usize },
        628usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(probability)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dropblock_size_rel) as usize - ptr as usize },
        632usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(dropblock_size_rel)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dropblock_size_abs) as usize - ptr as usize },
        636usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(dropblock_size_abs)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dropblock) as usize - ptr as usize },
        640usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(dropblock)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).scale) as usize - ptr as usize },
        644usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(scale)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).receptive_w) as usize - ptr as usize },
        648usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(receptive_w)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).receptive_h) as usize - ptr as usize },
        652usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(receptive_h)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).receptive_w_scale) as usize - ptr as usize },
        656usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(receptive_w_scale)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).receptive_h_scale) as usize - ptr as usize },
        660usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(receptive_h_scale)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).cweights) as usize - ptr as usize },
        664usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(cweights)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).indexes) as usize - ptr as usize },
        672usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(indexes)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).input_layers) as usize - ptr as usize },
        680usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(input_layers)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).input_sizes) as usize - ptr as usize },
        688usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(input_sizes)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).layers_output) as usize - ptr as usize },
        696usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(layers_output)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).layers_delta) as usize - ptr as usize },
        704usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(layers_delta)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).weights_type) as usize - ptr as usize },
        712usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(weights_type)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).weights_normalization) as usize - ptr as usize },
        716usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(weights_normalization)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).map) as usize - ptr as usize },
        720usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(map)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).counts) as usize - ptr as usize },
        728usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(counts)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).sums) as usize - ptr as usize },
        736usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(sums)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rand) as usize - ptr as usize },
        744usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(rand)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).cost) as usize - ptr as usize },
        752usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(cost)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).labels) as usize - ptr as usize },
        760usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(labels)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).class_ids) as usize - ptr as usize },
        768usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(class_ids)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).contrastive_neg_max) as usize - ptr as usize },
        776usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(contrastive_neg_max)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).cos_sim) as usize - ptr as usize },
        784usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(cos_sim)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).exp_cos_sim) as usize - ptr as usize },
        792usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(exp_cos_sim)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).p_constrastive) as usize - ptr as usize },
        800usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(p_constrastive)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).contrast_p_gpu) as usize - ptr as usize },
        808usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(contrast_p_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize },
        816usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(state)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).prev_state) as usize - ptr as usize },
        824usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(prev_state)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).forgot_state) as usize - ptr as usize },
        832usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(forgot_state)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).forgot_delta) as usize - ptr as usize },
        840usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(forgot_delta)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).state_delta) as usize - ptr as usize },
        848usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(state_delta)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).combine_cpu) as usize - ptr as usize },
        856usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(combine_cpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).combine_delta_cpu) as usize - ptr as usize },
        864usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(combine_delta_cpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).concat) as usize - ptr as usize },
        872usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(concat)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).concat_delta) as usize - ptr as usize },
        880usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(concat_delta)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).binary_weights) as usize - ptr as usize },
        888usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(binary_weights)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).biases) as usize - ptr as usize },
        896usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(biases)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bias_updates) as usize - ptr as usize },
        904usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(bias_updates)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).scales) as usize - ptr as usize },
        912usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(scales)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).scale_updates) as usize - ptr as usize },
        920usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(scale_updates)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).weights_ema) as usize - ptr as usize },
        928usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(weights_ema)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).biases_ema) as usize - ptr as usize },
        936usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(biases_ema)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).scales_ema) as usize - ptr as usize },
        944usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(scales_ema)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).weights) as usize - ptr as usize },
        952usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(weights)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).weight_updates) as usize - ptr as usize },
        960usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(weight_updates)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).scale_x_y) as usize - ptr as usize },
        968usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(scale_x_y)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).objectness_smooth) as usize - ptr as usize },
        972usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(objectness_smooth)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).new_coords) as usize - ptr as usize },
        976usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(new_coords)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).show_details) as usize - ptr as usize },
        980usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(show_details)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).max_delta) as usize - ptr as usize },
        984usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(max_delta)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uc_normalizer) as usize - ptr as usize },
        988usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(uc_normalizer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).iou_normalizer) as usize - ptr as usize },
        992usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(iou_normalizer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).obj_normalizer) as usize - ptr as usize },
        996usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(obj_normalizer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).cls_normalizer) as usize - ptr as usize },
        1000usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(cls_normalizer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).delta_normalizer) as usize - ptr as usize },
        1004usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(delta_normalizer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).iou_loss) as usize - ptr as usize },
        1008usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(iou_loss)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).iou_thresh_kind) as usize - ptr as usize },
        1012usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(iou_thresh_kind)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nms_kind) as usize - ptr as usize },
        1016usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(nms_kind)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).beta_nms) as usize - ptr as usize },
        1020usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(beta_nms)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).yolo_point) as usize - ptr as usize },
        1024usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(yolo_point)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).align_bit_weights_gpu) as usize - ptr as usize },
        1032usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(align_bit_weights_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mean_arr_gpu) as usize - ptr as usize },
        1040usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(mean_arr_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).align_workspace_gpu) as usize - ptr as usize },
        1048usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(align_workspace_gpu)
        )
    );
    assert_eq!(
        unsafe {
            ::std::ptr::addr_of!((*ptr).transposed_align_workspace_gpu) as usize - ptr as usize
        },
        1056usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(transposed_align_workspace_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).align_workspace_size) as usize - ptr as usize },
        1064usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(align_workspace_size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).align_bit_weights) as usize - ptr as usize },
        1072usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(align_bit_weights)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mean_arr) as usize - ptr as usize },
        1080usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(mean_arr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).align_bit_weights_size) as usize - ptr as usize },
        1088usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(align_bit_weights_size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).lda_align) as usize - ptr as usize },
        1092usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(lda_align)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).new_lda) as usize - ptr as usize },
        1096usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(new_lda)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bit_align) as usize - ptr as usize },
        1100usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(bit_align)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).col_image) as usize - ptr as usize },
        1104usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(col_image)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).delta) as usize - ptr as usize },
        1112usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(delta)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).output) as usize - ptr as usize },
        1120usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(output)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).activation_input) as usize - ptr as usize },
        1128usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(activation_input)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).delta_pinned) as usize - ptr as usize },
        1136usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(delta_pinned)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).output_pinned) as usize - ptr as usize },
        1140usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(output_pinned)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).loss) as usize - ptr as usize },
        1144usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(loss)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).squared) as usize - ptr as usize },
        1152usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(squared)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).norms) as usize - ptr as usize },
        1160usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(norms)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).spatial_mean) as usize - ptr as usize },
        1168usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(spatial_mean)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mean) as usize - ptr as usize },
        1176usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(mean)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).variance) as usize - ptr as usize },
        1184usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(variance)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mean_delta) as usize - ptr as usize },
        1192usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(mean_delta)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).variance_delta) as usize - ptr as usize },
        1200usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(variance_delta)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rolling_mean) as usize - ptr as usize },
        1208usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(rolling_mean)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rolling_variance) as usize - ptr as usize },
        1216usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(rolling_variance)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
        1224usize,
        concat!("Offset of field: ", stringify!(layer), "::", stringify!(x))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).x_norm) as usize - ptr as usize },
        1232usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(x_norm)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).m) as usize - ptr as usize },
        1240usize,
        concat!("Offset of field: ", stringify!(layer), "::", stringify!(m))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).v) as usize - ptr as usize },
        1248usize,
        concat!("Offset of field: ", stringify!(layer), "::", stringify!(v))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bias_m) as usize - ptr as usize },
        1256usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(bias_m)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bias_v) as usize - ptr as usize },
        1264usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(bias_v)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).scale_m) as usize - ptr as usize },
        1272usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(scale_m)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).scale_v) as usize - ptr as usize },
        1280usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(scale_v)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).z_cpu) as usize - ptr as usize },
        1288usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(z_cpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).r_cpu) as usize - ptr as usize },
        1296usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(r_cpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).h_cpu) as usize - ptr as usize },
        1304usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(h_cpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).stored_h_cpu) as usize - ptr as usize },
        1312usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(stored_h_cpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).prev_state_cpu) as usize - ptr as usize },
        1320usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(prev_state_cpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).temp_cpu) as usize - ptr as usize },
        1328usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(temp_cpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).temp2_cpu) as usize - ptr as usize },
        1336usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(temp2_cpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).temp3_cpu) as usize - ptr as usize },
        1344usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(temp3_cpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dh_cpu) as usize - ptr as usize },
        1352usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(dh_cpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hh_cpu) as usize - ptr as usize },
        1360usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(hh_cpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).prev_cell_cpu) as usize - ptr as usize },
        1368usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(prev_cell_cpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).cell_cpu) as usize - ptr as usize },
        1376usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(cell_cpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).f_cpu) as usize - ptr as usize },
        1384usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(f_cpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).i_cpu) as usize - ptr as usize },
        1392usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(i_cpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).g_cpu) as usize - ptr as usize },
        1400usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(g_cpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).o_cpu) as usize - ptr as usize },
        1408usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(o_cpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).c_cpu) as usize - ptr as usize },
        1416usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(c_cpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).stored_c_cpu) as usize - ptr as usize },
        1424usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(stored_c_cpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dc_cpu) as usize - ptr as usize },
        1432usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(dc_cpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).binary_input) as usize - ptr as usize },
        1440usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(binary_input)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bin_re_packed_input) as usize - ptr as usize },
        1448usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(bin_re_packed_input)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).t_bit_input) as usize - ptr as usize },
        1456usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(t_bit_input)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).input_layer) as usize - ptr as usize },
        1464usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(input_layer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).self_layer) as usize - ptr as usize },
        1472usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(self_layer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).output_layer) as usize - ptr as usize },
        1480usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(output_layer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).reset_layer) as usize - ptr as usize },
        1488usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(reset_layer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).update_layer) as usize - ptr as usize },
        1496usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(update_layer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).state_layer) as usize - ptr as usize },
        1504usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(state_layer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).input_gate_layer) as usize - ptr as usize },
        1512usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(input_gate_layer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).state_gate_layer) as usize - ptr as usize },
        1520usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(state_gate_layer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).input_save_layer) as usize - ptr as usize },
        1528usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(input_save_layer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).state_save_layer) as usize - ptr as usize },
        1536usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(state_save_layer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).input_state_layer) as usize - ptr as usize },
        1544usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(input_state_layer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).state_state_layer) as usize - ptr as usize },
        1552usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(state_state_layer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).input_z_layer) as usize - ptr as usize },
        1560usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(input_z_layer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).state_z_layer) as usize - ptr as usize },
        1568usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(state_z_layer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).input_r_layer) as usize - ptr as usize },
        1576usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(input_r_layer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).state_r_layer) as usize - ptr as usize },
        1584usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(state_r_layer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).input_h_layer) as usize - ptr as usize },
        1592usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(input_h_layer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).state_h_layer) as usize - ptr as usize },
        1600usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(state_h_layer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).wz) as usize - ptr as usize },
        1608usize,
        concat!("Offset of field: ", stringify!(layer), "::", stringify!(wz))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uz) as usize - ptr as usize },
        1616usize,
        concat!("Offset of field: ", stringify!(layer), "::", stringify!(uz))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).wr) as usize - ptr as usize },
        1624usize,
        concat!("Offset of field: ", stringify!(layer), "::", stringify!(wr))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ur) as usize - ptr as usize },
        1632usize,
        concat!("Offset of field: ", stringify!(layer), "::", stringify!(ur))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).wh) as usize - ptr as usize },
        1640usize,
        concat!("Offset of field: ", stringify!(layer), "::", stringify!(wh))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uh) as usize - ptr as usize },
        1648usize,
        concat!("Offset of field: ", stringify!(layer), "::", stringify!(uh))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uo) as usize - ptr as usize },
        1656usize,
        concat!("Offset of field: ", stringify!(layer), "::", stringify!(uo))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).wo) as usize - ptr as usize },
        1664usize,
        concat!("Offset of field: ", stringify!(layer), "::", stringify!(wo))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).vo) as usize - ptr as usize },
        1672usize,
        concat!("Offset of field: ", stringify!(layer), "::", stringify!(vo))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uf) as usize - ptr as usize },
        1680usize,
        concat!("Offset of field: ", stringify!(layer), "::", stringify!(uf))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).wf) as usize - ptr as usize },
        1688usize,
        concat!("Offset of field: ", stringify!(layer), "::", stringify!(wf))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).vf) as usize - ptr as usize },
        1696usize,
        concat!("Offset of field: ", stringify!(layer), "::", stringify!(vf))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ui) as usize - ptr as usize },
        1704usize,
        concat!("Offset of field: ", stringify!(layer), "::", stringify!(ui))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).wi) as usize - ptr as usize },
        1712usize,
        concat!("Offset of field: ", stringify!(layer), "::", stringify!(wi))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).vi) as usize - ptr as usize },
        1720usize,
        concat!("Offset of field: ", stringify!(layer), "::", stringify!(vi))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ug) as usize - ptr as usize },
        1728usize,
        concat!("Offset of field: ", stringify!(layer), "::", stringify!(ug))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).wg) as usize - ptr as usize },
        1736usize,
        concat!("Offset of field: ", stringify!(layer), "::", stringify!(wg))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).softmax_tree) as usize - ptr as usize },
        1744usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(softmax_tree)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).workspace_size) as usize - ptr as usize },
        1752usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(workspace_size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).indexes_gpu) as usize - ptr as usize },
        1760usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(indexes_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).stream) as usize - ptr as usize },
        1768usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(stream)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).wait_stream_id) as usize - ptr as usize },
        1772usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(wait_stream_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).z_gpu) as usize - ptr as usize },
        1776usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(z_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).r_gpu) as usize - ptr as usize },
        1784usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(r_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).h_gpu) as usize - ptr as usize },
        1792usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(h_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).stored_h_gpu) as usize - ptr as usize },
        1800usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(stored_h_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bottelneck_hi_gpu) as usize - ptr as usize },
        1808usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(bottelneck_hi_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bottelneck_delta_gpu) as usize - ptr as usize },
        1816usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(bottelneck_delta_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).temp_gpu) as usize - ptr as usize },
        1824usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(temp_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).temp2_gpu) as usize - ptr as usize },
        1832usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(temp2_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).temp3_gpu) as usize - ptr as usize },
        1840usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(temp3_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dh_gpu) as usize - ptr as usize },
        1848usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(dh_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hh_gpu) as usize - ptr as usize },
        1856usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(hh_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).prev_cell_gpu) as usize - ptr as usize },
        1864usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(prev_cell_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).prev_state_gpu) as usize - ptr as usize },
        1872usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(prev_state_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).last_prev_state_gpu) as usize - ptr as usize },
        1880usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(last_prev_state_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).last_prev_cell_gpu) as usize - ptr as usize },
        1888usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(last_prev_cell_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).cell_gpu) as usize - ptr as usize },
        1896usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(cell_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).f_gpu) as usize - ptr as usize },
        1904usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(f_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).i_gpu) as usize - ptr as usize },
        1912usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(i_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).g_gpu) as usize - ptr as usize },
        1920usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(g_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).o_gpu) as usize - ptr as usize },
        1928usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(o_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).c_gpu) as usize - ptr as usize },
        1936usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(c_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).stored_c_gpu) as usize - ptr as usize },
        1944usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(stored_c_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dc_gpu) as usize - ptr as usize },
        1952usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(dc_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).m_gpu) as usize - ptr as usize },
        1960usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(m_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).v_gpu) as usize - ptr as usize },
        1968usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(v_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bias_m_gpu) as usize - ptr as usize },
        1976usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(bias_m_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).scale_m_gpu) as usize - ptr as usize },
        1984usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(scale_m_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bias_v_gpu) as usize - ptr as usize },
        1992usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(bias_v_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).scale_v_gpu) as usize - ptr as usize },
        2000usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(scale_v_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).combine_gpu) as usize - ptr as usize },
        2008usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(combine_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).combine_delta_gpu) as usize - ptr as usize },
        2016usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(combine_delta_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).forgot_state_gpu) as usize - ptr as usize },
        2024usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(forgot_state_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).forgot_delta_gpu) as usize - ptr as usize },
        2032usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(forgot_delta_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).state_gpu) as usize - ptr as usize },
        2040usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(state_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).state_delta_gpu) as usize - ptr as usize },
        2048usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(state_delta_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).gate_gpu) as usize - ptr as usize },
        2056usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(gate_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).gate_delta_gpu) as usize - ptr as usize },
        2064usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(gate_delta_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).save_gpu) as usize - ptr as usize },
        2072usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(save_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).save_delta_gpu) as usize - ptr as usize },
        2080usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(save_delta_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).concat_gpu) as usize - ptr as usize },
        2088usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(concat_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).concat_delta_gpu) as usize - ptr as usize },
        2096usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(concat_delta_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).binary_input_gpu) as usize - ptr as usize },
        2104usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(binary_input_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).binary_weights_gpu) as usize - ptr as usize },
        2112usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(binary_weights_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bin_conv_shortcut_in_gpu) as usize - ptr as usize },
        2120usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(bin_conv_shortcut_in_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bin_conv_shortcut_out_gpu) as usize - ptr as usize },
        2128usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(bin_conv_shortcut_out_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mean_gpu) as usize - ptr as usize },
        2136usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(mean_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).variance_gpu) as usize - ptr as usize },
        2144usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(variance_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).m_cbn_avg_gpu) as usize - ptr as usize },
        2152usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(m_cbn_avg_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).v_cbn_avg_gpu) as usize - ptr as usize },
        2160usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(v_cbn_avg_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rolling_mean_gpu) as usize - ptr as usize },
        2168usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(rolling_mean_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rolling_variance_gpu) as usize - ptr as usize },
        2176usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(rolling_variance_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).variance_delta_gpu) as usize - ptr as usize },
        2184usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(variance_delta_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mean_delta_gpu) as usize - ptr as usize },
        2192usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(mean_delta_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).col_image_gpu) as usize - ptr as usize },
        2200usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(col_image_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).x_gpu) as usize - ptr as usize },
        2208usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(x_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).x_norm_gpu) as usize - ptr as usize },
        2216usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(x_norm_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).weights_gpu) as usize - ptr as usize },
        2224usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(weights_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).weight_updates_gpu) as usize - ptr as usize },
        2232usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(weight_updates_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).weight_deform_gpu) as usize - ptr as usize },
        2240usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(weight_deform_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).weight_change_gpu) as usize - ptr as usize },
        2248usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(weight_change_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).weights_gpu16) as usize - ptr as usize },
        2256usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(weights_gpu16)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).weight_updates_gpu16) as usize - ptr as usize },
        2264usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(weight_updates_gpu16)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).biases_gpu) as usize - ptr as usize },
        2272usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(biases_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bias_updates_gpu) as usize - ptr as usize },
        2280usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(bias_updates_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bias_change_gpu) as usize - ptr as usize },
        2288usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(bias_change_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).scales_gpu) as usize - ptr as usize },
        2296usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(scales_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).scale_updates_gpu) as usize - ptr as usize },
        2304usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(scale_updates_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).scale_change_gpu) as usize - ptr as usize },
        2312usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(scale_change_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).input_antialiasing_gpu) as usize - ptr as usize },
        2320usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(input_antialiasing_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).output_gpu) as usize - ptr as usize },
        2328usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(output_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).output_avg_gpu) as usize - ptr as usize },
        2336usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(output_avg_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).activation_input_gpu) as usize - ptr as usize },
        2344usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(activation_input_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).loss_gpu) as usize - ptr as usize },
        2352usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(loss_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).delta_gpu) as usize - ptr as usize },
        2360usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(delta_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).cos_sim_gpu) as usize - ptr as usize },
        2368usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(cos_sim_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rand_gpu) as usize - ptr as usize },
        2376usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(rand_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).drop_blocks_scale) as usize - ptr as usize },
        2384usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(drop_blocks_scale)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).drop_blocks_scale_gpu) as usize - ptr as usize },
        2392usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(drop_blocks_scale_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).squared_gpu) as usize - ptr as usize },
        2400usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(squared_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).norms_gpu) as usize - ptr as usize },
        2408usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(norms_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).gt_gpu) as usize - ptr as usize },
        2416usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(gt_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).a_avg_gpu) as usize - ptr as usize },
        2424usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(a_avg_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).input_sizes_gpu) as usize - ptr as usize },
        2432usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(input_sizes_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).layers_output_gpu) as usize - ptr as usize },
        2440usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(layers_output_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).layers_delta_gpu) as usize - ptr as usize },
        2448usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(layers_delta_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).srcTensorDesc) as usize - ptr as usize },
        2456usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(srcTensorDesc)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dstTensorDesc) as usize - ptr as usize },
        2464usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(dstTensorDesc)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).srcTensorDesc16) as usize - ptr as usize },
        2472usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(srcTensorDesc16)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dstTensorDesc16) as usize - ptr as usize },
        2480usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(dstTensorDesc16)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dsrcTensorDesc) as usize - ptr as usize },
        2488usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(dsrcTensorDesc)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ddstTensorDesc) as usize - ptr as usize },
        2496usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(ddstTensorDesc)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dsrcTensorDesc16) as usize - ptr as usize },
        2504usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(dsrcTensorDesc16)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ddstTensorDesc16) as usize - ptr as usize },
        2512usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(ddstTensorDesc16)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).normTensorDesc) as usize - ptr as usize },
        2520usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(normTensorDesc)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).normDstTensorDesc) as usize - ptr as usize },
        2528usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(normDstTensorDesc)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).normDstTensorDescF16) as usize - ptr as usize },
        2536usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(normDstTensorDescF16)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).weightDesc) as usize - ptr as usize },
        2544usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(weightDesc)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).weightDesc16) as usize - ptr as usize },
        2552usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(weightDesc16)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dweightDesc) as usize - ptr as usize },
        2560usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(dweightDesc)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dweightDesc16) as usize - ptr as usize },
        2568usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(dweightDesc16)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).convDesc) as usize - ptr as usize },
        2576usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(convDesc)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fw_algo) as usize - ptr as usize },
        2584usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(fw_algo)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fw_algo16) as usize - ptr as usize },
        2588usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(fw_algo16)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bd_algo) as usize - ptr as usize },
        2592usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(bd_algo)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bd_algo16) as usize - ptr as usize },
        2596usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(bd_algo16)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bf_algo) as usize - ptr as usize },
        2600usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(bf_algo)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bf_algo16) as usize - ptr as usize },
        2604usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(bf_algo16)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).poolingDesc) as usize - ptr as usize },
        2608usize,
        concat!(
        "Offset of field: ",
        stringify!(layer),
        "::",
        stringify!(poolingDesc)
        )
    );
}
pub const learning_rate_policy_CONSTANT: learning_rate_policy = 0;
pub const learning_rate_policy_STEP: learning_rate_policy = 1;
pub const learning_rate_policy_EXP: learning_rate_policy = 2;
pub const learning_rate_policy_POLY: learning_rate_policy = 3;
pub const learning_rate_policy_STEPS: learning_rate_policy = 4;
pub const learning_rate_policy_SIG: learning_rate_policy = 5;
pub const learning_rate_policy_RANDOM: learning_rate_policy = 6;
pub const learning_rate_policy_SGDR: learning_rate_policy = 7;
pub type learning_rate_policy = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct network {
    pub n: ::std::os::raw::c_int,
    pub batch: ::std::os::raw::c_int,
    pub seen: *mut u64,
    pub badlabels_reject_threshold: *mut f32,
    pub delta_rolling_max: *mut f32,
    pub delta_rolling_avg: *mut f32,
    pub delta_rolling_std: *mut f32,
    pub weights_reject_freq: ::std::os::raw::c_int,
    pub equidistant_point: ::std::os::raw::c_int,
    pub badlabels_rejection_percentage: f32,
    pub num_sigmas_reject_badlabels: f32,
    pub ema_alpha: f32,
    pub cur_iteration: *mut ::std::os::raw::c_int,
    pub loss_scale: f32,
    pub t: *mut ::std::os::raw::c_int,
    pub epoch: f32,
    pub subdivisions: ::std::os::raw::c_int,
    pub layers: *mut layer,
    pub output: *mut f32,
    pub policy: learning_rate_policy,
    pub benchmark_layers: ::std::os::raw::c_int,
    pub total_bbox: *mut ::std::os::raw::c_int,
    pub rewritten_bbox: *mut ::std::os::raw::c_int,
    pub learning_rate: f32,
    pub learning_rate_min: f32,
    pub learning_rate_max: f32,
    pub batches_per_cycle: ::std::os::raw::c_int,
    pub batches_cycle_mult: ::std::os::raw::c_int,
    pub momentum: f32,
    pub decay: f32,
    pub gamma: f32,
    pub scale: f32,
    pub power: f32,
    pub time_steps: ::std::os::raw::c_int,
    pub step: ::std::os::raw::c_int,
    pub max_batches: ::std::os::raw::c_int,
    pub num_boxes: ::std::os::raw::c_int,
    pub train_images_num: ::std::os::raw::c_int,
    pub seq_scales: *mut f32,
    pub scales: *mut f32,
    pub steps: *mut ::std::os::raw::c_int,
    pub num_steps: ::std::os::raw::c_int,
    pub burn_in: ::std::os::raw::c_int,
    pub cudnn_half: ::std::os::raw::c_int,
    pub adam: ::std::os::raw::c_int,
    pub B1: f32,
    pub B2: f32,
    pub eps: f32,
    pub inputs: ::std::os::raw::c_int,
    pub outputs: ::std::os::raw::c_int,
    pub truths: ::std::os::raw::c_int,
    pub notruth: ::std::os::raw::c_int,
    pub h: ::std::os::raw::c_int,
    pub w: ::std::os::raw::c_int,
    pub c: ::std::os::raw::c_int,
    pub max_crop: ::std::os::raw::c_int,
    pub min_crop: ::std::os::raw::c_int,
    pub max_ratio: f32,
    pub min_ratio: f32,
    pub center: ::std::os::raw::c_int,
    pub flip: ::std::os::raw::c_int,
    pub gaussian_noise: ::std::os::raw::c_int,
    pub blur: ::std::os::raw::c_int,
    pub mixup: ::std::os::raw::c_int,
    pub label_smooth_eps: f32,
    pub resize_step: ::std::os::raw::c_int,
    pub attention: ::std::os::raw::c_int,
    pub adversarial: ::std::os::raw::c_int,
    pub adversarial_lr: f32,
    pub max_chart_loss: f32,
    pub letter_box: ::std::os::raw::c_int,
    pub mosaic_bound: ::std::os::raw::c_int,
    pub contrastive: ::std::os::raw::c_int,
    pub contrastive_jit_flip: ::std::os::raw::c_int,
    pub contrastive_color: ::std::os::raw::c_int,
    pub unsupervised: ::std::os::raw::c_int,
    pub angle: f32,
    pub aspect: f32,
    pub exposure: f32,
    pub saturation: f32,
    pub hue: f32,
    pub random: ::std::os::raw::c_int,
    pub track: ::std::os::raw::c_int,
    pub augment_speed: ::std::os::raw::c_int,
    pub sequential_subdivisions: ::std::os::raw::c_int,
    pub init_sequential_subdivisions: ::std::os::raw::c_int,
    pub current_subdivision: ::std::os::raw::c_int,
    pub try_fix_nan: ::std::os::raw::c_int,
    pub gpu_index: ::std::os::raw::c_int,
    pub hierarchy: *mut tree,
    pub input: *mut f32,
    pub truth: *mut f32,
    pub delta: *mut f32,
    pub workspace: *mut f32,
    pub train: ::std::os::raw::c_int,
    pub index: ::std::os::raw::c_int,
    pub cost: *mut f32,
    pub clip: f32,
    pub delta_gpu: *mut f32,
    pub output_gpu: *mut f32,
    pub input_state_gpu: *mut f32,
    pub input_pinned_cpu: *mut f32,
    pub input_pinned_cpu_flag: ::std::os::raw::c_int,
    pub input_gpu: *mut *mut f32,
    pub truth_gpu: *mut *mut f32,
    pub input16_gpu: *mut *mut f32,
    pub output16_gpu: *mut *mut f32,
    pub max_input16_size: *mut usize,
    pub max_output16_size: *mut usize,
    pub wait_stream: ::std::os::raw::c_int,
    pub cuda_graph: *mut ::std::os::raw::c_void,
    pub cuda_graph_exec: *mut ::std::os::raw::c_void,
    pub use_cuda_graph: ::std::os::raw::c_int,
    pub cuda_graph_ready: *mut ::std::os::raw::c_int,
    pub global_delta_gpu: *mut f32,
    pub state_delta_gpu: *mut f32,
    pub max_delta_gpu_size: usize,
    pub optimized_memory: ::std::os::raw::c_int,
    pub dynamic_minibatch: ::std::os::raw::c_int,
    pub workspace_size_limit: usize,
}
#[test]
fn bindgen_test_layout_network() {
    const UNINIT: ::std::mem::MaybeUninit<network> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<network>(),
        656usize,
        concat!("Size of: ", stringify!(network))
    );
    assert_eq!(
        ::std::mem::align_of::<network>(),
        8usize,
        concat!("Alignment of ", stringify!(network))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).n) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(n)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).batch) as usize - ptr as usize },
        4usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(batch)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).seen) as usize - ptr as usize },
        8usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(seen)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).badlabels_reject_threshold) as usize - ptr as usize },
        16usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(badlabels_reject_threshold)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).delta_rolling_max) as usize - ptr as usize },
        24usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(delta_rolling_max)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).delta_rolling_avg) as usize - ptr as usize },
        32usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(delta_rolling_avg)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).delta_rolling_std) as usize - ptr as usize },
        40usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(delta_rolling_std)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).weights_reject_freq) as usize - ptr as usize },
        48usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(weights_reject_freq)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).equidistant_point) as usize - ptr as usize },
        52usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(equidistant_point)
        )
    );
    assert_eq!(
        unsafe {
            ::std::ptr::addr_of!((*ptr).badlabels_rejection_percentage) as usize - ptr as usize
        },
        56usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(badlabels_rejection_percentage)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).num_sigmas_reject_badlabels) as usize - ptr as usize },
        60usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(num_sigmas_reject_badlabels)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ema_alpha) as usize - ptr as usize },
        64usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(ema_alpha)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).cur_iteration) as usize - ptr as usize },
        72usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(cur_iteration)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).loss_scale) as usize - ptr as usize },
        80usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(loss_scale)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).t) as usize - ptr as usize },
        88usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(t)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).epoch) as usize - ptr as usize },
        96usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(epoch)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).subdivisions) as usize - ptr as usize },
        100usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(subdivisions)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).layers) as usize - ptr as usize },
        104usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(layers)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).output) as usize - ptr as usize },
        112usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(output)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).policy) as usize - ptr as usize },
        120usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(policy)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).benchmark_layers) as usize - ptr as usize },
        124usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(benchmark_layers)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).total_bbox) as usize - ptr as usize },
        128usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(total_bbox)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rewritten_bbox) as usize - ptr as usize },
        136usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(rewritten_bbox)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).learning_rate) as usize - ptr as usize },
        144usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(learning_rate)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).learning_rate_min) as usize - ptr as usize },
        148usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(learning_rate_min)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).learning_rate_max) as usize - ptr as usize },
        152usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(learning_rate_max)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).batches_per_cycle) as usize - ptr as usize },
        156usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(batches_per_cycle)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).batches_cycle_mult) as usize - ptr as usize },
        160usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(batches_cycle_mult)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).momentum) as usize - ptr as usize },
        164usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(momentum)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).decay) as usize - ptr as usize },
        168usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(decay)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).gamma) as usize - ptr as usize },
        172usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(gamma)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).scale) as usize - ptr as usize },
        176usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(scale)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).power) as usize - ptr as usize },
        180usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(power)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).time_steps) as usize - ptr as usize },
        184usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(time_steps)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).step) as usize - ptr as usize },
        188usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(step)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).max_batches) as usize - ptr as usize },
        192usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(max_batches)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).num_boxes) as usize - ptr as usize },
        196usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(num_boxes)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).train_images_num) as usize - ptr as usize },
        200usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(train_images_num)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).seq_scales) as usize - ptr as usize },
        208usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(seq_scales)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).scales) as usize - ptr as usize },
        216usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(scales)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).steps) as usize - ptr as usize },
        224usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(steps)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).num_steps) as usize - ptr as usize },
        232usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(num_steps)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).burn_in) as usize - ptr as usize },
        236usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(burn_in)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).cudnn_half) as usize - ptr as usize },
        240usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(cudnn_half)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).adam) as usize - ptr as usize },
        244usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(adam)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).B1) as usize - ptr as usize },
        248usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(B1)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).B2) as usize - ptr as usize },
        252usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(B2)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).eps) as usize - ptr as usize },
        256usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(eps)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).inputs) as usize - ptr as usize },
        260usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(inputs)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).outputs) as usize - ptr as usize },
        264usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(outputs)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).truths) as usize - ptr as usize },
        268usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(truths)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).notruth) as usize - ptr as usize },
        272usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(notruth)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).h) as usize - ptr as usize },
        276usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(h)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).w) as usize - ptr as usize },
        280usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(w)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).c) as usize - ptr as usize },
        284usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(c)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).max_crop) as usize - ptr as usize },
        288usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(max_crop)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).min_crop) as usize - ptr as usize },
        292usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(min_crop)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).max_ratio) as usize - ptr as usize },
        296usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(max_ratio)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).min_ratio) as usize - ptr as usize },
        300usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(min_ratio)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).center) as usize - ptr as usize },
        304usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(center)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).flip) as usize - ptr as usize },
        308usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(flip)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).gaussian_noise) as usize - ptr as usize },
        312usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(gaussian_noise)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).blur) as usize - ptr as usize },
        316usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(blur)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mixup) as usize - ptr as usize },
        320usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(mixup)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).label_smooth_eps) as usize - ptr as usize },
        324usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(label_smooth_eps)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).resize_step) as usize - ptr as usize },
        328usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(resize_step)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).attention) as usize - ptr as usize },
        332usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(attention)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).adversarial) as usize - ptr as usize },
        336usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(adversarial)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).adversarial_lr) as usize - ptr as usize },
        340usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(adversarial_lr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).max_chart_loss) as usize - ptr as usize },
        344usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(max_chart_loss)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).letter_box) as usize - ptr as usize },
        348usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(letter_box)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mosaic_bound) as usize - ptr as usize },
        352usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(mosaic_bound)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).contrastive) as usize - ptr as usize },
        356usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(contrastive)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).contrastive_jit_flip) as usize - ptr as usize },
        360usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(contrastive_jit_flip)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).contrastive_color) as usize - ptr as usize },
        364usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(contrastive_color)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).unsupervised) as usize - ptr as usize },
        368usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(unsupervised)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).angle) as usize - ptr as usize },
        372usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(angle)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).aspect) as usize - ptr as usize },
        376usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(aspect)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).exposure) as usize - ptr as usize },
        380usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(exposure)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).saturation) as usize - ptr as usize },
        384usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(saturation)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hue) as usize - ptr as usize },
        388usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(hue)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).random) as usize - ptr as usize },
        392usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(random)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).track) as usize - ptr as usize },
        396usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(track)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).augment_speed) as usize - ptr as usize },
        400usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(augment_speed)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).sequential_subdivisions) as usize - ptr as usize },
        404usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(sequential_subdivisions)
        )
    );
    assert_eq!(
        unsafe {
            ::std::ptr::addr_of!((*ptr).init_sequential_subdivisions) as usize - ptr as usize
        },
        408usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(init_sequential_subdivisions)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).current_subdivision) as usize - ptr as usize },
        412usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(current_subdivision)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).try_fix_nan) as usize - ptr as usize },
        416usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(try_fix_nan)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).gpu_index) as usize - ptr as usize },
        420usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(gpu_index)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hierarchy) as usize - ptr as usize },
        424usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(hierarchy)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).input) as usize - ptr as usize },
        432usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(input)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).truth) as usize - ptr as usize },
        440usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(truth)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).delta) as usize - ptr as usize },
        448usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(delta)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).workspace) as usize - ptr as usize },
        456usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(workspace)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).train) as usize - ptr as usize },
        464usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(train)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).index) as usize - ptr as usize },
        468usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(index)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).cost) as usize - ptr as usize },
        472usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(cost)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).clip) as usize - ptr as usize },
        480usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(clip)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).delta_gpu) as usize - ptr as usize },
        488usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(delta_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).output_gpu) as usize - ptr as usize },
        496usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(output_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).input_state_gpu) as usize - ptr as usize },
        504usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(input_state_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).input_pinned_cpu) as usize - ptr as usize },
        512usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(input_pinned_cpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).input_pinned_cpu_flag) as usize - ptr as usize },
        520usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(input_pinned_cpu_flag)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).input_gpu) as usize - ptr as usize },
        528usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(input_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).truth_gpu) as usize - ptr as usize },
        536usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(truth_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).input16_gpu) as usize - ptr as usize },
        544usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(input16_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).output16_gpu) as usize - ptr as usize },
        552usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(output16_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).max_input16_size) as usize - ptr as usize },
        560usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(max_input16_size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).max_output16_size) as usize - ptr as usize },
        568usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(max_output16_size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).wait_stream) as usize - ptr as usize },
        576usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(wait_stream)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).cuda_graph) as usize - ptr as usize },
        584usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(cuda_graph)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).cuda_graph_exec) as usize - ptr as usize },
        592usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(cuda_graph_exec)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).use_cuda_graph) as usize - ptr as usize },
        600usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(use_cuda_graph)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).cuda_graph_ready) as usize - ptr as usize },
        608usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(cuda_graph_ready)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).global_delta_gpu) as usize - ptr as usize },
        616usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(global_delta_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).state_delta_gpu) as usize - ptr as usize },
        624usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(state_delta_gpu)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).max_delta_gpu_size) as usize - ptr as usize },
        632usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(max_delta_gpu_size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).optimized_memory) as usize - ptr as usize },
        640usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(optimized_memory)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dynamic_minibatch) as usize - ptr as usize },
        644usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(dynamic_minibatch)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).workspace_size_limit) as usize - ptr as usize },
        648usize,
        concat!(
        "Offset of field: ",
        stringify!(network),
        "::",
        stringify!(workspace_size_limit)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct network_state {
    pub truth: *mut f32,
    pub input: *mut f32,
    pub delta: *mut f32,
    pub workspace: *mut f32,
    pub train: ::std::os::raw::c_int,
    pub index: ::std::os::raw::c_int,
    pub net: network,
}
#[test]
fn bindgen_test_layout_network_state() {
    const UNINIT: ::std::mem::MaybeUninit<network_state> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<network_state>(),
        696usize,
        concat!("Size of: ", stringify!(network_state))
    );
    assert_eq!(
        ::std::mem::align_of::<network_state>(),
        8usize,
        concat!("Alignment of ", stringify!(network_state))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).truth) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(network_state),
        "::",
        stringify!(truth)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).input) as usize - ptr as usize },
        8usize,
        concat!(
        "Offset of field: ",
        stringify!(network_state),
        "::",
        stringify!(input)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).delta) as usize - ptr as usize },
        16usize,
        concat!(
        "Offset of field: ",
        stringify!(network_state),
        "::",
        stringify!(delta)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).workspace) as usize - ptr as usize },
        24usize,
        concat!(
        "Offset of field: ",
        stringify!(network_state),
        "::",
        stringify!(workspace)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).train) as usize - ptr as usize },
        32usize,
        concat!(
        "Offset of field: ",
        stringify!(network_state),
        "::",
        stringify!(train)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).index) as usize - ptr as usize },
        36usize,
        concat!(
        "Offset of field: ",
        stringify!(network_state),
        "::",
        stringify!(index)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).net) as usize - ptr as usize },
        40usize,
        concat!(
        "Offset of field: ",
        stringify!(network_state),
        "::",
        stringify!(net)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct image {
    pub w: ::std::os::raw::c_int,
    pub h: ::std::os::raw::c_int,
    pub c: ::std::os::raw::c_int,
    pub data: *mut f32,
}
#[test]
fn bindgen_test_layout_image() {
    const UNINIT: ::std::mem::MaybeUninit<image> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<image>(),
        24usize,
        concat!("Size of: ", stringify!(image))
    );
    assert_eq!(
        ::std::mem::align_of::<image>(),
        8usize,
        concat!("Alignment of ", stringify!(image))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).w) as usize - ptr as usize },
        0usize,
        concat!("Offset of field: ", stringify!(image), "::", stringify!(w))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).h) as usize - ptr as usize },
        4usize,
        concat!("Offset of field: ", stringify!(image), "::", stringify!(h))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).c) as usize - ptr as usize },
        8usize,
        concat!("Offset of field: ", stringify!(image), "::", stringify!(c))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        16usize,
        concat!(
        "Offset of field: ",
        stringify!(image),
        "::",
        stringify!(data)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct box_ {
    pub x: f32,
    pub y: f32,
    pub w: f32,
    pub h: f32,
}
#[test]
fn bindgen_test_layout_box_() {
    const UNINIT: ::std::mem::MaybeUninit<box_> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<box_>(),
        16usize,
        concat!("Size of: ", stringify!(box_))
    );
    assert_eq!(
        ::std::mem::align_of::<box_>(),
        4usize,
        concat!("Alignment of ", stringify!(box_))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
        0usize,
        concat!("Offset of field: ", stringify!(box_), "::", stringify!(x))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
        4usize,
        concat!("Offset of field: ", stringify!(box_), "::", stringify!(y))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).w) as usize - ptr as usize },
        8usize,
        concat!("Offset of field: ", stringify!(box_), "::", stringify!(w))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).h) as usize - ptr as usize },
        12usize,
        concat!("Offset of field: ", stringify!(box_), "::", stringify!(h))
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct boxabs {
    pub left: f32,
    pub right: f32,
    pub top: f32,
    pub bot: f32,
}
#[test]
fn bindgen_test_layout_boxabs() {
    const UNINIT: ::std::mem::MaybeUninit<boxabs> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<boxabs>(),
        16usize,
        concat!("Size of: ", stringify!(boxabs))
    );
    assert_eq!(
        ::std::mem::align_of::<boxabs>(),
        4usize,
        concat!("Alignment of ", stringify!(boxabs))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).left) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(boxabs),
        "::",
        stringify!(left)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).right) as usize - ptr as usize },
        4usize,
        concat!(
        "Offset of field: ",
        stringify!(boxabs),
        "::",
        stringify!(right)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).top) as usize - ptr as usize },
        8usize,
        concat!(
        "Offset of field: ",
        stringify!(boxabs),
        "::",
        stringify!(top)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bot) as usize - ptr as usize },
        12usize,
        concat!(
        "Offset of field: ",
        stringify!(boxabs),
        "::",
        stringify!(bot)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dxrep {
    pub dt: f32,
    pub db: f32,
    pub dl: f32,
    pub dr: f32,
}
#[test]
fn bindgen_test_layout_dxrep() {
    const UNINIT: ::std::mem::MaybeUninit<dxrep> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<dxrep>(),
        16usize,
        concat!("Size of: ", stringify!(dxrep))
    );
    assert_eq!(
        ::std::mem::align_of::<dxrep>(),
        4usize,
        concat!("Alignment of ", stringify!(dxrep))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dt) as usize - ptr as usize },
        0usize,
        concat!("Offset of field: ", stringify!(dxrep), "::", stringify!(dt))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).db) as usize - ptr as usize },
        4usize,
        concat!("Offset of field: ", stringify!(dxrep), "::", stringify!(db))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dl) as usize - ptr as usize },
        8usize,
        concat!("Offset of field: ", stringify!(dxrep), "::", stringify!(dl))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dr) as usize - ptr as usize },
        12usize,
        concat!("Offset of field: ", stringify!(dxrep), "::", stringify!(dr))
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ious {
    pub iou: f32,
    pub giou: f32,
    pub diou: f32,
    pub ciou: f32,
    pub dx_iou: dxrep,
    pub dx_giou: dxrep,
}
#[test]
fn bindgen_test_layout_ious() {
    const UNINIT: ::std::mem::MaybeUninit<ious> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<ious>(),
        48usize,
        concat!("Size of: ", stringify!(ious))
    );
    assert_eq!(
        ::std::mem::align_of::<ious>(),
        4usize,
        concat!("Alignment of ", stringify!(ious))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).iou) as usize - ptr as usize },
        0usize,
        concat!("Offset of field: ", stringify!(ious), "::", stringify!(iou))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).giou) as usize - ptr as usize },
        4usize,
        concat!(
        "Offset of field: ",
        stringify!(ious),
        "::",
        stringify!(giou)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).diou) as usize - ptr as usize },
        8usize,
        concat!(
        "Offset of field: ",
        stringify!(ious),
        "::",
        stringify!(diou)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ciou) as usize - ptr as usize },
        12usize,
        concat!(
        "Offset of field: ",
        stringify!(ious),
        "::",
        stringify!(ciou)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dx_iou) as usize - ptr as usize },
        16usize,
        concat!(
        "Offset of field: ",
        stringify!(ious),
        "::",
        stringify!(dx_iou)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dx_giou) as usize - ptr as usize },
        32usize,
        concat!(
        "Offset of field: ",
        stringify!(ious),
        "::",
        stringify!(dx_giou)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct detection {
    pub bbox: box_,
    pub classes: ::std::os::raw::c_int,
    pub best_class_idx: ::std::os::raw::c_int,
    pub prob: *mut f32,
    pub mask: *mut f32,
    pub objectness: f32,
    pub sort_class: ::std::os::raw::c_int,
    pub uc: *mut f32,
    pub points: ::std::os::raw::c_int,
    pub embeddings: *mut f32,
    pub embedding_size: ::std::os::raw::c_int,
    pub sim: f32,
    pub track_id: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_detection() {
    const UNINIT: ::std::mem::MaybeUninit<detection> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<detection>(),
        88usize,
        concat!("Size of: ", stringify!(detection))
    );
    assert_eq!(
        ::std::mem::align_of::<detection>(),
        8usize,
        concat!("Alignment of ", stringify!(detection))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bbox) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(detection),
        "::",
        stringify!(bbox)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).classes) as usize - ptr as usize },
        16usize,
        concat!(
        "Offset of field: ",
        stringify!(detection),
        "::",
        stringify!(classes)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).best_class_idx) as usize - ptr as usize },
        20usize,
        concat!(
        "Offset of field: ",
        stringify!(detection),
        "::",
        stringify!(best_class_idx)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).prob) as usize - ptr as usize },
        24usize,
        concat!(
        "Offset of field: ",
        stringify!(detection),
        "::",
        stringify!(prob)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mask) as usize - ptr as usize },
        32usize,
        concat!(
        "Offset of field: ",
        stringify!(detection),
        "::",
        stringify!(mask)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).objectness) as usize - ptr as usize },
        40usize,
        concat!(
        "Offset of field: ",
        stringify!(detection),
        "::",
        stringify!(objectness)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).sort_class) as usize - ptr as usize },
        44usize,
        concat!(
        "Offset of field: ",
        stringify!(detection),
        "::",
        stringify!(sort_class)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uc) as usize - ptr as usize },
        48usize,
        concat!(
        "Offset of field: ",
        stringify!(detection),
        "::",
        stringify!(uc)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).points) as usize - ptr as usize },
        56usize,
        concat!(
        "Offset of field: ",
        stringify!(detection),
        "::",
        stringify!(points)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).embeddings) as usize - ptr as usize },
        64usize,
        concat!(
        "Offset of field: ",
        stringify!(detection),
        "::",
        stringify!(embeddings)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).embedding_size) as usize - ptr as usize },
        72usize,
        concat!(
        "Offset of field: ",
        stringify!(detection),
        "::",
        stringify!(embedding_size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).sim) as usize - ptr as usize },
        76usize,
        concat!(
        "Offset of field: ",
        stringify!(detection),
        "::",
        stringify!(sim)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).track_id) as usize - ptr as usize },
        80usize,
        concat!(
        "Offset of field: ",
        stringify!(detection),
        "::",
        stringify!(track_id)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct det_num_pair {
    pub num: ::std::os::raw::c_int,
    pub dets: *mut detection,
}
#[test]
fn bindgen_test_layout_det_num_pair() {
    const UNINIT: ::std::mem::MaybeUninit<det_num_pair> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<det_num_pair>(),
        16usize,
        concat!("Size of: ", stringify!(det_num_pair))
    );
    assert_eq!(
        ::std::mem::align_of::<det_num_pair>(),
        8usize,
        concat!("Alignment of ", stringify!(det_num_pair))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).num) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(det_num_pair),
        "::",
        stringify!(num)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dets) as usize - ptr as usize },
        8usize,
        concat!(
        "Offset of field: ",
        stringify!(det_num_pair),
        "::",
        stringify!(dets)
        )
    );
}
pub type pdet_num_pair = *mut det_num_pair;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct matrix {
    pub rows: ::std::os::raw::c_int,
    pub cols: ::std::os::raw::c_int,
    pub vals: *mut *mut f32,
}
#[test]
fn bindgen_test_layout_matrix() {
    const UNINIT: ::std::mem::MaybeUninit<matrix> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<matrix>(),
        16usize,
        concat!("Size of: ", stringify!(matrix))
    );
    assert_eq!(
        ::std::mem::align_of::<matrix>(),
        8usize,
        concat!("Alignment of ", stringify!(matrix))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rows) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(matrix),
        "::",
        stringify!(rows)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).cols) as usize - ptr as usize },
        4usize,
        concat!(
        "Offset of field: ",
        stringify!(matrix),
        "::",
        stringify!(cols)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).vals) as usize - ptr as usize },
        8usize,
        concat!(
        "Offset of field: ",
        stringify!(matrix),
        "::",
        stringify!(vals)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct data {
    pub w: ::std::os::raw::c_int,
    pub h: ::std::os::raw::c_int,
    pub X: matrix,
    pub y: matrix,
    pub shallow: ::std::os::raw::c_int,
    pub num_boxes: *mut ::std::os::raw::c_int,
    pub boxes: *mut *mut box_,
}
#[test]
fn bindgen_test_layout_data() {
    const UNINIT: ::std::mem::MaybeUninit<data> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<data>(),
        64usize,
        concat!("Size of: ", stringify!(data))
    );
    assert_eq!(
        ::std::mem::align_of::<data>(),
        8usize,
        concat!("Alignment of ", stringify!(data))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).w) as usize - ptr as usize },
        0usize,
        concat!("Offset of field: ", stringify!(data), "::", stringify!(w))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).h) as usize - ptr as usize },
        4usize,
        concat!("Offset of field: ", stringify!(data), "::", stringify!(h))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).X) as usize - ptr as usize },
        8usize,
        concat!("Offset of field: ", stringify!(data), "::", stringify!(X))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
        24usize,
        concat!("Offset of field: ", stringify!(data), "::", stringify!(y))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).shallow) as usize - ptr as usize },
        40usize,
        concat!(
        "Offset of field: ",
        stringify!(data),
        "::",
        stringify!(shallow)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).num_boxes) as usize - ptr as usize },
        48usize,
        concat!(
        "Offset of field: ",
        stringify!(data),
        "::",
        stringify!(num_boxes)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).boxes) as usize - ptr as usize },
        56usize,
        concat!(
        "Offset of field: ",
        stringify!(data),
        "::",
        stringify!(boxes)
        )
    );
}
pub const data_type_CLASSIFICATION_DATA: data_type = 0;
pub const data_type_DETECTION_DATA: data_type = 1;
pub const data_type_CAPTCHA_DATA: data_type = 2;
pub const data_type_REGION_DATA: data_type = 3;
pub const data_type_IMAGE_DATA: data_type = 4;
pub const data_type_COMPARE_DATA: data_type = 5;
pub const data_type_WRITING_DATA: data_type = 6;
pub const data_type_SWAG_DATA: data_type = 7;
pub const data_type_TAG_DATA: data_type = 8;
pub const data_type_OLD_CLASSIFICATION_DATA: data_type = 9;
pub const data_type_STUDY_DATA: data_type = 10;
pub const data_type_DET_DATA: data_type = 11;
pub const data_type_SUPER_DATA: data_type = 12;
pub const data_type_LETTERBOX_DATA: data_type = 13;
pub const data_type_REGRESSION_DATA: data_type = 14;
pub const data_type_SEGMENTATION_DATA: data_type = 15;
pub const data_type_INSTANCE_DATA: data_type = 16;
pub const data_type_ISEG_DATA: data_type = 17;
pub type data_type = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct load_args {
    pub threads: ::std::os::raw::c_int,
    pub paths: *mut *mut ::std::os::raw::c_char,
    pub path: *mut ::std::os::raw::c_char,
    pub n: ::std::os::raw::c_int,
    pub m: ::std::os::raw::c_int,
    pub labels: *mut *mut ::std::os::raw::c_char,
    pub h: ::std::os::raw::c_int,
    pub w: ::std::os::raw::c_int,
    pub c: ::std::os::raw::c_int,
    pub out_w: ::std::os::raw::c_int,
    pub out_h: ::std::os::raw::c_int,
    pub nh: ::std::os::raw::c_int,
    pub nw: ::std::os::raw::c_int,
    pub num_boxes: ::std::os::raw::c_int,
    pub truth_size: ::std::os::raw::c_int,
    pub min: ::std::os::raw::c_int,
    pub max: ::std::os::raw::c_int,
    pub size: ::std::os::raw::c_int,
    pub classes: ::std::os::raw::c_int,
    pub background: ::std::os::raw::c_int,
    pub scale: ::std::os::raw::c_int,
    pub center: ::std::os::raw::c_int,
    pub coords: ::std::os::raw::c_int,
    pub mini_batch: ::std::os::raw::c_int,
    pub track: ::std::os::raw::c_int,
    pub augment_speed: ::std::os::raw::c_int,
    pub letter_box: ::std::os::raw::c_int,
    pub mosaic_bound: ::std::os::raw::c_int,
    pub show_imgs: ::std::os::raw::c_int,
    pub dontuse_opencv: ::std::os::raw::c_int,
    pub contrastive: ::std::os::raw::c_int,
    pub contrastive_jit_flip: ::std::os::raw::c_int,
    pub contrastive_color: ::std::os::raw::c_int,
    pub jitter: f32,
    pub resize: f32,
    pub flip: ::std::os::raw::c_int,
    pub gaussian_noise: ::std::os::raw::c_int,
    pub blur: ::std::os::raw::c_int,
    pub mixup: ::std::os::raw::c_int,
    pub label_smooth_eps: f32,
    pub angle: f32,
    pub aspect: f32,
    pub saturation: f32,
    pub exposure: f32,
    pub hue: f32,
    pub d: *mut data,
    pub im: *mut image,
    pub resized: *mut image,
    pub type_: data_type,
    pub hierarchy: *mut tree,
}
#[test]
fn bindgen_test_layout_load_args() {
    const UNINIT: ::std::mem::MaybeUninit<load_args> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<load_args>(),
        240usize,
        concat!("Size of: ", stringify!(load_args))
    );
    assert_eq!(
        ::std::mem::align_of::<load_args>(),
        8usize,
        concat!("Alignment of ", stringify!(load_args))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).threads) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(threads)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).paths) as usize - ptr as usize },
        8usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(paths)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).path) as usize - ptr as usize },
        16usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(path)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).n) as usize - ptr as usize },
        24usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(n)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).m) as usize - ptr as usize },
        28usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(m)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).labels) as usize - ptr as usize },
        32usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(labels)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).h) as usize - ptr as usize },
        40usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(h)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).w) as usize - ptr as usize },
        44usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(w)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).c) as usize - ptr as usize },
        48usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(c)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).out_w) as usize - ptr as usize },
        52usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(out_w)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).out_h) as usize - ptr as usize },
        56usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(out_h)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nh) as usize - ptr as usize },
        60usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(nh)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nw) as usize - ptr as usize },
        64usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(nw)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).num_boxes) as usize - ptr as usize },
        68usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(num_boxes)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).truth_size) as usize - ptr as usize },
        72usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(truth_size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).min) as usize - ptr as usize },
        76usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(min)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).max) as usize - ptr as usize },
        80usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(max)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        84usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).classes) as usize - ptr as usize },
        88usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(classes)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).background) as usize - ptr as usize },
        92usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(background)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).scale) as usize - ptr as usize },
        96usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(scale)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).center) as usize - ptr as usize },
        100usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(center)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).coords) as usize - ptr as usize },
        104usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(coords)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mini_batch) as usize - ptr as usize },
        108usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(mini_batch)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).track) as usize - ptr as usize },
        112usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(track)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).augment_speed) as usize - ptr as usize },
        116usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(augment_speed)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).letter_box) as usize - ptr as usize },
        120usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(letter_box)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mosaic_bound) as usize - ptr as usize },
        124usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(mosaic_bound)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).show_imgs) as usize - ptr as usize },
        128usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(show_imgs)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dontuse_opencv) as usize - ptr as usize },
        132usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(dontuse_opencv)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).contrastive) as usize - ptr as usize },
        136usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(contrastive)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).contrastive_jit_flip) as usize - ptr as usize },
        140usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(contrastive_jit_flip)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).contrastive_color) as usize - ptr as usize },
        144usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(contrastive_color)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).jitter) as usize - ptr as usize },
        148usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(jitter)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).resize) as usize - ptr as usize },
        152usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(resize)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).flip) as usize - ptr as usize },
        156usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(flip)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).gaussian_noise) as usize - ptr as usize },
        160usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(gaussian_noise)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).blur) as usize - ptr as usize },
        164usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(blur)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mixup) as usize - ptr as usize },
        168usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(mixup)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).label_smooth_eps) as usize - ptr as usize },
        172usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(label_smooth_eps)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).angle) as usize - ptr as usize },
        176usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(angle)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).aspect) as usize - ptr as usize },
        180usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(aspect)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).saturation) as usize - ptr as usize },
        184usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(saturation)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).exposure) as usize - ptr as usize },
        188usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(exposure)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hue) as usize - ptr as usize },
        192usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(hue)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
        200usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(d)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).im) as usize - ptr as usize },
        208usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(im)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).resized) as usize - ptr as usize },
        216usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(resized)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
        224usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(type_)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hierarchy) as usize - ptr as usize },
        232usize,
        concat!(
        "Offset of field: ",
        stringify!(load_args),
        "::",
        stringify!(hierarchy)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct box_label {
    pub id: ::std::os::raw::c_int,
    pub track_id: ::std::os::raw::c_int,
    pub x: f32,
    pub y: f32,
    pub w: f32,
    pub h: f32,
    pub left: f32,
    pub right: f32,
    pub top: f32,
    pub bottom: f32,
}
#[test]
fn bindgen_test_layout_box_label() {
    const UNINIT: ::std::mem::MaybeUninit<box_label> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<box_label>(),
        40usize,
        concat!("Size of: ", stringify!(box_label))
    );
    assert_eq!(
        ::std::mem::align_of::<box_label>(),
        4usize,
        concat!("Alignment of ", stringify!(box_label))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(box_label),
        "::",
        stringify!(id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).track_id) as usize - ptr as usize },
        4usize,
        concat!(
        "Offset of field: ",
        stringify!(box_label),
        "::",
        stringify!(track_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
        8usize,
        concat!(
        "Offset of field: ",
        stringify!(box_label),
        "::",
        stringify!(x)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
        12usize,
        concat!(
        "Offset of field: ",
        stringify!(box_label),
        "::",
        stringify!(y)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).w) as usize - ptr as usize },
        16usize,
        concat!(
        "Offset of field: ",
        stringify!(box_label),
        "::",
        stringify!(w)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).h) as usize - ptr as usize },
        20usize,
        concat!(
        "Offset of field: ",
        stringify!(box_label),
        "::",
        stringify!(h)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).left) as usize - ptr as usize },
        24usize,
        concat!(
        "Offset of field: ",
        stringify!(box_label),
        "::",
        stringify!(left)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).right) as usize - ptr as usize },
        28usize,
        concat!(
        "Offset of field: ",
        stringify!(box_label),
        "::",
        stringify!(right)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).top) as usize - ptr as usize },
        32usize,
        concat!(
        "Offset of field: ",
        stringify!(box_label),
        "::",
        stringify!(top)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bottom) as usize - ptr as usize },
        36usize,
        concat!(
        "Offset of field: ",
        stringify!(box_label),
        "::",
        stringify!(bottom)
        )
    );
}
extern "C" {
    pub fn load_network(
        cfg: *mut ::std::os::raw::c_char,
        weights: *mut ::std::os::raw::c_char,
        clear: ::std::os::raw::c_int,
    ) -> *mut network;
}
extern "C" {
    pub fn load_network_custom(
        cfg: *mut ::std::os::raw::c_char,
        weights: *mut ::std::os::raw::c_char,
        clear: ::std::os::raw::c_int,
        batch: ::std::os::raw::c_int,
    ) -> *mut network;
}
extern "C" {
    pub fn free_network(net: network);
}
extern "C" {
    pub fn free_network_ptr(net: *mut network);
}
extern "C" {
    pub fn get_base_args(net: *mut network) -> load_args;
}
extern "C" {
    pub fn do_nms_sort(
        dets: *mut detection,
        total: ::std::os::raw::c_int,
        classes: ::std::os::raw::c_int,
        thresh: f32,
    );
}
extern "C" {
    pub fn do_nms_obj(
        dets: *mut detection,
        total: ::std::os::raw::c_int,
        classes: ::std::os::raw::c_int,
        thresh: f32,
    );
}
extern "C" {
    pub fn diounms_sort(
        dets: *mut detection,
        total: ::std::os::raw::c_int,
        classes: ::std::os::raw::c_int,
        thresh: f32,
        nms_kind: NMS_KIND,
        beta1: f32,
    );
}
extern "C" {
    pub fn network_predict(net: network, input: *mut f32) -> *mut f32;
}
extern "C" {
    pub fn network_predict_ptr(net: *mut network, input: *mut f32) -> *mut f32;
}
extern "C" {
    pub fn get_network_boxes(
        net: *mut network,
        w: ::std::os::raw::c_int,
        h: ::std::os::raw::c_int,
        thresh: f32,
        hier: f32,
        map: *mut ::std::os::raw::c_int,
        relative: ::std::os::raw::c_int,
        num: *mut ::std::os::raw::c_int,
        letter: ::std::os::raw::c_int,
    ) -> *mut detection;
}
extern "C" {
    pub fn network_predict_batch(
        net: *mut network,
        im: image,
        batch_size: ::std::os::raw::c_int,
        w: ::std::os::raw::c_int,
        h: ::std::os::raw::c_int,
        thresh: f32,
        hier: f32,
        map: *mut ::std::os::raw::c_int,
        relative: ::std::os::raw::c_int,
        letter: ::std::os::raw::c_int,
    ) -> *mut det_num_pair;
}
extern "C" {
    pub fn free_detections(dets: *mut detection, n: ::std::os::raw::c_int);
}
extern "C" {
    pub fn free_batch_detections(det_num_pairs: *mut det_num_pair, n: ::std::os::raw::c_int);
}
extern "C" {
    pub fn fuse_conv_batchnorm(net: network);
}
extern "C" {
    pub fn calculate_binary_weights(net: network);
}
extern "C" {
    pub fn detection_to_json(
        dets: *mut detection,
        nboxes: ::std::os::raw::c_int,
        classes: ::std::os::raw::c_int,
        names: *mut *mut ::std::os::raw::c_char,
        frame_id: ::std::os::raw::c_longlong,
        filename: *mut ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn get_network_layer(net: *mut network, i: ::std::os::raw::c_int) -> *mut layer;
}
extern "C" {
    pub fn make_network_boxes(
        net: *mut network,
        thresh: f32,
        num: *mut ::std::os::raw::c_int,
    ) -> *mut detection;
}
extern "C" {
    pub fn reset_rnn(net: *mut network);
}
extern "C" {
    pub fn network_predict_image(net: *mut network, im: image) -> *mut f32;
}
extern "C" {
    pub fn network_predict_image_letterbox(net: *mut network, im: image) -> *mut f32;
}
extern "C" {
    pub fn validate_detector_map(
        datacfg: *mut ::std::os::raw::c_char,
        cfgfile: *mut ::std::os::raw::c_char,
        weightfile: *mut ::std::os::raw::c_char,
        thresh_calc_avg_iou: f32,
        iou_thresh: f32,
        map_points: ::std::os::raw::c_int,
        letter_box: ::std::os::raw::c_int,
        existing_net: *mut network,
    ) -> f32;
}
extern "C" {
    pub fn train_detector(
        datacfg: *mut ::std::os::raw::c_char,
        cfgfile: *mut ::std::os::raw::c_char,
        weightfile: *mut ::std::os::raw::c_char,
        gpus: *mut ::std::os::raw::c_int,
        ngpus: ::std::os::raw::c_int,
        clear: ::std::os::raw::c_int,
        dont_show: ::std::os::raw::c_int,
        calc_map: ::std::os::raw::c_int,
        thresh: f32,
        iou_thresh: f32,
        mjpeg_port: ::std::os::raw::c_int,
        show_imgs: ::std::os::raw::c_int,
        benchmark_layers: ::std::os::raw::c_int,
        chart_path: *mut ::std::os::raw::c_char,
    );
}
extern "C" {
    pub fn test_detector(
        datacfg: *mut ::std::os::raw::c_char,
        cfgfile: *mut ::std::os::raw::c_char,
        weightfile: *mut ::std::os::raw::c_char,
        filename: *mut ::std::os::raw::c_char,
        thresh: f32,
        hier_thresh: f32,
        dont_show: ::std::os::raw::c_int,
        ext_output: ::std::os::raw::c_int,
        save_labels: ::std::os::raw::c_int,
        outfile: *mut ::std::os::raw::c_char,
        letter_box: ::std::os::raw::c_int,
        benchmark_layers: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn network_width(net: *mut network) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn network_height(net: *mut network) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn optimize_picture(
        net: *mut network,
        orig: image,
        max_layer: ::std::os::raw::c_int,
        scale: f32,
        rate: f32,
        thresh: f32,
        norm: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn make_image_red(im: image);
}
extern "C" {
    pub fn make_attention_image(
        img_size: ::std::os::raw::c_int,
        original_delta_cpu: *mut f32,
        original_input_cpu: *mut f32,
        w: ::std::os::raw::c_int,
        h: ::std::os::raw::c_int,
        c: ::std::os::raw::c_int,
        alpha: f32,
    ) -> image;
}
extern "C" {
    pub fn resize_image(im: image, w: ::std::os::raw::c_int, h: ::std::os::raw::c_int) -> image;
}
extern "C" {
    pub fn quantize_image(im: image);
}
extern "C" {
    pub fn copy_image_from_bytes(im: image, pdata: *mut ::std::os::raw::c_char);
}
extern "C" {
    pub fn letterbox_image(im: image, w: ::std::os::raw::c_int, h: ::std::os::raw::c_int) -> image;
}
extern "C" {
    pub fn rgbgr_image(im: image);
}
extern "C" {
    pub fn make_image(
        w: ::std::os::raw::c_int,
        h: ::std::os::raw::c_int,
        c: ::std::os::raw::c_int,
    ) -> image;
}
extern "C" {
    pub fn load_image_color(
        filename: *mut ::std::os::raw::c_char,
        w: ::std::os::raw::c_int,
        h: ::std::os::raw::c_int,
    ) -> image;
}
extern "C" {
    pub fn free_image(m: image);
}
extern "C" {
    pub fn crop_image(
        im: image,
        dx: ::std::os::raw::c_int,
        dy: ::std::os::raw::c_int,
        w: ::std::os::raw::c_int,
        h: ::std::os::raw::c_int,
    ) -> image;
}
extern "C" {
    pub fn resize_min(im: image, min: ::std::os::raw::c_int) -> image;
}
extern "C" {
    pub fn free_layer_custom(l: layer, keep_cudnn_desc: ::std::os::raw::c_int);
}
extern "C" {
    pub fn free_layer(l: layer);
}
extern "C" {
    pub fn free_data(d: data);
}
extern "C" {
    pub fn load_data(args: load_args) -> pthread_t;
}
extern "C" {
    pub fn free_load_threads(ptr: *mut ::std::os::raw::c_void);
}
extern "C" {
    pub fn load_data_in_thread(args: load_args) -> pthread_t;
}
extern "C" {
    pub fn load_thread(ptr: *mut ::std::os::raw::c_void) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn cuda_pull_array(x_gpu: *mut f32, x: *mut f32, n: usize);
}
extern "C" {
    pub fn cuda_pull_array_async(x_gpu: *mut f32, x: *mut f32, n: usize);
}
extern "C" {
    pub fn cuda_set_device(n: ::std::os::raw::c_int);
}
extern "C" {
    pub fn cuda_get_context() -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn free_ptrs(ptrs: *mut *mut ::std::os::raw::c_void, n: ::std::os::raw::c_int);
}
extern "C" {
    pub fn top_k(
        a: *mut f32,
        n: ::std::os::raw::c_int,
        k: ::std::os::raw::c_int,
        index: *mut ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn read_tree(filename: *mut ::std::os::raw::c_char) -> *mut tree;
}
extern "C" {
    pub fn get_metadata(file: *mut ::std::os::raw::c_char) -> metadata;
}
extern "C" {
    pub fn delete_json_sender();
}
extern "C" {
    pub fn send_json_custom(
        send_buf: *const ::std::os::raw::c_char,
        port: ::std::os::raw::c_int,
        timeout: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn get_time_point() -> f64;
}
extern "C" {
    pub fn start_timer();
}
extern "C" {
    pub fn stop_timer();
}
extern "C" {
    pub fn get_time() -> f64;
}
extern "C" {
    pub fn stop_timer_and_show();
}
extern "C" {
    pub fn stop_timer_and_show_name(name: *mut ::std::os::raw::c_char);
}
extern "C" {
    pub fn show_total_time();
}
extern "C" {
    pub fn set_track_id(
        new_dets: *mut detection,
        new_dets_num: ::std::os::raw::c_int,
        thresh: f32,
        sim_thresh: f32,
        track_ciou_norm: f32,
        deque_size: ::std::os::raw::c_int,
        dets_for_track: ::std::os::raw::c_int,
        dets_for_show: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn fill_remaining_id(
        new_dets: *mut detection,
        new_dets_num: ::std::os::raw::c_int,
        new_track_id: ::std::os::raw::c_int,
        thresh: f32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn init_cpu();
}
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() {
    const UNINIT: ::std::mem::MaybeUninit<__va_list_tag> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    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::addr_of!((*ptr).gp_offset) as usize - ptr as usize },
        0usize,
        concat!(
        "Offset of field: ",
        stringify!(__va_list_tag),
        "::",
        stringify!(gp_offset)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fp_offset) as usize - ptr as usize },
        4usize,
        concat!(
        "Offset of field: ",
        stringify!(__va_list_tag),
        "::",
        stringify!(fp_offset)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).overflow_arg_area) as usize - ptr as usize },
        8usize,
        concat!(
        "Offset of field: ",
        stringify!(__va_list_tag),
        "::",
        stringify!(overflow_arg_area)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).reg_save_area) as usize - ptr as usize },
        16usize,
        concat!(
        "Offset of field: ",
        stringify!(__va_list_tag),
        "::",
        stringify!(reg_save_area)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __locale_data {
    pub _address: u8,
}