/* automatically generated by rust-bindgen */

#![no_std]
#![allow(non_upper_case_globals)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
extern "C" {
	pub fn abort() -> !;
	pub fn exit(__status: cty::c_int) -> !;
}

pub type __u_char = cty::c_uchar;
pub type __u_short = cty::c_ushort;
pub type __u_int = cty::c_uint;
pub type __u_long = cty::c_ulong;
pub type __int8_t = cty::c_schar;
pub type __uint8_t = cty::c_uchar;
pub type __int16_t = cty::c_short;
pub type __uint16_t = cty::c_ushort;
pub type __int32_t = cty::c_int;
pub type __uint32_t = cty::c_uint;
pub type __int64_t = cty::c_long;
pub type __uint64_t = cty::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 = cty::c_long;
pub type __u_quad_t = cty::c_ulong;
pub type __intmax_t = cty::c_long;
pub type __uintmax_t = cty::c_ulong;
pub type __dev_t = cty::c_ulong;
pub type __uid_t = cty::c_uint;
pub type __gid_t = cty::c_uint;
pub type __ino_t = cty::c_ulong;
pub type __ino64_t = cty::c_ulong;
pub type __mode_t = cty::c_uint;
pub type __nlink_t = cty::c_ulong;
pub type __off_t = cty::c_long;
pub type __off64_t = cty::c_long;
pub type __pid_t = cty::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __fsid_t {
    pub __val: [cty::c_int; 2usize],
}
#[test]
fn bindgen_test_layout___fsid_t() {
    assert_eq!(
        ::core::mem::size_of::<__fsid_t>(),
        8usize,
        concat!("Size of: ", stringify!(__fsid_t))
    );
    assert_eq!(
        ::core::mem::align_of::<__fsid_t>(),
        4usize,
        concat!("Alignment of ", stringify!(__fsid_t))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__fsid_t>())).__val as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__fsid_t),
            "::",
            stringify!(__val)
        )
    );
}
pub type __clock_t = cty::c_long;
pub type __rlim_t = cty::c_ulong;
pub type __rlim64_t = cty::c_ulong;
pub type __id_t = cty::c_uint;
pub type __time_t = cty::c_long;
pub type __useconds_t = cty::c_uint;
pub type __suseconds_t = cty::c_long;
pub type __daddr_t = cty::c_int;
pub type __key_t = cty::c_int;
pub type __clockid_t = cty::c_int;
pub type __timer_t = *mut cty::c_void;
pub type __blksize_t = cty::c_long;
pub type __blkcnt_t = cty::c_long;
pub type __blkcnt64_t = cty::c_long;
pub type __fsblkcnt_t = cty::c_ulong;
pub type __fsblkcnt64_t = cty::c_ulong;
pub type __fsfilcnt_t = cty::c_ulong;
pub type __fsfilcnt64_t = cty::c_ulong;
pub type __fsword_t = cty::c_long;
pub type __ssize_t = cty::c_long;
pub type __syscall_slong_t = cty::c_long;
pub type __syscall_ulong_t = cty::c_ulong;
pub type __loff_t = __off64_t;
pub type __caddr_t = *mut cty::c_char;
pub type __intptr_t = cty::c_long;
pub type __socklen_t = cty::c_uint;
pub type __sig_atomic_t = cty::c_int;
pub type int_least8_t = __int_least8_t;
pub type int_least16_t = __int_least16_t;
pub type int_least32_t = __int_least32_t;
pub type int_least64_t = __int_least64_t;
pub type uint_least8_t = __uint_least8_t;
pub type uint_least16_t = __uint_least16_t;
pub type uint_least32_t = __uint_least32_t;
pub type uint_least64_t = __uint_least64_t;
pub type int_fast8_t = cty::c_schar;
pub type int_fast16_t = cty::c_long;
pub type int_fast32_t = cty::c_long;
pub type int_fast64_t = cty::c_long;
pub type uint_fast8_t = cty::c_uchar;
pub type uint_fast16_t = cty::c_ulong;
pub type uint_fast32_t = cty::c_ulong;
pub type uint_fast64_t = cty::c_ulong;
pub type intmax_t = __intmax_t;
pub type uintmax_t = __uintmax_t;
pub type wchar_t = cty::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: cty::c_int,
    pub rem: cty::c_int,
}
#[test]
fn bindgen_test_layout_div_t() {
    assert_eq!(
        ::core::mem::size_of::<div_t>(),
        8usize,
        concat!("Size of: ", stringify!(div_t))
    );
    assert_eq!(
        ::core::mem::align_of::<div_t>(),
        4usize,
        concat!("Alignment of ", stringify!(div_t))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<div_t>())).quot as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(div_t),
            "::",
            stringify!(quot)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<div_t>())).rem as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(div_t),
            "::",
            stringify!(rem)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ldiv_t {
    pub quot: cty::c_long,
    pub rem: cty::c_long,
}
#[test]
fn bindgen_test_layout_ldiv_t() {
    assert_eq!(
        ::core::mem::size_of::<ldiv_t>(),
        16usize,
        concat!("Size of: ", stringify!(ldiv_t))
    );
    assert_eq!(
        ::core::mem::align_of::<ldiv_t>(),
        8usize,
        concat!("Alignment of ", stringify!(ldiv_t))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<ldiv_t>())).quot as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(ldiv_t),
            "::",
            stringify!(quot)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<ldiv_t>())).rem as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(ldiv_t),
            "::",
            stringify!(rem)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lldiv_t {
    pub quot: cty::c_longlong,
    pub rem: cty::c_longlong,
}
#[test]
fn bindgen_test_layout_lldiv_t() {
    assert_eq!(
        ::core::mem::size_of::<lldiv_t>(),
        16usize,
        concat!("Size of: ", stringify!(lldiv_t))
    );
    assert_eq!(
        ::core::mem::align_of::<lldiv_t>(),
        8usize,
        concat!("Alignment of ", stringify!(lldiv_t))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<lldiv_t>())).quot as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(lldiv_t),
            "::",
            stringify!(quot)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<lldiv_t>())).rem as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(lldiv_t),
            "::",
            stringify!(rem)
        )
    );
}
extern "C" {
    pub fn __ctype_get_mb_cur_max() -> usize;
}
extern "C" {
    pub fn atof(__nptr: *const cty::c_char) -> f64;
}
extern "C" {
    pub fn atoi(__nptr: *const cty::c_char) -> cty::c_int;
}
extern "C" {
    pub fn atol(__nptr: *const cty::c_char) -> cty::c_long;
}
extern "C" {
    pub fn atoll(__nptr: *const cty::c_char) -> cty::c_longlong;
}
extern "C" {
    pub fn strtod(__nptr: *const cty::c_char, __endptr: *mut *mut cty::c_char) -> f64;
}
extern "C" {
    pub fn strtof(__nptr: *const cty::c_char, __endptr: *mut *mut cty::c_char) -> f32;
}
extern "C" {
    pub fn strtold(__nptr: *const cty::c_char, __endptr: *mut *mut cty::c_char) -> u128;
}
extern "C" {
    pub fn strtol(
        __nptr: *const cty::c_char,
        __endptr: *mut *mut cty::c_char,
        _start: cty::c_int,
    ) -> cty::c_long;
}
extern "C" {
    pub fn strtoul(
        __nptr: *const cty::c_char,
        __endptr: *mut *mut cty::c_char,
        _start: cty::c_int,
    ) -> cty::c_ulong;
}
extern "C" {
    pub fn strtoq(
        __nptr: *const cty::c_char,
        __endptr: *mut *mut cty::c_char,
        _start: cty::c_int,
    ) -> cty::c_longlong;
}
extern "C" {
    pub fn strtouq(
        __nptr: *const cty::c_char,
        __endptr: *mut *mut cty::c_char,
        _start: cty::c_int,
    ) -> cty::c_ulonglong;
}
extern "C" {
    pub fn strtoll(
        __nptr: *const cty::c_char,
        __endptr: *mut *mut cty::c_char,
        _start: cty::c_int,
    ) -> cty::c_longlong;
}
extern "C" {
    pub fn strtoull(
        __nptr: *const cty::c_char,
        __endptr: *mut *mut cty::c_char,
        _start: cty::c_int,
    ) -> cty::c_ulonglong;
}
extern "C" {
    pub fn l64a(__n: cty::c_long) -> *mut cty::c_char;
}
extern "C" {
    pub fn a64l(__s: *const cty::c_char) -> cty::c_long;
}
pub type u_char = __u_char;
pub type u_short = __u_short;
pub type u_int = __u_int;
pub type u_long = __u_long;
pub type quad_t = __quad_t;
pub type u_quad_t = __u_quad_t;
pub type fsid_t = __fsid_t;
pub type loff_t = __loff_t;
pub type ino_t = __ino_t;
pub type 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 = cty::c_ulong;
pub type ushort = cty::c_ushort;
pub type uint = cty::c_uint;
pub type u_int8_t = cty::c_uchar;
pub type u_int16_t = cty::c_ushort;
pub type u_int32_t = cty::c_uint;
pub type u_int64_t = cty::c_ulong;
pub type register_t = cty::c_long;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __sigset_t {
    pub __val: [cty::c_ulong; 16usize],
}
#[test]
fn bindgen_test_layout___sigset_t() {
    assert_eq!(
        ::core::mem::size_of::<__sigset_t>(),
        128usize,
        concat!("Size of: ", stringify!(__sigset_t))
    );
    assert_eq!(
        ::core::mem::align_of::<__sigset_t>(),
        8usize,
        concat!("Alignment of ", stringify!(__sigset_t))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__sigset_t>())).__val as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__sigset_t),
            "::",
            stringify!(__val)
        )
    );
}
pub type sigset_t = __sigset_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct timeval {
    pub tv_sec: __time_t,
    pub tv_usec: __suseconds_t,
}
#[test]
fn bindgen_test_layout_timeval() {
    assert_eq!(
        ::core::mem::size_of::<timeval>(),
        16usize,
        concat!("Size of: ", stringify!(timeval))
    );
    assert_eq!(
        ::core::mem::align_of::<timeval>(),
        8usize,
        concat!("Alignment of ", stringify!(timeval))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<timeval>())).tv_sec as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(timeval),
            "::",
            stringify!(tv_sec)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<timeval>())).tv_usec as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(timeval),
            "::",
            stringify!(tv_usec)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct timespec {
    pub tv_sec: __time_t,
    pub tv_nsec: __syscall_slong_t,
}
#[test]
fn bindgen_test_layout_timespec() {
    assert_eq!(
        ::core::mem::size_of::<timespec>(),
        16usize,
        concat!("Size of: ", stringify!(timespec))
    );
    assert_eq!(
        ::core::mem::align_of::<timespec>(),
        8usize,
        concat!("Alignment of ", stringify!(timespec))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<timespec>())).tv_sec as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(timespec),
            "::",
            stringify!(tv_sec)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<timespec>())).tv_nsec as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(timespec),
            "::",
            stringify!(tv_nsec)
        )
    );
}
pub type suseconds_t = __suseconds_t;
pub type __fd_mask = cty::c_long;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct fd_set {
    pub __fds_bits: [__fd_mask; 16usize],
}
#[test]
fn bindgen_test_layout_fd_set() {
    assert_eq!(
        ::core::mem::size_of::<fd_set>(),
        128usize,
        concat!("Size of: ", stringify!(fd_set))
    );
    assert_eq!(
        ::core::mem::align_of::<fd_set>(),
        8usize,
        concat!("Alignment of ", stringify!(fd_set))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<fd_set>())).__fds_bits as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(fd_set),
            "::",
            stringify!(__fds_bits)
        )
    );
}
pub type fd_mask = __fd_mask;
extern "C" {
    pub fn select(
        __nfds: cty::c_int,
        __readfds: *mut fd_set,
        __writefds: *mut fd_set,
        __exceptfds: *mut fd_set,
        __timeout: *mut timeval,
    ) -> cty::c_int;
}
extern "C" {
    pub fn pselect(
        __nfds: cty::c_int,
        __readfds: *mut fd_set,
        __writefds: *mut fd_set,
        __exceptfds: *mut fd_set,
        __timeout: *const timespec,
        __sigmask: *const __sigset_t,
    ) -> cty::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(Debug, Copy, Clone)]
pub struct __pthread_rwlock_arch_t {
    pub __readers: cty::c_uint,
    pub __writers: cty::c_uint,
    pub __wrphase_futex: cty::c_uint,
    pub __writers_futex: cty::c_uint,
    pub __pad3: cty::c_uint,
    pub __pad4: cty::c_uint,
    pub __cur_writer: cty::c_int,
    pub __shared: cty::c_int,
    pub __rwelision: cty::c_schar,
    pub __pad1: [cty::c_uchar; 7usize],
    pub __pad2: cty::c_ulong,
    pub __flags: cty::c_uint,
}
#[test]
fn bindgen_test_layout___pthread_rwlock_arch_t() {
    assert_eq!(
        ::core::mem::size_of::<__pthread_rwlock_arch_t>(),
        56usize,
        concat!("Size of: ", stringify!(__pthread_rwlock_arch_t))
    );
    assert_eq!(
        ::core::mem::align_of::<__pthread_rwlock_arch_t>(),
        8usize,
        concat!("Alignment of ", stringify!(__pthread_rwlock_arch_t))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__pthread_rwlock_arch_t>())).__readers as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_rwlock_arch_t),
            "::",
            stringify!(__readers)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__pthread_rwlock_arch_t>())).__writers as *const _ as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_rwlock_arch_t),
            "::",
            stringify!(__writers)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__pthread_rwlock_arch_t>())).__wrphase_futex as *const _
                as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_rwlock_arch_t),
            "::",
            stringify!(__wrphase_futex)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__pthread_rwlock_arch_t>())).__writers_futex as *const _
                as usize
        },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_rwlock_arch_t),
            "::",
            stringify!(__writers_futex)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__pthread_rwlock_arch_t>())).__pad3 as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_rwlock_arch_t),
            "::",
            stringify!(__pad3)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__pthread_rwlock_arch_t>())).__pad4 as *const _ as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_rwlock_arch_t),
            "::",
            stringify!(__pad4)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__pthread_rwlock_arch_t>())).__cur_writer as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_rwlock_arch_t),
            "::",
            stringify!(__cur_writer)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__pthread_rwlock_arch_t>())).__shared as *const _ as usize
        },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_rwlock_arch_t),
            "::",
            stringify!(__shared)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__pthread_rwlock_arch_t>())).__rwelision as *const _ as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_rwlock_arch_t),
            "::",
            stringify!(__rwelision)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__pthread_rwlock_arch_t>())).__pad1 as *const _ as usize },
        33usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_rwlock_arch_t),
            "::",
            stringify!(__pad1)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__pthread_rwlock_arch_t>())).__pad2 as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_rwlock_arch_t),
            "::",
            stringify!(__pad2)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__pthread_rwlock_arch_t>())).__flags as *const _ as usize
        },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_rwlock_arch_t),
            "::",
            stringify!(__flags)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_internal_list {
    pub __prev: *mut __pthread_internal_list,
    pub __next: *mut __pthread_internal_list,
}
#[test]
fn bindgen_test_layout___pthread_internal_list() {
    assert_eq!(
        ::core::mem::size_of::<__pthread_internal_list>(),
        16usize,
        concat!("Size of: ", stringify!(__pthread_internal_list))
    );
    assert_eq!(
        ::core::mem::align_of::<__pthread_internal_list>(),
        8usize,
        concat!("Alignment of ", stringify!(__pthread_internal_list))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__pthread_internal_list>())).__prev as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_internal_list),
            "::",
            stringify!(__prev)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__pthread_internal_list>())).__next as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_internal_list),
            "::",
            stringify!(__next)
        )
    );
}
pub type __pthread_list_t = __pthread_internal_list;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_mutex_s {
    pub __lock: cty::c_int,
    pub __count: cty::c_uint,
    pub __owner: cty::c_int,
    pub __nusers: cty::c_uint,
    pub __kind: cty::c_int,
    pub __spins: cty::c_short,
    pub __elision: cty::c_short,
    pub __list: __pthread_list_t,
}
#[test]
fn bindgen_test_layout___pthread_mutex_s() {
    assert_eq!(
        ::core::mem::size_of::<__pthread_mutex_s>(),
        40usize,
        concat!("Size of: ", stringify!(__pthread_mutex_s))
    );
    assert_eq!(
        ::core::mem::align_of::<__pthread_mutex_s>(),
        8usize,
        concat!("Alignment of ", stringify!(__pthread_mutex_s))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__pthread_mutex_s>())).__lock as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_mutex_s),
            "::",
            stringify!(__lock)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__pthread_mutex_s>())).__count as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_mutex_s),
            "::",
            stringify!(__count)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__pthread_mutex_s>())).__owner as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_mutex_s),
            "::",
            stringify!(__owner)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__pthread_mutex_s>())).__nusers as *const _ as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_mutex_s),
            "::",
            stringify!(__nusers)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__pthread_mutex_s>())).__kind as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_mutex_s),
            "::",
            stringify!(__kind)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__pthread_mutex_s>())).__spins as *const _ as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_mutex_s),
            "::",
            stringify!(__spins)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__pthread_mutex_s>())).__elision as *const _ as usize },
        22usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_mutex_s),
            "::",
            stringify!(__elision)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__pthread_mutex_s>())).__list as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_mutex_s),
            "::",
            stringify!(__list)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct __pthread_cond_s {
    pub __bindgen_anon_1: __pthread_cond_s__bindgen_ty_1,
    pub __bindgen_anon_2: __pthread_cond_s__bindgen_ty_2,
    pub __g_refs: [cty::c_uint; 2usize],
    pub __g_size: [cty::c_uint; 2usize],
    pub __g1_orig_size: cty::c_uint,
    pub __wrefs: cty::c_uint,
    pub __g_signals: [cty::c_uint; 2usize],
}
#[repr(C)]
#[repr(align(8))]
#[derive(Copy, Clone)]
pub union __pthread_cond_s__bindgen_ty_1 {
    pub __wseq: cty::c_ulonglong,
    pub __wseq32: __pthread_cond_s__bindgen_ty_1__bindgen_ty_1,
    _bindgen_union_align: u64,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_cond_s__bindgen_ty_1__bindgen_ty_1 {
    pub __low: cty::c_uint,
    pub __high: cty::c_uint,
}
#[test]
fn bindgen_test_layout___pthread_cond_s__bindgen_ty_1__bindgen_ty_1() {
    assert_eq!(
        ::core::mem::size_of::<__pthread_cond_s__bindgen_ty_1__bindgen_ty_1>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(__pthread_cond_s__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<__pthread_cond_s__bindgen_ty_1__bindgen_ty_1>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(__pthread_cond_s__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__pthread_cond_s__bindgen_ty_1__bindgen_ty_1>())).__low
                as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_cond_s__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(__low)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__pthread_cond_s__bindgen_ty_1__bindgen_ty_1>())).__high
                as *const _ as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_cond_s__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(__high)
        )
    );
}
#[test]
fn bindgen_test_layout___pthread_cond_s__bindgen_ty_1() {
    assert_eq!(
        ::core::mem::size_of::<__pthread_cond_s__bindgen_ty_1>(),
        8usize,
        concat!("Size of: ", stringify!(__pthread_cond_s__bindgen_ty_1))
    );
    assert_eq!(
        ::core::mem::align_of::<__pthread_cond_s__bindgen_ty_1>(),
        8usize,
        concat!("Alignment of ", stringify!(__pthread_cond_s__bindgen_ty_1))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__pthread_cond_s__bindgen_ty_1>())).__wseq as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_cond_s__bindgen_ty_1),
            "::",
            stringify!(__wseq)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__pthread_cond_s__bindgen_ty_1>())).__wseq32 as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_cond_s__bindgen_ty_1),
            "::",
            stringify!(__wseq32)
        )
    );
}
#[repr(C)]
#[repr(align(8))]
#[derive(Copy, Clone)]
pub union __pthread_cond_s__bindgen_ty_2 {
    pub __g1_start: cty::c_ulonglong,
    pub __g1_start32: __pthread_cond_s__bindgen_ty_2__bindgen_ty_1,
    _bindgen_union_align: u64,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_cond_s__bindgen_ty_2__bindgen_ty_1 {
    pub __low: cty::c_uint,
    pub __high: cty::c_uint,
}
#[test]
fn bindgen_test_layout___pthread_cond_s__bindgen_ty_2__bindgen_ty_1() {
    assert_eq!(
        ::core::mem::size_of::<__pthread_cond_s__bindgen_ty_2__bindgen_ty_1>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(__pthread_cond_s__bindgen_ty_2__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<__pthread_cond_s__bindgen_ty_2__bindgen_ty_1>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(__pthread_cond_s__bindgen_ty_2__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__pthread_cond_s__bindgen_ty_2__bindgen_ty_1>())).__low
                as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_cond_s__bindgen_ty_2__bindgen_ty_1),
            "::",
            stringify!(__low)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__pthread_cond_s__bindgen_ty_2__bindgen_ty_1>())).__high
                as *const _ as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_cond_s__bindgen_ty_2__bindgen_ty_1),
            "::",
            stringify!(__high)
        )
    );
}
#[test]
fn bindgen_test_layout___pthread_cond_s__bindgen_ty_2() {
    assert_eq!(
        ::core::mem::size_of::<__pthread_cond_s__bindgen_ty_2>(),
        8usize,
        concat!("Size of: ", stringify!(__pthread_cond_s__bindgen_ty_2))
    );
    assert_eq!(
        ::core::mem::align_of::<__pthread_cond_s__bindgen_ty_2>(),
        8usize,
        concat!("Alignment of ", stringify!(__pthread_cond_s__bindgen_ty_2))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__pthread_cond_s__bindgen_ty_2>())).__g1_start as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_cond_s__bindgen_ty_2),
            "::",
            stringify!(__g1_start)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__pthread_cond_s__bindgen_ty_2>())).__g1_start32 as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_cond_s__bindgen_ty_2),
            "::",
            stringify!(__g1_start32)
        )
    );
}
#[test]
fn bindgen_test_layout___pthread_cond_s() {
    assert_eq!(
        ::core::mem::size_of::<__pthread_cond_s>(),
        48usize,
        concat!("Size of: ", stringify!(__pthread_cond_s))
    );
    assert_eq!(
        ::core::mem::align_of::<__pthread_cond_s>(),
        8usize,
        concat!("Alignment of ", stringify!(__pthread_cond_s))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__pthread_cond_s>())).__g_refs as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_cond_s),
            "::",
            stringify!(__g_refs)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__pthread_cond_s>())).__g_size as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_cond_s),
            "::",
            stringify!(__g_size)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__pthread_cond_s>())).__g1_orig_size as *const _ as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_cond_s),
            "::",
            stringify!(__g1_orig_size)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__pthread_cond_s>())).__wrefs as *const _ as usize },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_cond_s),
            "::",
            stringify!(__wrefs)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__pthread_cond_s>())).__g_signals as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_cond_s),
            "::",
            stringify!(__g_signals)
        )
    );
}
pub type pthread_t = cty::c_ulong;
#[repr(C)]
#[repr(align(4))]
#[derive(Copy, Clone)]
pub union pthread_mutexattr_t {
    pub __size: [cty::c_char; 4usize],
    pub __align: cty::c_int,
    _bindgen_union_align: u32,
}
#[test]
fn bindgen_test_layout_pthread_mutexattr_t() {
    assert_eq!(
        ::core::mem::size_of::<pthread_mutexattr_t>(),
        4usize,
        concat!("Size of: ", stringify!(pthread_mutexattr_t))
    );
    assert_eq!(
        ::core::mem::align_of::<pthread_mutexattr_t>(),
        4usize,
        concat!("Alignment of ", stringify!(pthread_mutexattr_t))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<pthread_mutexattr_t>())).__size as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_mutexattr_t),
            "::",
            stringify!(__size)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<pthread_mutexattr_t>())).__align as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_mutexattr_t),
            "::",
            stringify!(__align)
        )
    );
}
#[repr(C)]
#[repr(align(4))]
#[derive(Copy, Clone)]
pub union pthread_condattr_t {
    pub __size: [cty::c_char; 4usize],
    pub __align: cty::c_int,
    _bindgen_union_align: u32,
}
#[test]
fn bindgen_test_layout_pthread_condattr_t() {
    assert_eq!(
        ::core::mem::size_of::<pthread_condattr_t>(),
        4usize,
        concat!("Size of: ", stringify!(pthread_condattr_t))
    );
    assert_eq!(
        ::core::mem::align_of::<pthread_condattr_t>(),
        4usize,
        concat!("Alignment of ", stringify!(pthread_condattr_t))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<pthread_condattr_t>())).__size as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_condattr_t),
            "::",
            stringify!(__size)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<pthread_condattr_t>())).__align as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_condattr_t),
            "::",
            stringify!(__align)
        )
    );
}
pub type pthread_key_t = cty::c_uint;
pub type pthread_once_t = cty::c_int;
#[repr(C)]
#[repr(align(8))]
#[derive(Copy, Clone)]
pub union pthread_attr_t {
    pub __size: [cty::c_char; 56usize],
    pub __align: cty::c_long,
    _bindgen_union_align: [u64; 7usize],
}
#[test]
fn bindgen_test_layout_pthread_attr_t() {
    assert_eq!(
        ::core::mem::size_of::<pthread_attr_t>(),
        56usize,
        concat!("Size of: ", stringify!(pthread_attr_t))
    );
    assert_eq!(
        ::core::mem::align_of::<pthread_attr_t>(),
        8usize,
        concat!("Alignment of ", stringify!(pthread_attr_t))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<pthread_attr_t>())).__size as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_attr_t),
            "::",
            stringify!(__size)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<pthread_attr_t>())).__align as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_attr_t),
            "::",
            stringify!(__align)
        )
    );
}
#[repr(C)]
#[repr(align(8))]
#[derive(Copy, Clone)]
pub union pthread_mutex_t {
    pub __data: __pthread_mutex_s,
    pub __size: [cty::c_char; 40usize],
    pub __align: cty::c_long,
    _bindgen_union_align: [u64; 5usize],
}
#[test]
fn bindgen_test_layout_pthread_mutex_t() {
    assert_eq!(
        ::core::mem::size_of::<pthread_mutex_t>(),
        40usize,
        concat!("Size of: ", stringify!(pthread_mutex_t))
    );
    assert_eq!(
        ::core::mem::align_of::<pthread_mutex_t>(),
        8usize,
        concat!("Alignment of ", stringify!(pthread_mutex_t))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<pthread_mutex_t>())).__data as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_mutex_t),
            "::",
            stringify!(__data)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<pthread_mutex_t>())).__size as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_mutex_t),
            "::",
            stringify!(__size)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<pthread_mutex_t>())).__align as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_mutex_t),
            "::",
            stringify!(__align)
        )
    );
}
#[repr(C)]
#[repr(align(8))]
#[derive(Copy, Clone)]
pub union pthread_cond_t {
    pub __data: __pthread_cond_s,
    pub __size: [cty::c_char; 48usize],
    pub __align: cty::c_longlong,
    _bindgen_union_align: [u64; 6usize],
}
#[test]
fn bindgen_test_layout_pthread_cond_t() {
    assert_eq!(
        ::core::mem::size_of::<pthread_cond_t>(),
        48usize,
        concat!("Size of: ", stringify!(pthread_cond_t))
    );
    assert_eq!(
        ::core::mem::align_of::<pthread_cond_t>(),
        8usize,
        concat!("Alignment of ", stringify!(pthread_cond_t))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<pthread_cond_t>())).__data as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_cond_t),
            "::",
            stringify!(__data)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<pthread_cond_t>())).__size as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_cond_t),
            "::",
            stringify!(__size)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<pthread_cond_t>())).__align as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_cond_t),
            "::",
            stringify!(__align)
        )
    );
}
#[repr(C)]
#[repr(align(8))]
#[derive(Copy, Clone)]
pub union pthread_rwlock_t {
    pub __data: __pthread_rwlock_arch_t,
    pub __size: [cty::c_char; 56usize],
    pub __align: cty::c_long,
    _bindgen_union_align: [u64; 7usize],
}
#[test]
fn bindgen_test_layout_pthread_rwlock_t() {
    assert_eq!(
        ::core::mem::size_of::<pthread_rwlock_t>(),
        56usize,
        concat!("Size of: ", stringify!(pthread_rwlock_t))
    );
    assert_eq!(
        ::core::mem::align_of::<pthread_rwlock_t>(),
        8usize,
        concat!("Alignment of ", stringify!(pthread_rwlock_t))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<pthread_rwlock_t>())).__data as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_rwlock_t),
            "::",
            stringify!(__data)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<pthread_rwlock_t>())).__size as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_rwlock_t),
            "::",
            stringify!(__size)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<pthread_rwlock_t>())).__align as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_rwlock_t),
            "::",
            stringify!(__align)
        )
    );
}
#[repr(C)]
#[repr(align(8))]
#[derive(Copy, Clone)]
pub union pthread_rwlockattr_t {
    pub __size: [cty::c_char; 8usize],
    pub __align: cty::c_long,
    _bindgen_union_align: u64,
}
#[test]
fn bindgen_test_layout_pthread_rwlockattr_t() {
    assert_eq!(
        ::core::mem::size_of::<pthread_rwlockattr_t>(),
        8usize,
        concat!("Size of: ", stringify!(pthread_rwlockattr_t))
    );
    assert_eq!(
        ::core::mem::align_of::<pthread_rwlockattr_t>(),
        8usize,
        concat!("Alignment of ", stringify!(pthread_rwlockattr_t))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<pthread_rwlockattr_t>())).__size as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_rwlockattr_t),
            "::",
            stringify!(__size)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<pthread_rwlockattr_t>())).__align as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_rwlockattr_t),
            "::",
            stringify!(__align)
        )
    );
}
pub type pthread_spinlock_t = cty::c_int;
#[repr(C)]
#[repr(align(8))]
#[derive(Copy, Clone)]
pub union pthread_barrier_t {
    pub __size: [cty::c_char; 32usize],
    pub __align: cty::c_long,
    _bindgen_union_align: [u64; 4usize],
}
#[test]
fn bindgen_test_layout_pthread_barrier_t() {
    assert_eq!(
        ::core::mem::size_of::<pthread_barrier_t>(),
        32usize,
        concat!("Size of: ", stringify!(pthread_barrier_t))
    );
    assert_eq!(
        ::core::mem::align_of::<pthread_barrier_t>(),
        8usize,
        concat!("Alignment of ", stringify!(pthread_barrier_t))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<pthread_barrier_t>())).__size as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_barrier_t),
            "::",
            stringify!(__size)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<pthread_barrier_t>())).__align as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_barrier_t),
            "::",
            stringify!(__align)
        )
    );
}
#[repr(C)]
#[repr(align(4))]
#[derive(Copy, Clone)]
pub union pthread_barrierattr_t {
    pub __size: [cty::c_char; 4usize],
    pub __align: cty::c_int,
    _bindgen_union_align: u32,
}
#[test]
fn bindgen_test_layout_pthread_barrierattr_t() {
    assert_eq!(
        ::core::mem::size_of::<pthread_barrierattr_t>(),
        4usize,
        concat!("Size of: ", stringify!(pthread_barrierattr_t))
    );
    assert_eq!(
        ::core::mem::align_of::<pthread_barrierattr_t>(),
        4usize,
        concat!("Alignment of ", stringify!(pthread_barrierattr_t))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<pthread_barrierattr_t>())).__size as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_barrierattr_t),
            "::",
            stringify!(__size)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<pthread_barrierattr_t>())).__align as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_barrierattr_t),
            "::",
            stringify!(__align)
        )
    );
}
extern "C" {
    pub fn random() -> cty::c_long;
}
extern "C" {
    pub fn srandom(__seed: cty::c_uint);
}
extern "C" {
    pub fn initstate(
        __seed: cty::c_uint,
        __statebuf: *mut cty::c_char,
        __statelen: usize,
    ) -> *mut cty::c_char;
}
extern "C" {
    pub fn setstate(__statebuf: *mut cty::c_char) -> *mut cty::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: cty::c_int,
    pub rand_deg: cty::c_int,
    pub rand_sep: cty::c_int,
    pub end_ptr: *mut i32,
}
#[test]
fn bindgen_test_layout_random_data() {
    assert_eq!(
        ::core::mem::size_of::<random_data>(),
        48usize,
        concat!("Size of: ", stringify!(random_data))
    );
    assert_eq!(
        ::core::mem::align_of::<random_data>(),
        8usize,
        concat!("Alignment of ", stringify!(random_data))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<random_data>())).fptr as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(random_data),
            "::",
            stringify!(fptr)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<random_data>())).rptr as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(random_data),
            "::",
            stringify!(rptr)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<random_data>())).state as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(random_data),
            "::",
            stringify!(state)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<random_data>())).rand_type as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(random_data),
            "::",
            stringify!(rand_type)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<random_data>())).rand_deg as *const _ as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(random_data),
            "::",
            stringify!(rand_deg)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<random_data>())).rand_sep as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(random_data),
            "::",
            stringify!(rand_sep)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<random_data>())).end_ptr as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(random_data),
            "::",
            stringify!(end_ptr)
        )
    );
}
extern "C" {
    pub fn random_r(__buf: *mut random_data, __result: *mut i32) -> cty::c_int;
}
extern "C" {
    pub fn srandom_r(__seed: cty::c_uint, __buf: *mut random_data) -> cty::c_int;
}
extern "C" {
    pub fn initstate_r(
        __seed: cty::c_uint,
        __statebuf: *mut cty::c_char,
        __statelen: usize,
        __buf: *mut random_data,
    ) -> cty::c_int;
}
extern "C" {
    pub fn setstate_r(__statebuf: *mut cty::c_char, __buf: *mut random_data) -> cty::c_int;
}
extern "C" {
    pub fn rand() -> cty::c_int;
}
extern "C" {
    pub fn srand(__seed: cty::c_uint);
}
extern "C" {
    pub fn rand_r(__seed: *mut cty::c_uint) -> cty::c_int;
}
extern "C" {
    pub fn drand48() -> f64;
}
extern "C" {
    pub fn erand48(__xsubi: *mut cty::c_ushort) -> f64;
}
extern "C" {
    pub fn lrand48() -> cty::c_long;
}
extern "C" {
    pub fn nrand48(__xsubi: *mut cty::c_ushort) -> cty::c_long;
}
extern "C" {
    pub fn mrand48() -> cty::c_long;
}
extern "C" {
    pub fn jrand48(__xsubi: *mut cty::c_ushort) -> cty::c_long;
}
extern "C" {
    pub fn srand48(__seedval: cty::c_long);
}
extern "C" {
    pub fn seed48(__seed16v: *mut cty::c_ushort) -> *mut cty::c_ushort;
}
extern "C" {
    pub fn lcong48(__param: *mut cty::c_ushort);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct drand48_data {
    pub __x: [cty::c_ushort; 3usize],
    pub __old_x: [cty::c_ushort; 3usize],
    pub __c: cty::c_ushort,
    pub __init: cty::c_ushort,
    pub __a: cty::c_ulonglong,
}
#[test]
fn bindgen_test_layout_drand48_data() {
    assert_eq!(
        ::core::mem::size_of::<drand48_data>(),
        24usize,
        concat!("Size of: ", stringify!(drand48_data))
    );
    assert_eq!(
        ::core::mem::align_of::<drand48_data>(),
        8usize,
        concat!("Alignment of ", stringify!(drand48_data))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<drand48_data>())).__x as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(drand48_data),
            "::",
            stringify!(__x)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<drand48_data>())).__old_x as *const _ as usize },
        6usize,
        concat!(
            "Offset of field: ",
            stringify!(drand48_data),
            "::",
            stringify!(__old_x)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<drand48_data>())).__c as *const _ as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(drand48_data),
            "::",
            stringify!(__c)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<drand48_data>())).__init as *const _ as usize },
        14usize,
        concat!(
            "Offset of field: ",
            stringify!(drand48_data),
            "::",
            stringify!(__init)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<drand48_data>())).__a as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(drand48_data),
            "::",
            stringify!(__a)
        )
    );
}
extern "C" {
    pub fn drand48_r(__buffer: *mut drand48_data, __result: *mut f64) -> cty::c_int;
}
extern "C" {
    pub fn erand48_r(
        __xsubi: *mut cty::c_ushort,
        __buffer: *mut drand48_data,
        __result: *mut f64,
    ) -> cty::c_int;
}
extern "C" {
    pub fn lrand48_r(__buffer: *mut drand48_data, __result: *mut cty::c_long) -> cty::c_int;
}
extern "C" {
    pub fn nrand48_r(
        __xsubi: *mut cty::c_ushort,
        __buffer: *mut drand48_data,
        __result: *mut cty::c_long,
    ) -> cty::c_int;
}
extern "C" {
    pub fn mrand48_r(__buffer: *mut drand48_data, __result: *mut cty::c_long) -> cty::c_int;
}
extern "C" {
    pub fn jrand48_r(
        __xsubi: *mut cty::c_ushort,
        __buffer: *mut drand48_data,
        __result: *mut cty::c_long,
    ) -> cty::c_int;
}
extern "C" {
    pub fn srand48_r(__seedval: cty::c_long, __buffer: *mut drand48_data) -> cty::c_int;
}
extern "C" {
    pub fn seed48_r(__seed16v: *mut cty::c_ushort, __buffer: *mut drand48_data) -> cty::c_int;
}
extern "C" {
    pub fn lcong48_r(__param: *mut cty::c_ushort, __buffer: *mut drand48_data) -> cty::c_int;
}
extern "C" {
    pub fn malloc(__size: usize) -> *mut cty::c_void;
}
extern "C" {
    pub fn calloc(__nmemb: usize, __size: usize) -> *mut cty::c_void;
}
extern "C" {
    pub fn realloc(__ptr: *mut cty::c_void, __size: usize) -> *mut cty::c_void;
}
extern "C" {
    pub fn free(__ptr: *mut cty::c_void);
}
extern "C" {
    pub fn alloca(__size: usize) -> *mut cty::c_void;
}
extern "C" {
    pub fn valloc(__size: usize) -> *mut cty::c_void;
}
extern "C" {
    pub fn posix_memalign(
        __memptr: *mut *mut cty::c_void,
        __alignment: usize,
        __size: usize,
    ) -> cty::c_int;
}
extern "C" {
    pub fn aligned_alloc(__alignment: usize, __size: usize) -> *mut cty::c_void;
}
extern "C" {
    pub fn atexit(__func: ::core::option::Option<unsafe extern "C" fn()>) -> cty::c_int;
}
extern "C" {
    pub fn at_quick_exit(__func: ::core::option::Option<unsafe extern "C" fn()>) -> cty::c_int;
}
extern "C" {
    pub fn on_exit(
        __func: ::core::option::Option<
            unsafe extern "C" fn(__status: cty::c_int, __arg: *mut cty::c_void),
        >,
        __arg: *mut cty::c_void,
    ) -> cty::c_int;
}
extern "C" {
    pub fn quick_exit(__status: cty::c_int);
}
extern "C" {
    pub fn _Exit(__status: cty::c_int);
}
extern "C" {
    pub fn getenv(__name: *const cty::c_char) -> *mut cty::c_char;
}
extern "C" {
    pub fn putenv(__string: *mut cty::c_char) -> cty::c_int;
}
extern "C" {
    pub fn setenv(
        __name: *const cty::c_char,
        __value: *const cty::c_char,
        __replace: cty::c_int,
    ) -> cty::c_int;
}
extern "C" {
    pub fn unsetenv(__name: *const cty::c_char) -> cty::c_int;
}
extern "C" {
    pub fn clearenv() -> cty::c_int;
}
extern "C" {
    pub fn mktemp(__template: *mut cty::c_char) -> *mut cty::c_char;
}
extern "C" {
    pub fn mkstemp(__template: *mut cty::c_char) -> cty::c_int;
}
extern "C" {
    pub fn mkstemps(__template: *mut cty::c_char, __suffixlen: cty::c_int) -> cty::c_int;
}
extern "C" {
    pub fn mkdtemp(__template: *mut cty::c_char) -> *mut cty::c_char;
}
extern "C" {
    pub fn system(__command: *const cty::c_char) -> cty::c_int;
}
extern "C" {
    pub fn realpath(__name: *const cty::c_char, __resolved: *mut cty::c_char) -> *mut cty::c_char;
}
pub type __compar_fn_t = ::core::option::Option<
    unsafe extern "C" fn(arg1: *const cty::c_void, arg2: *const cty::c_void) -> cty::c_int,
>;
extern "C" {
    pub fn bsearch(
        __key: *const cty::c_void,
        _start: *const cty::c_void,
        __nmemb: usize,
        __size: usize,
        __compar: __compar_fn_t,
    ) -> *mut cty::c_void;
}
extern "C" {
    pub fn qsort(_start: *mut cty::c_void, __nmemb: usize, __size: usize, __compar: __compar_fn_t);
}
extern "C" {
    pub fn abs(__x: cty::c_int) -> cty::c_int;
}
extern "C" {
    pub fn labs(__x: cty::c_long) -> cty::c_long;
}
extern "C" {
    pub fn llabs(__x: cty::c_longlong) -> cty::c_longlong;
}
extern "C" {
    pub fn div(__numer: cty::c_int, __denom: cty::c_int) -> div_t;
}
extern "C" {
    pub fn ldiv(__numer: cty::c_long, __denom: cty::c_long) -> ldiv_t;
}
extern "C" {
    pub fn lldiv(__numer: cty::c_longlong, __denom: cty::c_longlong) -> lldiv_t;
}
extern "C" {
    pub fn ecvt(
        __value: f64,
        __ndigit: cty::c_int,
        __decpt: *mut cty::c_int,
        __sign: *mut cty::c_int,
    ) -> *mut cty::c_char;
}
extern "C" {
    pub fn fcvt(
        __value: f64,
        __ndigit: cty::c_int,
        __decpt: *mut cty::c_int,
        __sign: *mut cty::c_int,
    ) -> *mut cty::c_char;
}
extern "C" {
    pub fn gcvt(__value: f64, __ndigit: cty::c_int, __buf: *mut cty::c_char) -> *mut cty::c_char;
}
extern "C" {
    pub fn qecvt(
        __value: u128,
        __ndigit: cty::c_int,
        __decpt: *mut cty::c_int,
        __sign: *mut cty::c_int,
    ) -> *mut cty::c_char;
}
extern "C" {
    pub fn qfcvt(
        __value: u128,
        __ndigit: cty::c_int,
        __decpt: *mut cty::c_int,
        __sign: *mut cty::c_int,
    ) -> *mut cty::c_char;
}
extern "C" {
    pub fn qgcvt(__value: u128, __ndigit: cty::c_int, __buf: *mut cty::c_char) -> *mut cty::c_char;
}
extern "C" {
    pub fn ecvt_r(
        __value: f64,
        __ndigit: cty::c_int,
        __decpt: *mut cty::c_int,
        __sign: *mut cty::c_int,
        __buf: *mut cty::c_char,
        __len: usize,
    ) -> cty::c_int;
}
extern "C" {
    pub fn fcvt_r(
        __value: f64,
        __ndigit: cty::c_int,
        __decpt: *mut cty::c_int,
        __sign: *mut cty::c_int,
        __buf: *mut cty::c_char,
        __len: usize,
    ) -> cty::c_int;
}
extern "C" {
    pub fn qecvt_r(
        __value: u128,
        __ndigit: cty::c_int,
        __decpt: *mut cty::c_int,
        __sign: *mut cty::c_int,
        __buf: *mut cty::c_char,
        __len: usize,
    ) -> cty::c_int;
}
extern "C" {
    pub fn qfcvt_r(
        __value: u128,
        __ndigit: cty::c_int,
        __decpt: *mut cty::c_int,
        __sign: *mut cty::c_int,
        __buf: *mut cty::c_char,
        __len: usize,
    ) -> cty::c_int;
}
extern "C" {
    pub fn mblen(__s: *const cty::c_char, __n: usize) -> cty::c_int;
}
extern "C" {
    pub fn mbtowc(__pwc: *mut wchar_t, __s: *const cty::c_char, __n: usize) -> cty::c_int;
}
extern "C" {
    pub fn wctomb(__s: *mut cty::c_char, __wchar: wchar_t) -> cty::c_int;
}
extern "C" {
    pub fn mbstowcs(__pwcs: *mut wchar_t, __s: *const cty::c_char, __n: usize) -> usize;
}
extern "C" {
    pub fn wcstombs(__s: *mut cty::c_char, __pwcs: *const wchar_t, __n: usize) -> usize;
}
extern "C" {
    pub fn rpmatch(__response: *const cty::c_char) -> cty::c_int;
}
extern "C" {
    pub fn getsubopt(
        __optionp: *mut *mut cty::c_char,
        __tokens: *const *mut cty::c_char,
        __valuep: *mut *mut cty::c_char,
    ) -> cty::c_int;
}
extern "C" {
    pub fn getloadavg(__loadavg: *mut f64, __nelem: cty::c_int) -> cty::c_int;
}
pub type va_list = __builtin_va_list;
pub type __gnuc_va_list = __builtin_va_list;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct __mbstate_t {
    pub __count: cty::c_int,
    pub __value: __mbstate_t__bindgen_ty_1,
}
#[repr(C)]
#[repr(align(4))]
#[derive(Copy, Clone)]
pub union __mbstate_t__bindgen_ty_1 {
    pub __wch: cty::c_uint,
    pub __wchb: [cty::c_char; 4usize],
    _bindgen_union_align: u32,
}
#[test]
fn bindgen_test_layout___mbstate_t__bindgen_ty_1() {
    assert_eq!(
        ::core::mem::size_of::<__mbstate_t__bindgen_ty_1>(),
        4usize,
        concat!("Size of: ", stringify!(__mbstate_t__bindgen_ty_1))
    );
    assert_eq!(
        ::core::mem::align_of::<__mbstate_t__bindgen_ty_1>(),
        4usize,
        concat!("Alignment of ", stringify!(__mbstate_t__bindgen_ty_1))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__mbstate_t__bindgen_ty_1>())).__wch as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__mbstate_t__bindgen_ty_1),
            "::",
            stringify!(__wch)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__mbstate_t__bindgen_ty_1>())).__wchb as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__mbstate_t__bindgen_ty_1),
            "::",
            stringify!(__wchb)
        )
    );
}
#[test]
fn bindgen_test_layout___mbstate_t() {
    assert_eq!(
        ::core::mem::size_of::<__mbstate_t>(),
        8usize,
        concat!("Size of: ", stringify!(__mbstate_t))
    );
    assert_eq!(
        ::core::mem::align_of::<__mbstate_t>(),
        4usize,
        concat!("Alignment of ", stringify!(__mbstate_t))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__mbstate_t>())).__count as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__mbstate_t),
            "::",
            stringify!(__count)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__mbstate_t>())).__value as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(__mbstate_t),
            "::",
            stringify!(__value)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _G_fpos_t {
    pub __pos: __off_t,
    pub __state: __mbstate_t,
}
#[test]
fn bindgen_test_layout__G_fpos_t() {
    assert_eq!(
        ::core::mem::size_of::<_G_fpos_t>(),
        16usize,
        concat!("Size of: ", stringify!(_G_fpos_t))
    );
    assert_eq!(
        ::core::mem::align_of::<_G_fpos_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_G_fpos_t))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_G_fpos_t>())).__pos as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_G_fpos_t),
            "::",
            stringify!(__pos)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_G_fpos_t>())).__state as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_G_fpos_t),
            "::",
            stringify!(__state)
        )
    );
}
pub type __fpos_t = _G_fpos_t;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _G_fpos64_t {
    pub __pos: __off64_t,
    pub __state: __mbstate_t,
}
#[test]
fn bindgen_test_layout__G_fpos64_t() {
    assert_eq!(
        ::core::mem::size_of::<_G_fpos64_t>(),
        16usize,
        concat!("Size of: ", stringify!(_G_fpos64_t))
    );
    assert_eq!(
        ::core::mem::align_of::<_G_fpos64_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_G_fpos64_t))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_G_fpos64_t>())).__pos as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_G_fpos64_t),
            "::",
            stringify!(__pos)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_G_fpos64_t>())).__state as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_G_fpos64_t),
            "::",
            stringify!(__state)
        )
    );
}
pub type __fpos64_t = _G_fpos64_t;
pub type __FILE = _IO_FILE;
pub type FILE = _IO_FILE;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_marker {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_codecvt {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_wide_data {
    _unused: [u8; 0],
}
pub type _IO_lock_t = cty::c_void;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_FILE {
    pub _flags: cty::c_int,
    pub _IO_read_ptr: *mut cty::c_char,
    pub _IO_read_end: *mut cty::c_char,
    pub _IO_read_base: *mut cty::c_char,
    pub _IO_write_base: *mut cty::c_char,
    pub _IO_write_ptr: *mut cty::c_char,
    pub _IO_write_end: *mut cty::c_char,
    pub _IO_buf_base: *mut cty::c_char,
    pub _IO_buf_end: *mut cty::c_char,
    pub _IO_save_base: *mut cty::c_char,
    pub _IO_backup_base: *mut cty::c_char,
    pub _IO_save_end: *mut cty::c_char,
    pub _markers: *mut _IO_marker,
    pub _chain: *mut _IO_FILE,
    pub _fileno: cty::c_int,
    pub _flags2: cty::c_int,
    pub _old_offset: __off_t,
    pub _cur_column: cty::c_ushort,
    pub _vtable_offset: cty::c_schar,
    pub _shortbuf: [cty::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 cty::c_void,
    pub __pad5: usize,
    pub _mode: cty::c_int,
    pub _unused2: [cty::c_char; 20usize],
}
#[test]
fn bindgen_test_layout__IO_FILE() {
    assert_eq!(
        ::core::mem::size_of::<_IO_FILE>(),
        216usize,
        concat!("Size of: ", stringify!(_IO_FILE))
    );
    assert_eq!(
        ::core::mem::align_of::<_IO_FILE>(),
        8usize,
        concat!("Alignment of ", stringify!(_IO_FILE))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._flags as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_flags)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._IO_read_ptr as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_read_ptr)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._IO_read_end as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_read_end)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._IO_read_base as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_read_base)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._IO_write_base as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_write_base)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._IO_write_ptr as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_write_ptr)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._IO_write_end as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_write_end)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._IO_buf_base as *const _ as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_buf_base)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._IO_buf_end as *const _ as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_buf_end)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._IO_save_base as *const _ as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_save_base)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._IO_backup_base as *const _ as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_backup_base)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._IO_save_end as *const _ as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_save_end)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._markers as *const _ as usize },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_markers)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._chain as *const _ as usize },
        104usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_chain)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._fileno as *const _ as usize },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_fileno)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._flags2 as *const _ as usize },
        116usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_flags2)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._old_offset as *const _ as usize },
        120usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_old_offset)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._cur_column as *const _ as usize },
        128usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_cur_column)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._vtable_offset as *const _ as usize },
        130usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_vtable_offset)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._shortbuf as *const _ as usize },
        131usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_shortbuf)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._lock as *const _ as usize },
        136usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_lock)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._offset as *const _ as usize },
        144usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_offset)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._codecvt as *const _ as usize },
        152usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_codecvt)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._wide_data as *const _ as usize },
        160usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_wide_data)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._freeres_list as *const _ as usize },
        168usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_freeres_list)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._freeres_buf as *const _ as usize },
        176usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_freeres_buf)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>())).__pad5 as *const _ as usize },
        184usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(__pad5)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._mode as *const _ as usize },
        192usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_mode)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._unused2 as *const _ as usize },
        196usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_unused2)
        )
    );
}
pub type fpos_t = __fpos_t;
extern "C" {
    pub fn remove(__filename: *const cty::c_char) -> cty::c_int;
}
extern "C" {
    pub fn rename(__old: *const cty::c_char, __new: *const cty::c_char) -> cty::c_int;
}
extern "C" {
    pub fn renameat(
        __oldfd: cty::c_int,
        __old: *const cty::c_char,
        __newfd: cty::c_int,
        __new: *const cty::c_char,
    ) -> cty::c_int;
}
extern "C" {
    pub fn tmpfile() -> *mut FILE;
}
extern "C" {
    pub fn tmpnam(__s: *mut cty::c_char) -> *mut cty::c_char;
}
extern "C" {
    pub fn tmpnam_r(__s: *mut cty::c_char) -> *mut cty::c_char;
}
extern "C" {
    pub fn tempnam(__dir: *const cty::c_char, __pfx: *const cty::c_char) -> *mut cty::c_char;
}
extern "C" {
    pub fn fclose(__stream: *mut FILE) -> cty::c_int;
}
extern "C" {
    pub fn fflush(__stream: *mut FILE) -> cty::c_int;
}
extern "C" {
    pub fn fflush_unlocked(__stream: *mut FILE) -> cty::c_int;
}
extern "C" {
    pub fn fopen(__filename: *const cty::c_char, __modes: *const cty::c_char) -> *mut FILE;
}
extern "C" {
    pub fn freopen(
        __filename: *const cty::c_char,
        __modes: *const cty::c_char,
        __stream: *mut FILE,
    ) -> *mut FILE;
}
extern "C" {
    pub fn fdopen(__fd: cty::c_int, __modes: *const cty::c_char) -> *mut FILE;
}
extern "C" {
    pub fn fmemopen(__s: *mut cty::c_void, __len: usize, __modes: *const cty::c_char) -> *mut FILE;
}
extern "C" {
    pub fn open_memstream(__bufloc: *mut *mut cty::c_char, __sizeloc: *mut usize) -> *mut FILE;
}
extern "C" {
    pub fn setbuf(__stream: *mut FILE, __buf: *mut cty::c_char);
}
extern "C" {
    pub fn setvbuf(
        __stream: *mut FILE,
        __buf: *mut cty::c_char,
        __modes: cty::c_int,
        __n: usize,
    ) -> cty::c_int;
}
extern "C" {
    pub fn setbuffer(__stream: *mut FILE, __buf: *mut cty::c_char, __size: usize);
}
extern "C" {
    pub fn setlinebuf(__stream: *mut FILE);
}
extern "C" {
    pub fn fprintf(__stream: *mut FILE, __format: *const cty::c_char, ...) -> cty::c_int;
}
extern "C" {
    pub fn printf(__format: *const cty::c_char, ...) -> cty::c_int;
}
extern "C" {
    pub fn sprintf(__s: *mut cty::c_char, __format: *const cty::c_char, ...) -> cty::c_int;
}
extern "C" {
    pub fn vfprintf(
        __s: *mut FILE,
        __format: *const cty::c_char,
        __arg: *mut __va_list_tag,
    ) -> cty::c_int;
}
extern "C" {
    pub fn vprintf(__format: *const cty::c_char, __arg: *mut __va_list_tag) -> cty::c_int;
}
extern "C" {
    pub fn vsprintf(
        __s: *mut cty::c_char,
        __format: *const cty::c_char,
        __arg: *mut __va_list_tag,
    ) -> cty::c_int;
}
extern "C" {
    pub fn snprintf(
        __s: *mut cty::c_char,
        __maxlen: usize,
        __format: *const cty::c_char,
        ...
    ) -> cty::c_int;
}
extern "C" {
    pub fn vsnprintf(
        __s: *mut cty::c_char,
        __maxlen: usize,
        __format: *const cty::c_char,
        __arg: *mut __va_list_tag,
    ) -> cty::c_int;
}
extern "C" {
    pub fn vdprintf(
        __fd: cty::c_int,
        __fmt: *const cty::c_char,
        __arg: *mut __va_list_tag,
    ) -> cty::c_int;
}
extern "C" {
    pub fn dprintf(__fd: cty::c_int, __fmt: *const cty::c_char, ...) -> cty::c_int;
}
extern "C" {
    pub fn fscanf(__stream: *mut FILE, __format: *const cty::c_char, ...) -> cty::c_int;
}
extern "C" {
    pub fn scanf(__format: *const cty::c_char, ...) -> cty::c_int;
}
extern "C" {
    pub fn sscanf(__s: *const cty::c_char, __format: *const cty::c_char, ...) -> cty::c_int;
}
extern "C" {
    #[link_name = "\u{1}__isoc99_fscanf"]
    pub fn fscanf1(__stream: *mut FILE, __format: *const cty::c_char, ...) -> cty::c_int;
}
extern "C" {
    #[link_name = "\u{1}__isoc99_scanf"]
    pub fn scanf1(__format: *const cty::c_char, ...) -> cty::c_int;
}
extern "C" {
    #[link_name = "\u{1}__isoc99_sscanf"]
    pub fn sscanf1(__s: *const cty::c_char, __format: *const cty::c_char, ...) -> cty::c_int;
}
extern "C" {
    pub fn vfscanf(
        __s: *mut FILE,
        __format: *const cty::c_char,
        __arg: *mut __va_list_tag,
    ) -> cty::c_int;
}
extern "C" {
    pub fn vscanf(__format: *const cty::c_char, __arg: *mut __va_list_tag) -> cty::c_int;
}
extern "C" {
    pub fn vsscanf(
        __s: *const cty::c_char,
        __format: *const cty::c_char,
        __arg: *mut __va_list_tag,
    ) -> cty::c_int;
}
extern "C" {
    #[link_name = "\u{1}__isoc99_vfscanf"]
    pub fn vfscanf1(
        __s: *mut FILE,
        __format: *const cty::c_char,
        __arg: *mut __va_list_tag,
    ) -> cty::c_int;
}
extern "C" {
    #[link_name = "\u{1}__isoc99_vscanf"]
    pub fn vscanf1(__format: *const cty::c_char, __arg: *mut __va_list_tag) -> cty::c_int;
}
extern "C" {
    #[link_name = "\u{1}__isoc99_vsscanf"]
    pub fn vsscanf1(
        __s: *const cty::c_char,
        __format: *const cty::c_char,
        __arg: *mut __va_list_tag,
    ) -> cty::c_int;
}
extern "C" {
    pub fn fgetc(__stream: *mut FILE) -> cty::c_int;
}
extern "C" {
    pub fn getc(__stream: *mut FILE) -> cty::c_int;
}
extern "C" {
    pub fn getchar() -> cty::c_int;
}
extern "C" {
    pub fn getc_unlocked(__stream: *mut FILE) -> cty::c_int;
}
extern "C" {
    pub fn getchar_unlocked() -> cty::c_int;
}
extern "C" {
    pub fn fgetc_unlocked(__stream: *mut FILE) -> cty::c_int;
}
extern "C" {
    pub fn fputc(__c: cty::c_int, __stream: *mut FILE) -> cty::c_int;
}
extern "C" {
    pub fn putc(__c: cty::c_int, __stream: *mut FILE) -> cty::c_int;
}
extern "C" {
    pub fn putchar(__c: cty::c_int) -> cty::c_int;
}
extern "C" {
    pub fn fputc_unlocked(__c: cty::c_int, __stream: *mut FILE) -> cty::c_int;
}
extern "C" {
    pub fn putc_unlocked(__c: cty::c_int, __stream: *mut FILE) -> cty::c_int;
}
extern "C" {
    pub fn putchar_unlocked(__c: cty::c_int) -> cty::c_int;
}
extern "C" {
    pub fn getw(__stream: *mut FILE) -> cty::c_int;
}
extern "C" {
    pub fn putw(__w: cty::c_int, __stream: *mut FILE) -> cty::c_int;
}
extern "C" {
    pub fn fgets(__s: *mut cty::c_char, __n: cty::c_int, __stream: *mut FILE) -> *mut cty::c_char;
}
extern "C" {
    pub fn __getdelim(
        __lineptr: *mut *mut cty::c_char,
        __n: *mut usize,
        __delimiter: cty::c_int,
        __stream: *mut FILE,
    ) -> __ssize_t;
}
extern "C" {
    pub fn getdelim(
        __lineptr: *mut *mut cty::c_char,
        __n: *mut usize,
        __delimiter: cty::c_int,
        __stream: *mut FILE,
    ) -> __ssize_t;
}
extern "C" {
    pub fn getline(
        __lineptr: *mut *mut cty::c_char,
        __n: *mut usize,
        __stream: *mut FILE,
    ) -> __ssize_t;
}
extern "C" {
    pub fn fputs(__s: *const cty::c_char, __stream: *mut FILE) -> cty::c_int;
}
extern "C" {
    pub fn puts(__s: *const cty::c_char) -> cty::c_int;
}
extern "C" {
    pub fn ungetc(__c: cty::c_int, __stream: *mut FILE) -> cty::c_int;
}
extern "C" {
    pub fn fread(
        __ptr: *mut cty::c_void,
        __size: usize,
        __n: usize,
        __stream: *mut FILE,
    ) -> cty::c_ulong;
}
extern "C" {
    pub fn fwrite(
        __ptr: *const cty::c_void,
        __size: usize,
        __n: usize,
        __s: *mut FILE,
    ) -> cty::c_ulong;
}
extern "C" {
    pub fn fread_unlocked(
        __ptr: *mut cty::c_void,
        __size: usize,
        __n: usize,
        __stream: *mut FILE,
    ) -> usize;
}
extern "C" {
    pub fn fwrite_unlocked(
        __ptr: *const cty::c_void,
        __size: usize,
        __n: usize,
        __stream: *mut FILE,
    ) -> usize;
}
extern "C" {
    pub fn fseek(__stream: *mut FILE, __off: cty::c_long, __whence: cty::c_int) -> cty::c_int;
}
extern "C" {
    pub fn ftell(__stream: *mut FILE) -> cty::c_long;
}
extern "C" {
    pub fn rewind(__stream: *mut FILE);
}
extern "C" {
    pub fn fseeko(__stream: *mut FILE, __off: __off_t, __whence: cty::c_int) -> cty::c_int;
}
extern "C" {
    pub fn ftello(__stream: *mut FILE) -> __off_t;
}
extern "C" {
    pub fn fgetpos(__stream: *mut FILE, __pos: *mut fpos_t) -> cty::c_int;
}
extern "C" {
    pub fn fsetpos(__stream: *mut FILE, __pos: *const fpos_t) -> cty::c_int;
}
extern "C" {
    pub fn clearerr(__stream: *mut FILE);
}
extern "C" {
    pub fn feof(__stream: *mut FILE) -> cty::c_int;
}
extern "C" {
    pub fn ferror(__stream: *mut FILE) -> cty::c_int;
}
extern "C" {
    pub fn clearerr_unlocked(__stream: *mut FILE);
}
extern "C" {
    pub fn feof_unlocked(__stream: *mut FILE) -> cty::c_int;
}
extern "C" {
    pub fn ferror_unlocked(__stream: *mut FILE) -> cty::c_int;
}
extern "C" {
    pub fn perror(__s: *const cty::c_char);
}
extern "C" {
    pub fn fileno(__stream: *mut FILE) -> cty::c_int;
}
extern "C" {
    pub fn fileno_unlocked(__stream: *mut FILE) -> cty::c_int;
}
extern "C" {
    pub fn popen(__command: *const cty::c_char, __modes: *const cty::c_char) -> *mut FILE;
}
extern "C" {
    pub fn pclose(__stream: *mut FILE) -> cty::c_int;
}
extern "C" {
    pub fn ctermid(__s: *mut cty::c_char) -> *mut cty::c_char;
}
extern "C" {
    pub fn flockfile(__stream: *mut FILE);
}
extern "C" {
    pub fn ftrylockfile(__stream: *mut FILE) -> cty::c_int;
}
extern "C" {
    pub fn funlockfile(__stream: *mut FILE);
}
extern "C" {
    pub fn __uflow(arg1: *mut FILE) -> cty::c_int;
}
extern "C" {
    pub fn __overflow(arg1: *mut FILE, arg2: cty::c_int) -> cty::c_int;
}
extern "C" {
    pub fn memcpy(
        __dest: *mut cty::c_void,
        __src: *const cty::c_void,
        __n: usize,
    ) -> *mut cty::c_void;
}
extern "C" {
    pub fn memmove(
        __dest: *mut cty::c_void,
        __src: *const cty::c_void,
        __n: usize,
    ) -> *mut cty::c_void;
}
extern "C" {
    pub fn memccpy(
        __dest: *mut cty::c_void,
        __src: *const cty::c_void,
        __c: cty::c_int,
        __n: usize,
    ) -> *mut cty::c_void;
}
extern "C" {
    pub fn memset(__s: *mut cty::c_void, __c: cty::c_int, __n: usize) -> *mut cty::c_void;
}
extern "C" {
    pub fn memcmp(__s1: *const cty::c_void, __s2: *const cty::c_void, __n: usize) -> cty::c_int;
}
extern "C" {
    pub fn memchr(__s: *const cty::c_void, __c: cty::c_int, __n: usize) -> *mut cty::c_void;
}
extern "C" {
    pub fn strcpy(__dest: *mut cty::c_char, __src: *const cty::c_char) -> *mut cty::c_char;
}
extern "C" {
    pub fn strncpy(
        __dest: *mut cty::c_char,
        __src: *const cty::c_char,
        __n: usize,
    ) -> *mut cty::c_char;
}
extern "C" {
    pub fn strcat(__dest: *mut cty::c_char, __src: *const cty::c_char) -> *mut cty::c_char;
}
extern "C" {
    pub fn strncat(
        __dest: *mut cty::c_char,
        __src: *const cty::c_char,
        __n: usize,
    ) -> *mut cty::c_char;
}
extern "C" {
    pub fn strcmp(__s1: *const cty::c_char, __s2: *const cty::c_char) -> cty::c_int;
}
extern "C" {
    pub fn strncmp(__s1: *const cty::c_char, __s2: *const cty::c_char, __n: usize) -> cty::c_int;
}
extern "C" {
    pub fn strcoll(__s1: *const cty::c_char, __s2: *const cty::c_char) -> cty::c_int;
}
extern "C" {
    pub fn strxfrm(__dest: *mut cty::c_char, __src: *const cty::c_char, __n: usize)
        -> cty::c_ulong;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __locale_struct {
    pub __locales: [*mut __locale_data; 13usize],
    pub __ctype_b: *const cty::c_ushort,
    pub __ctype_tolower: *const cty::c_int,
    pub __ctype_toupper: *const cty::c_int,
    pub __names: [*const cty::c_char; 13usize],
}
#[test]
fn bindgen_test_layout___locale_struct() {
    assert_eq!(
        ::core::mem::size_of::<__locale_struct>(),
        232usize,
        concat!("Size of: ", stringify!(__locale_struct))
    );
    assert_eq!(
        ::core::mem::align_of::<__locale_struct>(),
        8usize,
        concat!("Alignment of ", stringify!(__locale_struct))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__locale_struct>())).__locales as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__locale_struct),
            "::",
            stringify!(__locales)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__locale_struct>())).__ctype_b as *const _ as usize },
        104usize,
        concat!(
            "Offset of field: ",
            stringify!(__locale_struct),
            "::",
            stringify!(__ctype_b)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__locale_struct>())).__ctype_tolower as *const _ as usize
        },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(__locale_struct),
            "::",
            stringify!(__ctype_tolower)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__locale_struct>())).__ctype_toupper as *const _ as usize
        },
        120usize,
        concat!(
            "Offset of field: ",
            stringify!(__locale_struct),
            "::",
            stringify!(__ctype_toupper)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__locale_struct>())).__names as *const _ as usize },
        128usize,
        concat!(
            "Offset of field: ",
            stringify!(__locale_struct),
            "::",
            stringify!(__names)
        )
    );
}
pub type __locale_t = *mut __locale_struct;
pub type locale_t = __locale_t;
extern "C" {
    pub fn strcoll_l(
        __s1: *const cty::c_char,
        __s2: *const cty::c_char,
        __l: locale_t,
    ) -> cty::c_int;
}
extern "C" {
    pub fn strxfrm_l(
        __dest: *mut cty::c_char,
        __src: *const cty::c_char,
        __n: usize,
        __l: locale_t,
    ) -> usize;
}
extern "C" {
    pub fn strdup(__s: *const cty::c_char) -> *mut cty::c_char;
}
extern "C" {
    pub fn strndup(__string: *const cty::c_char, __n: usize) -> *mut cty::c_char;
}
extern "C" {
    pub fn strchr(__s: *const cty::c_char, __c: cty::c_int) -> *mut cty::c_char;
}
extern "C" {
    pub fn strrchr(__s: *const cty::c_char, __c: cty::c_int) -> *mut cty::c_char;
}
extern "C" {
    pub fn strcspn(__s: *const cty::c_char, __reject: *const cty::c_char) -> cty::c_ulong;
}
extern "C" {
    pub fn strspn(__s: *const cty::c_char, __accept: *const cty::c_char) -> cty::c_ulong;
}
extern "C" {
    pub fn strpbrk(__s: *const cty::c_char, __accept: *const cty::c_char) -> *mut cty::c_char;
}
extern "C" {
    pub fn strstr(__haystack: *const cty::c_char, __needle: *const cty::c_char)
        -> *mut cty::c_char;
}
extern "C" {
    pub fn strtok(__s: *mut cty::c_char, __delim: *const cty::c_char) -> *mut cty::c_char;
}
extern "C" {
    pub fn __strtok_r(
        __s: *mut cty::c_char,
        __delim: *const cty::c_char,
        __save_ptr: *mut *mut cty::c_char,
    ) -> *mut cty::c_char;
}
extern "C" {
    pub fn strtok_r(
        __s: *mut cty::c_char,
        __delim: *const cty::c_char,
        __save_ptr: *mut *mut cty::c_char,
    ) -> *mut cty::c_char;
}
extern "C" {
    pub fn strlen(__s: *const cty::c_char) -> cty::c_ulong;
}
extern "C" {
    pub fn strnlen(__string: *const cty::c_char, __maxlen: usize) -> usize;
}
extern "C" {
    pub fn strerror(__errnum: cty::c_int) -> *mut cty::c_char;
}
extern "C" {
    #[link_name = "\u{1}__xpg_strerror_r"]
    pub fn strerror_r(__errnum: cty::c_int, __buf: *mut cty::c_char, __buflen: usize)
        -> cty::c_int;
}
extern "C" {
    pub fn strerror_l(__errnum: cty::c_int, __l: locale_t) -> *mut cty::c_char;
}
extern "C" {
    pub fn bcmp(__s1: *const cty::c_void, __s2: *const cty::c_void, __n: usize) -> cty::c_int;
}
extern "C" {
    pub fn bcopy(__src: *const cty::c_void, __dest: *mut cty::c_void, __n: usize);
}
extern "C" {
    pub fn bzero(__s: *mut cty::c_void, __n: usize);
}
extern "C" {
    pub fn index(__s: *const cty::c_char, __c: cty::c_int) -> *mut cty::c_char;
}
extern "C" {
    pub fn rindex(__s: *const cty::c_char, __c: cty::c_int) -> *mut cty::c_char;
}
extern "C" {
    pub fn ffs(__i: cty::c_int) -> cty::c_int;
}
extern "C" {
    pub fn ffsl(__l: cty::c_long) -> cty::c_int;
}
extern "C" {
    pub fn ffsll(__ll: cty::c_longlong) -> cty::c_int;
}
extern "C" {
    pub fn strcasecmp(__s1: *const cty::c_char, __s2: *const cty::c_char) -> cty::c_int;
}
extern "C" {
    pub fn strncasecmp(
        __s1: *const cty::c_char,
        __s2: *const cty::c_char,
        __n: usize,
    ) -> cty::c_int;
}
extern "C" {
    pub fn strcasecmp_l(
        __s1: *const cty::c_char,
        __s2: *const cty::c_char,
        __loc: locale_t,
    ) -> cty::c_int;
}
extern "C" {
    pub fn strncasecmp_l(
        __s1: *const cty::c_char,
        __s2: *const cty::c_char,
        __n: usize,
        __loc: locale_t,
    ) -> cty::c_int;
}
extern "C" {
    pub fn explicit_bzero(__s: *mut cty::c_void, __n: usize);
}
extern "C" {
    pub fn strsep(
        __stringp: *mut *mut cty::c_char,
        __delim: *const cty::c_char,
    ) -> *mut cty::c_char;
}
extern "C" {
    pub fn strsignal(__sig: cty::c_int) -> *mut cty::c_char;
}
extern "C" {
    pub fn __stpcpy(__dest: *mut cty::c_char, __src: *const cty::c_char) -> *mut cty::c_char;
}
extern "C" {
    pub fn stpcpy(__dest: *mut cty::c_char, __src: *const cty::c_char) -> *mut cty::c_char;
}
extern "C" {
    pub fn __stpncpy(
        __dest: *mut cty::c_char,
        __src: *const cty::c_char,
        __n: usize,
    ) -> *mut cty::c_char;
}
extern "C" {
    pub fn stpncpy(
        __dest: *mut cty::c_char,
        __src: *const cty::c_char,
        __n: usize,
    ) -> *mut cty::c_char;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct stat {
    pub st_dev: __dev_t,
    pub st_ino: __ino_t,
    pub st_nlink: __nlink_t,
    pub st_mode: __mode_t,
    pub st_uid: __uid_t,
    pub st_gid: __gid_t,
    pub __pad0: cty::c_int,
    pub st_rdev: __dev_t,
    pub st_size: __off_t,
    pub st_blksize: __blksize_t,
    pub st_blocks: __blkcnt_t,
    pub st_atim: timespec,
    pub st_mtim: timespec,
    pub st_ctim: timespec,
    pub __glibc_reserved: [__syscall_slong_t; 3usize],
}
#[test]
fn bindgen_test_layout_stat() {
    assert_eq!(
        ::core::mem::size_of::<stat>(),
        144usize,
        concat!("Size of: ", stringify!(stat))
    );
    assert_eq!(
        ::core::mem::align_of::<stat>(),
        8usize,
        concat!("Alignment of ", stringify!(stat))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<stat>())).st_dev as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(stat),
            "::",
            stringify!(st_dev)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<stat>())).st_ino as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(stat),
            "::",
            stringify!(st_ino)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<stat>())).st_nlink as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(stat),
            "::",
            stringify!(st_nlink)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<stat>())).st_mode as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(stat),
            "::",
            stringify!(st_mode)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<stat>())).st_uid as *const _ as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(stat),
            "::",
            stringify!(st_uid)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<stat>())).st_gid as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(stat),
            "::",
            stringify!(st_gid)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<stat>())).__pad0 as *const _ as usize },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(stat),
            "::",
            stringify!(__pad0)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<stat>())).st_rdev as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(stat),
            "::",
            stringify!(st_rdev)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<stat>())).st_size as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(stat),
            "::",
            stringify!(st_size)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<stat>())).st_blksize as *const _ as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(stat),
            "::",
            stringify!(st_blksize)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<stat>())).st_blocks as *const _ as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(stat),
            "::",
            stringify!(st_blocks)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<stat>())).st_atim as *const _ as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(stat),
            "::",
            stringify!(st_atim)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<stat>())).st_mtim as *const _ as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(stat),
            "::",
            stringify!(st_mtim)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<stat>())).st_ctim as *const _ as usize },
        104usize,
        concat!(
            "Offset of field: ",
            stringify!(stat),
            "::",
            stringify!(st_ctim)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<stat>())).__glibc_reserved as *const _ as usize },
        120usize,
        concat!(
            "Offset of field: ",
            stringify!(stat),
            "::",
            stringify!(__glibc_reserved)
        )
    );
}
extern "C" {
    pub fn stat(__file: *const cty::c_char, __buf: *mut stat) -> cty::c_int;
}
extern "C" {
    pub fn fstat(__fd: cty::c_int, __buf: *mut stat) -> cty::c_int;
}
extern "C" {
    pub fn fstatat(
        __fd: cty::c_int,
        __file: *const cty::c_char,
        __buf: *mut stat,
        __flag: cty::c_int,
    ) -> cty::c_int;
}
extern "C" {
    pub fn lstat(__file: *const cty::c_char, __buf: *mut stat) -> cty::c_int;
}
extern "C" {
    pub fn chmod(__file: *const cty::c_char, __mode: __mode_t) -> cty::c_int;
}
extern "C" {
    pub fn lchmod(__file: *const cty::c_char, __mode: __mode_t) -> cty::c_int;
}
extern "C" {
    pub fn fchmod(__fd: cty::c_int, __mode: __mode_t) -> cty::c_int;
}
extern "C" {
    pub fn fchmodat(
        __fd: cty::c_int,
        __file: *const cty::c_char,
        __mode: __mode_t,
        __flag: cty::c_int,
    ) -> cty::c_int;
}
extern "C" {
    pub fn umask(__mask: __mode_t) -> __mode_t;
}
extern "C" {
    pub fn mkdir(__path: *const cty::c_char, __mode: __mode_t) -> cty::c_int;
}
extern "C" {
    pub fn mkdirat(__fd: cty::c_int, __path: *const cty::c_char, __mode: __mode_t) -> cty::c_int;
}
extern "C" {
    pub fn mknod(__path: *const cty::c_char, __mode: __mode_t, __dev: __dev_t) -> cty::c_int;
}
extern "C" {
    pub fn mknodat(
        __fd: cty::c_int,
        __path: *const cty::c_char,
        __mode: __mode_t,
        __dev: __dev_t,
    ) -> cty::c_int;
}
extern "C" {
    pub fn mkfifo(__path: *const cty::c_char, __mode: __mode_t) -> cty::c_int;
}
extern "C" {
    pub fn mkfifoat(__fd: cty::c_int, __path: *const cty::c_char, __mode: __mode_t) -> cty::c_int;
}
extern "C" {
    pub fn utimensat(
        __fd: cty::c_int,
        __path: *const cty::c_char,
        __times: *const timespec,
        __flags: cty::c_int,
    ) -> cty::c_int;
}
extern "C" {
    pub fn futimens(__fd: cty::c_int, __times: *const timespec) -> cty::c_int;
}
extern "C" {
    pub fn __fxstat(__ver: cty::c_int, __fildes: cty::c_int, __stat_buf: *mut stat) -> cty::c_int;
}
extern "C" {
    pub fn __xstat(
        __ver: cty::c_int,
        __filename: *const cty::c_char,
        __stat_buf: *mut stat,
    ) -> cty::c_int;
}
extern "C" {
    pub fn __lxstat(
        __ver: cty::c_int,
        __filename: *const cty::c_char,
        __stat_buf: *mut stat,
    ) -> cty::c_int;
}
extern "C" {
    pub fn __fxstatat(
        __ver: cty::c_int,
        __fildes: cty::c_int,
        __filename: *const cty::c_char,
        __stat_buf: *mut stat,
        __flag: cty::c_int,
    ) -> cty::c_int;
}
extern "C" {
    pub fn __xmknod(
        __ver: cty::c_int,
        __path: *const cty::c_char,
        __mode: __mode_t,
        __dev: *mut __dev_t,
    ) -> cty::c_int;
}
extern "C" {
    pub fn __xmknodat(
        __ver: cty::c_int,
        __fd: cty::c_int,
        __path: *const cty::c_char,
        __mode: __mode_t,
        __dev: *mut __dev_t,
    ) -> cty::c_int;
}
pub type useconds_t = __useconds_t;
pub type socklen_t = __socklen_t;
extern "C" {
    pub fn access(__name: *const cty::c_char, __type: cty::c_int) -> cty::c_int;
}
extern "C" {
    pub fn faccessat(
        __fd: cty::c_int,
        __file: *const cty::c_char,
        __type: cty::c_int,
        __flag: cty::c_int,
    ) -> cty::c_int;
}
extern "C" {
    pub fn lseek(__fd: cty::c_int, __offset: __off_t, __whence: cty::c_int) -> __off_t;
}
extern "C" {
    pub fn close(__fd: cty::c_int) -> cty::c_int;
}
extern "C" {
    pub fn read(__fd: cty::c_int, __buf: *mut cty::c_void, __nbytes: usize) -> isize;
}
extern "C" {
    pub fn write(__fd: cty::c_int, __buf: *const cty::c_void, __n: usize) -> isize;
}
extern "C" {
    pub fn pread(
        __fd: cty::c_int,
        __buf: *mut cty::c_void,
        __nbytes: usize,
        __offset: __off_t,
    ) -> isize;
}
extern "C" {
    pub fn pwrite(
        __fd: cty::c_int,
        __buf: *const cty::c_void,
        __n: usize,
        __offset: __off_t,
    ) -> isize;
}
extern "C" {
    pub fn pipe(__pipedes: *mut cty::c_int) -> cty::c_int;
}
extern "C" {
    pub fn alarm(__seconds: cty::c_uint) -> cty::c_uint;
}
extern "C" {
    pub fn sleep(__seconds: cty::c_uint) -> cty::c_uint;
}
extern "C" {
    pub fn ualarm(__value: __useconds_t, __interval: __useconds_t) -> __useconds_t;
}
extern "C" {
    pub fn usleep(__useconds: __useconds_t) -> cty::c_int;
}
extern "C" {
    pub fn pause() -> cty::c_int;
}
extern "C" {
    pub fn chown(__file: *const cty::c_char, __owner: __uid_t, __group: __gid_t) -> cty::c_int;
}
extern "C" {
    pub fn fchown(__fd: cty::c_int, __owner: __uid_t, __group: __gid_t) -> cty::c_int;
}
extern "C" {
    pub fn lchown(__file: *const cty::c_char, __owner: __uid_t, __group: __gid_t) -> cty::c_int;
}
extern "C" {
    pub fn fchownat(
        __fd: cty::c_int,
        __file: *const cty::c_char,
        __owner: __uid_t,
        __group: __gid_t,
        __flag: cty::c_int,
    ) -> cty::c_int;
}
extern "C" {
    pub fn chdir(__path: *const cty::c_char) -> cty::c_int;
}
extern "C" {
    pub fn fchdir(__fd: cty::c_int) -> cty::c_int;
}
extern "C" {
    pub fn getcwd(__buf: *mut cty::c_char, __size: usize) -> *mut cty::c_char;
}
extern "C" {
    pub fn getwd(__buf: *mut cty::c_char) -> *mut cty::c_char;
}
extern "C" {
    pub fn dup(__fd: cty::c_int) -> cty::c_int;
}
extern "C" {
    pub fn dup2(__fd: cty::c_int, __fd2: cty::c_int) -> cty::c_int;
}
extern "C" {
    pub fn execve(
        __path: *const cty::c_char,
        __argv: *const *mut cty::c_char,
        __envp: *const *mut cty::c_char,
    ) -> cty::c_int;
}
extern "C" {
    pub fn fexecve(
        __fd: cty::c_int,
        __argv: *const *mut cty::c_char,
        __envp: *const *mut cty::c_char,
    ) -> cty::c_int;
}
extern "C" {
    pub fn execv(__path: *const cty::c_char, __argv: *const *mut cty::c_char) -> cty::c_int;
}
extern "C" {
    pub fn execle(__path: *const cty::c_char, __arg: *const cty::c_char, ...) -> cty::c_int;
}
extern "C" {
    pub fn execl(__path: *const cty::c_char, __arg: *const cty::c_char, ...) -> cty::c_int;
}
extern "C" {
    pub fn execvp(__file: *const cty::c_char, __argv: *const *mut cty::c_char) -> cty::c_int;
}
extern "C" {
    pub fn execlp(__file: *const cty::c_char, __arg: *const cty::c_char, ...) -> cty::c_int;
}
extern "C" {
    pub fn nice(__inc: cty::c_int) -> cty::c_int;
}
extern "C" {
    pub fn _exit(__status: cty::c_int);
}
pub const _PC_LINK_MAX: _bindgen_ty_1 = 0;
pub const _PC_MAX_CANON: _bindgen_ty_1 = 1;
pub const _PC_MAX_INPUT: _bindgen_ty_1 = 2;
pub const _PC_NAME_MAX: _bindgen_ty_1 = 3;
pub const _PC_PATH_MAX: _bindgen_ty_1 = 4;
pub const _PC_PIPE_BUF: _bindgen_ty_1 = 5;
pub const _PC_CHOWN_RESTRICTED: _bindgen_ty_1 = 6;
pub const _PC_NO_TRUNC: _bindgen_ty_1 = 7;
pub const _PC_VDISABLE: _bindgen_ty_1 = 8;
pub const _PC_SYNC_IO: _bindgen_ty_1 = 9;
pub const _PC_ASYNC_IO: _bindgen_ty_1 = 10;
pub const _PC_PRIO_IO: _bindgen_ty_1 = 11;
pub const _PC_SOCK_MAXBUF: _bindgen_ty_1 = 12;
pub const _PC_FILESIZEBITS: _bindgen_ty_1 = 13;
pub const _PC_REC_INCR_XFER_SIZE: _bindgen_ty_1 = 14;
pub const _PC_REC_MAX_XFER_SIZE: _bindgen_ty_1 = 15;
pub const _PC_REC_MIN_XFER_SIZE: _bindgen_ty_1 = 16;
pub const _PC_REC_XFER_ALIGN: _bindgen_ty_1 = 17;
pub const _PC_ALLOC_SIZE_MIN: _bindgen_ty_1 = 18;
pub const _PC_SYMLINK_MAX: _bindgen_ty_1 = 19;
pub const _PC_2_SYMLINKS: _bindgen_ty_1 = 20;
pub type _bindgen_ty_1 = u32;
pub const _SC_ARG_MAX: _bindgen_ty_2 = 0;
pub const _SC_CHILD_MAX: _bindgen_ty_2 = 1;
pub const _SC_CLK_TCK: _bindgen_ty_2 = 2;
pub const _SC_NGROUPS_MAX: _bindgen_ty_2 = 3;
pub const _SC_OPEN_MAX: _bindgen_ty_2 = 4;
pub const _SC_STREAM_MAX: _bindgen_ty_2 = 5;
pub const _SC_TZNAME_MAX: _bindgen_ty_2 = 6;
pub const _SC_JOB_CONTROL: _bindgen_ty_2 = 7;
pub const _SC_SAVED_IDS: _bindgen_ty_2 = 8;
pub const _SC_REALTIME_SIGNALS: _bindgen_ty_2 = 9;
pub const _SC_PRIORITY_SCHEDULING: _bindgen_ty_2 = 10;
pub const _SC_TIMERS: _bindgen_ty_2 = 11;
pub const _SC_ASYNCHRONOUS_IO: _bindgen_ty_2 = 12;
pub const _SC_PRIORITIZED_IO: _bindgen_ty_2 = 13;
pub const _SC_SYNCHRONIZED_IO: _bindgen_ty_2 = 14;
pub const _SC_FSYNC: _bindgen_ty_2 = 15;
pub const _SC_MAPPED_FILES: _bindgen_ty_2 = 16;
pub const _SC_MEMLOCK: _bindgen_ty_2 = 17;
pub const _SC_MEMLOCK_RANGE: _bindgen_ty_2 = 18;
pub const _SC_MEMORY_PROTECTION: _bindgen_ty_2 = 19;
pub const _SC_MESSAGE_PASSING: _bindgen_ty_2 = 20;
pub const _SC_SEMAPHORES: _bindgen_ty_2 = 21;
pub const _SC_SHARED_MEMORY_OBJECTS: _bindgen_ty_2 = 22;
pub const _SC_AIO_LISTIO_MAX: _bindgen_ty_2 = 23;
pub const _SC_AIO_MAX: _bindgen_ty_2 = 24;
pub const _SC_AIO_PRIO_DELTA_MAX: _bindgen_ty_2 = 25;
pub const _SC_DELAYTIMER_MAX: _bindgen_ty_2 = 26;
pub const _SC_MQ_OPEN_MAX: _bindgen_ty_2 = 27;
pub const _SC_MQ_PRIO_MAX: _bindgen_ty_2 = 28;
pub const _SC_VERSION: _bindgen_ty_2 = 29;
pub const _SC_PAGESIZE: _bindgen_ty_2 = 30;
pub const _SC_RTSIG_MAX: _bindgen_ty_2 = 31;
pub const _SC_SEM_NSEMS_MAX: _bindgen_ty_2 = 32;
pub const _SC_SEM_VALUE_MAX: _bindgen_ty_2 = 33;
pub const _SC_SIGQUEUE_MAX: _bindgen_ty_2 = 34;
pub const _SC_TIMER_MAX: _bindgen_ty_2 = 35;
pub const _SC_BC_BASE_MAX: _bindgen_ty_2 = 36;
pub const _SC_BC_DIM_MAX: _bindgen_ty_2 = 37;
pub const _SC_BC_SCALE_MAX: _bindgen_ty_2 = 38;
pub const _SC_BC_STRING_MAX: _bindgen_ty_2 = 39;
pub const _SC_COLL_WEIGHTS_MAX: _bindgen_ty_2 = 40;
pub const _SC_EQUIV_CLASS_MAX: _bindgen_ty_2 = 41;
pub const _SC_EXPR_NEST_MAX: _bindgen_ty_2 = 42;
pub const _SC_LINE_MAX: _bindgen_ty_2 = 43;
pub const _SC_RE_DUP_MAX: _bindgen_ty_2 = 44;
pub const _SC_CHARCLASS_NAME_MAX: _bindgen_ty_2 = 45;
pub const _SC_2_VERSION: _bindgen_ty_2 = 46;
pub const _SC_2_C_BIND: _bindgen_ty_2 = 47;
pub const _SC_2_C_DEV: _bindgen_ty_2 = 48;
pub const _SC_2_FORT_DEV: _bindgen_ty_2 = 49;
pub const _SC_2_FORT_RUN: _bindgen_ty_2 = 50;
pub const _SC_2_SW_DEV: _bindgen_ty_2 = 51;
pub const _SC_2_LOCALEDEF: _bindgen_ty_2 = 52;
pub const _SC_PII: _bindgen_ty_2 = 53;
pub const _SC_PII_XTI: _bindgen_ty_2 = 54;
pub const _SC_PII_SOCKET: _bindgen_ty_2 = 55;
pub const _SC_PII_INTERNET: _bindgen_ty_2 = 56;
pub const _SC_PII_OSI: _bindgen_ty_2 = 57;
pub const _SC_POLL: _bindgen_ty_2 = 58;
pub const _SC_SELECT: _bindgen_ty_2 = 59;
pub const _SC_UIO_MAXIOV: _bindgen_ty_2 = 60;
pub const _SC_IOV_MAX: _bindgen_ty_2 = 60;
pub const _SC_PII_INTERNET_STREAM: _bindgen_ty_2 = 61;
pub const _SC_PII_INTERNET_DGRAM: _bindgen_ty_2 = 62;
pub const _SC_PII_OSI_COTS: _bindgen_ty_2 = 63;
pub const _SC_PII_OSI_CLTS: _bindgen_ty_2 = 64;
pub const _SC_PII_OSI_M: _bindgen_ty_2 = 65;
pub const _SC_T_IOV_MAX: _bindgen_ty_2 = 66;
pub const _SC_THREADS: _bindgen_ty_2 = 67;
pub const _SC_THREAD_SAFE_FUNCTIONS: _bindgen_ty_2 = 68;
pub const _SC_GETGR_R_SIZE_MAX: _bindgen_ty_2 = 69;
pub const _SC_GETPW_R_SIZE_MAX: _bindgen_ty_2 = 70;
pub const _SC_LOGIN_NAME_MAX: _bindgen_ty_2 = 71;
pub const _SC_TTY_NAME_MAX: _bindgen_ty_2 = 72;
pub const _SC_THREAD_DESTRUCTOR_ITERATIONS: _bindgen_ty_2 = 73;
pub const _SC_THREAD_KEYS_MAX: _bindgen_ty_2 = 74;
pub const _SC_THREAD_STACK_MIN: _bindgen_ty_2 = 75;
pub const _SC_THREAD_THREADS_MAX: _bindgen_ty_2 = 76;
pub const _SC_THREAD_ATTR_STACKADDR: _bindgen_ty_2 = 77;
pub const _SC_THREAD_ATTR_STACKSIZE: _bindgen_ty_2 = 78;
pub const _SC_THREAD_PRIORITY_SCHEDULING: _bindgen_ty_2 = 79;
pub const _SC_THREAD_PRIO_INHERIT: _bindgen_ty_2 = 80;
pub const _SC_THREAD_PRIO_PROTECT: _bindgen_ty_2 = 81;
pub const _SC_THREAD_PROCESS_SHARED: _bindgen_ty_2 = 82;
pub const _SC_NPROCESSORS_CONF: _bindgen_ty_2 = 83;
pub const _SC_NPROCESSORS_ONLN: _bindgen_ty_2 = 84;
pub const _SC_PHYS_PAGES: _bindgen_ty_2 = 85;
pub const _SC_AVPHYS_PAGES: _bindgen_ty_2 = 86;
pub const _SC_ATEXIT_MAX: _bindgen_ty_2 = 87;
pub const _SC_PASS_MAX: _bindgen_ty_2 = 88;
pub const _SC_XOPEN_VERSION: _bindgen_ty_2 = 89;
pub const _SC_XOPEN_XCU_VERSION: _bindgen_ty_2 = 90;
pub const _SC_XOPEN_UNIX: _bindgen_ty_2 = 91;
pub const _SC_XOPEN_CRYPT: _bindgen_ty_2 = 92;
pub const _SC_XOPEN_ENH_I18N: _bindgen_ty_2 = 93;
pub const _SC_XOPEN_SHM: _bindgen_ty_2 = 94;
pub const _SC_2_CHAR_TERM: _bindgen_ty_2 = 95;
pub const _SC_2_C_VERSION: _bindgen_ty_2 = 96;
pub const _SC_2_UPE: _bindgen_ty_2 = 97;
pub const _SC_XOPEN_XPG2: _bindgen_ty_2 = 98;
pub const _SC_XOPEN_XPG3: _bindgen_ty_2 = 99;
pub const _SC_XOPEN_XPG4: _bindgen_ty_2 = 100;
pub const _SC_CHAR_BIT: _bindgen_ty_2 = 101;
pub const _SC_CHAR_MAX: _bindgen_ty_2 = 102;
pub const _SC_CHAR_MIN: _bindgen_ty_2 = 103;
pub const _SC_INT_MAX: _bindgen_ty_2 = 104;
pub const _SC_INT_MIN: _bindgen_ty_2 = 105;
pub const _SC_LONG_BIT: _bindgen_ty_2 = 106;
pub const _SC_WORD_BIT: _bindgen_ty_2 = 107;
pub const _SC_MB_LEN_MAX: _bindgen_ty_2 = 108;
pub const _SC_NZERO: _bindgen_ty_2 = 109;
pub const _SC_SSIZE_MAX: _bindgen_ty_2 = 110;
pub const _SC_SCHAR_MAX: _bindgen_ty_2 = 111;
pub const _SC_SCHAR_MIN: _bindgen_ty_2 = 112;
pub const _SC_SHRT_MAX: _bindgen_ty_2 = 113;
pub const _SC_SHRT_MIN: _bindgen_ty_2 = 114;
pub const _SC_UCHAR_MAX: _bindgen_ty_2 = 115;
pub const _SC_UINT_MAX: _bindgen_ty_2 = 116;
pub const _SC_ULONG_MAX: _bindgen_ty_2 = 117;
pub const _SC_USHRT_MAX: _bindgen_ty_2 = 118;
pub const _SC_NL_ARGMAX: _bindgen_ty_2 = 119;
pub const _SC_NL_LANGMAX: _bindgen_ty_2 = 120;
pub const _SC_NL_MSGMAX: _bindgen_ty_2 = 121;
pub const _SC_NL_NMAX: _bindgen_ty_2 = 122;
pub const _SC_NL_SETMAX: _bindgen_ty_2 = 123;
pub const _SC_NL_TEXTMAX: _bindgen_ty_2 = 124;
pub const _SC_XBS5_ILP32_OFF32: _bindgen_ty_2 = 125;
pub const _SC_XBS5_ILP32_OFFBIG: _bindgen_ty_2 = 126;
pub const _SC_XBS5_LP64_OFF64: _bindgen_ty_2 = 127;
pub const _SC_XBS5_LPBIG_OFFBIG: _bindgen_ty_2 = 128;
pub const _SC_XOPEN_LEGACY: _bindgen_ty_2 = 129;
pub const _SC_XOPEN_REALTIME: _bindgen_ty_2 = 130;
pub const _SC_XOPEN_REALTIME_THREADS: _bindgen_ty_2 = 131;
pub const _SC_ADVISORY_INFO: _bindgen_ty_2 = 132;
pub const _SC_BARRIERS: _bindgen_ty_2 = 133;
pub const _SC_BASE: _bindgen_ty_2 = 134;
pub const _SC_C_LANG_SUPPORT: _bindgen_ty_2 = 135;
pub const _SC_C_LANG_SUPPORT_R: _bindgen_ty_2 = 136;
pub const _SC_CLOCK_SELECTION: _bindgen_ty_2 = 137;
pub const _SC_CPUTIME: _bindgen_ty_2 = 138;
pub const _SC_THREAD_CPUTIME: _bindgen_ty_2 = 139;
pub const _SC_DEVICE_IO: _bindgen_ty_2 = 140;
pub const _SC_DEVICE_SPECIFIC: _bindgen_ty_2 = 141;
pub const _SC_DEVICE_SPECIFIC_R: _bindgen_ty_2 = 142;
pub const _SC_FD_MGMT: _bindgen_ty_2 = 143;
pub const _SC_FIFO: _bindgen_ty_2 = 144;
pub const _SC_PIPE: _bindgen_ty_2 = 145;
pub const _SC_FILE_ATTRIBUTES: _bindgen_ty_2 = 146;
pub const _SC_FILE_LOCKING: _bindgen_ty_2 = 147;
pub const _SC_FILE_SYSTEM: _bindgen_ty_2 = 148;
pub const _SC_MONOTONIC_CLOCK: _bindgen_ty_2 = 149;
pub const _SC_MULTI_PROCESS: _bindgen_ty_2 = 150;
pub const _SC_SINGLE_PROCESS: _bindgen_ty_2 = 151;
pub const _SC_NETWORKING: _bindgen_ty_2 = 152;
pub const _SC_READER_WRITER_LOCKS: _bindgen_ty_2 = 153;
pub const _SC_SPIN_LOCKS: _bindgen_ty_2 = 154;
pub const _SC_REGEXP: _bindgen_ty_2 = 155;
pub const _SC_REGEX_VERSION: _bindgen_ty_2 = 156;
pub const _SC_SHELL: _bindgen_ty_2 = 157;
pub const _SC_SIGNALS: _bindgen_ty_2 = 158;
pub const _SC_SPAWN: _bindgen_ty_2 = 159;
pub const _SC_SPORADIC_SERVER: _bindgen_ty_2 = 160;
pub const _SC_THREAD_SPORADIC_SERVER: _bindgen_ty_2 = 161;
pub const _SC_SYSTEM_DATABASE: _bindgen_ty_2 = 162;
pub const _SC_SYSTEM_DATABASE_R: _bindgen_ty_2 = 163;
pub const _SC_TIMEOUTS: _bindgen_ty_2 = 164;
pub const _SC_TYPED_MEMORY_OBJECTS: _bindgen_ty_2 = 165;
pub const _SC_USER_GROUPS: _bindgen_ty_2 = 166;
pub const _SC_USER_GROUPS_R: _bindgen_ty_2 = 167;
pub const _SC_2_PBS: _bindgen_ty_2 = 168;
pub const _SC_2_PBS_ACCOUNTING: _bindgen_ty_2 = 169;
pub const _SC_2_PBS_LOCATE: _bindgen_ty_2 = 170;
pub const _SC_2_PBS_MESSAGE: _bindgen_ty_2 = 171;
pub const _SC_2_PBS_TRACK: _bindgen_ty_2 = 172;
pub const _SC_SYMLOOP_MAX: _bindgen_ty_2 = 173;
pub const _SC_STREAMS: _bindgen_ty_2 = 174;
pub const _SC_2_PBS_CHECKPOINT: _bindgen_ty_2 = 175;
pub const _SC_V6_ILP32_OFF32: _bindgen_ty_2 = 176;
pub const _SC_V6_ILP32_OFFBIG: _bindgen_ty_2 = 177;
pub const _SC_V6_LP64_OFF64: _bindgen_ty_2 = 178;
pub const _SC_V6_LPBIG_OFFBIG: _bindgen_ty_2 = 179;
pub const _SC_HOST_NAME_MAX: _bindgen_ty_2 = 180;
pub const _SC_TRACE: _bindgen_ty_2 = 181;
pub const _SC_TRACE_EVENT_FILTER: _bindgen_ty_2 = 182;
pub const _SC_TRACE_INHERIT: _bindgen_ty_2 = 183;
pub const _SC_TRACE_LOG: _bindgen_ty_2 = 184;
pub const _SC_LEVEL1_ICACHE_SIZE: _bindgen_ty_2 = 185;
pub const _SC_LEVEL1_ICACHE_ASSOC: _bindgen_ty_2 = 186;
pub const _SC_LEVEL1_ICACHE_LINESIZE: _bindgen_ty_2 = 187;
pub const _SC_LEVEL1_DCACHE_SIZE: _bindgen_ty_2 = 188;
pub const _SC_LEVEL1_DCACHE_ASSOC: _bindgen_ty_2 = 189;
pub const _SC_LEVEL1_DCACHE_LINESIZE: _bindgen_ty_2 = 190;
pub const _SC_LEVEL2_CACHE_SIZE: _bindgen_ty_2 = 191;
pub const _SC_LEVEL2_CACHE_ASSOC: _bindgen_ty_2 = 192;
pub const _SC_LEVEL2_CACHE_LINESIZE: _bindgen_ty_2 = 193;
pub const _SC_LEVEL3_CACHE_SIZE: _bindgen_ty_2 = 194;
pub const _SC_LEVEL3_CACHE_ASSOC: _bindgen_ty_2 = 195;
pub const _SC_LEVEL3_CACHE_LINESIZE: _bindgen_ty_2 = 196;
pub const _SC_LEVEL4_CACHE_SIZE: _bindgen_ty_2 = 197;
pub const _SC_LEVEL4_CACHE_ASSOC: _bindgen_ty_2 = 198;
pub const _SC_LEVEL4_CACHE_LINESIZE: _bindgen_ty_2 = 199;
pub const _SC_IPV6: _bindgen_ty_2 = 235;
pub const _SC_RAW_SOCKETS: _bindgen_ty_2 = 236;
pub const _SC_V7_ILP32_OFF32: _bindgen_ty_2 = 237;
pub const _SC_V7_ILP32_OFFBIG: _bindgen_ty_2 = 238;
pub const _SC_V7_LP64_OFF64: _bindgen_ty_2 = 239;
pub const _SC_V7_LPBIG_OFFBIG: _bindgen_ty_2 = 240;
pub const _SC_SS_REPL_MAX: _bindgen_ty_2 = 241;
pub const _SC_TRACE_EVENT_NAME_MAX: _bindgen_ty_2 = 242;
pub const _SC_TRACE_NAME_MAX: _bindgen_ty_2 = 243;
pub const _SC_TRACE_SYS_MAX: _bindgen_ty_2 = 244;
pub const _SC_TRACE_USER_EVENT_MAX: _bindgen_ty_2 = 245;
pub const _SC_XOPEN_STREAMS: _bindgen_ty_2 = 246;
pub const _SC_THREAD_ROBUST_PRIO_INHERIT: _bindgen_ty_2 = 247;
pub const _SC_THREAD_ROBUST_PRIO_PROTECT: _bindgen_ty_2 = 248;
pub type _bindgen_ty_2 = u32;
pub const _CS_PATH: _bindgen_ty_3 = 0;
pub const _CS_V6_WIDTH_RESTRICTED_ENVS: _bindgen_ty_3 = 1;
pub const _CS_GNU_LIBC_VERSION: _bindgen_ty_3 = 2;
pub const _CS_GNU_LIBPTHREAD_VERSION: _bindgen_ty_3 = 3;
pub const _CS_V5_WIDTH_RESTRICTED_ENVS: _bindgen_ty_3 = 4;
pub const _CS_V7_WIDTH_RESTRICTED_ENVS: _bindgen_ty_3 = 5;
pub const _CS_LFS_CFLAGS: _bindgen_ty_3 = 1000;
pub const _CS_LFS_LDFLAGS: _bindgen_ty_3 = 1001;
pub const _CS_LFS_LIBS: _bindgen_ty_3 = 1002;
pub const _CS_LFS_LINTFLAGS: _bindgen_ty_3 = 1003;
pub const _CS_LFS64_CFLAGS: _bindgen_ty_3 = 1004;
pub const _CS_LFS64_LDFLAGS: _bindgen_ty_3 = 1005;
pub const _CS_LFS64_LIBS: _bindgen_ty_3 = 1006;
pub const _CS_LFS64_LINTFLAGS: _bindgen_ty_3 = 1007;
pub const _CS_XBS5_ILP32_OFF32_CFLAGS: _bindgen_ty_3 = 1100;
pub const _CS_XBS5_ILP32_OFF32_LDFLAGS: _bindgen_ty_3 = 1101;
pub const _CS_XBS5_ILP32_OFF32_LIBS: _bindgen_ty_3 = 1102;
pub const _CS_XBS5_ILP32_OFF32_LINTFLAGS: _bindgen_ty_3 = 1103;
pub const _CS_XBS5_ILP32_OFFBIG_CFLAGS: _bindgen_ty_3 = 1104;
pub const _CS_XBS5_ILP32_OFFBIG_LDFLAGS: _bindgen_ty_3 = 1105;
pub const _CS_XBS5_ILP32_OFFBIG_LIBS: _bindgen_ty_3 = 1106;
pub const _CS_XBS5_ILP32_OFFBIG_LINTFLAGS: _bindgen_ty_3 = 1107;
pub const _CS_XBS5_LP64_OFF64_CFLAGS: _bindgen_ty_3 = 1108;
pub const _CS_XBS5_LP64_OFF64_LDFLAGS: _bindgen_ty_3 = 1109;
pub const _CS_XBS5_LP64_OFF64_LIBS: _bindgen_ty_3 = 1110;
pub const _CS_XBS5_LP64_OFF64_LINTFLAGS: _bindgen_ty_3 = 1111;
pub const _CS_XBS5_LPBIG_OFFBIG_CFLAGS: _bindgen_ty_3 = 1112;
pub const _CS_XBS5_LPBIG_OFFBIG_LDFLAGS: _bindgen_ty_3 = 1113;
pub const _CS_XBS5_LPBIG_OFFBIG_LIBS: _bindgen_ty_3 = 1114;
pub const _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS: _bindgen_ty_3 = 1115;
pub const _CS_POSIX_V6_ILP32_OFF32_CFLAGS: _bindgen_ty_3 = 1116;
pub const _CS_POSIX_V6_ILP32_OFF32_LDFLAGS: _bindgen_ty_3 = 1117;
pub const _CS_POSIX_V6_ILP32_OFF32_LIBS: _bindgen_ty_3 = 1118;
pub const _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS: _bindgen_ty_3 = 1119;
pub const _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS: _bindgen_ty_3 = 1120;
pub const _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS: _bindgen_ty_3 = 1121;
pub const _CS_POSIX_V6_ILP32_OFFBIG_LIBS: _bindgen_ty_3 = 1122;
pub const _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS: _bindgen_ty_3 = 1123;
pub const _CS_POSIX_V6_LP64_OFF64_CFLAGS: _bindgen_ty_3 = 1124;
pub const _CS_POSIX_V6_LP64_OFF64_LDFLAGS: _bindgen_ty_3 = 1125;
pub const _CS_POSIX_V6_LP64_OFF64_LIBS: _bindgen_ty_3 = 1126;
pub const _CS_POSIX_V6_LP64_OFF64_LINTFLAGS: _bindgen_ty_3 = 1127;
pub const _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS: _bindgen_ty_3 = 1128;
pub const _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS: _bindgen_ty_3 = 1129;
pub const _CS_POSIX_V6_LPBIG_OFFBIG_LIBS: _bindgen_ty_3 = 1130;
pub const _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS: _bindgen_ty_3 = 1131;
pub const _CS_POSIX_V7_ILP32_OFF32_CFLAGS: _bindgen_ty_3 = 1132;
pub const _CS_POSIX_V7_ILP32_OFF32_LDFLAGS: _bindgen_ty_3 = 1133;
pub const _CS_POSIX_V7_ILP32_OFF32_LIBS: _bindgen_ty_3 = 1134;
pub const _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS: _bindgen_ty_3 = 1135;
pub const _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS: _bindgen_ty_3 = 1136;
pub const _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS: _bindgen_ty_3 = 1137;
pub const _CS_POSIX_V7_ILP32_OFFBIG_LIBS: _bindgen_ty_3 = 1138;
pub const _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS: _bindgen_ty_3 = 1139;
pub const _CS_POSIX_V7_LP64_OFF64_CFLAGS: _bindgen_ty_3 = 1140;
pub const _CS_POSIX_V7_LP64_OFF64_LDFLAGS: _bindgen_ty_3 = 1141;
pub const _CS_POSIX_V7_LP64_OFF64_LIBS: _bindgen_ty_3 = 1142;
pub const _CS_POSIX_V7_LP64_OFF64_LINTFLAGS: _bindgen_ty_3 = 1143;
pub const _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS: _bindgen_ty_3 = 1144;
pub const _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS: _bindgen_ty_3 = 1145;
pub const _CS_POSIX_V7_LPBIG_OFFBIG_LIBS: _bindgen_ty_3 = 1146;
pub const _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS: _bindgen_ty_3 = 1147;
pub const _CS_V6_ENV: _bindgen_ty_3 = 1148;
pub const _CS_V7_ENV: _bindgen_ty_3 = 1149;
pub type _bindgen_ty_3 = u32;
extern "C" {
    pub fn pathconf(__path: *const cty::c_char, __name: cty::c_int) -> cty::c_long;
}
extern "C" {
    pub fn fpathconf(__fd: cty::c_int, __name: cty::c_int) -> cty::c_long;
}
extern "C" {
    pub fn sysconf(__name: cty::c_int) -> cty::c_long;
}
extern "C" {
    pub fn confstr(__name: cty::c_int, __buf: *mut cty::c_char, __len: usize) -> usize;
}
extern "C" {
    pub fn getpid() -> __pid_t;
}
extern "C" {
    pub fn getppid() -> __pid_t;
}
extern "C" {
    pub fn getpgrp() -> __pid_t;
}
extern "C" {
    pub fn __getpgid(__pid: __pid_t) -> __pid_t;
}
extern "C" {
    pub fn getpgid(__pid: __pid_t) -> __pid_t;
}
extern "C" {
    pub fn setpgid(__pid: __pid_t, __pgid: __pid_t) -> cty::c_int;
}
extern "C" {
    pub fn setpgrp() -> cty::c_int;
}
extern "C" {
    pub fn setsid() -> __pid_t;
}
extern "C" {
    pub fn getsid(__pid: __pid_t) -> __pid_t;
}
extern "C" {
    pub fn getuid() -> __uid_t;
}
extern "C" {
    pub fn geteuid() -> __uid_t;
}
extern "C" {
    pub fn getgid() -> __gid_t;
}
extern "C" {
    pub fn getegid() -> __gid_t;
}
extern "C" {
    pub fn getgroups(__size: cty::c_int, __list: *mut __gid_t) -> cty::c_int;
}
extern "C" {
    pub fn setuid(__uid: __uid_t) -> cty::c_int;
}
extern "C" {
    pub fn setreuid(__ruid: __uid_t, __euid: __uid_t) -> cty::c_int;
}
extern "C" {
    pub fn seteuid(__uid: __uid_t) -> cty::c_int;
}
extern "C" {
    pub fn setgid(__gid: __gid_t) -> cty::c_int;
}
extern "C" {
    pub fn setregid(__rgid: __gid_t, __egid: __gid_t) -> cty::c_int;
}
extern "C" {
    pub fn setegid(__gid: __gid_t) -> cty::c_int;
}
extern "C" {
    pub fn fork() -> __pid_t;
}
extern "C" {
    pub fn vfork() -> cty::c_int;
}
extern "C" {
    pub fn ttyname(__fd: cty::c_int) -> *mut cty::c_char;
}
extern "C" {
    pub fn ttyname_r(__fd: cty::c_int, __buf: *mut cty::c_char, __buflen: usize) -> cty::c_int;
}
extern "C" {
    pub fn isatty(__fd: cty::c_int) -> cty::c_int;
}
extern "C" {
    pub fn ttyslot() -> cty::c_int;
}
extern "C" {
    pub fn link(__from: *const cty::c_char, __to: *const cty::c_char) -> cty::c_int;
}
extern "C" {
    pub fn linkat(
        __fromfd: cty::c_int,
        __from: *const cty::c_char,
        __tofd: cty::c_int,
        __to: *const cty::c_char,
        __flags: cty::c_int,
    ) -> cty::c_int;
}
extern "C" {
    pub fn symlink(__from: *const cty::c_char, __to: *const cty::c_char) -> cty::c_int;
}
extern "C" {
    pub fn readlink(__path: *const cty::c_char, __buf: *mut cty::c_char, __len: usize) -> isize;
}
extern "C" {
    pub fn symlinkat(
        __from: *const cty::c_char,
        __tofd: cty::c_int,
        __to: *const cty::c_char,
    ) -> cty::c_int;
}
extern "C" {
    pub fn readlinkat(
        __fd: cty::c_int,
        __path: *const cty::c_char,
        __buf: *mut cty::c_char,
        __len: usize,
    ) -> isize;
}
extern "C" {
    pub fn unlink(__name: *const cty::c_char) -> cty::c_int;
}
extern "C" {
    pub fn unlinkat(__fd: cty::c_int, __name: *const cty::c_char, __flag: cty::c_int)
        -> cty::c_int;
}
extern "C" {
    pub fn rmdir(__path: *const cty::c_char) -> cty::c_int;
}
extern "C" {
    pub fn tcgetpgrp(__fd: cty::c_int) -> __pid_t;
}
extern "C" {
    pub fn tcsetpgrp(__fd: cty::c_int, __pgrp_id: __pid_t) -> cty::c_int;
}
extern "C" {
    pub fn getlogin() -> *mut cty::c_char;
}
extern "C" {
    pub fn getlogin_r(__name: *mut cty::c_char, __name_len: usize) -> cty::c_int;
}
extern "C" {
    pub fn setlogin(__name: *const cty::c_char) -> cty::c_int;
}
extern "C" {
    pub fn getopt(
        ___argc: cty::c_int,
        ___argv: *const *mut cty::c_char,
        __shortopts: *const cty::c_char,
    ) -> cty::c_int;
}
extern "C" {
    pub fn gethostname(__name: *mut cty::c_char, __len: usize) -> cty::c_int;
}
extern "C" {
    pub fn sethostname(__name: *const cty::c_char, __len: usize) -> cty::c_int;
}
extern "C" {
    pub fn sethostid(__id: cty::c_long) -> cty::c_int;
}
extern "C" {
    pub fn getdomainname(__name: *mut cty::c_char, __len: usize) -> cty::c_int;
}
extern "C" {
    pub fn setdomainname(__name: *const cty::c_char, __len: usize) -> cty::c_int;
}
extern "C" {
    pub fn vhangup() -> cty::c_int;
}
extern "C" {
    pub fn revoke(__file: *const cty::c_char) -> cty::c_int;
}
extern "C" {
    pub fn profil(
        __sample_buffer: *mut cty::c_ushort,
        __size: usize,
        __offset: usize,
        __scale: cty::c_uint,
    ) -> cty::c_int;
}
extern "C" {
    pub fn acct(__name: *const cty::c_char) -> cty::c_int;
}
extern "C" {
    pub fn getusershell() -> *mut cty::c_char;
}
extern "C" {
    pub fn endusershell();
}
extern "C" {
    pub fn setusershell();
}
extern "C" {
    pub fn daemon(__nochdir: cty::c_int, __noclose: cty::c_int) -> cty::c_int;
}
extern "C" {
    pub fn chroot(__path: *const cty::c_char) -> cty::c_int;
}
extern "C" {
    pub fn getpass(__prompt: *const cty::c_char) -> *mut cty::c_char;
}
extern "C" {
    pub fn fsync(__fd: cty::c_int) -> cty::c_int;
}
extern "C" {
    pub fn gethostid() -> cty::c_long;
}
extern "C" {
    pub fn sync();
}
extern "C" {
    pub fn getpagesize() -> cty::c_int;
}
extern "C" {
    pub fn getdtablesize() -> cty::c_int;
}
extern "C" {
    pub fn truncate(__file: *const cty::c_char, __length: __off_t) -> cty::c_int;
}
extern "C" {
    pub fn ftruncate(__fd: cty::c_int, __length: __off_t) -> cty::c_int;
}
extern "C" {
    pub fn brk(__addr: *mut cty::c_void) -> cty::c_int;
}
extern "C" {
    pub fn sbrk(__delta: isize) -> *mut cty::c_void;
}
extern "C" {
    pub fn syscall(__sysno: cty::c_long, ...) -> cty::c_long;
}
extern "C" {
    pub fn lockf(__fd: cty::c_int, __cmd: cty::c_int, __len: __off_t) -> cty::c_int;
}
extern "C" {
    pub fn fdatasync(__fildes: cty::c_int) -> cty::c_int;
}
extern "C" {
    pub fn crypt(__key: *const cty::c_char, __salt: *const cty::c_char) -> *mut cty::c_char;
}
extern "C" {
    pub fn getentropy(__buffer: *mut cty::c_void, __length: usize) -> cty::c_int;
}
extern "C" {
    pub fn __errno_location() -> *mut cty::c_int;
}
pub type float_t = f32;
pub type double_t = f64;
extern "C" {
    pub fn __fpclassify(__value: f64) -> cty::c_int;
}
extern "C" {
    pub fn __signbit(__value: f64) -> cty::c_int;
}
extern "C" {
    pub fn __isinf(__value: f64) -> cty::c_int;
}
extern "C" {
    pub fn __finite(__value: f64) -> cty::c_int;
}
extern "C" {
    pub fn __isnan(__value: f64) -> cty::c_int;
}
extern "C" {
    pub fn __iseqsig(__x: f64, __y: f64) -> cty::c_int;
}
extern "C" {
    pub fn __issignaling(__value: f64) -> cty::c_int;
}
extern "C" {
    pub fn acos(__x: f64) -> f64;
}
extern "C" {
    pub fn __acos(__x: f64) -> f64;
}
extern "C" {
    pub fn asin(__x: f64) -> f64;
}
extern "C" {
    pub fn __asin(__x: f64) -> f64;
}
extern "C" {
    pub fn atan(__x: f64) -> f64;
}
extern "C" {
    pub fn __atan(__x: f64) -> f64;
}
extern "C" {
    pub fn atan2(__y: f64, __x: f64) -> f64;
}
extern "C" {
    pub fn __atan2(__y: f64, __x: f64) -> f64;
}
extern "C" {
    pub fn cos(__x: f64) -> f64;
}
extern "C" {
    pub fn __cos(__x: f64) -> f64;
}
extern "C" {
    pub fn sin(__x: f64) -> f64;
}
extern "C" {
    pub fn __sin(__x: f64) -> f64;
}
extern "C" {
    pub fn tan(__x: f64) -> f64;
}
extern "C" {
    pub fn __tan(__x: f64) -> f64;
}
extern "C" {
    pub fn cosh(__x: f64) -> f64;
}
extern "C" {
    pub fn __cosh(__x: f64) -> f64;
}
extern "C" {
    pub fn sinh(__x: f64) -> f64;
}
extern "C" {
    pub fn __sinh(__x: f64) -> f64;
}
extern "C" {
    pub fn tanh(__x: f64) -> f64;
}
extern "C" {
    pub fn __tanh(__x: f64) -> f64;
}
extern "C" {
    pub fn acosh(__x: f64) -> f64;
}
extern "C" {
    pub fn __acosh(__x: f64) -> f64;
}
extern "C" {
    pub fn asinh(__x: f64) -> f64;
}
extern "C" {
    pub fn __asinh(__x: f64) -> f64;
}
extern "C" {
    pub fn atanh(__x: f64) -> f64;
}
extern "C" {
    pub fn __atanh(__x: f64) -> f64;
}
extern "C" {
    pub fn exp(__x: f64) -> f64;
}
extern "C" {
    pub fn __exp(__x: f64) -> f64;
}
extern "C" {
    pub fn frexp(__x: f64, __exponent: *mut cty::c_int) -> f64;
}
extern "C" {
    pub fn __frexp(__x: f64, __exponent: *mut cty::c_int) -> f64;
}
extern "C" {
    pub fn ldexp(__x: f64, __exponent: cty::c_int) -> f64;
}
extern "C" {
    pub fn __ldexp(__x: f64, __exponent: cty::c_int) -> f64;
}
extern "C" {
    pub fn log(__x: f64) -> f64;
}
extern "C" {
    pub fn __log(__x: f64) -> f64;
}
extern "C" {
    pub fn log10(__x: f64) -> f64;
}
extern "C" {
    pub fn __log10(__x: f64) -> f64;
}
extern "C" {
    pub fn modf(__x: f64, __iptr: *mut f64) -> f64;
}
extern "C" {
    pub fn __modf(__x: f64, __iptr: *mut f64) -> f64;
}
extern "C" {
    pub fn expm1(__x: f64) -> f64;
}
extern "C" {
    pub fn __expm1(__x: f64) -> f64;
}
extern "C" {
    pub fn log1p(__x: f64) -> f64;
}
extern "C" {
    pub fn __log1p(__x: f64) -> f64;
}
extern "C" {
    pub fn logb(__x: f64) -> f64;
}
extern "C" {
    pub fn __logb(__x: f64) -> f64;
}
extern "C" {
    pub fn exp2(__x: f64) -> f64;
}
extern "C" {
    pub fn __exp2(__x: f64) -> f64;
}
extern "C" {
    pub fn log2(__x: f64) -> f64;
}
extern "C" {
    pub fn __log2(__x: f64) -> f64;
}
extern "C" {
    pub fn pow(__x: f64, __y: f64) -> f64;
}
extern "C" {
    pub fn __pow(__x: f64, __y: f64) -> f64;
}
extern "C" {
    pub fn sqrt(__x: f64) -> f64;
}
extern "C" {
    pub fn __sqrt(__x: f64) -> f64;
}
extern "C" {
    pub fn hypot(__x: f64, __y: f64) -> f64;
}
extern "C" {
    pub fn __hypot(__x: f64, __y: f64) -> f64;
}
extern "C" {
    pub fn cbrt(__x: f64) -> f64;
}
extern "C" {
    pub fn __cbrt(__x: f64) -> f64;
}
extern "C" {
    pub fn ceil(__x: f64) -> f64;
}
extern "C" {
    pub fn __ceil(__x: f64) -> f64;
}
extern "C" {
    pub fn fabs(__x: f64) -> f64;
}
extern "C" {
    pub fn __fabs(__x: f64) -> f64;
}
extern "C" {
    pub fn floor(__x: f64) -> f64;
}
extern "C" {
    pub fn __floor(__x: f64) -> f64;
}
extern "C" {
    pub fn fmod(__x: f64, __y: f64) -> f64;
}
extern "C" {
    pub fn __fmod(__x: f64, __y: f64) -> f64;
}
extern "C" {
    pub fn isinf(__value: f64) -> cty::c_int;
}
extern "C" {
    pub fn finite(__value: f64) -> cty::c_int;
}
extern "C" {
    pub fn drem(__x: f64, __y: f64) -> f64;
}
extern "C" {
    pub fn __drem(__x: f64, __y: f64) -> f64;
}
extern "C" {
    pub fn significand(__x: f64) -> f64;
}
extern "C" {
    pub fn __significand(__x: f64) -> f64;
}
extern "C" {
    pub fn copysign(__x: f64, __y: f64) -> f64;
}
extern "C" {
    pub fn __copysign(__x: f64, __y: f64) -> f64;
}
extern "C" {
    pub fn nan(__tagb: *const cty::c_char) -> f64;
}
extern "C" {
    pub fn __nan(__tagb: *const cty::c_char) -> f64;
}
extern "C" {
    pub fn isnan(__value: f64) -> cty::c_int;
}
extern "C" {
    pub fn j0(arg1: f64) -> f64;
}
extern "C" {
    pub fn __j0(arg1: f64) -> f64;
}
extern "C" {
    pub fn j1(arg1: f64) -> f64;
}
extern "C" {
    pub fn __j1(arg1: f64) -> f64;
}
extern "C" {
    pub fn jn(arg1: cty::c_int, arg2: f64) -> f64;
}
extern "C" {
    pub fn __jn(arg1: cty::c_int, arg2: f64) -> f64;
}
extern "C" {
    pub fn y0(arg1: f64) -> f64;
}
extern "C" {
    pub fn __y0(arg1: f64) -> f64;
}
extern "C" {
    pub fn y1(arg1: f64) -> f64;
}
extern "C" {
    pub fn __y1(arg1: f64) -> f64;
}
extern "C" {
    pub fn yn(arg1: cty::c_int, arg2: f64) -> f64;
}
extern "C" {
    pub fn __yn(arg1: cty::c_int, arg2: f64) -> f64;
}
extern "C" {
    pub fn erf(arg1: f64) -> f64;
}
extern "C" {
    pub fn __erf(arg1: f64) -> f64;
}
extern "C" {
    pub fn erfc(arg1: f64) -> f64;
}
extern "C" {
    pub fn __erfc(arg1: f64) -> f64;
}
extern "C" {
    pub fn lgamma(arg1: f64) -> f64;
}
extern "C" {
    pub fn __lgamma(arg1: f64) -> f64;
}
extern "C" {
    pub fn tgamma(arg1: f64) -> f64;
}
extern "C" {
    pub fn __tgamma(arg1: f64) -> f64;
}
extern "C" {
    pub fn gamma(arg1: f64) -> f64;
}
extern "C" {
    pub fn __gamma(arg1: f64) -> f64;
}
extern "C" {
    pub fn lgamma_r(arg1: f64, __signgamp: *mut cty::c_int) -> f64;
}
extern "C" {
    pub fn __lgamma_r(arg1: f64, __signgamp: *mut cty::c_int) -> f64;
}
extern "C" {
    pub fn rint(__x: f64) -> f64;
}
extern "C" {
    pub fn __rint(__x: f64) -> f64;
}
extern "C" {
    pub fn nextafter(__x: f64, __y: f64) -> f64;
}
extern "C" {
    pub fn __nextafter(__x: f64, __y: f64) -> f64;
}
extern "C" {
    pub fn nexttoward(__x: f64, __y: u128) -> f64;
}
extern "C" {
    pub fn __nexttoward(__x: f64, __y: u128) -> f64;
}
extern "C" {
    pub fn remainder(__x: f64, __y: f64) -> f64;
}
extern "C" {
    pub fn __remainder(__x: f64, __y: f64) -> f64;
}
extern "C" {
    pub fn scalbn(__x: f64, __n: cty::c_int) -> f64;
}
extern "C" {
    pub fn __scalbn(__x: f64, __n: cty::c_int) -> f64;
}
extern "C" {
    pub fn ilogb(__x: f64) -> cty::c_int;
}
extern "C" {
    pub fn __ilogb(__x: f64) -> cty::c_int;
}
extern "C" {
    pub fn scalbln(__x: f64, __n: cty::c_long) -> f64;
}
extern "C" {
    pub fn __scalbln(__x: f64, __n: cty::c_long) -> f64;
}
extern "C" {
    pub fn nearbyint(__x: f64) -> f64;
}
extern "C" {
    pub fn __nearbyint(__x: f64) -> f64;
}
extern "C" {
    pub fn round(__x: f64) -> f64;
}
extern "C" {
    pub fn __round(__x: f64) -> f64;
}
extern "C" {
    pub fn trunc(__x: f64) -> f64;
}
extern "C" {
    pub fn __trunc(__x: f64) -> f64;
}
extern "C" {
    pub fn remquo(__x: f64, __y: f64, __quo: *mut cty::c_int) -> f64;
}
extern "C" {
    pub fn __remquo(__x: f64, __y: f64, __quo: *mut cty::c_int) -> f64;
}
extern "C" {
    pub fn lrint(__x: f64) -> cty::c_long;
}
extern "C" {
    pub fn __lrint(__x: f64) -> cty::c_long;
}
extern "C" {
    pub fn llrint(__x: f64) -> cty::c_longlong;
}
extern "C" {
    pub fn __llrint(__x: f64) -> cty::c_longlong;
}
extern "C" {
    pub fn lround(__x: f64) -> cty::c_long;
}
extern "C" {
    pub fn __lround(__x: f64) -> cty::c_long;
}
extern "C" {
    pub fn llround(__x: f64) -> cty::c_longlong;
}
extern "C" {
    pub fn __llround(__x: f64) -> cty::c_longlong;
}
extern "C" {
    pub fn fdim(__x: f64, __y: f64) -> f64;
}
extern "C" {
    pub fn __fdim(__x: f64, __y: f64) -> f64;
}
extern "C" {
    pub fn fmax(__x: f64, __y: f64) -> f64;
}
extern "C" {
    pub fn __fmax(__x: f64, __y: f64) -> f64;
}
extern "C" {
    pub fn fmin(__x: f64, __y: f64) -> f64;
}
extern "C" {
    pub fn __fmin(__x: f64, __y: f64) -> f64;
}
extern "C" {
    pub fn fma(__x: f64, __y: f64, __z: f64) -> f64;
}
extern "C" {
    pub fn __fma(__x: f64, __y: f64, __z: f64) -> f64;
}
extern "C" {
    pub fn scalb(__x: f64, __n: f64) -> f64;
}
extern "C" {
    pub fn __scalb(__x: f64, __n: f64) -> f64;
}
extern "C" {
    pub fn __fpclassifyf(__value: f32) -> cty::c_int;
}
extern "C" {
    pub fn __signbitf(__value: f32) -> cty::c_int;
}
extern "C" {
    pub fn __isinff(__value: f32) -> cty::c_int;
}
extern "C" {
    pub fn __finitef(__value: f32) -> cty::c_int;
}
extern "C" {
    pub fn __isnanf(__value: f32) -> cty::c_int;
}
extern "C" {
    pub fn __iseqsigf(__x: f32, __y: f32) -> cty::c_int;
}
extern "C" {
    pub fn __issignalingf(__value: f32) -> cty::c_int;
}
extern "C" {
    pub fn acosf(__x: f32) -> f32;
}
extern "C" {
    pub fn __acosf(__x: f32) -> f32;
}
extern "C" {
    pub fn asinf(__x: f32) -> f32;
}
extern "C" {
    pub fn __asinf(__x: f32) -> f32;
}
extern "C" {
    pub fn atanf(__x: f32) -> f32;
}
extern "C" {
    pub fn __atanf(__x: f32) -> f32;
}
extern "C" {
    pub fn atan2f(__y: f32, __x: f32) -> f32;
}
extern "C" {
    pub fn __atan2f(__y: f32, __x: f32) -> f32;
}
extern "C" {
    pub fn cosf(__x: f32) -> f32;
}
extern "C" {
    pub fn __cosf(__x: f32) -> f32;
}
extern "C" {
    pub fn sinf(__x: f32) -> f32;
}
extern "C" {
    pub fn __sinf(__x: f32) -> f32;
}
extern "C" {
    pub fn tanf(__x: f32) -> f32;
}
extern "C" {
    pub fn __tanf(__x: f32) -> f32;
}
extern "C" {
    pub fn coshf(__x: f32) -> f32;
}
extern "C" {
    pub fn __coshf(__x: f32) -> f32;
}
extern "C" {
    pub fn sinhf(__x: f32) -> f32;
}
extern "C" {
    pub fn __sinhf(__x: f32) -> f32;
}
extern "C" {
    pub fn tanhf(__x: f32) -> f32;
}
extern "C" {
    pub fn __tanhf(__x: f32) -> f32;
}
extern "C" {
    pub fn acoshf(__x: f32) -> f32;
}
extern "C" {
    pub fn __acoshf(__x: f32) -> f32;
}
extern "C" {
    pub fn asinhf(__x: f32) -> f32;
}
extern "C" {
    pub fn __asinhf(__x: f32) -> f32;
}
extern "C" {
    pub fn atanhf(__x: f32) -> f32;
}
extern "C" {
    pub fn __atanhf(__x: f32) -> f32;
}
extern "C" {
    pub fn expf(__x: f32) -> f32;
}
extern "C" {
    pub fn __expf(__x: f32) -> f32;
}
extern "C" {
    pub fn frexpf(__x: f32, __exponent: *mut cty::c_int) -> f32;
}
extern "C" {
    pub fn __frexpf(__x: f32, __exponent: *mut cty::c_int) -> f32;
}
extern "C" {
    pub fn ldexpf(__x: f32, __exponent: cty::c_int) -> f32;
}
extern "C" {
    pub fn __ldexpf(__x: f32, __exponent: cty::c_int) -> f32;
}
extern "C" {
    pub fn logf(__x: f32) -> f32;
}
extern "C" {
    pub fn __logf(__x: f32) -> f32;
}
extern "C" {
    pub fn log10f(__x: f32) -> f32;
}
extern "C" {
    pub fn __log10f(__x: f32) -> f32;
}
extern "C" {
    pub fn modff(__x: f32, __iptr: *mut f32) -> f32;
}
extern "C" {
    pub fn __modff(__x: f32, __iptr: *mut f32) -> f32;
}
extern "C" {
    pub fn expm1f(__x: f32) -> f32;
}
extern "C" {
    pub fn __expm1f(__x: f32) -> f32;
}
extern "C" {
    pub fn log1pf(__x: f32) -> f32;
}
extern "C" {
    pub fn __log1pf(__x: f32) -> f32;
}
extern "C" {
    pub fn logbf(__x: f32) -> f32;
}
extern "C" {
    pub fn __logbf(__x: f32) -> f32;
}
extern "C" {
    pub fn exp2f(__x: f32) -> f32;
}
extern "C" {
    pub fn __exp2f(__x: f32) -> f32;
}
extern "C" {
    pub fn log2f(__x: f32) -> f32;
}
extern "C" {
    pub fn __log2f(__x: f32) -> f32;
}
extern "C" {
    pub fn powf(__x: f32, __y: f32) -> f32;
}
extern "C" {
    pub fn __powf(__x: f32, __y: f32) -> f32;
}
extern "C" {
    pub fn sqrtf(__x: f32) -> f32;
}
extern "C" {
    pub fn __sqrtf(__x: f32) -> f32;
}
extern "C" {
    pub fn hypotf(__x: f32, __y: f32) -> f32;
}
extern "C" {
    pub fn __hypotf(__x: f32, __y: f32) -> f32;
}
extern "C" {
    pub fn cbrtf(__x: f32) -> f32;
}
extern "C" {
    pub fn __cbrtf(__x: f32) -> f32;
}
extern "C" {
    pub fn ceilf(__x: f32) -> f32;
}
extern "C" {
    pub fn __ceilf(__x: f32) -> f32;
}
extern "C" {
    pub fn fabsf(__x: f32) -> f32;
}
extern "C" {
    pub fn __fabsf(__x: f32) -> f32;
}
extern "C" {
    pub fn floorf(__x: f32) -> f32;
}
extern "C" {
    pub fn __floorf(__x: f32) -> f32;
}
extern "C" {
    pub fn fmodf(__x: f32, __y: f32) -> f32;
}
extern "C" {
    pub fn __fmodf(__x: f32, __y: f32) -> f32;
}
extern "C" {
    pub fn isinff(__value: f32) -> cty::c_int;
}
extern "C" {
    pub fn finitef(__value: f32) -> cty::c_int;
}
extern "C" {
    pub fn dremf(__x: f32, __y: f32) -> f32;
}
extern "C" {
    pub fn __dremf(__x: f32, __y: f32) -> f32;
}
extern "C" {
    pub fn significandf(__x: f32) -> f32;
}
extern "C" {
    pub fn __significandf(__x: f32) -> f32;
}
extern "C" {
    pub fn copysignf(__x: f32, __y: f32) -> f32;
}
extern "C" {
    pub fn __copysignf(__x: f32, __y: f32) -> f32;
}
extern "C" {
    pub fn nanf(__tagb: *const cty::c_char) -> f32;
}
extern "C" {
    pub fn __nanf(__tagb: *const cty::c_char) -> f32;
}
extern "C" {
    pub fn isnanf(__value: f32) -> cty::c_int;
}
extern "C" {
    pub fn j0f(arg1: f32) -> f32;
}
extern "C" {
    pub fn __j0f(arg1: f32) -> f32;
}
extern "C" {
    pub fn j1f(arg1: f32) -> f32;
}
extern "C" {
    pub fn __j1f(arg1: f32) -> f32;
}
extern "C" {
    pub fn jnf(arg1: cty::c_int, arg2: f32) -> f32;
}
extern "C" {
    pub fn __jnf(arg1: cty::c_int, arg2: f32) -> f32;
}
extern "C" {
    pub fn y0f(arg1: f32) -> f32;
}
extern "C" {
    pub fn __y0f(arg1: f32) -> f32;
}
extern "C" {
    pub fn y1f(arg1: f32) -> f32;
}
extern "C" {
    pub fn __y1f(arg1: f32) -> f32;
}
extern "C" {
    pub fn ynf(arg1: cty::c_int, arg2: f32) -> f32;
}
extern "C" {
    pub fn __ynf(arg1: cty::c_int, arg2: f32) -> f32;
}
extern "C" {
    pub fn erff(arg1: f32) -> f32;
}
extern "C" {
    pub fn __erff(arg1: f32) -> f32;
}
extern "C" {
    pub fn erfcf(arg1: f32) -> f32;
}
extern "C" {
    pub fn __erfcf(arg1: f32) -> f32;
}
extern "C" {
    pub fn lgammaf(arg1: f32) -> f32;
}
extern "C" {
    pub fn __lgammaf(arg1: f32) -> f32;
}
extern "C" {
    pub fn tgammaf(arg1: f32) -> f32;
}
extern "C" {
    pub fn __tgammaf(arg1: f32) -> f32;
}
extern "C" {
    pub fn gammaf(arg1: f32) -> f32;
}
extern "C" {
    pub fn __gammaf(arg1: f32) -> f32;
}
extern "C" {
    pub fn lgammaf_r(arg1: f32, __signgamp: *mut cty::c_int) -> f32;
}
extern "C" {
    pub fn __lgammaf_r(arg1: f32, __signgamp: *mut cty::c_int) -> f32;
}
extern "C" {
    pub fn rintf(__x: f32) -> f32;
}
extern "C" {
    pub fn __rintf(__x: f32) -> f32;
}
extern "C" {
    pub fn nextafterf(__x: f32, __y: f32) -> f32;
}
extern "C" {
    pub fn __nextafterf(__x: f32, __y: f32) -> f32;
}
extern "C" {
    pub fn nexttowardf(__x: f32, __y: u128) -> f32;
}
extern "C" {
    pub fn __nexttowardf(__x: f32, __y: u128) -> f32;
}
extern "C" {
    pub fn remainderf(__x: f32, __y: f32) -> f32;
}
extern "C" {
    pub fn __remainderf(__x: f32, __y: f32) -> f32;
}
extern "C" {
    pub fn scalbnf(__x: f32, __n: cty::c_int) -> f32;
}
extern "C" {
    pub fn __scalbnf(__x: f32, __n: cty::c_int) -> f32;
}
extern "C" {
    pub fn ilogbf(__x: f32) -> cty::c_int;
}
extern "C" {
    pub fn __ilogbf(__x: f32) -> cty::c_int;
}
extern "C" {
    pub fn scalblnf(__x: f32, __n: cty::c_long) -> f32;
}
extern "C" {
    pub fn __scalblnf(__x: f32, __n: cty::c_long) -> f32;
}
extern "C" {
    pub fn nearbyintf(__x: f32) -> f32;
}
extern "C" {
    pub fn __nearbyintf(__x: f32) -> f32;
}
extern "C" {
    pub fn roundf(__x: f32) -> f32;
}
extern "C" {
    pub fn __roundf(__x: f32) -> f32;
}
extern "C" {
    pub fn truncf(__x: f32) -> f32;
}
extern "C" {
    pub fn __truncf(__x: f32) -> f32;
}
extern "C" {
    pub fn remquof(__x: f32, __y: f32, __quo: *mut cty::c_int) -> f32;
}
extern "C" {
    pub fn __remquof(__x: f32, __y: f32, __quo: *mut cty::c_int) -> f32;
}
extern "C" {
    pub fn lrintf(__x: f32) -> cty::c_long;
}
extern "C" {
    pub fn __lrintf(__x: f32) -> cty::c_long;
}
extern "C" {
    pub fn llrintf(__x: f32) -> cty::c_longlong;
}
extern "C" {
    pub fn __llrintf(__x: f32) -> cty::c_longlong;
}
extern "C" {
    pub fn lroundf(__x: f32) -> cty::c_long;
}
extern "C" {
    pub fn __lroundf(__x: f32) -> cty::c_long;
}
extern "C" {
    pub fn llroundf(__x: f32) -> cty::c_longlong;
}
extern "C" {
    pub fn __llroundf(__x: f32) -> cty::c_longlong;
}
extern "C" {
    pub fn fdimf(__x: f32, __y: f32) -> f32;
}
extern "C" {
    pub fn __fdimf(__x: f32, __y: f32) -> f32;
}
extern "C" {
    pub fn fmaxf(__x: f32, __y: f32) -> f32;
}
extern "C" {
    pub fn __fmaxf(__x: f32, __y: f32) -> f32;
}
extern "C" {
    pub fn fminf(__x: f32, __y: f32) -> f32;
}
extern "C" {
    pub fn __fminf(__x: f32, __y: f32) -> f32;
}
extern "C" {
    pub fn fmaf(__x: f32, __y: f32, __z: f32) -> f32;
}
extern "C" {
    pub fn __fmaf(__x: f32, __y: f32, __z: f32) -> f32;
}
extern "C" {
    pub fn scalbf(__x: f32, __n: f32) -> f32;
}
extern "C" {
    pub fn __scalbf(__x: f32, __n: f32) -> f32;
}
extern "C" {
    pub fn __fpclassifyl(__value: u128) -> cty::c_int;
}
extern "C" {
    pub fn __signbitl(__value: u128) -> cty::c_int;
}
extern "C" {
    pub fn __isinfl(__value: u128) -> cty::c_int;
}
extern "C" {
    pub fn __finitel(__value: u128) -> cty::c_int;
}
extern "C" {
    pub fn __isnanl(__value: u128) -> cty::c_int;
}
extern "C" {
    pub fn __iseqsigl(__x: u128, __y: u128) -> cty::c_int;
}
extern "C" {
    pub fn __issignalingl(__value: u128) -> cty::c_int;
}
extern "C" {
    pub fn acosl(__x: u128) -> u128;
}
extern "C" {
    pub fn __acosl(__x: u128) -> u128;
}
extern "C" {
    pub fn asinl(__x: u128) -> u128;
}
extern "C" {
    pub fn __asinl(__x: u128) -> u128;
}
extern "C" {
    pub fn atanl(__x: u128) -> u128;
}
extern "C" {
    pub fn __atanl(__x: u128) -> u128;
}
extern "C" {
    pub fn atan2l(__y: u128, __x: u128) -> u128;
}
extern "C" {
    pub fn __atan2l(__y: u128, __x: u128) -> u128;
}
extern "C" {
    pub fn cosl(__x: u128) -> u128;
}
extern "C" {
    pub fn __cosl(__x: u128) -> u128;
}
extern "C" {
    pub fn sinl(__x: u128) -> u128;
}
extern "C" {
    pub fn __sinl(__x: u128) -> u128;
}
extern "C" {
    pub fn tanl(__x: u128) -> u128;
}
extern "C" {
    pub fn __tanl(__x: u128) -> u128;
}
extern "C" {
    pub fn coshl(__x: u128) -> u128;
}
extern "C" {
    pub fn __coshl(__x: u128) -> u128;
}
extern "C" {
    pub fn sinhl(__x: u128) -> u128;
}
extern "C" {
    pub fn __sinhl(__x: u128) -> u128;
}
extern "C" {
    pub fn tanhl(__x: u128) -> u128;
}
extern "C" {
    pub fn __tanhl(__x: u128) -> u128;
}
extern "C" {
    pub fn acoshl(__x: u128) -> u128;
}
extern "C" {
    pub fn __acoshl(__x: u128) -> u128;
}
extern "C" {
    pub fn asinhl(__x: u128) -> u128;
}
extern "C" {
    pub fn __asinhl(__x: u128) -> u128;
}
extern "C" {
    pub fn atanhl(__x: u128) -> u128;
}
extern "C" {
    pub fn __atanhl(__x: u128) -> u128;
}
extern "C" {
    pub fn expl(__x: u128) -> u128;
}
extern "C" {
    pub fn __expl(__x: u128) -> u128;
}
extern "C" {
    pub fn frexpl(__x: u128, __exponent: *mut cty::c_int) -> u128;
}
extern "C" {
    pub fn __frexpl(__x: u128, __exponent: *mut cty::c_int) -> u128;
}
extern "C" {
    pub fn ldexpl(__x: u128, __exponent: cty::c_int) -> u128;
}
extern "C" {
    pub fn __ldexpl(__x: u128, __exponent: cty::c_int) -> u128;
}
extern "C" {
    pub fn logl(__x: u128) -> u128;
}
extern "C" {
    pub fn __logl(__x: u128) -> u128;
}
extern "C" {
    pub fn log10l(__x: u128) -> u128;
}
extern "C" {
    pub fn __log10l(__x: u128) -> u128;
}
extern "C" {
    pub fn modfl(__x: u128, __iptr: *mut u128) -> u128;
}
extern "C" {
    pub fn __modfl(__x: u128, __iptr: *mut u128) -> u128;
}
extern "C" {
    pub fn expm1l(__x: u128) -> u128;
}
extern "C" {
    pub fn __expm1l(__x: u128) -> u128;
}
extern "C" {
    pub fn log1pl(__x: u128) -> u128;
}
extern "C" {
    pub fn __log1pl(__x: u128) -> u128;
}
extern "C" {
    pub fn logbl(__x: u128) -> u128;
}
extern "C" {
    pub fn __logbl(__x: u128) -> u128;
}
extern "C" {
    pub fn exp2l(__x: u128) -> u128;
}
extern "C" {
    pub fn __exp2l(__x: u128) -> u128;
}
extern "C" {
    pub fn log2l(__x: u128) -> u128;
}
extern "C" {
    pub fn __log2l(__x: u128) -> u128;
}
extern "C" {
    pub fn powl(__x: u128, __y: u128) -> u128;
}
extern "C" {
    pub fn __powl(__x: u128, __y: u128) -> u128;
}
extern "C" {
    pub fn sqrtl(__x: u128) -> u128;
}
extern "C" {
    pub fn __sqrtl(__x: u128) -> u128;
}
extern "C" {
    pub fn hypotl(__x: u128, __y: u128) -> u128;
}
extern "C" {
    pub fn __hypotl(__x: u128, __y: u128) -> u128;
}
extern "C" {
    pub fn cbrtl(__x: u128) -> u128;
}
extern "C" {
    pub fn __cbrtl(__x: u128) -> u128;
}
extern "C" {
    pub fn ceill(__x: u128) -> u128;
}
extern "C" {
    pub fn __ceill(__x: u128) -> u128;
}
extern "C" {
    pub fn fabsl(__x: u128) -> u128;
}
extern "C" {
    pub fn __fabsl(__x: u128) -> u128;
}
extern "C" {
    pub fn floorl(__x: u128) -> u128;
}
extern "C" {
    pub fn __floorl(__x: u128) -> u128;
}
extern "C" {
    pub fn fmodl(__x: u128, __y: u128) -> u128;
}
extern "C" {
    pub fn __fmodl(__x: u128, __y: u128) -> u128;
}
extern "C" {
    pub fn isinfl(__value: u128) -> cty::c_int;
}
extern "C" {
    pub fn finitel(__value: u128) -> cty::c_int;
}
extern "C" {
    pub fn dreml(__x: u128, __y: u128) -> u128;
}
extern "C" {
    pub fn __dreml(__x: u128, __y: u128) -> u128;
}
extern "C" {
    pub fn significandl(__x: u128) -> u128;
}
extern "C" {
    pub fn __significandl(__x: u128) -> u128;
}
extern "C" {
    pub fn copysignl(__x: u128, __y: u128) -> u128;
}
extern "C" {
    pub fn __copysignl(__x: u128, __y: u128) -> u128;
}
extern "C" {
    pub fn nanl(__tagb: *const cty::c_char) -> u128;
}
extern "C" {
    pub fn __nanl(__tagb: *const cty::c_char) -> u128;
}
extern "C" {
    pub fn isnanl(__value: u128) -> cty::c_int;
}
extern "C" {
    pub fn j0l(arg1: u128) -> u128;
}
extern "C" {
    pub fn __j0l(arg1: u128) -> u128;
}
extern "C" {
    pub fn j1l(arg1: u128) -> u128;
}
extern "C" {
    pub fn __j1l(arg1: u128) -> u128;
}
extern "C" {
    pub fn jnl(arg1: cty::c_int, arg2: u128) -> u128;
}
extern "C" {
    pub fn __jnl(arg1: cty::c_int, arg2: u128) -> u128;
}
extern "C" {
    pub fn y0l(arg1: u128) -> u128;
}
extern "C" {
    pub fn __y0l(arg1: u128) -> u128;
}
extern "C" {
    pub fn y1l(arg1: u128) -> u128;
}
extern "C" {
    pub fn __y1l(arg1: u128) -> u128;
}
extern "C" {
    pub fn ynl(arg1: cty::c_int, arg2: u128) -> u128;
}
extern "C" {
    pub fn __ynl(arg1: cty::c_int, arg2: u128) -> u128;
}
extern "C" {
    pub fn erfl(arg1: u128) -> u128;
}
extern "C" {
    pub fn __erfl(arg1: u128) -> u128;
}
extern "C" {
    pub fn erfcl(arg1: u128) -> u128;
}
extern "C" {
    pub fn __erfcl(arg1: u128) -> u128;
}
extern "C" {
    pub fn lgammal(arg1: u128) -> u128;
}
extern "C" {
    pub fn __lgammal(arg1: u128) -> u128;
}
extern "C" {
    pub fn tgammal(arg1: u128) -> u128;
}
extern "C" {
    pub fn __tgammal(arg1: u128) -> u128;
}
extern "C" {
    pub fn gammal(arg1: u128) -> u128;
}
extern "C" {
    pub fn __gammal(arg1: u128) -> u128;
}
extern "C" {
    pub fn lgammal_r(arg1: u128, __signgamp: *mut cty::c_int) -> u128;
}
extern "C" {
    pub fn __lgammal_r(arg1: u128, __signgamp: *mut cty::c_int) -> u128;
}
extern "C" {
    pub fn rintl(__x: u128) -> u128;
}
extern "C" {
    pub fn __rintl(__x: u128) -> u128;
}
extern "C" {
    pub fn nextafterl(__x: u128, __y: u128) -> u128;
}
extern "C" {
    pub fn __nextafterl(__x: u128, __y: u128) -> u128;
}
extern "C" {
    pub fn nexttowardl(__x: u128, __y: u128) -> u128;
}
extern "C" {
    pub fn __nexttowardl(__x: u128, __y: u128) -> u128;
}
extern "C" {
    pub fn remainderl(__x: u128, __y: u128) -> u128;
}
extern "C" {
    pub fn __remainderl(__x: u128, __y: u128) -> u128;
}
extern "C" {
    pub fn scalbnl(__x: u128, __n: cty::c_int) -> u128;
}
extern "C" {
    pub fn __scalbnl(__x: u128, __n: cty::c_int) -> u128;
}
extern "C" {
    pub fn ilogbl(__x: u128) -> cty::c_int;
}
extern "C" {
    pub fn __ilogbl(__x: u128) -> cty::c_int;
}
extern "C" {
    pub fn scalblnl(__x: u128, __n: cty::c_long) -> u128;
}
extern "C" {
    pub fn __scalblnl(__x: u128, __n: cty::c_long) -> u128;
}
extern "C" {
    pub fn nearbyintl(__x: u128) -> u128;
}
extern "C" {
    pub fn __nearbyintl(__x: u128) -> u128;
}
extern "C" {
    pub fn roundl(__x: u128) -> u128;
}
extern "C" {
    pub fn __roundl(__x: u128) -> u128;
}
extern "C" {
    pub fn truncl(__x: u128) -> u128;
}
extern "C" {
    pub fn __truncl(__x: u128) -> u128;
}
extern "C" {
    pub fn remquol(__x: u128, __y: u128, __quo: *mut cty::c_int) -> u128;
}
extern "C" {
    pub fn __remquol(__x: u128, __y: u128, __quo: *mut cty::c_int) -> u128;
}
extern "C" {
    pub fn lrintl(__x: u128) -> cty::c_long;
}
extern "C" {
    pub fn __lrintl(__x: u128) -> cty::c_long;
}
extern "C" {
    pub fn llrintl(__x: u128) -> cty::c_longlong;
}
extern "C" {
    pub fn __llrintl(__x: u128) -> cty::c_longlong;
}
extern "C" {
    pub fn lroundl(__x: u128) -> cty::c_long;
}
extern "C" {
    pub fn __lroundl(__x: u128) -> cty::c_long;
}
extern "C" {
    pub fn llroundl(__x: u128) -> cty::c_longlong;
}
extern "C" {
    pub fn __llroundl(__x: u128) -> cty::c_longlong;
}
extern "C" {
    pub fn fdiml(__x: u128, __y: u128) -> u128;
}
extern "C" {
    pub fn __fdiml(__x: u128, __y: u128) -> u128;
}
extern "C" {
    pub fn fmaxl(__x: u128, __y: u128) -> u128;
}
extern "C" {
    pub fn __fmaxl(__x: u128, __y: u128) -> u128;
}
extern "C" {
    pub fn fminl(__x: u128, __y: u128) -> u128;
}
extern "C" {
    pub fn __fminl(__x: u128, __y: u128) -> u128;
}
extern "C" {
    pub fn fmal(__x: u128, __y: u128, __z: u128) -> u128;
}
extern "C" {
    pub fn __fmal(__x: u128, __y: u128, __z: u128) -> u128;
}
extern "C" {
    pub fn scalbl(__x: u128, __n: u128) -> u128;
}
extern "C" {
    pub fn __scalbl(__x: u128, __n: u128) -> u128;
}
pub const FP_NAN: _bindgen_ty_4 = 0;
pub const FP_INFINITE: _bindgen_ty_4 = 1;
pub const FP_ZERO: _bindgen_ty_4 = 2;
pub const FP_SUBNORMAL: _bindgen_ty_4 = 3;
pub const FP_NORMAL: _bindgen_ty_4 = 4;
pub type _bindgen_ty_4 = u32;
pub const tpad_arrow_TPAD_ARROW_NONE: tpad_arrow = 0;
pub const tpad_arrow_TPAD_ARROW_UP: tpad_arrow = 1;
pub const tpad_arrow_TPAD_ARROW_UPRIGHT: tpad_arrow = 2;
pub const tpad_arrow_TPAD_ARROW_RIGHT: tpad_arrow = 3;
pub const tpad_arrow_TPAD_ARROW_RIGHTDOWN: tpad_arrow = 4;
pub const tpad_arrow_TPAD_ARROW_DOWN: tpad_arrow = 5;
pub const tpad_arrow_TPAD_ARROW_DOWNLEFT: tpad_arrow = 6;
pub const tpad_arrow_TPAD_ARROW_LEFT: tpad_arrow = 7;
pub const tpad_arrow_TPAD_ARROW_LEFTUP: tpad_arrow = 8;
pub const tpad_arrow_TPAD_ARROW_CLICK: tpad_arrow = 9;
#[doc = " Keys (key=(offset, 2^bit #)"]
pub type tpad_arrow = u32;
pub use self::tpad_arrow as tpad_arrow_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct t_key {
    pub row: cty::c_int,
    pub col: cty::c_int,
    pub tpad_row: cty::c_int,
    pub tpad_col: cty::c_int,
    pub tpad_arrow: tpad_arrow_t,
}
#[test]
fn bindgen_test_layout_t_key() {
    assert_eq!(
        ::core::mem::size_of::<t_key>(),
        20usize,
        concat!("Size of: ", stringify!(t_key))
    );
    assert_eq!(
        ::core::mem::align_of::<t_key>(),
        4usize,
        concat!("Alignment of ", stringify!(t_key))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<t_key>())).row as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(t_key),
            "::",
            stringify!(row)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<t_key>())).col as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(t_key),
            "::",
            stringify!(col)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<t_key>())).tpad_row as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(t_key),
            "::",
            stringify!(tpad_row)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<t_key>())).tpad_col as *const _ as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(t_key),
            "::",
            stringify!(tpad_col)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<t_key>())).tpad_arrow as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(t_key),
            "::",
            stringify!(tpad_arrow)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct device {
    _unused: [u8; 0],
}
pub type device_t = *mut device;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct clist {
    pub c_cc: cty::c_int,
    pub c_cbcount: cty::c_int,
    pub c_cbmax: cty::c_int,
    pub c_cbreserved: cty::c_int,
    pub c_cf: *mut cty::c_char,
    pub c_cl: *mut cty::c_char,
}
#[test]
fn bindgen_test_layout_clist() {
    assert_eq!(
        ::core::mem::size_of::<clist>(),
        32usize,
        concat!("Size of: ", stringify!(clist))
    );
    assert_eq!(
        ::core::mem::align_of::<clist>(),
        8usize,
        concat!("Alignment of ", stringify!(clist))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<clist>())).c_cc as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(clist),
            "::",
            stringify!(c_cc)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<clist>())).c_cbcount as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(clist),
            "::",
            stringify!(c_cbcount)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<clist>())).c_cbmax as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(clist),
            "::",
            stringify!(c_cbmax)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<clist>())).c_cbreserved as *const _ as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(clist),
            "::",
            stringify!(c_cbreserved)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<clist>())).c_cf as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(clist),
            "::",
            stringify!(c_cf)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<clist>())).c_cl as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(clist),
            "::",
            stringify!(c_cl)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct timezone {
    pub tz_minuteswest: cty::c_int,
    pub tz_dsttime: cty::c_int,
}
#[test]
fn bindgen_test_layout_timezone() {
    assert_eq!(
        ::core::mem::size_of::<timezone>(),
        8usize,
        concat!("Size of: ", stringify!(timezone))
    );
    assert_eq!(
        ::core::mem::align_of::<timezone>(),
        4usize,
        concat!("Alignment of ", stringify!(timezone))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<timezone>())).tz_minuteswest as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(timezone),
            "::",
            stringify!(tz_minuteswest)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<timezone>())).tz_dsttime as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(timezone),
            "::",
            stringify!(tz_dsttime)
        )
    );
}
pub type __timezone_ptr_t = *mut timezone;
extern "C" {
    pub fn gettimeofday(__tv: *mut timeval, __tz: __timezone_ptr_t) -> cty::c_int;
}
extern "C" {
    pub fn settimeofday(__tv: *const timeval, __tz: *const timezone) -> cty::c_int;
}
extern "C" {
    pub fn adjtime(__delta: *const timeval, __olddelta: *mut timeval) -> cty::c_int;
}
pub const __itimer_which_ITIMER_REAL: __itimer_which = 0;
pub const __itimer_which_ITIMER_VIRTUAL: __itimer_which = 1;
pub const __itimer_which_ITIMER_PROF: __itimer_which = 2;
pub type __itimer_which = u32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct itimerval {
    pub it_interval: timeval,
    pub it_value: timeval,
}
#[test]
fn bindgen_test_layout_itimerval() {
    assert_eq!(
        ::core::mem::size_of::<itimerval>(),
        32usize,
        concat!("Size of: ", stringify!(itimerval))
    );
    assert_eq!(
        ::core::mem::align_of::<itimerval>(),
        8usize,
        concat!("Alignment of ", stringify!(itimerval))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<itimerval>())).it_interval as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(itimerval),
            "::",
            stringify!(it_interval)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<itimerval>())).it_value as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(itimerval),
            "::",
            stringify!(it_value)
        )
    );
}
pub type __itimer_which_t = cty::c_int;
extern "C" {
    pub fn getitimer(__which: __itimer_which_t, __value: *mut itimerval) -> cty::c_int;
}
extern "C" {
    pub fn setitimer(
        __which: __itimer_which_t,
        __new: *const itimerval,
        __old: *mut itimerval,
    ) -> cty::c_int;
}
extern "C" {
    pub fn utimes(__file: *const cty::c_char, __tvp: *const timeval) -> cty::c_int;
}
extern "C" {
    pub fn lutimes(__file: *const cty::c_char, __tvp: *const timeval) -> cty::c_int;
}
extern "C" {
    pub fn futimes(__fd: cty::c_int, __tvp: *const timeval) -> cty::c_int;
}
pub type uByte = u_int8_t;
pub type uWord = [u_int8_t; 2usize];
pub type uDWord = [u_int8_t; 4usize];
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct usb_device_request_t {
    pub bmRequestType: uByte,
    pub bRequest: uByte,
    pub wValue: uWord,
    pub wIndex: uWord,
    pub wLength: uWord,
}
#[test]
fn bindgen_test_layout_usb_device_request_t() {
    assert_eq!(
        ::core::mem::size_of::<usb_device_request_t>(),
        8usize,
        concat!("Size of: ", stringify!(usb_device_request_t))
    );
    assert_eq!(
        ::core::mem::align_of::<usb_device_request_t>(),
        1usize,
        concat!("Alignment of ", stringify!(usb_device_request_t))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_device_request_t>())).bmRequestType as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_request_t),
            "::",
            stringify!(bmRequestType)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_device_request_t>())).bRequest as *const _ as usize },
        1usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_request_t),
            "::",
            stringify!(bRequest)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_device_request_t>())).wValue as *const _ as usize },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_request_t),
            "::",
            stringify!(wValue)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_device_request_t>())).wIndex as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_request_t),
            "::",
            stringify!(wIndex)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_device_request_t>())).wLength as *const _ as usize },
        6usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_request_t),
            "::",
            stringify!(wLength)
        )
    );
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct usb_descriptor_t {
    pub bLength: uByte,
    pub bDescriptorType: uByte,
    pub bDescriptorSubtype: uByte,
}
#[test]
fn bindgen_test_layout_usb_descriptor_t() {
    assert_eq!(
        ::core::mem::size_of::<usb_descriptor_t>(),
        3usize,
        concat!("Size of: ", stringify!(usb_descriptor_t))
    );
    assert_eq!(
        ::core::mem::align_of::<usb_descriptor_t>(),
        1usize,
        concat!("Alignment of ", stringify!(usb_descriptor_t))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_descriptor_t>())).bLength as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_descriptor_t),
            "::",
            stringify!(bLength)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_descriptor_t>())).bDescriptorType as *const _ as usize
        },
        1usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_descriptor_t),
            "::",
            stringify!(bDescriptorType)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_descriptor_t>())).bDescriptorSubtype as *const _ as usize
        },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_descriptor_t),
            "::",
            stringify!(bDescriptorSubtype)
        )
    );
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct usb_device_descriptor_t {
    pub bLength: uByte,
    pub bDescriptorType: uByte,
    pub bcdUSB: uWord,
    pub bDeviceClass: uByte,
    pub bDeviceSubClass: uByte,
    pub bDeviceProtocol: uByte,
    pub bMaxPacketSize: uByte,
    pub idVendor: uWord,
    pub idProduct: uWord,
    pub bcdDevice: uWord,
    pub iManufacturer: uByte,
    pub iProduct: uByte,
    pub iSerialNumber: uByte,
    pub bNumConfigurations: uByte,
}
#[test]
fn bindgen_test_layout_usb_device_descriptor_t() {
    assert_eq!(
        ::core::mem::size_of::<usb_device_descriptor_t>(),
        18usize,
        concat!("Size of: ", stringify!(usb_device_descriptor_t))
    );
    assert_eq!(
        ::core::mem::align_of::<usb_device_descriptor_t>(),
        1usize,
        concat!("Alignment of ", stringify!(usb_device_descriptor_t))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_device_descriptor_t>())).bLength as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_descriptor_t),
            "::",
            stringify!(bLength)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_device_descriptor_t>())).bDescriptorType as *const _
                as usize
        },
        1usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_descriptor_t),
            "::",
            stringify!(bDescriptorType)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_device_descriptor_t>())).bcdUSB as *const _ as usize },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_descriptor_t),
            "::",
            stringify!(bcdUSB)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_device_descriptor_t>())).bDeviceClass as *const _ as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_descriptor_t),
            "::",
            stringify!(bDeviceClass)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_device_descriptor_t>())).bDeviceSubClass as *const _
                as usize
        },
        5usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_descriptor_t),
            "::",
            stringify!(bDeviceSubClass)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_device_descriptor_t>())).bDeviceProtocol as *const _
                as usize
        },
        6usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_descriptor_t),
            "::",
            stringify!(bDeviceProtocol)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_device_descriptor_t>())).bMaxPacketSize as *const _ as usize
        },
        7usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_descriptor_t),
            "::",
            stringify!(bMaxPacketSize)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_device_descriptor_t>())).idVendor as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_descriptor_t),
            "::",
            stringify!(idVendor)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_device_descriptor_t>())).idProduct as *const _ as usize
        },
        10usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_descriptor_t),
            "::",
            stringify!(idProduct)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_device_descriptor_t>())).bcdDevice as *const _ as usize
        },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_descriptor_t),
            "::",
            stringify!(bcdDevice)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_device_descriptor_t>())).iManufacturer as *const _ as usize
        },
        14usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_descriptor_t),
            "::",
            stringify!(iManufacturer)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_device_descriptor_t>())).iProduct as *const _ as usize
        },
        15usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_descriptor_t),
            "::",
            stringify!(iProduct)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_device_descriptor_t>())).iSerialNumber as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_descriptor_t),
            "::",
            stringify!(iSerialNumber)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_device_descriptor_t>())).bNumConfigurations as *const _
                as usize
        },
        17usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_descriptor_t),
            "::",
            stringify!(bNumConfigurations)
        )
    );
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct usb_config_descriptor_t {
    pub bLength: uByte,
    pub bDescriptorType: uByte,
    pub wTotalLength: uWord,
    pub bNumInterface: uByte,
    pub bConfigurationValue: uByte,
    pub iConfiguration: uByte,
    pub bmAttributes: uByte,
    pub bMaxPower: uByte,
}
#[test]
fn bindgen_test_layout_usb_config_descriptor_t() {
    assert_eq!(
        ::core::mem::size_of::<usb_config_descriptor_t>(),
        9usize,
        concat!("Size of: ", stringify!(usb_config_descriptor_t))
    );
    assert_eq!(
        ::core::mem::align_of::<usb_config_descriptor_t>(),
        1usize,
        concat!("Alignment of ", stringify!(usb_config_descriptor_t))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_config_descriptor_t>())).bLength as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_config_descriptor_t),
            "::",
            stringify!(bLength)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_config_descriptor_t>())).bDescriptorType as *const _
                as usize
        },
        1usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_config_descriptor_t),
            "::",
            stringify!(bDescriptorType)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_config_descriptor_t>())).wTotalLength as *const _ as usize
        },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_config_descriptor_t),
            "::",
            stringify!(wTotalLength)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_config_descriptor_t>())).bNumInterface as *const _ as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_config_descriptor_t),
            "::",
            stringify!(bNumInterface)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_config_descriptor_t>())).bConfigurationValue as *const _
                as usize
        },
        5usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_config_descriptor_t),
            "::",
            stringify!(bConfigurationValue)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_config_descriptor_t>())).iConfiguration as *const _ as usize
        },
        6usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_config_descriptor_t),
            "::",
            stringify!(iConfiguration)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_config_descriptor_t>())).bmAttributes as *const _ as usize
        },
        7usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_config_descriptor_t),
            "::",
            stringify!(bmAttributes)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_config_descriptor_t>())).bMaxPower as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_config_descriptor_t),
            "::",
            stringify!(bMaxPower)
        )
    );
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct usb_interface_descriptor_t {
    pub bLength: uByte,
    pub bDescriptorType: uByte,
    pub bInterfaceNumber: uByte,
    pub bAlternateSetting: uByte,
    pub bNumEndpoints: uByte,
    pub bInterfaceClass: uByte,
    pub bInterfaceSubClass: uByte,
    pub bInterfaceProtocol: uByte,
    pub iInterface: uByte,
}
#[test]
fn bindgen_test_layout_usb_interface_descriptor_t() {
    assert_eq!(
        ::core::mem::size_of::<usb_interface_descriptor_t>(),
        9usize,
        concat!("Size of: ", stringify!(usb_interface_descriptor_t))
    );
    assert_eq!(
        ::core::mem::align_of::<usb_interface_descriptor_t>(),
        1usize,
        concat!("Alignment of ", stringify!(usb_interface_descriptor_t))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_interface_descriptor_t>())).bLength as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_interface_descriptor_t),
            "::",
            stringify!(bLength)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_interface_descriptor_t>())).bDescriptorType as *const _
                as usize
        },
        1usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_interface_descriptor_t),
            "::",
            stringify!(bDescriptorType)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_interface_descriptor_t>())).bInterfaceNumber as *const _
                as usize
        },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_interface_descriptor_t),
            "::",
            stringify!(bInterfaceNumber)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_interface_descriptor_t>())).bAlternateSetting as *const _
                as usize
        },
        3usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_interface_descriptor_t),
            "::",
            stringify!(bAlternateSetting)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_interface_descriptor_t>())).bNumEndpoints as *const _
                as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_interface_descriptor_t),
            "::",
            stringify!(bNumEndpoints)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_interface_descriptor_t>())).bInterfaceClass as *const _
                as usize
        },
        5usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_interface_descriptor_t),
            "::",
            stringify!(bInterfaceClass)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_interface_descriptor_t>())).bInterfaceSubClass as *const _
                as usize
        },
        6usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_interface_descriptor_t),
            "::",
            stringify!(bInterfaceSubClass)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_interface_descriptor_t>())).bInterfaceProtocol as *const _
                as usize
        },
        7usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_interface_descriptor_t),
            "::",
            stringify!(bInterfaceProtocol)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_interface_descriptor_t>())).iInterface as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_interface_descriptor_t),
            "::",
            stringify!(iInterface)
        )
    );
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct usb_endpoint_descriptor_t {
    pub bLength: uByte,
    pub bDescriptorType: uByte,
    pub bEndpointAddress: uByte,
    pub bmAttributes: uByte,
    pub wMaxPacketSize: uWord,
    pub bInterval: uByte,
}
#[test]
fn bindgen_test_layout_usb_endpoint_descriptor_t() {
    assert_eq!(
        ::core::mem::size_of::<usb_endpoint_descriptor_t>(),
        7usize,
        concat!("Size of: ", stringify!(usb_endpoint_descriptor_t))
    );
    assert_eq!(
        ::core::mem::align_of::<usb_endpoint_descriptor_t>(),
        1usize,
        concat!("Alignment of ", stringify!(usb_endpoint_descriptor_t))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_endpoint_descriptor_t>())).bLength as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_endpoint_descriptor_t),
            "::",
            stringify!(bLength)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_endpoint_descriptor_t>())).bDescriptorType as *const _
                as usize
        },
        1usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_endpoint_descriptor_t),
            "::",
            stringify!(bDescriptorType)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_endpoint_descriptor_t>())).bEndpointAddress as *const _
                as usize
        },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_endpoint_descriptor_t),
            "::",
            stringify!(bEndpointAddress)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_endpoint_descriptor_t>())).bmAttributes as *const _ as usize
        },
        3usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_endpoint_descriptor_t),
            "::",
            stringify!(bmAttributes)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_endpoint_descriptor_t>())).wMaxPacketSize as *const _
                as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_endpoint_descriptor_t),
            "::",
            stringify!(wMaxPacketSize)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_endpoint_descriptor_t>())).bInterval as *const _ as usize
        },
        6usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_endpoint_descriptor_t),
            "::",
            stringify!(bInterval)
        )
    );
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct usb_string_descriptor_t {
    pub bLength: uByte,
    pub bDescriptorType: uByte,
    pub bString: [uWord; 127usize],
}
#[test]
fn bindgen_test_layout_usb_string_descriptor_t() {
    assert_eq!(
        ::core::mem::size_of::<usb_string_descriptor_t>(),
        256usize,
        concat!("Size of: ", stringify!(usb_string_descriptor_t))
    );
    assert_eq!(
        ::core::mem::align_of::<usb_string_descriptor_t>(),
        1usize,
        concat!("Alignment of ", stringify!(usb_string_descriptor_t))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_string_descriptor_t>())).bLength as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_string_descriptor_t),
            "::",
            stringify!(bLength)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_string_descriptor_t>())).bDescriptorType as *const _
                as usize
        },
        1usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_string_descriptor_t),
            "::",
            stringify!(bDescriptorType)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_string_descriptor_t>())).bString as *const _ as usize
        },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_string_descriptor_t),
            "::",
            stringify!(bString)
        )
    );
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct usb_hub_descriptor_t {
    pub bDescLength: uByte,
    pub bDescriptorType: uByte,
    pub bNbrPorts: uByte,
    pub wHubCharacteristics: uWord,
    pub bPwrOn2PwrGood: uByte,
    pub bHubContrCurrent: uByte,
    pub DeviceRemovable: [uByte; 32usize],
    pub PortPowerCtrlMask: [uByte; 1usize],
}
#[test]
fn bindgen_test_layout_usb_hub_descriptor_t() {
    assert_eq!(
        ::core::mem::size_of::<usb_hub_descriptor_t>(),
        40usize,
        concat!("Size of: ", stringify!(usb_hub_descriptor_t))
    );
    assert_eq!(
        ::core::mem::align_of::<usb_hub_descriptor_t>(),
        1usize,
        concat!("Alignment of ", stringify!(usb_hub_descriptor_t))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_hub_descriptor_t>())).bDescLength as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_hub_descriptor_t),
            "::",
            stringify!(bDescLength)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_hub_descriptor_t>())).bDescriptorType as *const _ as usize
        },
        1usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_hub_descriptor_t),
            "::",
            stringify!(bDescriptorType)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_hub_descriptor_t>())).bNbrPorts as *const _ as usize },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_hub_descriptor_t),
            "::",
            stringify!(bNbrPorts)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_hub_descriptor_t>())).wHubCharacteristics as *const _
                as usize
        },
        3usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_hub_descriptor_t),
            "::",
            stringify!(wHubCharacteristics)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_hub_descriptor_t>())).bPwrOn2PwrGood as *const _ as usize
        },
        5usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_hub_descriptor_t),
            "::",
            stringify!(bPwrOn2PwrGood)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_hub_descriptor_t>())).bHubContrCurrent as *const _ as usize
        },
        6usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_hub_descriptor_t),
            "::",
            stringify!(bHubContrCurrent)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_hub_descriptor_t>())).DeviceRemovable as *const _ as usize
        },
        7usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_hub_descriptor_t),
            "::",
            stringify!(DeviceRemovable)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_hub_descriptor_t>())).PortPowerCtrlMask as *const _ as usize
        },
        39usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_hub_descriptor_t),
            "::",
            stringify!(PortPowerCtrlMask)
        )
    );
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct usb_device_qualifier_t {
    pub bLength: uByte,
    pub bDescriptorType: uByte,
    pub bcdUSB: uWord,
    pub bDeviceClass: uByte,
    pub bDeviceSubClass: uByte,
    pub bDeviceProtocol: uByte,
    pub bMaxPacketSize0: uByte,
    pub bNumConfigurations: uByte,
    pub bReserved: uByte,
}
#[test]
fn bindgen_test_layout_usb_device_qualifier_t() {
    assert_eq!(
        ::core::mem::size_of::<usb_device_qualifier_t>(),
        10usize,
        concat!("Size of: ", stringify!(usb_device_qualifier_t))
    );
    assert_eq!(
        ::core::mem::align_of::<usb_device_qualifier_t>(),
        1usize,
        concat!("Alignment of ", stringify!(usb_device_qualifier_t))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_device_qualifier_t>())).bLength as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_qualifier_t),
            "::",
            stringify!(bLength)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_device_qualifier_t>())).bDescriptorType as *const _ as usize
        },
        1usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_qualifier_t),
            "::",
            stringify!(bDescriptorType)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_device_qualifier_t>())).bcdUSB as *const _ as usize },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_qualifier_t),
            "::",
            stringify!(bcdUSB)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_device_qualifier_t>())).bDeviceClass as *const _ as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_qualifier_t),
            "::",
            stringify!(bDeviceClass)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_device_qualifier_t>())).bDeviceSubClass as *const _ as usize
        },
        5usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_qualifier_t),
            "::",
            stringify!(bDeviceSubClass)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_device_qualifier_t>())).bDeviceProtocol as *const _ as usize
        },
        6usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_qualifier_t),
            "::",
            stringify!(bDeviceProtocol)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_device_qualifier_t>())).bMaxPacketSize0 as *const _ as usize
        },
        7usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_qualifier_t),
            "::",
            stringify!(bMaxPacketSize0)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_device_qualifier_t>())).bNumConfigurations as *const _
                as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_qualifier_t),
            "::",
            stringify!(bNumConfigurations)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_device_qualifier_t>())).bReserved as *const _ as usize
        },
        9usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_qualifier_t),
            "::",
            stringify!(bReserved)
        )
    );
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct usb_otg_descriptor_t {
    pub bLength: uByte,
    pub bDescriptorType: uByte,
    pub bmAttributes: uByte,
}
#[test]
fn bindgen_test_layout_usb_otg_descriptor_t() {
    assert_eq!(
        ::core::mem::size_of::<usb_otg_descriptor_t>(),
        3usize,
        concat!("Size of: ", stringify!(usb_otg_descriptor_t))
    );
    assert_eq!(
        ::core::mem::align_of::<usb_otg_descriptor_t>(),
        1usize,
        concat!("Alignment of ", stringify!(usb_otg_descriptor_t))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_otg_descriptor_t>())).bLength as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_otg_descriptor_t),
            "::",
            stringify!(bLength)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_otg_descriptor_t>())).bDescriptorType as *const _ as usize
        },
        1usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_otg_descriptor_t),
            "::",
            stringify!(bDescriptorType)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_otg_descriptor_t>())).bmAttributes as *const _ as usize
        },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_otg_descriptor_t),
            "::",
            stringify!(bmAttributes)
        )
    );
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct usb_status_t {
    pub wStatus: uWord,
}
#[test]
fn bindgen_test_layout_usb_status_t() {
    assert_eq!(
        ::core::mem::size_of::<usb_status_t>(),
        2usize,
        concat!("Size of: ", stringify!(usb_status_t))
    );
    assert_eq!(
        ::core::mem::align_of::<usb_status_t>(),
        1usize,
        concat!("Alignment of ", stringify!(usb_status_t))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_status_t>())).wStatus as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_status_t),
            "::",
            stringify!(wStatus)
        )
    );
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct usb_hub_status_t {
    pub wHubStatus: uWord,
    pub wHubChange: uWord,
}
#[test]
fn bindgen_test_layout_usb_hub_status_t() {
    assert_eq!(
        ::core::mem::size_of::<usb_hub_status_t>(),
        4usize,
        concat!("Size of: ", stringify!(usb_hub_status_t))
    );
    assert_eq!(
        ::core::mem::align_of::<usb_hub_status_t>(),
        1usize,
        concat!("Alignment of ", stringify!(usb_hub_status_t))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_hub_status_t>())).wHubStatus as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_hub_status_t),
            "::",
            stringify!(wHubStatus)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_hub_status_t>())).wHubChange as *const _ as usize },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_hub_status_t),
            "::",
            stringify!(wHubChange)
        )
    );
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct usb_port_status_t {
    pub wPortStatus: uWord,
    pub wPortChange: uWord,
}
#[test]
fn bindgen_test_layout_usb_port_status_t() {
    assert_eq!(
        ::core::mem::size_of::<usb_port_status_t>(),
        4usize,
        concat!("Size of: ", stringify!(usb_port_status_t))
    );
    assert_eq!(
        ::core::mem::align_of::<usb_port_status_t>(),
        1usize,
        concat!("Alignment of ", stringify!(usb_port_status_t))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_port_status_t>())).wPortStatus as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_port_status_t),
            "::",
            stringify!(wPortStatus)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_port_status_t>())).wPortChange as *const _ as usize },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_port_status_t),
            "::",
            stringify!(wPortChange)
        )
    );
}
#[doc = " ioctl() related stuff"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct usb_ctl_request {
    pub ucr_addr: cty::c_int,
    pub ucr_request: usb_device_request_t,
    pub ucr_data: *mut cty::c_void,
    pub ucr_flags: cty::c_int,
    pub ucr_actlen: cty::c_int,
}
#[test]
fn bindgen_test_layout_usb_ctl_request() {
    assert_eq!(
        ::core::mem::size_of::<usb_ctl_request>(),
        32usize,
        concat!("Size of: ", stringify!(usb_ctl_request))
    );
    assert_eq!(
        ::core::mem::align_of::<usb_ctl_request>(),
        8usize,
        concat!("Alignment of ", stringify!(usb_ctl_request))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_ctl_request>())).ucr_addr as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_ctl_request),
            "::",
            stringify!(ucr_addr)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_ctl_request>())).ucr_request as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_ctl_request),
            "::",
            stringify!(ucr_request)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_ctl_request>())).ucr_data as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_ctl_request),
            "::",
            stringify!(ucr_data)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_ctl_request>())).ucr_flags as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_ctl_request),
            "::",
            stringify!(ucr_flags)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_ctl_request>())).ucr_actlen as *const _ as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_ctl_request),
            "::",
            stringify!(ucr_actlen)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct usb_alt_interface {
    pub uai_config_index: cty::c_int,
    pub uai_interface_index: cty::c_int,
    pub uai_alt_no: cty::c_int,
}
#[test]
fn bindgen_test_layout_usb_alt_interface() {
    assert_eq!(
        ::core::mem::size_of::<usb_alt_interface>(),
        12usize,
        concat!("Size of: ", stringify!(usb_alt_interface))
    );
    assert_eq!(
        ::core::mem::align_of::<usb_alt_interface>(),
        4usize,
        concat!("Alignment of ", stringify!(usb_alt_interface))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_alt_interface>())).uai_config_index as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_alt_interface),
            "::",
            stringify!(uai_config_index)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_alt_interface>())).uai_interface_index as *const _ as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_alt_interface),
            "::",
            stringify!(uai_interface_index)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_alt_interface>())).uai_alt_no as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_alt_interface),
            "::",
            stringify!(uai_alt_no)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct usb_config_desc {
    pub ucd_config_index: cty::c_int,
    pub ucd_desc: usb_config_descriptor_t,
}
#[test]
fn bindgen_test_layout_usb_config_desc() {
    assert_eq!(
        ::core::mem::size_of::<usb_config_desc>(),
        16usize,
        concat!("Size of: ", stringify!(usb_config_desc))
    );
    assert_eq!(
        ::core::mem::align_of::<usb_config_desc>(),
        4usize,
        concat!("Alignment of ", stringify!(usb_config_desc))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_config_desc>())).ucd_config_index as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_config_desc),
            "::",
            stringify!(ucd_config_index)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_config_desc>())).ucd_desc as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_config_desc),
            "::",
            stringify!(ucd_desc)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct usb_interface_desc {
    pub uid_config_index: cty::c_int,
    pub uid_interface_index: cty::c_int,
    pub uid_alt_index: cty::c_int,
    pub uid_desc: usb_interface_descriptor_t,
}
#[test]
fn bindgen_test_layout_usb_interface_desc() {
    assert_eq!(
        ::core::mem::size_of::<usb_interface_desc>(),
        24usize,
        concat!("Size of: ", stringify!(usb_interface_desc))
    );
    assert_eq!(
        ::core::mem::align_of::<usb_interface_desc>(),
        4usize,
        concat!("Alignment of ", stringify!(usb_interface_desc))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_interface_desc>())).uid_config_index as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_interface_desc),
            "::",
            stringify!(uid_config_index)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_interface_desc>())).uid_interface_index as *const _ as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_interface_desc),
            "::",
            stringify!(uid_interface_index)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_interface_desc>())).uid_alt_index as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_interface_desc),
            "::",
            stringify!(uid_alt_index)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_interface_desc>())).uid_desc as *const _ as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_interface_desc),
            "::",
            stringify!(uid_desc)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct usb_endpoint_desc {
    pub ued_config_index: cty::c_int,
    pub ued_interface_index: cty::c_int,
    pub ued_alt_index: cty::c_int,
    pub ued_endpoint_index: cty::c_int,
    pub ued_desc: usb_endpoint_descriptor_t,
}
#[test]
fn bindgen_test_layout_usb_endpoint_desc() {
    assert_eq!(
        ::core::mem::size_of::<usb_endpoint_desc>(),
        24usize,
        concat!("Size of: ", stringify!(usb_endpoint_desc))
    );
    assert_eq!(
        ::core::mem::align_of::<usb_endpoint_desc>(),
        4usize,
        concat!("Alignment of ", stringify!(usb_endpoint_desc))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_endpoint_desc>())).ued_config_index as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_endpoint_desc),
            "::",
            stringify!(ued_config_index)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_endpoint_desc>())).ued_interface_index as *const _ as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_endpoint_desc),
            "::",
            stringify!(ued_interface_index)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_endpoint_desc>())).ued_alt_index as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_endpoint_desc),
            "::",
            stringify!(ued_alt_index)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_endpoint_desc>())).ued_endpoint_index as *const _ as usize
        },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_endpoint_desc),
            "::",
            stringify!(ued_endpoint_index)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_endpoint_desc>())).ued_desc as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_endpoint_desc),
            "::",
            stringify!(ued_desc)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct usb_full_desc {
    pub ufd_config_index: cty::c_int,
    pub ufd_size: u_int,
    pub ufd_data: *mut u_char,
}
#[test]
fn bindgen_test_layout_usb_full_desc() {
    assert_eq!(
        ::core::mem::size_of::<usb_full_desc>(),
        16usize,
        concat!("Size of: ", stringify!(usb_full_desc))
    );
    assert_eq!(
        ::core::mem::align_of::<usb_full_desc>(),
        8usize,
        concat!("Alignment of ", stringify!(usb_full_desc))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_full_desc>())).ufd_config_index as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_full_desc),
            "::",
            stringify!(ufd_config_index)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_full_desc>())).ufd_size as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_full_desc),
            "::",
            stringify!(ufd_size)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_full_desc>())).ufd_data as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_full_desc),
            "::",
            stringify!(ufd_data)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct usb_string_desc {
    pub usd_string_index: cty::c_int,
    pub usd_language_id: cty::c_int,
    pub usd_desc: usb_string_descriptor_t,
}
#[test]
fn bindgen_test_layout_usb_string_desc() {
    assert_eq!(
        ::core::mem::size_of::<usb_string_desc>(),
        264usize,
        concat!("Size of: ", stringify!(usb_string_desc))
    );
    assert_eq!(
        ::core::mem::align_of::<usb_string_desc>(),
        4usize,
        concat!("Alignment of ", stringify!(usb_string_desc))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_string_desc>())).usd_string_index as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_string_desc),
            "::",
            stringify!(usd_string_index)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_string_desc>())).usd_language_id as *const _ as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_string_desc),
            "::",
            stringify!(usd_language_id)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_string_desc>())).usd_desc as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_string_desc),
            "::",
            stringify!(usd_desc)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct usb_ctl_report_desc {
    pub ucrd_size: cty::c_int,
    pub ucrd_data: [u_char; 1024usize],
}
#[test]
fn bindgen_test_layout_usb_ctl_report_desc() {
    assert_eq!(
        ::core::mem::size_of::<usb_ctl_report_desc>(),
        1028usize,
        concat!("Size of: ", stringify!(usb_ctl_report_desc))
    );
    assert_eq!(
        ::core::mem::align_of::<usb_ctl_report_desc>(),
        4usize,
        concat!("Alignment of ", stringify!(usb_ctl_report_desc))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_ctl_report_desc>())).ucrd_size as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_ctl_report_desc),
            "::",
            stringify!(ucrd_size)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_ctl_report_desc>())).ucrd_data as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_ctl_report_desc),
            "::",
            stringify!(ucrd_data)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct usb_event_cookie_t {
    pub cookie: u_int32_t,
}
#[test]
fn bindgen_test_layout_usb_event_cookie_t() {
    assert_eq!(
        ::core::mem::size_of::<usb_event_cookie_t>(),
        4usize,
        concat!("Size of: ", stringify!(usb_event_cookie_t))
    );
    assert_eq!(
        ::core::mem::align_of::<usb_event_cookie_t>(),
        4usize,
        concat!("Alignment of ", stringify!(usb_event_cookie_t))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_event_cookie_t>())).cookie as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_event_cookie_t),
            "::",
            stringify!(cookie)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct usb_device_info {
    pub udi_bus: u_int8_t,
    pub udi_addr: u_int8_t,
    pub udi_cookie: usb_event_cookie_t,
    pub udi_product: [cty::c_char; 128usize],
    pub udi_vendor: [cty::c_char; 128usize],
    pub udi_release: [cty::c_char; 8usize],
    pub udi_productNo: u_int16_t,
    pub udi_vendorNo: u_int16_t,
    pub udi_releaseNo: u_int16_t,
    pub udi_class: u_int8_t,
    pub udi_subclass: u_int8_t,
    pub udi_protocol: u_int8_t,
    pub udi_config: u_int8_t,
    pub udi_speed: u_int8_t,
    pub udi_power: cty::c_int,
    pub udi_nports: cty::c_int,
    pub udi_devnames: [[cty::c_char; 16usize]; 4usize],
    pub udi_ports: [u_int8_t; 16usize],
}
#[test]
fn bindgen_test_layout_usb_device_info() {
    assert_eq!(
        ::core::mem::size_of::<usb_device_info>(),
        372usize,
        concat!("Size of: ", stringify!(usb_device_info))
    );
    assert_eq!(
        ::core::mem::align_of::<usb_device_info>(),
        4usize,
        concat!("Alignment of ", stringify!(usb_device_info))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_device_info>())).udi_bus as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_info),
            "::",
            stringify!(udi_bus)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_device_info>())).udi_addr as *const _ as usize },
        1usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_info),
            "::",
            stringify!(udi_addr)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_device_info>())).udi_cookie as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_info),
            "::",
            stringify!(udi_cookie)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_device_info>())).udi_product as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_info),
            "::",
            stringify!(udi_product)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_device_info>())).udi_vendor as *const _ as usize },
        136usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_info),
            "::",
            stringify!(udi_vendor)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_device_info>())).udi_release as *const _ as usize },
        264usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_info),
            "::",
            stringify!(udi_release)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_device_info>())).udi_productNo as *const _ as usize },
        272usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_info),
            "::",
            stringify!(udi_productNo)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_device_info>())).udi_vendorNo as *const _ as usize },
        274usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_info),
            "::",
            stringify!(udi_vendorNo)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_device_info>())).udi_releaseNo as *const _ as usize },
        276usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_info),
            "::",
            stringify!(udi_releaseNo)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_device_info>())).udi_class as *const _ as usize },
        278usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_info),
            "::",
            stringify!(udi_class)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_device_info>())).udi_subclass as *const _ as usize },
        279usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_info),
            "::",
            stringify!(udi_subclass)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_device_info>())).udi_protocol as *const _ as usize },
        280usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_info),
            "::",
            stringify!(udi_protocol)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_device_info>())).udi_config as *const _ as usize },
        281usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_info),
            "::",
            stringify!(udi_config)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_device_info>())).udi_speed as *const _ as usize },
        282usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_info),
            "::",
            stringify!(udi_speed)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_device_info>())).udi_power as *const _ as usize },
        284usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_info),
            "::",
            stringify!(udi_power)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_device_info>())).udi_nports as *const _ as usize },
        288usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_info),
            "::",
            stringify!(udi_nports)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_device_info>())).udi_devnames as *const _ as usize },
        292usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_info),
            "::",
            stringify!(udi_devnames)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_device_info>())).udi_ports as *const _ as usize },
        356usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_info),
            "::",
            stringify!(udi_ports)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct usb_ctl_report {
    pub ucr_report: cty::c_int,
    pub ucr_data: [u_char; 1024usize],
}
#[test]
fn bindgen_test_layout_usb_ctl_report() {
    assert_eq!(
        ::core::mem::size_of::<usb_ctl_report>(),
        1028usize,
        concat!("Size of: ", stringify!(usb_ctl_report))
    );
    assert_eq!(
        ::core::mem::align_of::<usb_ctl_report>(),
        4usize,
        concat!("Alignment of ", stringify!(usb_ctl_report))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_ctl_report>())).ucr_report as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_ctl_report),
            "::",
            stringify!(ucr_report)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_ctl_report>())).ucr_data as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_ctl_report),
            "::",
            stringify!(ucr_data)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct usb_device_stats {
    pub uds_requests: [u_long; 4usize],
}
#[test]
fn bindgen_test_layout_usb_device_stats() {
    assert_eq!(
        ::core::mem::size_of::<usb_device_stats>(),
        32usize,
        concat!("Size of: ", stringify!(usb_device_stats))
    );
    assert_eq!(
        ::core::mem::align_of::<usb_device_stats>(),
        8usize,
        concat!("Alignment of ", stringify!(usb_device_stats))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_device_stats>())).uds_requests as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_device_stats),
            "::",
            stringify!(uds_requests)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct usb_event {
    pub ue_type: cty::c_int,
    pub ue_time: timespec,
    pub u: usb_event__bindgen_ty_1,
}
#[repr(C)]
#[repr(align(4))]
#[derive(Copy, Clone)]
pub union usb_event__bindgen_ty_1 {
    pub ue_ctrlr: usb_event__bindgen_ty_1__bindgen_ty_1,
    pub ue_device: usb_device_info,
    pub ue_driver: usb_event__bindgen_ty_1__bindgen_ty_2,
    _bindgen_union_align: [u32; 93usize],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct usb_event__bindgen_ty_1__bindgen_ty_1 {
    pub ue_bus: cty::c_int,
}
#[test]
fn bindgen_test_layout_usb_event__bindgen_ty_1__bindgen_ty_1() {
    assert_eq!(
        ::core::mem::size_of::<usb_event__bindgen_ty_1__bindgen_ty_1>(),
        4usize,
        concat!(
            "Size of: ",
            stringify!(usb_event__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<usb_event__bindgen_ty_1__bindgen_ty_1>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(usb_event__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_event__bindgen_ty_1__bindgen_ty_1>())).ue_bus as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_event__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(ue_bus)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct usb_event__bindgen_ty_1__bindgen_ty_2 {
    pub ue_cookie: usb_event_cookie_t,
    pub ue_devname: [cty::c_char; 16usize],
}
#[test]
fn bindgen_test_layout_usb_event__bindgen_ty_1__bindgen_ty_2() {
    assert_eq!(
        ::core::mem::size_of::<usb_event__bindgen_ty_1__bindgen_ty_2>(),
        20usize,
        concat!(
            "Size of: ",
            stringify!(usb_event__bindgen_ty_1__bindgen_ty_2)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<usb_event__bindgen_ty_1__bindgen_ty_2>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(usb_event__bindgen_ty_1__bindgen_ty_2)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_event__bindgen_ty_1__bindgen_ty_2>())).ue_cookie as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_event__bindgen_ty_1__bindgen_ty_2),
            "::",
            stringify!(ue_cookie)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_event__bindgen_ty_1__bindgen_ty_2>())).ue_devname
                as *const _ as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_event__bindgen_ty_1__bindgen_ty_2),
            "::",
            stringify!(ue_devname)
        )
    );
}
#[test]
fn bindgen_test_layout_usb_event__bindgen_ty_1() {
    assert_eq!(
        ::core::mem::size_of::<usb_event__bindgen_ty_1>(),
        372usize,
        concat!("Size of: ", stringify!(usb_event__bindgen_ty_1))
    );
    assert_eq!(
        ::core::mem::align_of::<usb_event__bindgen_ty_1>(),
        4usize,
        concat!("Alignment of ", stringify!(usb_event__bindgen_ty_1))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_event__bindgen_ty_1>())).ue_ctrlr as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_event__bindgen_ty_1),
            "::",
            stringify!(ue_ctrlr)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_event__bindgen_ty_1>())).ue_device as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_event__bindgen_ty_1),
            "::",
            stringify!(ue_device)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_event__bindgen_ty_1>())).ue_driver as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_event__bindgen_ty_1),
            "::",
            stringify!(ue_driver)
        )
    );
}
#[test]
fn bindgen_test_layout_usb_event() {
    assert_eq!(
        ::core::mem::size_of::<usb_event>(),
        400usize,
        concat!("Size of: ", stringify!(usb_event))
    );
    assert_eq!(
        ::core::mem::align_of::<usb_event>(),
        8usize,
        concat!("Alignment of ", stringify!(usb_event))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_event>())).ue_type as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_event),
            "::",
            stringify!(ue_type)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_event>())).ue_time as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_event),
            "::",
            stringify!(ue_time)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_event>())).u as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_event),
            "::",
            stringify!(u)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct usbd_bus {
    _unused: [u8; 0],
}
pub type usbd_bus_handle = *mut usbd_bus;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct usbd_device {
    _unused: [u8; 0],
}
pub type usbd_device_handle = *mut usbd_device;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct usbd_interface {
    _unused: [u8; 0],
}
pub type usbd_interface_handle = *mut usbd_interface;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct usbd_pipe {
    _unused: [u8; 0],
}
pub type usbd_pipe_handle = *mut usbd_pipe;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct usbd_xfer {
    _unused: [u8; 0],
}
pub type usbd_xfer_handle = *mut usbd_xfer;
pub type usbd_private_handle = *mut cty::c_void;
pub const usbd_status_USBD_NORMAL_COMPLETION: usbd_status = 0;
pub const usbd_status_USBD_IN_PROGRESS: usbd_status = 1;
pub const usbd_status_USBD_PENDING_REQUESTS: usbd_status = 2;
pub const usbd_status_USBD_NOT_STARTED: usbd_status = 3;
pub const usbd_status_USBD_INVAL: usbd_status = 4;
pub const usbd_status_USBD_NOMEM: usbd_status = 5;
pub const usbd_status_USBD_CANCELLED: usbd_status = 6;
pub const usbd_status_USBD_BAD_ADDRESS: usbd_status = 7;
pub const usbd_status_USBD_IN_USE: usbd_status = 8;
pub const usbd_status_USBD_NO_ADDR: usbd_status = 9;
pub const usbd_status_USBD_SET_ADDR_FAILED: usbd_status = 10;
pub const usbd_status_USBD_NO_POWER: usbd_status = 11;
pub const usbd_status_USBD_TOO_DEEP: usbd_status = 12;
pub const usbd_status_USBD_IOERROR: usbd_status = 13;
pub const usbd_status_USBD_NOT_CONFIGURED: usbd_status = 14;
pub const usbd_status_USBD_TIMEOUT: usbd_status = 15;
pub const usbd_status_USBD_SHORT_XFER: usbd_status = 16;
pub const usbd_status_USBD_STALLED: usbd_status = 17;
pub const usbd_status_USBD_INTERRUPTED: usbd_status = 18;
pub const usbd_status_USBD_ERROR_MAX: usbd_status = 19;
pub type usbd_status = u32;
pub type usbd_callback = ::core::option::Option<
    unsafe extern "C" fn(arg1: usbd_xfer_handle, arg2: usbd_private_handle, arg3: usbd_status),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct usb_task {
    pub next: usb_task__bindgen_ty_1,
    pub fun: ::core::option::Option<unsafe extern "C" fn(arg1: *mut cty::c_void)>,
    pub arg: *mut cty::c_void,
    pub onqueue: cty::c_char,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct usb_task__bindgen_ty_1 {
    pub tqe_next: *mut usb_task,
    pub tqe_prev: *mut *mut usb_task,
}
#[test]
fn bindgen_test_layout_usb_task__bindgen_ty_1() {
    assert_eq!(
        ::core::mem::size_of::<usb_task__bindgen_ty_1>(),
        16usize,
        concat!("Size of: ", stringify!(usb_task__bindgen_ty_1))
    );
    assert_eq!(
        ::core::mem::align_of::<usb_task__bindgen_ty_1>(),
        8usize,
        concat!("Alignment of ", stringify!(usb_task__bindgen_ty_1))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_task__bindgen_ty_1>())).tqe_next as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_task__bindgen_ty_1),
            "::",
            stringify!(tqe_next)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<usb_task__bindgen_ty_1>())).tqe_prev as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_task__bindgen_ty_1),
            "::",
            stringify!(tqe_prev)
        )
    );
}
#[test]
fn bindgen_test_layout_usb_task() {
    assert_eq!(
        ::core::mem::size_of::<usb_task>(),
        40usize,
        concat!("Size of: ", stringify!(usb_task))
    );
    assert_eq!(
        ::core::mem::align_of::<usb_task>(),
        8usize,
        concat!("Alignment of ", stringify!(usb_task))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_task>())).next as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_task),
            "::",
            stringify!(next)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_task>())).fun as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_task),
            "::",
            stringify!(fun)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_task>())).arg as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_task),
            "::",
            stringify!(arg)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_task>())).onqueue as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_task),
            "::",
            stringify!(onqueue)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct usb_devno {
    pub ud_vendor: u_int16_t,
    pub ud_product: u_int16_t,
}
#[test]
fn bindgen_test_layout_usb_devno() {
    assert_eq!(
        ::core::mem::size_of::<usb_devno>(),
        4usize,
        concat!("Size of: ", stringify!(usb_devno))
    );
    assert_eq!(
        ::core::mem::align_of::<usb_devno>(),
        2usize,
        concat!("Alignment of ", stringify!(usb_devno))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_devno>())).ud_vendor as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_devno),
            "::",
            stringify!(ud_vendor)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_devno>())).ud_product as *const _ as usize },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_devno),
            "::",
            stringify!(ud_product)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct usb_attach_arg {
    pub port: cty::c_int,
    pub configno: cty::c_int,
    pub ifaceno: cty::c_int,
    pub vendor: cty::c_int,
    pub product: cty::c_int,
    pub release: cty::c_int,
    pub device: usbd_device_handle,
    pub iface: usbd_interface_handle,
    pub usegeneric: cty::c_int,
    pub ifaces: *mut usbd_interface_handle,
    pub nifaces: cty::c_int,
}
#[test]
fn bindgen_test_layout_usb_attach_arg() {
    assert_eq!(
        ::core::mem::size_of::<usb_attach_arg>(),
        64usize,
        concat!("Size of: ", stringify!(usb_attach_arg))
    );
    assert_eq!(
        ::core::mem::align_of::<usb_attach_arg>(),
        8usize,
        concat!("Alignment of ", stringify!(usb_attach_arg))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_attach_arg>())).port as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_attach_arg),
            "::",
            stringify!(port)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_attach_arg>())).configno as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_attach_arg),
            "::",
            stringify!(configno)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_attach_arg>())).ifaceno as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_attach_arg),
            "::",
            stringify!(ifaceno)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_attach_arg>())).vendor as *const _ as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_attach_arg),
            "::",
            stringify!(vendor)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_attach_arg>())).product as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_attach_arg),
            "::",
            stringify!(product)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_attach_arg>())).release as *const _ as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_attach_arg),
            "::",
            stringify!(release)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_attach_arg>())).device as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_attach_arg),
            "::",
            stringify!(device)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_attach_arg>())).iface as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_attach_arg),
            "::",
            stringify!(iface)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_attach_arg>())).usegeneric as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_attach_arg),
            "::",
            stringify!(usegeneric)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_attach_arg>())).ifaces as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_attach_arg),
            "::",
            stringify!(ifaces)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<usb_attach_arg>())).nifaces as *const _ as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(usb_attach_arg),
            "::",
            stringify!(nifaces)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lua_State {
    _unused: [u8; 0],
}
pub type lua_CFunction =
    ::core::option::Option<unsafe extern "C" fn(L: *mut lua_State) -> cty::c_int>;
pub type lua_Reader = ::core::option::Option<
    unsafe extern "C" fn(
        L: *mut lua_State,
        ud: *mut cty::c_void,
        sz: *mut usize,
    ) -> *const cty::c_char,
>;
pub type lua_Writer = ::core::option::Option<
    unsafe extern "C" fn(
        L: *mut lua_State,
        p: *const cty::c_void,
        sz: usize,
        ud: *mut cty::c_void,
    ) -> cty::c_int,
>;
pub type lua_Alloc = ::core::option::Option<
    unsafe extern "C" fn(
        ud: *mut cty::c_void,
        ptr: *mut cty::c_void,
        osize: usize,
        nsize: usize,
    ) -> *mut cty::c_void,
>;
pub type lua_Number = f64;
pub type lua_Integer = cty::c_int;
extern "C" {
    pub fn lua_newstate(f: lua_Alloc, ud: *mut cty::c_void) -> *mut lua_State;
}
extern "C" {
    pub fn lua_close(L: *mut lua_State);
}
extern "C" {
    pub fn lua_newthread(L: *mut lua_State) -> *mut lua_State;
}
extern "C" {
    pub fn lua_atpanic(L: *mut lua_State, panicf: lua_CFunction) -> lua_CFunction;
}
extern "C" {
    pub fn lua_gettop(L: *mut lua_State) -> cty::c_int;
}
extern "C" {
    pub fn lua_settop(L: *mut lua_State, idx: cty::c_int);
}
extern "C" {
    pub fn lua_pushvalue(L: *mut lua_State, idx: cty::c_int);
}
extern "C" {
    pub fn lua_remove(L: *mut lua_State, idx: cty::c_int);
}
extern "C" {
    pub fn lua_insert(L: *mut lua_State, idx: cty::c_int);
}
extern "C" {
    pub fn lua_replace(L: *mut lua_State, idx: cty::c_int);
}
extern "C" {
    pub fn lua_checkstack(L: *mut lua_State, sz: cty::c_int) -> cty::c_int;
}
extern "C" {
    pub fn lua_xmove(from: *mut lua_State, to: *mut lua_State, n: cty::c_int);
}
extern "C" {
    pub fn lua_isnumber(L: *mut lua_State, idx: cty::c_int) -> cty::c_int;
}
extern "C" {
    pub fn lua_isstring(L: *mut lua_State, idx: cty::c_int) -> cty::c_int;
}
extern "C" {
    pub fn lua_iscfunction(L: *mut lua_State, idx: cty::c_int) -> cty::c_int;
}
extern "C" {
    pub fn lua_isuserdata(L: *mut lua_State, idx: cty::c_int) -> cty::c_int;
}
extern "C" {
    pub fn lua_type(L: *mut lua_State, idx: cty::c_int) -> cty::c_int;
}
extern "C" {
    pub fn lua_typename(L: *mut lua_State, tp: cty::c_int) -> *const cty::c_char;
}
extern "C" {
    pub fn lua_equal(L: *mut lua_State, idx1: cty::c_int, idx2: cty::c_int) -> cty::c_int;
}
extern "C" {
    pub fn lua_rawequal(L: *mut lua_State, idx1: cty::c_int, idx2: cty::c_int) -> cty::c_int;
}
extern "C" {
    pub fn lua_lessthan(L: *mut lua_State, idx1: cty::c_int, idx2: cty::c_int) -> cty::c_int;
}
extern "C" {
    pub fn lua_tonumber(L: *mut lua_State, idx: cty::c_int) -> lua_Number;
}
extern "C" {
    pub fn lua_tointeger(L: *mut lua_State, idx: cty::c_int) -> lua_Integer;
}
extern "C" {
    pub fn lua_toboolean(L: *mut lua_State, idx: cty::c_int) -> cty::c_int;
}
extern "C" {
    pub fn lua_tolstring(L: *mut lua_State, idx: cty::c_int, len: *mut usize)
        -> *const cty::c_char;
}
extern "C" {
    pub fn lua_objlen(L: *mut lua_State, idx: cty::c_int) -> usize;
}
extern "C" {
    pub fn lua_tocfunction(L: *mut lua_State, idx: cty::c_int) -> lua_CFunction;
}
extern "C" {
    pub fn lua_touserdata(L: *mut lua_State, idx: cty::c_int) -> *mut cty::c_void;
}
extern "C" {
    pub fn lua_tothread(L: *mut lua_State, idx: cty::c_int) -> *mut lua_State;
}
extern "C" {
    pub fn lua_topointer(L: *mut lua_State, idx: cty::c_int) -> *const cty::c_void;
}
extern "C" {
    pub fn lua_pushnil(L: *mut lua_State);
}
extern "C" {
    pub fn lua_pushnumber(L: *mut lua_State, n: lua_Number);
}
extern "C" {
    pub fn lua_pushinteger(L: *mut lua_State, n: lua_Integer);
}
extern "C" {
    pub fn lua_pushlstring(L: *mut lua_State, s: *const cty::c_char, l: usize);
}
extern "C" {
    pub fn lua_pushstring(L: *mut lua_State, s: *const cty::c_char);
}
extern "C" {
    pub fn lua_pushvfstring(
        L: *mut lua_State,
        fmt: *const cty::c_char,
        argp: *mut __va_list_tag,
    ) -> *const cty::c_char;
}
extern "C" {
    pub fn lua_pushfstring(L: *mut lua_State, fmt: *const cty::c_char, ...) -> *const cty::c_char;
}
extern "C" {
    pub fn lua_pushcclosure(L: *mut lua_State, fn_: lua_CFunction, n: cty::c_int);
}
extern "C" {
    pub fn lua_pushboolean(L: *mut lua_State, b: cty::c_int);
}
extern "C" {
    pub fn lua_pushlightuserdata(L: *mut lua_State, p: *mut cty::c_void);
}
extern "C" {
    pub fn lua_pushthread(L: *mut lua_State) -> cty::c_int;
}
extern "C" {
    pub fn lua_gettable(L: *mut lua_State, idx: cty::c_int);
}
extern "C" {
    pub fn lua_getfield(L: *mut lua_State, idx: cty::c_int, k: *const cty::c_char);
}
extern "C" {
    pub fn lua_rawget(L: *mut lua_State, idx: cty::c_int);
}
extern "C" {
    pub fn lua_rawgeti(L: *mut lua_State, idx: cty::c_int, n: cty::c_int);
}
extern "C" {
    pub fn lua_createtable(L: *mut lua_State, narr: cty::c_int, nrec: cty::c_int);
}
extern "C" {
    pub fn lua_newuserdata(L: *mut lua_State, sz: usize) -> *mut cty::c_void;
}
extern "C" {
    pub fn lua_getmetatable(L: *mut lua_State, objindex: cty::c_int) -> cty::c_int;
}
extern "C" {
    pub fn lua_getfenv(L: *mut lua_State, idx: cty::c_int);
}
extern "C" {
    pub fn lua_settable(L: *mut lua_State, idx: cty::c_int);
}
extern "C" {
    pub fn lua_setfield(L: *mut lua_State, idx: cty::c_int, k: *const cty::c_char);
}
extern "C" {
    pub fn lua_rawset(L: *mut lua_State, idx: cty::c_int);
}
extern "C" {
    pub fn lua_rawseti(L: *mut lua_State, idx: cty::c_int, n: cty::c_int);
}
extern "C" {
    pub fn lua_setmetatable(L: *mut lua_State, objindex: cty::c_int) -> cty::c_int;
}
extern "C" {
    pub fn lua_setfenv(L: *mut lua_State, idx: cty::c_int) -> cty::c_int;
}
extern "C" {
    pub fn lua_call(L: *mut lua_State, nargs: cty::c_int, nresults: cty::c_int);
}
extern "C" {
    pub fn lua_pcall(
        L: *mut lua_State,
        nargs: cty::c_int,
        nresults: cty::c_int,
        errfunc: cty::c_int,
    ) -> cty::c_int;
}
extern "C" {
    pub fn lua_cpcall(L: *mut lua_State, func: lua_CFunction, ud: *mut cty::c_void) -> cty::c_int;
}
extern "C" {
    pub fn lua_load(
        L: *mut lua_State,
        reader: lua_Reader,
        dt: *mut cty::c_void,
        chunkname: *const cty::c_char,
    ) -> cty::c_int;
}
extern "C" {
    pub fn lua_dump(L: *mut lua_State, writer: lua_Writer, data: *mut cty::c_void) -> cty::c_int;
}
extern "C" {
    pub fn lua_yield(L: *mut lua_State, nresults: cty::c_int) -> cty::c_int;
}
extern "C" {
    pub fn lua_resume(L: *mut lua_State, narg: cty::c_int) -> cty::c_int;
}
extern "C" {
    pub fn lua_status(L: *mut lua_State) -> cty::c_int;
}
extern "C" {
    pub fn lua_gc(L: *mut lua_State, what: cty::c_int, data: cty::c_int) -> cty::c_int;
}
extern "C" {
    pub fn lua_error(L: *mut lua_State) -> cty::c_int;
}
extern "C" {
    pub fn lua_next(L: *mut lua_State, idx: cty::c_int) -> cty::c_int;
}
extern "C" {
    pub fn lua_concat(L: *mut lua_State, n: cty::c_int);
}
extern "C" {
    pub fn lua_getallocf(L: *mut lua_State, ud: *mut *mut cty::c_void) -> lua_Alloc;
}
extern "C" {
    pub fn lua_setallocf(L: *mut lua_State, f: lua_Alloc, ud: *mut cty::c_void);
}
pub type lua_Hook =
    ::core::option::Option<unsafe extern "C" fn(L: *mut lua_State, ar: *mut lua_Debug)>;
extern "C" {
    pub fn lua_getstack(L: *mut lua_State, level: cty::c_int, ar: *mut lua_Debug) -> cty::c_int;
}
extern "C" {
    pub fn lua_getinfo(
        L: *mut lua_State,
        what: *const cty::c_char,
        ar: *mut lua_Debug,
    ) -> cty::c_int;
}
extern "C" {
    pub fn lua_getlocal(
        L: *mut lua_State,
        ar: *const lua_Debug,
        n: cty::c_int,
    ) -> *const cty::c_char;
}
extern "C" {
    pub fn lua_setlocal(
        L: *mut lua_State,
        ar: *const lua_Debug,
        n: cty::c_int,
    ) -> *const cty::c_char;
}
extern "C" {
    pub fn lua_getupvalue(
        L: *mut lua_State,
        funcindex: cty::c_int,
        n: cty::c_int,
    ) -> *const cty::c_char;
}
extern "C" {
    pub fn lua_setupvalue(
        L: *mut lua_State,
        funcindex: cty::c_int,
        n: cty::c_int,
    ) -> *const cty::c_char;
}
extern "C" {
    pub fn lua_sethook(
        L: *mut lua_State,
        func: lua_Hook,
        mask: cty::c_int,
        count: cty::c_int,
    ) -> cty::c_int;
}
extern "C" {
    pub fn lua_gethook(L: *mut lua_State) -> lua_Hook;
}
extern "C" {
    pub fn lua_gethookmask(L: *mut lua_State) -> cty::c_int;
}
extern "C" {
    pub fn lua_gethookcount(L: *mut lua_State) -> cty::c_int;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct lua_Debug {
    pub event: cty::c_int,
    pub name: *const cty::c_char,
    pub namewhat: *const cty::c_char,
    pub what: *const cty::c_char,
    pub source: *const cty::c_char,
    pub currentline: cty::c_int,
    pub nups: cty::c_int,
    pub linedefined: cty::c_int,
    pub lastlinedefined: cty::c_int,
    pub short_src: [cty::c_char; 60usize],
    pub i_ci: cty::c_int,
}
#[test]
fn bindgen_test_layout_lua_Debug() {
    assert_eq!(
        ::core::mem::size_of::<lua_Debug>(),
        120usize,
        concat!("Size of: ", stringify!(lua_Debug))
    );
    assert_eq!(
        ::core::mem::align_of::<lua_Debug>(),
        8usize,
        concat!("Alignment of ", stringify!(lua_Debug))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<lua_Debug>())).event as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(lua_Debug),
            "::",
            stringify!(event)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<lua_Debug>())).name as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(lua_Debug),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<lua_Debug>())).namewhat as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(lua_Debug),
            "::",
            stringify!(namewhat)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<lua_Debug>())).what as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(lua_Debug),
            "::",
            stringify!(what)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<lua_Debug>())).source as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(lua_Debug),
            "::",
            stringify!(source)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<lua_Debug>())).currentline as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(lua_Debug),
            "::",
            stringify!(currentline)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<lua_Debug>())).nups as *const _ as usize },
        44usize,
        concat!(
            "Offset of field: ",
            stringify!(lua_Debug),
            "::",
            stringify!(nups)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<lua_Debug>())).linedefined as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(lua_Debug),
            "::",
            stringify!(linedefined)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<lua_Debug>())).lastlinedefined as *const _ as usize },
        52usize,
        concat!(
            "Offset of field: ",
            stringify!(lua_Debug),
            "::",
            stringify!(lastlinedefined)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<lua_Debug>())).short_src as *const _ as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(lua_Debug),
            "::",
            stringify!(short_src)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<lua_Debug>())).i_ci as *const _ as usize },
        116usize,
        concat!(
            "Offset of field: ",
            stringify!(lua_Debug),
            "::",
            stringify!(i_ci)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct luaL_Reg {
    pub name: *const cty::c_char,
    pub func: lua_CFunction,
}
#[test]
fn bindgen_test_layout_luaL_Reg() {
    assert_eq!(
        ::core::mem::size_of::<luaL_Reg>(),
        16usize,
        concat!("Size of: ", stringify!(luaL_Reg))
    );
    assert_eq!(
        ::core::mem::align_of::<luaL_Reg>(),
        8usize,
        concat!("Alignment of ", stringify!(luaL_Reg))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<luaL_Reg>())).name as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(luaL_Reg),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<luaL_Reg>())).func as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(luaL_Reg),
            "::",
            stringify!(func)
        )
    );
}
extern "C" {
    pub fn luaL_openlib(
        L: *mut lua_State,
        libname: *const cty::c_char,
        l: *const luaL_Reg,
        nup: cty::c_int,
    );
}
extern "C" {
    pub fn luaL_getmetafield(
        L: *mut lua_State,
        obj: cty::c_int,
        e: *const cty::c_char,
    ) -> cty::c_int;
}
extern "C" {
    pub fn luaL_callmeta(L: *mut lua_State, obj: cty::c_int, e: *const cty::c_char) -> cty::c_int;
}
extern "C" {
    pub fn luaL_typerror(
        L: *mut lua_State,
        narg: cty::c_int,
        tname: *const cty::c_char,
    ) -> cty::c_int;
}
extern "C" {
    pub fn luaL_argerror(
        L: *mut lua_State,
        numarg: cty::c_int,
        extramsg: *const cty::c_char,
    ) -> cty::c_int;
}
extern "C" {
    pub fn luaL_optlstring(
        L: *mut lua_State,
        numArg: cty::c_int,
        def: *const cty::c_char,
        l: *mut usize,
    ) -> *const cty::c_char;
}
extern "C" {
    pub fn luaL_checknumber(L: *mut lua_State, numArg: cty::c_int) -> lua_Number;
}
extern "C" {
    pub fn luaL_optnumber(L: *mut lua_State, nArg: cty::c_int, def: lua_Number) -> lua_Number;
}
extern "C" {
    pub fn luaL_checkinteger(L: *mut lua_State, numArg: cty::c_int) -> lua_Integer;
}
extern "C" {
    pub fn luaL_optinteger(L: *mut lua_State, nArg: cty::c_int, def: lua_Integer) -> lua_Integer;
}
extern "C" {
    pub fn luaL_checkstack(L: *mut lua_State, sz: cty::c_int, msg: *const cty::c_char);
}
extern "C" {
    pub fn luaL_checktype(L: *mut lua_State, narg: cty::c_int, t: cty::c_int);
}
extern "C" {
    pub fn luaL_checkany(L: *mut lua_State, narg: cty::c_int);
}
extern "C" {
    pub fn luaL_newmetatable(L: *mut lua_State, tname: *const cty::c_char) -> cty::c_int;
}
extern "C" {
    pub fn luaL_checkudata(
        L: *mut lua_State,
        ud: cty::c_int,
        tname: *const cty::c_char,
    ) -> *mut cty::c_void;
}
extern "C" {
    pub fn luaL_where(L: *mut lua_State, lvl: cty::c_int);
}
extern "C" {
    pub fn luaL_checkoption(
        L: *mut lua_State,
        narg: cty::c_int,
        def: *const cty::c_char,
        lst: *const *const cty::c_char,
    ) -> cty::c_int;
}
extern "C" {
    pub fn luaL_ref(L: *mut lua_State, t: cty::c_int) -> cty::c_int;
}
extern "C" {
    pub fn luaL_unref(L: *mut lua_State, t: cty::c_int, ref_: cty::c_int);
}
extern "C" {
    pub fn luaL_loadfile(L: *mut lua_State, filename: *const cty::c_char) -> cty::c_int;
}
extern "C" {
    pub fn luaL_loadbuffer(
        L: *mut lua_State,
        buff: *const cty::c_char,
        sz: usize,
        name: *const cty::c_char,
    ) -> cty::c_int;
}
extern "C" {
    pub fn luaL_loadstring(L: *mut lua_State, s: *const cty::c_char) -> cty::c_int;
}
extern "C" {
    pub fn luaL_newstate() -> *mut lua_State;
}
extern "C" {
    pub fn luaL_gsub(
        L: *mut lua_State,
        s: *const cty::c_char,
        p: *const cty::c_char,
        r: *const cty::c_char,
    ) -> *const cty::c_char;
}
extern "C" {
    pub fn luaL_findtable(
        L: *mut lua_State,
        idx: cty::c_int,
        fname: *const cty::c_char,
        szhint: cty::c_int,
    ) -> *const cty::c_char;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct luaL_Buffer {
    pub p: *mut cty::c_char,
    pub lvl: cty::c_int,
    pub L: *mut lua_State,
    pub buffer: [cty::c_char; 8192usize],
}
#[test]
fn bindgen_test_layout_luaL_Buffer() {
    assert_eq!(
        ::core::mem::size_of::<luaL_Buffer>(),
        8216usize,
        concat!("Size of: ", stringify!(luaL_Buffer))
    );
    assert_eq!(
        ::core::mem::align_of::<luaL_Buffer>(),
        8usize,
        concat!("Alignment of ", stringify!(luaL_Buffer))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<luaL_Buffer>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(luaL_Buffer),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<luaL_Buffer>())).lvl as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(luaL_Buffer),
            "::",
            stringify!(lvl)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<luaL_Buffer>())).L as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(luaL_Buffer),
            "::",
            stringify!(L)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<luaL_Buffer>())).buffer as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(luaL_Buffer),
            "::",
            stringify!(buffer)
        )
    );
}
extern "C" {
    pub fn luaL_buffinit(L: *mut lua_State, B: *mut luaL_Buffer);
}
extern "C" {
    pub fn luaL_prepbuffer(B: *mut luaL_Buffer) -> *mut cty::c_char;
}
extern "C" {
    pub fn luaL_addlstring(B: *mut luaL_Buffer, s: *const cty::c_char, l: usize);
}
extern "C" {
    pub fn luaL_addstring(B: *mut luaL_Buffer, s: *const cty::c_char);
}
extern "C" {
    pub fn luaL_addvalue(B: *mut luaL_Buffer);
}
extern "C" {
    pub fn luaL_pushresult(B: *mut luaL_Buffer);
}
pub const BOOL_FALSE: BOOL = 0;
pub const BOOL_TRUE: BOOL = 1;
pub type BOOL = u32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _bindgen_ty_5 {
    pub str: *mut cty::c_char,
    pub len: cty::c_int,
    pub chunk_size: cty::c_int,
    pub unknown_field: cty::c_int,
}
#[test]
fn bindgen_test_layout__bindgen_ty_5() {
    assert_eq!(
        ::core::mem::size_of::<_bindgen_ty_5>(),
        24usize,
        concat!("Size of: ", stringify!(_bindgen_ty_5))
    );
    assert_eq!(
        ::core::mem::align_of::<_bindgen_ty_5>(),
        8usize,
        concat!("Alignment of ", stringify!(_bindgen_ty_5))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_bindgen_ty_5>())).str as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_bindgen_ty_5),
            "::",
            stringify!(str)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_bindgen_ty_5>())).len as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_bindgen_ty_5),
            "::",
            stringify!(len)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_bindgen_ty_5>())).chunk_size as *const _ as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(_bindgen_ty_5),
            "::",
            stringify!(chunk_size)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_bindgen_ty_5>())).unknown_field as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(_bindgen_ty_5),
            "::",
            stringify!(unknown_field)
        )
    );
}
pub type String = *mut _bindgen_ty_5;
pub type NU_TASK = cty::c_void;
pub type PCFD = cty::c_int;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct dstat {
    pub unknown1: [cty::c_char; 13usize],
    pub filepath: [cty::c_char; 266usize],
    pub fattribute: cty::c_uchar,
    pub unknown2: cty::c_ushort,
    pub unknown3: cty::c_ushort,
    pub unknown4: cty::c_ushort,
    pub unknown5: cty::c_ushort,
    pub fsize: cty::c_ulong,
    pub unknown6: *mut cty::c_void,
    pub unknown7: *mut cty::c_void,
    pub unknown8: cty::c_uint,
    pub unknown9: cty::c_ushort,
}
#[test]
fn bindgen_test_layout_dstat() {
    assert_eq!(
        ::core::mem::size_of::<dstat>(),
        320usize,
        concat!("Size of: ", stringify!(dstat))
    );
    assert_eq!(
        ::core::mem::align_of::<dstat>(),
        8usize,
        concat!("Alignment of ", stringify!(dstat))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<dstat>())).unknown1 as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(dstat),
            "::",
            stringify!(unknown1)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<dstat>())).filepath as *const _ as usize },
        13usize,
        concat!(
            "Offset of field: ",
            stringify!(dstat),
            "::",
            stringify!(filepath)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<dstat>())).fattribute as *const _ as usize },
        279usize,
        concat!(
            "Offset of field: ",
            stringify!(dstat),
            "::",
            stringify!(fattribute)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<dstat>())).unknown2 as *const _ as usize },
        280usize,
        concat!(
            "Offset of field: ",
            stringify!(dstat),
            "::",
            stringify!(unknown2)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<dstat>())).unknown3 as *const _ as usize },
        282usize,
        concat!(
            "Offset of field: ",
            stringify!(dstat),
            "::",
            stringify!(unknown3)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<dstat>())).unknown4 as *const _ as usize },
        284usize,
        concat!(
            "Offset of field: ",
            stringify!(dstat),
            "::",
            stringify!(unknown4)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<dstat>())).unknown5 as *const _ as usize },
        286usize,
        concat!(
            "Offset of field: ",
            stringify!(dstat),
            "::",
            stringify!(unknown5)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<dstat>())).fsize as *const _ as usize },
        288usize,
        concat!(
            "Offset of field: ",
            stringify!(dstat),
            "::",
            stringify!(fsize)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<dstat>())).unknown6 as *const _ as usize },
        296usize,
        concat!(
            "Offset of field: ",
            stringify!(dstat),
            "::",
            stringify!(unknown6)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<dstat>())).unknown7 as *const _ as usize },
        304usize,
        concat!(
            "Offset of field: ",
            stringify!(dstat),
            "::",
            stringify!(unknown7)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<dstat>())).unknown8 as *const _ as usize },
        312usize,
        concat!(
            "Offset of field: ",
            stringify!(dstat),
            "::",
            stringify!(unknown8)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<dstat>())).unknown9 as *const _ as usize },
        316usize,
        concat!(
            "Offset of field: ",
            stringify!(dstat),
            "::",
            stringify!(unknown9)
        )
    );
}
pub type DSTAT = dstat;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct s_ns_event {
    pub timestamp: cty::c_uint,
    pub type_: cty::c_ushort,
    pub ascii: cty::c_ushort,
    pub key: cty::c_uint,
    pub cursor_x: cty::c_uint,
    pub cursor_y: cty::c_uint,
    pub unknown: cty::c_uint,
    pub modifiers: cty::c_ushort,
    pub click: cty::c_uchar,
}
#[test]
fn bindgen_test_layout_s_ns_event() {
    assert_eq!(
        ::core::mem::size_of::<s_ns_event>(),
        28usize,
        concat!("Size of: ", stringify!(s_ns_event))
    );
    assert_eq!(
        ::core::mem::align_of::<s_ns_event>(),
        4usize,
        concat!("Alignment of ", stringify!(s_ns_event))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<s_ns_event>())).timestamp as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(s_ns_event),
            "::",
            stringify!(timestamp)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<s_ns_event>())).type_ as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(s_ns_event),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<s_ns_event>())).ascii as *const _ as usize },
        6usize,
        concat!(
            "Offset of field: ",
            stringify!(s_ns_event),
            "::",
            stringify!(ascii)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<s_ns_event>())).key as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(s_ns_event),
            "::",
            stringify!(key)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<s_ns_event>())).cursor_x as *const _ as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(s_ns_event),
            "::",
            stringify!(cursor_x)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<s_ns_event>())).cursor_y as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(s_ns_event),
            "::",
            stringify!(cursor_y)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<s_ns_event>())).unknown as *const _ as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(s_ns_event),
            "::",
            stringify!(unknown)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<s_ns_event>())).modifiers as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(s_ns_event),
            "::",
            stringify!(modifiers)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<s_ns_event>())).click as *const _ as usize },
        26usize,
        concat!(
            "Offset of field: ",
            stringify!(s_ns_event),
            "::",
            stringify!(click)
        )
    );
}
pub const e_resourceID_RES_CLNK: e_resourceID = 1668050539;
pub const e_resourceID_RES_CTLG: e_resourceID = 1668574311;
pub const e_resourceID_RES_DCOL: e_resourceID = 1684238188;
pub const e_resourceID_RES_DLOG: e_resourceID = 1684828007;
pub const e_resourceID_RES_DTST: e_resourceID = 1685353332;
pub const e_resourceID_RES_GEOG: e_resourceID = 1734700903;
pub const e_resourceID_RES_MATH: e_resourceID = 1835103336;
pub const e_resourceID_RES_MWIZ: e_resourceID = 1836542330;
pub const e_resourceID_RES_NTPD: e_resourceID = 1853124708;
pub const e_resourceID_RES_PGED: e_resourceID = 1885824356;
pub const e_resourceID_RES_QCKP: e_resourceID = 1902340976;
pub const e_resourceID_RES_QUES: e_resourceID = 1903519091;
pub const e_resourceID_RES_SCPD: e_resourceID = 1935896676;
pub const e_resourceID_RES_SYST: e_resourceID = 1937339252;
pub const e_resourceID_RES_TBLT: e_resourceID = 1952607348;
pub type e_resourceID = u32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nuc_stat {
    pub st_dev: cty::c_ushort,
    pub st_ino: cty::c_uint,
    pub st_mode: cty::c_uint,
    pub st_nlink: cty::c_ushort,
    pub st_uid: cty::c_ushort,
    pub st_gid: cty::c_ushort,
    pub st_rdev: cty::c_ushort,
    pub st_size: cty::c_uint,
    pub st_atime: cty::c_uint,
    pub st_mtime: cty::c_uint,
    pub st_ctime: cty::c_uint,
}
#[test]
fn bindgen_test_layout_nuc_stat() {
    assert_eq!(
        ::core::mem::size_of::<nuc_stat>(),
        36usize,
        concat!("Size of: ", stringify!(nuc_stat))
    );
    assert_eq!(
        ::core::mem::align_of::<nuc_stat>(),
        4usize,
        concat!("Alignment of ", stringify!(nuc_stat))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<nuc_stat>())).st_dev as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(nuc_stat),
            "::",
            stringify!(st_dev)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<nuc_stat>())).st_ino as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(nuc_stat),
            "::",
            stringify!(st_ino)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<nuc_stat>())).st_mode as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(nuc_stat),
            "::",
            stringify!(st_mode)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<nuc_stat>())).st_nlink as *const _ as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(nuc_stat),
            "::",
            stringify!(st_nlink)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<nuc_stat>())).st_uid as *const _ as usize },
        14usize,
        concat!(
            "Offset of field: ",
            stringify!(nuc_stat),
            "::",
            stringify!(st_uid)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<nuc_stat>())).st_gid as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(nuc_stat),
            "::",
            stringify!(st_gid)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<nuc_stat>())).st_rdev as *const _ as usize },
        18usize,
        concat!(
            "Offset of field: ",
            stringify!(nuc_stat),
            "::",
            stringify!(st_rdev)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<nuc_stat>())).st_size as *const _ as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(nuc_stat),
            "::",
            stringify!(st_size)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<nuc_stat>())).st_atime as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(nuc_stat),
            "::",
            stringify!(st_atime)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<nuc_stat>())).st_mtime as *const _ as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(nuc_stat),
            "::",
            stringify!(st_mtime)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<nuc_stat>())).st_ctime as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(nuc_stat),
            "::",
            stringify!(st_ctime)
        )
    );
}
pub type NUC_FILE = cty::c_void;
pub type NUC_DIR = cty::c_void;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nuc_dirent {
    pub d_name: [cty::c_char; 1usize],
}
#[test]
fn bindgen_test_layout_nuc_dirent() {
    assert_eq!(
        ::core::mem::size_of::<nuc_dirent>(),
        1usize,
        concat!("Size of: ", stringify!(nuc_dirent))
    );
    assert_eq!(
        ::core::mem::align_of::<nuc_dirent>(),
        1usize,
        concat!("Alignment of ", stringify!(nuc_dirent))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<nuc_dirent>())).d_name as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(nuc_dirent),
            "::",
            stringify!(d_name)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _nn_ch {
    _unused: [u8; 0],
}
pub type nn_ch_t = *mut _nn_ch;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _nn_nh {
    _unused: [u8; 0],
}
pub type nn_nh_t = *mut _nn_nh;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _nn_oh {
    _unused: [u8; 0],
}
pub type nn_oh_t = *mut _nn_oh;
extern "C" {
    pub fn keypad_type() -> *mut cty::c_uchar;
}
extern "C" {
    pub fn nl_ndless_rev() -> cty::c_uint;
}
extern "C" {
    pub fn nl_hwtype() -> cty::c_uint;
}
extern "C" {
    pub fn nl_hwsubtype() -> cty::c_uint;
}
extern "C" {
    pub fn nl_loaded_by_3rd_party_loader() -> BOOL;
}
extern "C" {
    pub fn nl_isstartup() -> BOOL;
}
extern "C" {
    pub fn _nl_hassyscall(nr: cty::c_int) -> BOOL;
}
extern "C" {
    pub fn nl_set_resident();
}
extern "C" {
    pub fn nl_osvalue(values: *const cty::c_uint, size: cty::c_uint) -> cty::c_uint;
}
extern "C" {
    pub fn nl_exec(
        prg: *const cty::c_char,
        argc: cty::c_int,
        argv: *mut *mut cty::c_char,
    ) -> cty::c_int;
}
extern "C" {
    pub fn nl_lua_getstate() -> *mut lua_State;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct touchpad_info_t {
    pub width: u16,
    pub height: u16,
}
#[test]
fn bindgen_test_layout_touchpad_info_t() {
    assert_eq!(
        ::core::mem::size_of::<touchpad_info_t>(),
        4usize,
        concat!("Size of: ", stringify!(touchpad_info_t))
    );
    assert_eq!(
        ::core::mem::align_of::<touchpad_info_t>(),
        2usize,
        concat!("Alignment of ", stringify!(touchpad_info_t))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<touchpad_info_t>())).width as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(touchpad_info_t),
            "::",
            stringify!(width)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<touchpad_info_t>())).height as *const _ as usize },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(touchpad_info_t),
            "::",
            stringify!(height)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct touchpad_report_t {
    pub contact: cty::c_uchar,
    pub proximity: cty::c_uchar,
    pub x: u16,
    pub y: u16,
    pub x_velocity: cty::c_uchar,
    pub y_velocity: cty::c_uchar,
    pub dummy: u16,
    pub pressed: cty::c_uchar,
    pub arrow: cty::c_uchar,
}
#[test]
fn bindgen_test_layout_touchpad_report_t() {
    assert_eq!(
        ::core::mem::size_of::<touchpad_report_t>(),
        12usize,
        concat!("Size of: ", stringify!(touchpad_report_t))
    );
    assert_eq!(
        ::core::mem::align_of::<touchpad_report_t>(),
        2usize,
        concat!("Alignment of ", stringify!(touchpad_report_t))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<touchpad_report_t>())).contact as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(touchpad_report_t),
            "::",
            stringify!(contact)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<touchpad_report_t>())).proximity as *const _ as usize },
        1usize,
        concat!(
            "Offset of field: ",
            stringify!(touchpad_report_t),
            "::",
            stringify!(proximity)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<touchpad_report_t>())).x as *const _ as usize },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(touchpad_report_t),
            "::",
            stringify!(x)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<touchpad_report_t>())).y as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(touchpad_report_t),
            "::",
            stringify!(y)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<touchpad_report_t>())).x_velocity as *const _ as usize },
        6usize,
        concat!(
            "Offset of field: ",
            stringify!(touchpad_report_t),
            "::",
            stringify!(x_velocity)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<touchpad_report_t>())).y_velocity as *const _ as usize },
        7usize,
        concat!(
            "Offset of field: ",
            stringify!(touchpad_report_t),
            "::",
            stringify!(y_velocity)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<touchpad_report_t>())).dummy as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(touchpad_report_t),
            "::",
            stringify!(dummy)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<touchpad_report_t>())).pressed as *const _ as usize },
        10usize,
        concat!(
            "Offset of field: ",
            stringify!(touchpad_report_t),
            "::",
            stringify!(pressed)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<touchpad_report_t>())).arrow as *const _ as usize },
        11usize,
        concat!(
            "Offset of field: ",
            stringify!(touchpad_report_t),
            "::",
            stringify!(arrow)
        )
    );
}
pub const scr_type_t_SCR_TYPE_INVALID: scr_type_t = -1;
pub const scr_type_t_SCR_320x240_565: scr_type_t = 0;
pub const scr_type_t_SCR_320x240_4: scr_type_t = 1;
pub const scr_type_t_SCR_240x320_565: scr_type_t = 2;
pub const scr_type_t_SCR_320x240_16: scr_type_t = 3;
pub const scr_type_t_SCR_320x240_8: scr_type_t = 4;
pub const scr_type_t_SCR_320x240_555: scr_type_t = 5;
pub const scr_type_t_SCR_240x320_555: scr_type_t = 6;
pub const scr_type_t_SCR_TYPE_COUNT: scr_type_t = 7;
pub type scr_type_t = i32;
extern "C" {
    pub fn assert_ndless_rev(required_rev: cty::c_uint);
}
extern "C" {
    pub fn any_key_pressed() -> BOOL;
}
extern "C" {
    pub fn clear_cache();
}
extern "C" {
    pub fn enable_relative_paths(argv: *mut *mut cty::c_char) -> cty::c_int;
}
extern "C" {
    pub fn file_each(
        folder: *const cty::c_char,
        callback: ::core::option::Option<
            unsafe extern "C" fn(path: *const cty::c_char, context: *mut cty::c_void) -> cty::c_int,
        >,
        context: *mut cty::c_void,
    ) -> cty::c_int;
}
extern "C" {
    pub fn idle();
}
extern "C" {
    pub fn msleep(millisec: cty::c_uint) -> cty::c_uint;
}
extern "C" {
    pub fn locate(
        filename: *const cty::c_char,
        dst_path: *mut cty::c_char,
        dst_path_size: usize,
    ) -> cty::c_int;
}
extern "C" {
    pub fn on_key_pressed() -> BOOL;
}
extern "C" {
    pub fn refresh_osscr();
}
extern "C" {
    pub fn set_cpu_speed(speed: cty::c_uint) -> cty::c_uint;
}
extern "C" {
    pub fn _show_msgbox(
        title: *const cty::c_char,
        msg: *const cty::c_char,
        button_num: cty::c_uint,
        ...
    ) -> cty::c_uint;
}
extern "C" {
    pub fn show_msg_user_input(
        title: *const cty::c_char,
        msg: *const cty::c_char,
        defaultvalue: *const cty::c_char,
        value_ref: *mut *mut cty::c_char,
    ) -> cty::c_int;
}
extern "C" {
    pub fn show_1numeric_input(
        title: *const cty::c_char,
        subtitle: *const cty::c_char,
        msg: *const cty::c_char,
        value_ref: *mut cty::c_int,
        min_value: cty::c_int,
        max_value: cty::c_int,
    ) -> cty::c_int;
}
extern "C" {
    pub fn show_2numeric_input(
        title: *const cty::c_char,
        subtitle: *const cty::c_char,
        msg1: *const cty::c_char,
        value1_ref: *mut cty::c_int,
        min_value1: cty::c_int,
        max_value1: cty::c_int,
        msg2: *const cty::c_char,
        value2_ref: *mut cty::c_int,
        min_value2: cty::c_int,
        max_value2: cty::c_int,
    ) -> cty::c_int;
}
extern "C" {
    pub fn touchpad_getinfo() -> *mut touchpad_info_t;
}
extern "C" {
    pub fn touchpad_scan(report: *mut touchpad_report_t) -> cty::c_int;
}
extern "C" {
    pub fn touchpad_arrow_pressed(arrow: tpad_arrow_t) -> BOOL;
}
extern "C" {
    pub fn usbd_set_idle(
        iface: usbd_interface_handle,
        duration: cty::c_int,
        id: cty::c_int,
    ) -> usbd_status;
}
extern "C" {
    pub fn usbd_set_protocol(iface: usbd_interface_handle, report: cty::c_int) -> usbd_status;
}
extern "C" {
    pub fn isKeyPressed(key: *const t_key) -> BOOL;
}
extern "C" {
    pub fn wait_key_pressed();
}
extern "C" {
    pub fn wait_no_key_pressed();
}
extern "C" {
    pub fn cfg_open();
}
extern "C" {
    pub fn cfg_open_file(filepath: *const cty::c_char);
}
extern "C" {
    pub fn cfg_close();
}
extern "C" {
    pub fn cfg_get(key: *const cty::c_char) -> *mut cty::c_char;
}
extern "C" {
    pub fn cfg_register_fileext(ext: *const cty::c_char, prgm: *const cty::c_char);
}
extern "C" {
    pub fn cfg_register_fileext_file(
        fielpath: *const cty::c_char,
        ext: *const cty::c_char,
        prgm: *const cty::c_char,
    );
}
extern "C" {
    pub fn lcd_init(type_: scr_type_t) -> bool;
}
extern "C" {
    pub fn lcd_blit(buffer: *mut cty::c_void, buffer_type: scr_type_t);
}
extern "C" {
    pub fn lcd_type() -> scr_type_t;
}
extern "C" {
    pub fn _is_touchpad() -> BOOL;
}
extern "C" {
    pub fn hwtype() -> cty::c_uint;
}
pub const gui_gc_ClipRectOp_GC_CRO_RESET: gui_gc_ClipRectOp = 0;
pub const gui_gc_ClipRectOp_GC_CRO_SET: gui_gc_ClipRectOp = 1;
pub const gui_gc_ClipRectOp_GC_CRO_INTERSECT: gui_gc_ClipRectOp = 2;
pub const gui_gc_ClipRectOp_GC_CRO_NULL: gui_gc_ClipRectOp = 3;
pub type gui_gc_ClipRectOp = u32;
pub const gui_gc_Alpha_GC_A_OFF: gui_gc_Alpha = 255;
pub const gui_gc_Alpha_GC_A_HALF: gui_gc_Alpha = 128;
pub type gui_gc_Alpha = u32;
pub const gui_gc_PenMode_GC_PM_SMOOTH: gui_gc_PenMode = 0;
pub const gui_gc_PenMode_GC_PM_DOTTED: gui_gc_PenMode = 1;
pub const gui_gc_PenMode_GC_PM_DASHED: gui_gc_PenMode = 2;
pub type gui_gc_PenMode = u32;
pub const gui_gc_PenSize_GC_PS_THIN: gui_gc_PenSize = 0;
pub const gui_gc_PenSize_GC_PS_MEDIUM: gui_gc_PenSize = 1;
pub const gui_gc_PenSize_GC_PS_THICK: gui_gc_PenSize = 2;
pub type gui_gc_PenSize = u32;
pub const gui_gc_StringMode_GC_SM_NORMAL: gui_gc_StringMode = 1;
pub const gui_gc_StringMode_GC_SM_SHRINK: gui_gc_StringMode = 2;
pub const gui_gc_StringMode_GC_SM_OVERLAP: gui_gc_StringMode = 3;
pub const gui_gc_StringMode_GC_SM_BASELINE: gui_gc_StringMode = 16;
pub const gui_gc_StringMode_GC_SM_BOTTOM: gui_gc_StringMode = 32;
pub const gui_gc_StringMode_GC_SM_MIDDLE: gui_gc_StringMode = 48;
pub const gui_gc_StringMode_GC_SM_TOP: gui_gc_StringMode = 64;
pub const gui_gc_StringMode_GC_SM_RIGHT: gui_gc_StringMode = 256;
pub const gui_gc_StringMode_GC_SM_DOWN: gui_gc_StringMode = 512;
pub const gui_gc_StringMode_GC_SM_LEFT: gui_gc_StringMode = 768;
pub type gui_gc_StringMode = u32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct gui_gc_Sprite {
    pub width: cty::c_short,
    pub height: cty::c_short,
    pub pixels: *mut cty::c_char,
}
#[test]
fn bindgen_test_layout_gui_gc_Sprite() {
    assert_eq!(
        ::core::mem::size_of::<gui_gc_Sprite>(),
        16usize,
        concat!("Size of: ", stringify!(gui_gc_Sprite))
    );
    assert_eq!(
        ::core::mem::align_of::<gui_gc_Sprite>(),
        8usize,
        concat!("Alignment of ", stringify!(gui_gc_Sprite))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<gui_gc_Sprite>())).width as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(gui_gc_Sprite),
            "::",
            stringify!(width)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<gui_gc_Sprite>())).height as *const _ as usize },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(gui_gc_Sprite),
            "::",
            stringify!(height)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<gui_gc_Sprite>())).pixels as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(gui_gc_Sprite),
            "::",
            stringify!(pixels)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct gui_gc_Image_header {
    pub width: cty::c_uint,
    pub height: cty::c_uint,
    pub empty: cty::c_uint,
    pub buff_size: cty::c_uint,
    pub depth: cty::c_short,
    pub enc: cty::c_short,
}
#[test]
fn bindgen_test_layout_gui_gc_Image_header() {
    assert_eq!(
        ::core::mem::size_of::<gui_gc_Image_header>(),
        20usize,
        concat!("Size of: ", stringify!(gui_gc_Image_header))
    );
    assert_eq!(
        ::core::mem::align_of::<gui_gc_Image_header>(),
        4usize,
        concat!("Alignment of ", stringify!(gui_gc_Image_header))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<gui_gc_Image_header>())).width as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(gui_gc_Image_header),
            "::",
            stringify!(width)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<gui_gc_Image_header>())).height as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(gui_gc_Image_header),
            "::",
            stringify!(height)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<gui_gc_Image_header>())).empty as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(gui_gc_Image_header),
            "::",
            stringify!(empty)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<gui_gc_Image_header>())).buff_size as *const _ as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(gui_gc_Image_header),
            "::",
            stringify!(buff_size)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<gui_gc_Image_header>())).depth as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(gui_gc_Image_header),
            "::",
            stringify!(depth)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<gui_gc_Image_header>())).enc as *const _ as usize },
        18usize,
        concat!(
            "Offset of field: ",
            stringify!(gui_gc_Image_header),
            "::",
            stringify!(enc)
        )
    );
}
pub const gui_gc_Font_Regular9: gui_gc_Font = 9;
pub const gui_gc_Font_SerifRegular9: gui_gc_Font = 1033;
pub const gui_gc_Font_Regular10: gui_gc_Font = 10;
pub const gui_gc_Font_SerifRegular10: gui_gc_Font = 1034;
pub const gui_gc_Font_Regular11: gui_gc_Font = 11;
pub const gui_gc_Font_SerifRegular11: gui_gc_Font = 1035;
pub const gui_gc_Font_Regular12: gui_gc_Font = 12;
pub const gui_gc_Font_SerifRegular12: gui_gc_Font = 1036;
pub const gui_gc_Font_Bold9: gui_gc_Font = 265;
pub const gui_gc_Font_SerifBold9: gui_gc_Font = 1289;
pub const gui_gc_Font_Bold10: gui_gc_Font = 266;
pub const gui_gc_Font_SerifBold10: gui_gc_Font = 1290;
pub const gui_gc_Font_Bold11: gui_gc_Font = 267;
pub const gui_gc_Font_SerifBold11: gui_gc_Font = 1291;
pub const gui_gc_Font_Bold12: gui_gc_Font = 268;
pub const gui_gc_Font_SerifBold12: gui_gc_Font = 1292;
pub const gui_gc_Font_Italic9: gui_gc_Font = 521;
pub const gui_gc_Font_SerifItalic9: gui_gc_Font = 1545;
pub const gui_gc_Font_Italic10: gui_gc_Font = 522;
pub const gui_gc_Font_SerifItalic10: gui_gc_Font = 1546;
pub const gui_gc_Font_Italic11: gui_gc_Font = 523;
pub const gui_gc_Font_SerifItalic11: gui_gc_Font = 1547;
pub const gui_gc_Font_Italic12: gui_gc_Font = 524;
pub const gui_gc_Font_SerifItalic12: gui_gc_Font = 1548;
pub const gui_gc_Font_BoldItalic9: gui_gc_Font = 777;
pub const gui_gc_Font_SerifBoldItalic9: gui_gc_Font = 1801;
pub const gui_gc_Font_BoldItalic10: gui_gc_Font = 778;
pub const gui_gc_Font_SerifBoldItalic10: gui_gc_Font = 1802;
pub const gui_gc_Font_BoldItalic11: gui_gc_Font = 779;
pub const gui_gc_Font_SerifBoldItalic11: gui_gc_Font = 1803;
pub const gui_gc_Font_BoldItalic12: gui_gc_Font = 780;
pub const gui_gc_Font_SerifBoldItalic12: gui_gc_Font = 1804;
pub const gui_gc_Font_SerifBold24: gui_gc_Font = 1304;
pub const gui_gc_Font_SerifRegular7: gui_gc_Font = 1031;
pub type gui_gc_Font = u32;
pub type Gc = *mut *mut cty::c_void;
extern "C" {
    pub fn gui_gc_global_GC() -> Gc;
}
extern "C" {
    pub fn gui_gc_free(arg1: Gc);
}
extern "C" {
    pub fn gui_gc_copy(arg1: Gc, w: cty::c_int, h: cty::c_int) -> Gc;
}
extern "C" {
    pub fn gui_gc_begin(arg1: Gc) -> cty::c_int;
}
extern "C" {
    pub fn gui_gc_finish(arg1: Gc);
}
extern "C" {
    pub fn gui_gc_clipRect(
        gc: Gc,
        x: cty::c_int,
        y: cty::c_int,
        w: cty::c_int,
        h: cty::c_int,
        op: gui_gc_ClipRectOp,
    );
}
extern "C" {
    pub fn gui_gc_setColorRGB(arg1: Gc, r: cty::c_int, g: cty::c_int, b: cty::c_int);
}
extern "C" {
    pub fn gui_gc_setColor(arg1: Gc, arg2: cty::c_int);
}
extern "C" {
    pub fn gui_gc_setAlpha(arg1: Gc, arg2: gui_gc_Alpha);
}
extern "C" {
    pub fn gui_gc_setFont(arg1: Gc, arg2: gui_gc_Font);
}
extern "C" {
    pub fn gui_gc_getFont(arg1: Gc) -> gui_gc_Font;
}
extern "C" {
    pub fn gui_gc_setPen(arg1: Gc, arg2: gui_gc_PenSize, arg3: gui_gc_PenMode);
}
extern "C" {
    pub fn gui_gc_setRegin(
        gc: Gc,
        xs: cty::c_int,
        ys: cty::c_int,
        ws: cty::c_int,
        hs: cty::c_int,
        x: cty::c_int,
        y: cty::c_int,
        w: cty::c_int,
        h: cty::c_int,
    );
}
extern "C" {
    pub fn gui_gc_drawArc(
        gc: Gc,
        x: cty::c_int,
        y: cty::c_int,
        w: cty::c_int,
        h: cty::c_int,
        start: cty::c_int,
        end: cty::c_int,
    );
}
extern "C" {
    pub fn gui_gc_drawIcon(
        gc: Gc,
        res: e_resourceID,
        icon: cty::c_int,
        x: cty::c_int,
        y: cty::c_int,
    );
}
extern "C" {
    pub fn gui_gc_drawSprite(arg1: Gc, arg2: *mut gui_gc_Sprite, x: cty::c_int, y: cty::c_int);
}
extern "C" {
    pub fn gui_gc_drawLine(
        arg1: Gc,
        x1: cty::c_int,
        y1: cty::c_int,
        x2: cty::c_int,
        y2: cty::c_int,
    );
}
extern "C" {
    pub fn gui_gc_drawRect(arg1: Gc, x: cty::c_int, y: cty::c_int, w: cty::c_int, h: cty::c_int);
}
extern "C" {
    pub fn gui_gc_drawString(
        gc: Gc,
        utf16: *mut cty::c_char,
        x: cty::c_int,
        y: cty::c_int,
        mode: gui_gc_StringMode,
    );
}
extern "C" {
    pub fn gui_gc_drawPoly(arg1: Gc, points: *mut cty::c_uint, count: cty::c_uint);
}
extern "C" {
    pub fn gui_gc_fillArc(
        arg1: Gc,
        x: cty::c_int,
        y: cty::c_int,
        w: cty::c_int,
        h: cty::c_int,
        start: cty::c_int,
        end: cty::c_int,
    );
}
extern "C" {
    pub fn gui_gc_fillPoly(arg1: Gc, points: *mut cty::c_uint, count: cty::c_uint);
}
extern "C" {
    pub fn gui_gc_fillRect(arg1: Gc, x: cty::c_int, y: cty::c_int, w: cty::c_int, h: cty::c_int);
}
extern "C" {
    pub fn gui_gc_fillGradient(
        arg1: Gc,
        x: cty::c_int,
        y: cty::c_int,
        w: cty::c_int,
        h: cty::c_int,
        start_color: cty::c_int,
        end_color: cty::c_int,
        vertical: cty::c_int,
    );
}
extern "C" {
    pub fn gui_gc_drawImage(arg1: Gc, TI_Image: *mut cty::c_char, x: cty::c_int, y: cty::c_int);
}
extern "C" {
    pub fn gui_gc_getStringWidth(
        arg1: Gc,
        arg2: gui_gc_Font,
        utf16: *mut cty::c_char,
        start: cty::c_int,
        length: cty::c_int,
    ) -> cty::c_int;
}
extern "C" {
    pub fn gui_gc_getCharWidth(arg1: Gc, arg2: gui_gc_Font, c: cty::c_short) -> cty::c_int;
}
extern "C" {
    pub fn gui_gc_getStringSmallHeight(
        arg1: Gc,
        font: gui_gc_Font,
        utf16: *mut cty::c_char,
        start: cty::c_int,
        length: cty::c_int,
    ) -> cty::c_int;
}
extern "C" {
    pub fn gui_gc_getCharHeight(arg1: Gc, arg2: gui_gc_Font, c: cty::c_short) -> cty::c_int;
}
extern "C" {
    pub fn gui_gc_getStringHeight(
        arg1: Gc,
        font: gui_gc_Font,
        utf16: *mut cty::c_char,
        start: cty::c_int,
        length: cty::c_int,
    ) -> cty::c_int;
}
extern "C" {
    pub fn gui_gc_getFontHeight(arg1: Gc, arg2: gui_gc_Font) -> cty::c_int;
}
extern "C" {
    pub fn gui_gc_getIconSize(
        arg1: Gc,
        res: e_resourceID,
        icon: cty::c_uint,
        w: *mut cty::c_uint,
        h: *mut cty::c_uint,
    ) -> cty::c_int;
}
extern "C" {
    pub fn gui_gc_blit_gc(
        source: Gc,
        xs: cty::c_int,
        ys: cty::c_int,
        ws: cty::c_int,
        hs: cty::c_int,
        dest: Gc,
        xd: cty::c_int,
        yd: cty::c_int,
        wd: cty::c_int,
        hd: cty::c_int,
    );
}
extern "C" {
    pub fn gui_gc_blit_buffer(
        gc: Gc,
        buffer: *mut cty::c_char,
        x: cty::c_int,
        y: cty::c_int,
        w: cty::c_int,
        h: cty::c_int,
    );
}
extern "C" {
    pub fn gui_gc_blit_to_screen(gc: Gc);
}
extern "C" {
    pub fn gui_gc_blit_to_screen_region(
        gc: Gc,
        x: cty::c_uint,
        y: cty::c_uint,
        w: cty::c_uint,
        h: cty::c_uint,
    );
}
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Copy, Clone)]
pub struct max_align_t {
    pub __clang_max_align_nonce1: cty::c_longlong,
    pub __bindgen_padding_0: u64,
    pub __clang_max_align_nonce2: u128,
}
#[test]
fn bindgen_test_layout_max_align_t() {
    assert_eq!(
        ::core::mem::size_of::<max_align_t>(),
        32usize,
        concat!("Size of: ", stringify!(max_align_t))
    );
    assert_eq!(
        ::core::mem::align_of::<max_align_t>(),
        16usize,
        concat!("Alignment of ", stringify!(max_align_t))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<max_align_t>())).__clang_max_align_nonce1 as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(max_align_t),
            "::",
            stringify!(__clang_max_align_nonce1)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<max_align_t>())).__clang_max_align_nonce2 as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(max_align_t),
            "::",
            stringify!(__clang_max_align_nonce2)
        )
    );
}
extern "C" {
    pub fn luaopen_base(L: *mut lua_State) -> cty::c_int;
}
extern "C" {
    pub fn luaopen_table(L: *mut lua_State) -> cty::c_int;
}
extern "C" {
    pub fn luaopen_io(L: *mut lua_State) -> cty::c_int;
}
extern "C" {
    pub fn luaopen_os(L: *mut lua_State) -> cty::c_int;
}
extern "C" {
    pub fn luaopen_string(L: *mut lua_State) -> cty::c_int;
}
extern "C" {
    pub fn luaopen_math(L: *mut lua_State) -> cty::c_int;
}
extern "C" {
    pub fn luaopen_debug(L: *mut lua_State) -> cty::c_int;
}
extern "C" {
    pub fn luaopen_package(L: *mut lua_State) -> cty::c_int;
}
extern "C" {
    pub fn luaL_openlibs(L: *mut lua_State);
}
extern "C" {
    pub fn nuc_fopen(p1: *const cty::c_char, p2: *const cty::c_char) -> *mut NUC_FILE;
}
extern "C" {
    pub fn nuc_fread(p1: *mut cty::c_void, p2: usize, p3: usize, p4: *mut NUC_FILE) -> usize;
}
extern "C" {
    pub fn nuc_fwrite(p1: *mut cty::c_void, p2: usize, p3: usize, p4: *mut NUC_FILE) -> usize;
}
extern "C" {
    pub fn nuc_fclose(p1: *mut NUC_FILE) -> cty::c_int;
}
extern "C" {
    pub fn nuc_fgets(p1: *mut cty::c_char, p2: cty::c_int, p3: *mut NUC_FILE) -> *mut cty::c_char;
}
extern "C" {
    pub fn ascii2utf16(p1: *mut cty::c_void, p2: *const cty::c_char, p3: cty::c_int);
}
extern "C" {
    pub fn TCT_Local_Control_Interrupts(p1: cty::c_int) -> cty::c_int;
}
extern "C" {
    pub fn nuc_stat(p1: *const cty::c_char, p2: *mut nuc_stat) -> cty::c_int;
}
extern "C" {
    pub fn TCC_Terminate_Task(p1: *mut NU_TASK) -> cty::c_int;
}
extern "C" {
    pub fn nuc_puts(p1: *const cty::c_char) -> cty::c_int;
}
extern "C" {
    pub fn NU_Get_First(p1: *mut dstat, p2: *const cty::c_char) -> cty::c_int;
}
extern "C" {
    pub fn NU_Get_Next(p1: *mut dstat) -> cty::c_int;
}
extern "C" {
    pub fn NU_Done(p1: *mut dstat);
}
extern "C" {
    pub fn show_dialog_box2_(
        p1: cty::c_int,
        p2: *const cty::c_char,
        p3: *const cty::c_char,
        p4: *mut *const cty::c_char,
    );
}
extern "C" {
    pub fn nuc_fseek(p1: *mut NUC_FILE, p2: cty::c_long, p3: cty::c_int) -> cty::c_int;
}
extern "C" {
    pub fn NU_Current_Dir(p1: *const cty::c_char, p2: *const cty::c_char) -> cty::c_int;
}
extern "C" {
    pub fn NU_Set_Current_Dir(p1: *const cty::c_char) -> cty::c_int;
}
extern "C" {
    pub fn touchpad_read(p1: cty::c_uchar, p2: cty::c_uchar, p3: *mut cty::c_void) -> cty::c_int;
}
extern "C" {
    pub fn touchpad_write(p1: cty::c_uchar, p2: cty::c_uchar, p3: *mut cty::c_void) -> cty::c_int;
}
extern "C" {
    pub fn TCC_Current_Task_Pointer() -> *mut NU_TASK;
}
extern "C" {
    pub fn nuc_ftell(p1: *mut NUC_FILE) -> cty::c_long;
}
extern "C" {
    pub fn NU_Open(p1: *mut cty::c_char, p2: u32, p3: u32) -> PCFD;
}
extern "C" {
    pub fn NU_Close(p1: PCFD) -> cty::c_int;
}
extern "C" {
    pub fn NU_Truncate(p1: PCFD, p2: cty::c_long) -> cty::c_int;
}
extern "C" {
    pub fn _show_msgbox_2b(
        p1: cty::c_int,
        p2: *const cty::c_char,
        p3: *const cty::c_char,
        p4: *const cty::c_char,
        p5: cty::c_int,
        p6: *const cty::c_char,
        p7: cty::c_int,
        p8: *mut *const cty::c_char,
    ) -> cty::c_int;
}
extern "C" {
    pub fn _show_msgbox_3b(
        p1: cty::c_int,
        p2: *const cty::c_char,
        p3: *const cty::c_char,
        p4: *const cty::c_char,
        p5: cty::c_int,
        p6: *const cty::c_char,
        p7: cty::c_int,
        p8: *const cty::c_char,
        p9: cty::c_int,
        p10: *mut *const cty::c_char,
    ) -> cty::c_int;
}
extern "C" {
    pub fn nuc_opendir(p1: *const cty::c_char) -> *mut NUC_DIR;
}
extern "C" {
    pub fn nuc_readdir(p1: *mut NUC_DIR) -> *mut nuc_dirent;
}
extern "C" {
    pub fn nuc_closedir(p1: *mut NUC_DIR) -> cty::c_int;
}
extern "C" {
    pub fn luaL_register(p1: *mut lua_State, p2: *const cty::c_char, p3: *const luaL_Reg);
}
extern "C" {
    pub fn luaL_checklstring(
        p1: *mut lua_State,
        p2: cty::c_int,
        p3: *mut usize,
    ) -> *const cty::c_char;
}
extern "C" {
    pub fn luaL_error(p1: *mut lua_State, fmt: *const cty::c_char, ...) -> cty::c_int;
}
extern "C" {
    pub fn refresh_homescr();
}
extern "C" {
    pub fn refresh_docbrowser(p1: cty::c_int);
}
extern "C" {
    pub fn utf162ascii(p1: *mut cty::c_char, p2: *const u16, p3: cty::c_int);
}
extern "C" {
    pub fn utf16_strlen(p1: *const u16) -> usize;
}
extern "C" {
    pub fn _show_1NumericInput(
        p1: cty::c_int,
        p2: *const cty::c_char,
        p3: *const cty::c_char,
        p4: *const cty::c_char,
        p5: *mut cty::c_int,
        p6: cty::c_int,
        p7: cty::c_int,
        p8: cty::c_int,
    ) -> cty::c_int;
}
extern "C" {
    pub fn _show_2NumericInput(
        p1: cty::c_int,
        p2: *const cty::c_char,
        p3: *const cty::c_char,
        p4: *const cty::c_char,
        p5: *mut cty::c_int,
        p6: cty::c_int,
        p7: cty::c_int,
        p8: cty::c_int,
        p9: *const cty::c_char,
        p10: *mut cty::c_int,
        p11: cty::c_int,
        p12: cty::c_int,
        p13: cty::c_int,
    ) -> cty::c_int;
}
extern "C" {
    pub fn _show_msgUserInput(
        p1: cty::c_int,
        p2: *mut String,
        p3: *const cty::c_char,
        p4: *const cty::c_char,
    ) -> cty::c_int;
}
extern "C" {
    pub fn string_new() -> String;
}
extern "C" {
    pub fn string_free(p1: String);
}
extern "C" {
    pub fn string_to_ascii(p1: String) -> *mut cty::c_char;
}
extern "C" {
    pub fn string_lower(p1: String);
}
extern "C" {
    pub fn string_charAt(p1: String, p2: cty::c_int) -> cty::c_char;
}
extern "C" {
    pub fn string_concat_utf16(p1: String, p2: *const cty::c_char) -> cty::c_int;
}
extern "C" {
    pub fn string_set_ascii(p1: String, p2: *const cty::c_char) -> cty::c_int;
}
extern "C" {
    pub fn string_set_utf16(p1: String, p2: *const cty::c_char) -> cty::c_int;
}
extern "C" {
    pub fn string_indexOf_utf16(p1: String, p2: cty::c_int, p3: *const cty::c_char) -> cty::c_int;
}
extern "C" {
    pub fn string_last_indexOf_utf16(
        p1: String,
        p2: cty::c_int,
        p3: *const cty::c_char,
    ) -> cty::c_int;
}
extern "C" {
    pub fn string_compareTo_utf16(p1: String, p2: *const cty::c_char) -> cty::c_int;
}
extern "C" {
    pub fn string_substring(
        p1: String,
        p2: String,
        p3: cty::c_int,
        p4: cty::c_int,
    ) -> *mut cty::c_char;
}
extern "C" {
    pub fn string_erase(p1: String, p2: cty::c_int);
}
extern "C" {
    pub fn string_truncate(p1: String, p2: cty::c_int);
}
extern "C" {
    pub fn string_subtrsing_utf16(
        p1: String,
        p2: *const cty::c_char,
        p3: *mut cty::c_int,
    ) -> *mut cty::c_char;
}
extern "C" {
    pub fn string_insert_replace_utf16(
        p1: String,
        p2: *const cty::c_char,
        p3: cty::c_int,
        p4: cty::c_int,
    ) -> cty::c_int;
}
extern "C" {
    pub fn string_insert_utf16(p1: String, p2: *const cty::c_char, p3: cty::c_int) -> cty::c_int;
}
extern "C" {
    pub fn string_sprintf_utf16(p1: String, fmt: *const cty::c_char, ...) -> cty::c_int;
}
extern "C" {
    pub fn usbd_open_pipe(
        p1: usbd_interface_handle,
        p2: u8,
        p3: u8,
        p4: *mut usbd_pipe_handle,
    ) -> usbd_status;
}
extern "C" {
    pub fn usbd_close_pipe(p1: usbd_pipe_handle) -> usbd_status;
}
extern "C" {
    pub fn usbd_transfer(p1: usbd_xfer_handle) -> usbd_status;
}
extern "C" {
    pub fn usbd_alloc_xfer(p1: usbd_device_handle) -> usbd_xfer_handle;
}
extern "C" {
    pub fn usbd_free_xfer(p1: usbd_xfer_handle) -> usbd_status;
}
extern "C" {
    pub fn usbd_setup_xfer(
        p1: usbd_xfer_handle,
        p2: usbd_pipe_handle,
        p3: usbd_private_handle,
        p4: *mut cty::c_void,
        p5: u32,
        p6: u16,
        p7: u32,
        p8: usbd_callback,
    );
}
extern "C" {
    pub fn usbd_setup_isoc_xfer(
        p1: usbd_xfer_handle,
        p2: usbd_pipe_handle,
        p3: usbd_private_handle,
        p4: *mut u16,
        p5: u32,
        p6: u16,
        p7: usbd_callback,
    );
}
extern "C" {
    pub fn usbd_get_xfer_status(
        p1: usbd_xfer_handle,
        p2: *mut usbd_private_handle,
        p3: *mut *mut cty::c_void,
        p4: *mut u32,
        p5: *mut usbd_status,
    );
}
extern "C" {
    pub fn usbd_interface2endpoint_descriptor(
        p1: usbd_interface_handle,
        p2: u8,
    ) -> *mut usb_endpoint_descriptor_t;
}
extern "C" {
    pub fn usbd_abort_pipe(p1: usbd_pipe_handle) -> usbd_status;
}
extern "C" {
    pub fn usbd_clear_endpoint_stall(p1: usbd_pipe_handle) -> usbd_status;
}
extern "C" {
    pub fn usbd_endpoint_count(p1: usbd_interface_handle, p2: *mut u8) -> usbd_status;
}
extern "C" {
    pub fn usbd_interface_count(p1: usbd_device_handle, p2: *mut u8) -> usbd_status;
}
extern "C" {
    pub fn usbd_interface2device_handle(
        p1: usbd_interface_handle,
        p2: *mut usbd_device_handle,
    ) -> usbd_status;
}
extern "C" {
    pub fn usbd_device2interface_handle(
        p1: usbd_device_handle,
        p2: u8,
        p3: *mut usbd_interface_handle,
    ) -> usbd_status;
}
extern "C" {
    pub fn usbd_pipe2device_handle(p1: usbd_pipe_handle) -> usbd_status;
}
extern "C" {
    pub fn usbd_sync_transfer(p1: usbd_xfer_handle) -> usbd_status;
}
extern "C" {
    pub fn usbd_open_pipe_intr(
        p1: usbd_interface_handle,
        p2: u8,
        p3: u8,
        p4: *mut usbd_pipe_handle,
        p5: usbd_private_handle,
        p6: *mut cty::c_void,
        p8: *mut u32,
        p9: usbd_callback,
        p10: cty::c_int,
    ) -> usbd_status;
}
extern "C" {
    pub fn usbd_do_request(
        p1: usbd_device_handle,
        p2: *mut usb_device_request_t,
        p3: *mut cty::c_void,
    ) -> usbd_status;
}
extern "C" {
    pub fn usbd_do_request_flags(
        p1: usbd_device_handle,
        p2: *mut usb_device_request_t,
        p3: *mut cty::c_void,
        p4: u16,
        p5: *mut cty::c_int,
    ) -> usbd_status;
}
extern "C" {
    pub fn usbd_do_request_flags_pipe(
        p1: usbd_device_handle,
        p2: usbd_pipe_handle,
        p3: *mut usb_device_request_t,
        p4: *mut cty::c_void,
        p5: u16,
        p6: *mut cty::c_int,
    ) -> usbd_status;
}
extern "C" {
    pub fn usbd_get_interface_descriptor(
        p1: usbd_interface_handle,
    ) -> *mut usb_interface_descriptor_t;
}
extern "C" {
    pub fn usbd_get_config_descriptor(p1: usbd_device_handle) -> *mut usb_config_descriptor_t;
}
extern "C" {
    pub fn usbd_set_interface(p1: usbd_interface_handle, p2: cty::c_int) -> usbd_status;
}
extern "C" {
    pub fn usbd_get_interface(p1: usbd_interface_handle, p2: *mut u8) -> usbd_status;
}
extern "C" {
    pub fn usbd_find_idesc(
        p1: *mut usb_config_descriptor_t,
        p2: cty::c_int,
        p3: cty::c_int,
    ) -> *mut usb_interface_descriptor_t;
}
extern "C" {
    pub fn usbd_errstr(p1: usbd_status) -> *const cty::c_char;
}
extern "C" {
    pub fn usbd_devinfo(p1: usbd_device_handle, p2: cty::c_int, p3: *mut cty::c_char);
}
extern "C" {
    pub fn usbd_get_endpoint_descriptor(
        p1: usbd_interface_handle,
        p2: u8,
    ) -> *mut usb_endpoint_descriptor_t;
}
extern "C" {
    pub fn usb_register_driver(
        p1: cty::c_int,
        p2: *mut ::core::option::Option<unsafe extern "C" fn(arg1: device_t) -> cty::c_int>,
        p3: *const cty::c_char,
        p4: cty::c_int,
        p5: cty::c_uint,
    ) -> cty::c_int;
}
extern "C" {
    pub fn device_get_ivars(p1: device_t) -> *mut cty::c_void;
}
extern "C" {
    pub fn device_get_softc(p1: device_t) -> *mut cty::c_void;
}
extern "C" {
    pub fn get_event(p1: *mut s_ns_event) -> cty::c_int;
}
extern "C" {
    pub fn send_key_event(p1: *mut s_ns_event, p2: cty::c_ushort, p3: BOOL, p4: BOOL);
}
extern "C" {
    pub fn send_click_event(p1: *mut s_ns_event, p2: cty::c_ushort, p3: BOOL, p4: BOOL);
}
extern "C" {
    pub fn send_pad_event(p1: *mut s_ns_event, p2: cty::c_ushort, p3: BOOL, p4: BOOL);
}
extern "C" {
    pub fn TI_NN_NodeEnumDone(p1: nn_oh_t) -> i16;
}
extern "C" {
    pub fn TI_NN_NodeEnumNext(p1: nn_oh_t, p2: *mut nn_nh_t) -> i16;
}
extern "C" {
    pub fn TI_NN_GetConnMaxPktSize(p1: nn_ch_t) -> u32;
}
extern "C" {
    pub fn TI_NN_Read(p1: nn_ch_t, p2: u32, p3: *mut cty::c_void, p4: u32, p5: u32) -> u16;
}
extern "C" {
    pub fn TI_NN_Write(p1: nn_ch_t, p2: *mut cty::c_void, p3: u32) -> i16;
}
extern "C" {
    pub fn TI_NN_StartService(
        p1: u32,
        p2: *mut cty::c_void,
        p3: ::core::option::Option<unsafe extern "C" fn(arg1: nn_ch_t, arg2: *mut cty::c_void)>,
    ) -> i16;
}
extern "C" {
    pub fn TI_NN_StopService(p1: u32) -> i16;
}
extern "C" {
    pub fn TI_NN_Connect(p1: nn_nh_t, p2: u32, p3: *mut nn_ch_t) -> i16;
}
extern "C" {
    pub fn TI_NN_Disconnect(p1: nn_ch_t) -> i16;
}
extern "C" {
    pub fn TI_NN_NodeEnumInit(p1: nn_ch_t) -> i16;
}
extern "C" {
    pub fn TI_NN_DestroyOperationHandle(p1: nn_oh_t) -> i16;
}
extern "C" {
    pub fn TI_NN_CreateOperationHandle() -> nn_oh_t;
}
extern "C" {
    pub fn get_documents_dir() -> *const cty::c_char;
}
extern "C" {
    pub fn gui_gc_setRegion(
        p1: Gc,
        p2: cty::c_int,
        p3: cty::c_int,
        p4: cty::c_int,
        p5: cty::c_int,
        p6: cty::c_int,
        p7: cty::c_int,
        p8: cty::c_int,
        p9: cty::c_int,
    );
}
extern "C" {
    pub fn read_nand(
        dest: *mut cty::c_void,
        size: cty::c_int,
        nand_offset: cty::c_int,
        unknown: cty::c_int,
        percent_max: cty::c_int,
        progress_cb: *mut cty::c_void,
    );
}
extern "C" {
    pub fn write_nand(p1: *mut cty::c_void, p2: cty::c_int, p3: cty::c_uint) -> cty::c_int;
}
extern "C" {
    pub fn nand_erase_range(p1: cty::c_int, p2: cty::c_int) -> cty::c_int;
}
extern "C" {
    pub fn TI_MS_evaluateExpr_ACBER(
        p1: *mut cty::c_void,
        p2: *mut cty::c_void,
        p3: *const u16,
        p4: *mut cty::c_void,
        p5: *mut cty::c_void,
    ) -> cty::c_int;
}
extern "C" {
    pub fn get_res_string(p1: cty::c_int, p2: cty::c_int) -> *mut cty::c_char;
}
extern "C" {
    pub fn disp_str(p1: *const cty::c_char, p2: *mut cty::c_int, p3: cty::c_int);
}
extern "C" {
    pub fn TI_MS_MathExprToStr(
        p1: *mut cty::c_void,
        p2: *mut cty::c_void,
        p3: *mut *mut u16,
    ) -> cty::c_int;
}
pub type __builtin_va_list = [__va_list_tag; 1usize];
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __va_list_tag {
    pub gp_offset: cty::c_uint,
    pub fp_offset: cty::c_uint,
    pub overflow_arg_area: *mut cty::c_void,
    pub reg_save_area: *mut cty::c_void,
}
#[test]
fn bindgen_test_layout___va_list_tag() {
    assert_eq!(
        ::core::mem::size_of::<__va_list_tag>(),
        24usize,
        concat!("Size of: ", stringify!(__va_list_tag))
    );
    assert_eq!(
        ::core::mem::align_of::<__va_list_tag>(),
        8usize,
        concat!("Alignment of ", stringify!(__va_list_tag))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__va_list_tag),
            "::",
            stringify!(gp_offset)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(__va_list_tag),
            "::",
            stringify!(fp_offset)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(__va_list_tag),
            "::",
            stringify!(overflow_arg_area)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(__va_list_tag),
            "::",
            stringify!(reg_save_area)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __locale_data {
    pub _address: u8,
}