flite-sys 0.1.2

#![allow(non_upper_case_globals)]
#![allow(non_snake_case)]
#![allow(non_camel_case_types)]
/* automatically generated by rust-bindgen 0.61.0 */

pub const _STRING_H: u32 = 1;
pub const _FEATURES_H: u32 = 1;
pub const _DEFAULT_SOURCE: u32 = 1;
pub const __GLIBC_USE_ISOC2X: u32 = 0;
pub const __USE_ISOC11: u32 = 1;
pub const __USE_ISOC99: u32 = 1;
pub const __USE_ISOC95: u32 = 1;
pub const __USE_POSIX_IMPLICITLY: u32 = 1;
pub const _POSIX_SOURCE: u32 = 1;
pub const _POSIX_C_SOURCE: u32 = 200809;
pub const __USE_POSIX: u32 = 1;
pub const __USE_POSIX2: u32 = 1;
pub const __USE_POSIX199309: u32 = 1;
pub const __USE_POSIX199506: u32 = 1;
pub const __USE_XOPEN2K: u32 = 1;
pub const __USE_XOPEN2K8: u32 = 1;
pub const _ATFILE_SOURCE: u32 = 1;
pub const __WORDSIZE: u32 = 64;
pub const __WORDSIZE_TIME64_COMPAT32: u32 = 1;
pub const __SYSCALL_WORDSIZE: u32 = 64;
pub const __TIMESIZE: u32 = 64;
pub const __USE_MISC: u32 = 1;
pub const __USE_ATFILE: u32 = 1;
pub const __USE_FORTIFY_LEVEL: u32 = 0;
pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 0;
pub const __GLIBC_USE_DEPRECATED_SCANF: u32 = 0;
pub const _STDC_PREDEF_H: u32 = 1;
pub const __STDC_IEC_559__: u32 = 1;
pub const __STDC_IEC_60559_BFP__: u32 = 201404;
pub const __STDC_IEC_559_COMPLEX__: u32 = 1;
pub const __STDC_IEC_60559_COMPLEX__: u32 = 201404;
pub const __STDC_ISO_10646__: u32 = 201706;
pub const __GNU_LIBRARY__: u32 = 6;
pub const __GLIBC__: u32 = 2;
pub const __GLIBC_MINOR__: u32 = 36;
pub const _SYS_CDEFS_H: u32 = 1;
pub const __glibc_c99_flexarr_available: u32 = 1;
pub const __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI: u32 = 0;
pub const __HAVE_GENERIC_SELECTION: u32 = 1;
pub const __GLIBC_USE_LIB_EXT2: u32 = 0;
pub const __GLIBC_USE_IEC_60559_BFP_EXT: u32 = 0;
pub const __GLIBC_USE_IEC_60559_BFP_EXT_C2X: u32 = 0;
pub const __GLIBC_USE_IEC_60559_EXT: u32 = 0;
pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: u32 = 0;
pub const __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X: u32 = 0;
pub const __GLIBC_USE_IEC_60559_TYPES_EXT: u32 = 0;
pub const _BITS_TYPES_LOCALE_T_H: u32 = 1;
pub const _BITS_TYPES___LOCALE_T_H: u32 = 1;
pub const _STRINGS_H: u32 = 1;
pub const CST_WRONG_FORMAT: i32 = -2;
pub const CST_ERROR_FORMAT: i32 = -1;
pub const CST_OK_FORMAT: u32 = 0;
pub const _STDIO_H: u32 = 1;
pub const __GNUC_VA_LIST: u32 = 1;
pub const _BITS_TYPES_H: u32 = 1;
pub const _BITS_TYPESIZES_H: u32 = 1;
pub const __OFF_T_MATCHES_OFF64_T: u32 = 1;
pub const __INO_T_MATCHES_INO64_T: u32 = 1;
pub const __RLIM_T_MATCHES_RLIM64_T: u32 = 1;
pub const __STATFS_MATCHES_STATFS64: u32 = 1;
pub const __KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64: u32 = 1;
pub const __FD_SETSIZE: u32 = 1024;
pub const _BITS_TIME64_H: u32 = 1;
pub const _____fpos_t_defined: u32 = 1;
pub const ____mbstate_t_defined: u32 = 1;
pub const _____fpos64_t_defined: u32 = 1;
pub const ____FILE_defined: u32 = 1;
pub const __FILE_defined: u32 = 1;
pub const __struct_FILE_defined: u32 = 1;
pub const _IO_EOF_SEEN: u32 = 16;
pub const _IO_ERR_SEEN: u32 = 32;
pub const _IO_USER_LOCK: u32 = 32768;
pub const _IOFBF: u32 = 0;
pub const _IOLBF: u32 = 1;
pub const _IONBF: u32 = 2;
pub const BUFSIZ: u32 = 8192;
pub const EOF: i32 = -1;
pub const SEEK_SET: u32 = 0;
pub const SEEK_CUR: u32 = 1;
pub const SEEK_END: u32 = 2;
pub const P_tmpdir: &[u8; 5usize] = b"/tmp\0";
pub const _BITS_STDIO_LIM_H: u32 = 1;
pub const L_tmpnam: u32 = 20;
pub const TMP_MAX: u32 = 238328;
pub const FILENAME_MAX: u32 = 4096;
pub const L_ctermid: u32 = 9;
pub const FOPEN_MAX: u32 = 16;
pub const __HAVE_FLOAT128: u32 = 0;
pub const __HAVE_DISTINCT_FLOAT128: u32 = 0;
pub const __HAVE_FLOAT64X: u32 = 1;
pub const __HAVE_FLOAT64X_LONG_DOUBLE: u32 = 1;
pub const __HAVE_FLOAT16: u32 = 0;
pub const __HAVE_FLOAT32: u32 = 1;
pub const __HAVE_FLOAT64: u32 = 1;
pub const __HAVE_FLOAT32X: u32 = 1;
pub const __HAVE_FLOAT128X: u32 = 0;
pub const __HAVE_DISTINCT_FLOAT16: u32 = 0;
pub const __HAVE_DISTINCT_FLOAT32: u32 = 0;
pub const __HAVE_DISTINCT_FLOAT64: u32 = 0;
pub const __HAVE_DISTINCT_FLOAT32X: u32 = 0;
pub const __HAVE_DISTINCT_FLOAT64X: u32 = 0;
pub const __HAVE_DISTINCT_FLOAT128X: u32 = 0;
pub const __HAVE_FLOATN_NOT_TYPEDEF: u32 = 0;
pub const CST_OPEN_WRITE: u32 = 1;
pub const CST_OPEN_READ: u32 = 2;
pub const CST_OPEN_APPEND: u32 = 4;
pub const CST_OPEN_BINARY: u32 = 8;
pub const CST_SEEK_ABSOLUTE: u32 = 0;
pub const CST_SEEK_RELATIVE: u32 = 1;
pub const CST_SEEK_ENDREL: u32 = 2;
pub const CST_REGMAGIC: u32 = 156;
pub const CST_NSUBEXP: u32 = 10;
pub const CST_RX_dotted_abbrev_NUM: u32 = 0;
pub const _STDLIB_H: u32 = 1;
pub const WNOHANG: u32 = 1;
pub const WUNTRACED: u32 = 2;
pub const WSTOPPED: u32 = 2;
pub const WEXITED: u32 = 4;
pub const WCONTINUED: u32 = 8;
pub const WNOWAIT: u32 = 16777216;
pub const __WNOTHREAD: u32 = 536870912;
pub const __WALL: u32 = 1073741824;
pub const __WCLONE: u32 = 2147483648;
pub const __W_CONTINUED: u32 = 65535;
pub const __WCOREFLAG: u32 = 128;
pub const __ldiv_t_defined: u32 = 1;
pub const __lldiv_t_defined: u32 = 1;
pub const RAND_MAX: u32 = 2147483647;
pub const EXIT_FAILURE: u32 = 1;
pub const EXIT_SUCCESS: u32 = 0;
pub const _SYS_TYPES_H: u32 = 1;
pub const __clock_t_defined: u32 = 1;
pub const __clockid_t_defined: u32 = 1;
pub const __time_t_defined: u32 = 1;
pub const __timer_t_defined: u32 = 1;
pub const _BITS_STDINT_INTN_H: u32 = 1;
pub const __BIT_TYPES_DEFINED__: u32 = 1;
pub const _ENDIAN_H: u32 = 1;
pub const _BITS_ENDIAN_H: u32 = 1;
pub const __LITTLE_ENDIAN: u32 = 1234;
pub const __BIG_ENDIAN: u32 = 4321;
pub const __PDP_ENDIAN: u32 = 3412;
pub const _BITS_ENDIANNESS_H: u32 = 1;
pub const __BYTE_ORDER: u32 = 1234;
pub const __FLOAT_WORD_ORDER: u32 = 1234;
pub const LITTLE_ENDIAN: u32 = 1234;
pub const BIG_ENDIAN: u32 = 4321;
pub const PDP_ENDIAN: u32 = 3412;
pub const BYTE_ORDER: u32 = 1234;
pub const _BITS_BYTESWAP_H: u32 = 1;
pub const _BITS_UINTN_IDENTITY_H: u32 = 1;
pub const _SYS_SELECT_H: u32 = 1;
pub const __sigset_t_defined: u32 = 1;
pub const __timeval_defined: u32 = 1;
pub const _STRUCT_TIMESPEC: u32 = 1;
pub const FD_SETSIZE: u32 = 1024;
pub const _BITS_PTHREADTYPES_COMMON_H: u32 = 1;
pub const _THREAD_SHARED_TYPES_H: u32 = 1;
pub const _BITS_PTHREADTYPES_ARCH_H: u32 = 1;
pub const __SIZEOF_PTHREAD_MUTEX_T: u32 = 40;
pub const __SIZEOF_PTHREAD_ATTR_T: u32 = 56;
pub const __SIZEOF_PTHREAD_RWLOCK_T: u32 = 56;
pub const __SIZEOF_PTHREAD_BARRIER_T: u32 = 32;
pub const __SIZEOF_PTHREAD_MUTEXATTR_T: u32 = 4;
pub const __SIZEOF_PTHREAD_COND_T: u32 = 48;
pub const __SIZEOF_PTHREAD_CONDATTR_T: u32 = 4;
pub const __SIZEOF_PTHREAD_RWLOCKATTR_T: u32 = 8;
pub const __SIZEOF_PTHREAD_BARRIERATTR_T: u32 = 4;
pub const _THREAD_MUTEX_INTERNAL_H: u32 = 1;
pub const __PTHREAD_MUTEX_HAVE_PREV: u32 = 1;
pub const __have_pthread_attr_t: u32 = 1;
pub const _ALLOCA_H: u32 = 1;
pub const _SETJMP_H: u32 = 1;
pub const _BITS_SETJMP_H: u32 = 1;
pub const __jmp_buf_tag_defined: u32 = 1;
pub const CST_VAL_TYPE_CONS: u32 = 0;
pub const CST_VAL_TYPE_INT: u32 = 1;
pub const CST_VAL_TYPE_FLOAT: u32 = 3;
pub const CST_VAL_TYPE_STRING: u32 = 5;
pub const CST_VAL_TYPE_FIRST_FREE: u32 = 7;
pub const CST_VAL_TYPE_MAX: u32 = 54;
pub const CST_CONST_INT_MAX: u32 = 19;
pub const BYTE_ORDER_BIG: &[u8; 3usize] = b"10\0";
pub const BYTE_ORDER_LITTLE: &[u8; 3usize] = b"01\0";
pub const RIFF_FORMAT_PCM: u32 = 1;
pub const RIFF_FORMAT_ADPCM: u32 = 2;
pub const RIFF_FORMAT_MULAW: u32 = 6;
pub const RIFF_FORMAT_ALAW: u32 = 7;
pub const CST_SND_ULAW: u32 = 1;
pub const CST_SND_UCHAR: u32 = 2;
pub const CST_SND_SHORT: u32 = 3;
pub const CST_G721_LEADIN: u32 = 8;
pub const CST_CART_OP_NONE: u32 = 255;
pub const CST_CART_OP_LEAF: u32 = 255;
pub const CST_CART_OP_IS: u32 = 0;
pub const CST_CART_OP_IN: u32 = 1;
pub const CST_CART_OP_LESS: u32 = 2;
pub const CST_CART_OP_GREATER: u32 = 3;
pub const CST_CART_OP_MATCHES: u32 = 4;
pub const CST_CART_OP_EQUALS: u32 = 5;
pub const CST_LTS_EOR: u32 = 255;
pub const CST_AUDIOBUFFSIZE: u32 = 128;
pub const CST_AUDIO_DEFAULT_PORT: u32 = 1746;
pub const CST_AUDIO_DEFAULT_SERVER: &[u8; 10usize] = b"localhost\0";
pub const CST_AUDIO_DEFAULT_ENCODING: &[u8; 6usize] = b"short\0";
pub const CST_AUDIO_STREAM_STOP: i32 = -1;
pub const CST_AUDIO_STREAM_CONT: u32 = 0;
pub const TS_CHARCLASS_NONE: u32 = 0;
pub const TS_CHARCLASS_WHITESPACE: u32 = 2;
pub const TS_CHARCLASS_SINGLECHAR: u32 = 4;
pub const TS_CHARCLASS_PREPUNCT: u32 = 8;
pub const TS_CHARCLASS_POSTPUNCT: u32 = 16;
pub const TS_CHARCLASS_QUOTE: u32 = 32;
extern "C" {
    pub fn memcpy(
        __dest: *mut ::std::os::raw::c_void,
        __src: *const ::std::os::raw::c_void,
        __n: ::std::os::raw::c_ulong,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn memmove(
        __dest: *mut ::std::os::raw::c_void,
        __src: *const ::std::os::raw::c_void,
        __n: ::std::os::raw::c_ulong,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn memccpy(
        __dest: *mut ::std::os::raw::c_void,
        __src: *const ::std::os::raw::c_void,
        __c: ::std::os::raw::c_int,
        __n: ::std::os::raw::c_ulong,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn memset(
        __s: *mut ::std::os::raw::c_void,
        __c: ::std::os::raw::c_int,
        __n: ::std::os::raw::c_ulong,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn memcmp(
        __s1: *const ::std::os::raw::c_void,
        __s2: *const ::std::os::raw::c_void,
        __n: ::std::os::raw::c_ulong,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn __memcmpeq(
        __s1: *const ::std::os::raw::c_void,
        __s2: *const ::std::os::raw::c_void,
        __n: usize,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn memchr(
        __s: *const ::std::os::raw::c_void,
        __c: ::std::os::raw::c_int,
        __n: ::std::os::raw::c_ulong,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn strcpy(
        __dest: *mut ::std::os::raw::c_char,
        __src: *const ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn strncpy(
        __dest: *mut ::std::os::raw::c_char,
        __src: *const ::std::os::raw::c_char,
        __n: ::std::os::raw::c_ulong,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn strcat(
        __dest: *mut ::std::os::raw::c_char,
        __src: *const ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn strncat(
        __dest: *mut ::std::os::raw::c_char,
        __src: *const ::std::os::raw::c_char,
        __n: ::std::os::raw::c_ulong,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn strcmp(
        __s1: *const ::std::os::raw::c_char,
        __s2: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn strncmp(
        __s1: *const ::std::os::raw::c_char,
        __s2: *const ::std::os::raw::c_char,
        __n: ::std::os::raw::c_ulong,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn strcoll(
        __s1: *const ::std::os::raw::c_char,
        __s2: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn strxfrm(
        __dest: *mut ::std::os::raw::c_char,
        __src: *const ::std::os::raw::c_char,
        __n: ::std::os::raw::c_ulong,
    ) -> ::std::os::raw::c_ulong;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __locale_struct {
    pub __locales: [*mut __locale_data; 13usize],
    pub __ctype_b: *const ::std::os::raw::c_ushort,
    pub __ctype_tolower: *const ::std::os::raw::c_int,
    pub __ctype_toupper: *const ::std::os::raw::c_int,
    pub __names: [*const ::std::os::raw::c_char; 13usize],
}
#[test]
fn bindgen_test_layout___locale_struct() {
    const UNINIT: ::std::mem::MaybeUninit<__locale_struct> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<__locale_struct>(),
        232usize,
        concat!("Size of: ", stringify!(__locale_struct))
    );
    assert_eq!(
        ::std::mem::align_of::<__locale_struct>(),
        8usize,
        concat!("Alignment of ", stringify!(__locale_struct))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__locales) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__locale_struct),
            "::",
            stringify!(__locales)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__ctype_b) as usize - ptr as usize },
        104usize,
        concat!(
            "Offset of field: ",
            stringify!(__locale_struct),
            "::",
            stringify!(__ctype_b)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__ctype_tolower) as usize - ptr as usize },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(__locale_struct),
            "::",
            stringify!(__ctype_tolower)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__ctype_toupper) as usize - ptr as usize },
        120usize,
        concat!(
            "Offset of field: ",
            stringify!(__locale_struct),
            "::",
            stringify!(__ctype_toupper)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__names) as usize - ptr as usize },
        128usize,
        concat!(
            "Offset of field: ",
            stringify!(__locale_struct),
            "::",
            stringify!(__names)
        )
    );
}
pub type __locale_t = *mut __locale_struct;
pub type locale_t = __locale_t;
extern "C" {
    pub fn strcoll_l(
        __s1: *const ::std::os::raw::c_char,
        __s2: *const ::std::os::raw::c_char,
        __l: locale_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn strxfrm_l(
        __dest: *mut ::std::os::raw::c_char,
        __src: *const ::std::os::raw::c_char,
        __n: usize,
        __l: locale_t,
    ) -> usize;
}
extern "C" {
    pub fn strdup(__s: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn strndup(
        __string: *const ::std::os::raw::c_char,
        __n: ::std::os::raw::c_ulong,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn strchr(
        __s: *const ::std::os::raw::c_char,
        __c: ::std::os::raw::c_int,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn strrchr(
        __s: *const ::std::os::raw::c_char,
        __c: ::std::os::raw::c_int,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn strcspn(
        __s: *const ::std::os::raw::c_char,
        __reject: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_ulong;
}
extern "C" {
    pub fn strspn(
        __s: *const ::std::os::raw::c_char,
        __accept: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_ulong;
}
extern "C" {
    pub fn strpbrk(
        __s: *const ::std::os::raw::c_char,
        __accept: *const ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn strstr(
        __haystack: *const ::std::os::raw::c_char,
        __needle: *const ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn strtok(
        __s: *mut ::std::os::raw::c_char,
        __delim: *const ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn __strtok_r(
        __s: *mut ::std::os::raw::c_char,
        __delim: *const ::std::os::raw::c_char,
        __save_ptr: *mut *mut ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn strtok_r(
        __s: *mut ::std::os::raw::c_char,
        __delim: *const ::std::os::raw::c_char,
        __save_ptr: *mut *mut ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn strlen(__s: *const ::std::os::raw::c_char) -> ::std::os::raw::c_ulong;
}
extern "C" {
    pub fn strnlen(__string: *const ::std::os::raw::c_char, __maxlen: usize) -> usize;
}
extern "C" {
    pub fn strerror(__errnum: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    #[link_name = "\u{1}__xpg_strerror_r"]
    pub fn strerror_r(
        __errnum: ::std::os::raw::c_int,
        __buf: *mut ::std::os::raw::c_char,
        __buflen: usize,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn strerror_l(
        __errnum: ::std::os::raw::c_int,
        __l: locale_t,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn bcmp(
        __s1: *const ::std::os::raw::c_void,
        __s2: *const ::std::os::raw::c_void,
        __n: ::std::os::raw::c_ulong,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn bcopy(
        __src: *const ::std::os::raw::c_void,
        __dest: *mut ::std::os::raw::c_void,
        __n: usize,
    );
}
extern "C" {
    pub fn bzero(__s: *mut ::std::os::raw::c_void, __n: ::std::os::raw::c_ulong);
}
extern "C" {
    pub fn index(
        __s: *const ::std::os::raw::c_char,
        __c: ::std::os::raw::c_int,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn rindex(
        __s: *const ::std::os::raw::c_char,
        __c: ::std::os::raw::c_int,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn ffs(__i: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn ffsl(__l: ::std::os::raw::c_long) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn ffsll(__ll: ::std::os::raw::c_longlong) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn strcasecmp(
        __s1: *const ::std::os::raw::c_char,
        __s2: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn strncasecmp(
        __s1: *const ::std::os::raw::c_char,
        __s2: *const ::std::os::raw::c_char,
        __n: ::std::os::raw::c_ulong,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn strcasecmp_l(
        __s1: *const ::std::os::raw::c_char,
        __s2: *const ::std::os::raw::c_char,
        __loc: locale_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn strncasecmp_l(
        __s1: *const ::std::os::raw::c_char,
        __s2: *const ::std::os::raw::c_char,
        __n: usize,
        __loc: locale_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn explicit_bzero(__s: *mut ::std::os::raw::c_void, __n: usize);
}
extern "C" {
    pub fn strsep(
        __stringp: *mut *mut ::std::os::raw::c_char,
        __delim: *const ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn strsignal(__sig: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn __stpcpy(
        __dest: *mut ::std::os::raw::c_char,
        __src: *const ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn stpcpy(
        __dest: *mut ::std::os::raw::c_char,
        __src: *const ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn __stpncpy(
        __dest: *mut ::std::os::raw::c_char,
        __src: *const ::std::os::raw::c_char,
        __n: usize,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn stpncpy(
        __dest: *mut ::std::os::raw::c_char,
        __src: *const ::std::os::raw::c_char,
        __n: ::std::os::raw::c_ulong,
    ) -> *mut ::std::os::raw::c_char;
}
pub type cst_string = ::std::os::raw::c_char;
extern "C" {
    pub fn cst_atof(str_: *const ::std::os::raw::c_char) -> f64;
}
extern "C" {
    pub fn cst_strdup(s: *const cst_string) -> *mut cst_string;
}
extern "C" {
    pub fn cst_strchr(s: *const cst_string, c: ::std::os::raw::c_int) -> *mut cst_string;
}
extern "C" {
    pub fn cst_strrchr(str_: *const cst_string, c: ::std::os::raw::c_int) -> *mut cst_string;
}
extern "C" {
    pub fn cst_member_string(
        str_: *const ::std::os::raw::c_char,
        slist: *const *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn cst_substr(
        str_: *const ::std::os::raw::c_char,
        start: ::std::os::raw::c_int,
        length: ::std::os::raw::c_int,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn cst_string_before(
        s: *const ::std::os::raw::c_char,
        c: *const ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn cst_strcat(
        a: *const ::std::os::raw::c_char,
        b: *const ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn cst_strcat3(
        a: *const ::std::os::raw::c_char,
        b: *const ::std::os::raw::c_char,
        c: *const ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn cst_downcase(str_: *const cst_string) -> *mut cst_string;
}
extern "C" {
    pub fn cst_upcase(str_: *const cst_string) -> *mut cst_string;
}
pub type va_list = __builtin_va_list;
pub type __gnuc_va_list = __builtin_va_list;
pub type __u_char = ::std::os::raw::c_uchar;
pub type __u_short = ::std::os::raw::c_ushort;
pub type __u_int = ::std::os::raw::c_uint;
pub type __u_long = ::std::os::raw::c_ulong;
pub type __int8_t = ::std::os::raw::c_schar;
pub type __uint8_t = ::std::os::raw::c_uchar;
pub type __int16_t = ::std::os::raw::c_short;
pub type __uint16_t = ::std::os::raw::c_ushort;
pub type __int32_t = ::std::os::raw::c_int;
pub type __uint32_t = ::std::os::raw::c_uint;
pub type __int64_t = ::std::os::raw::c_long;
pub type __uint64_t = ::std::os::raw::c_ulong;
pub type __int_least8_t = __int8_t;
pub type __uint_least8_t = __uint8_t;
pub type __int_least16_t = __int16_t;
pub type __uint_least16_t = __uint16_t;
pub type __int_least32_t = __int32_t;
pub type __uint_least32_t = __uint32_t;
pub type __int_least64_t = __int64_t;
pub type __uint_least64_t = __uint64_t;
pub type __quad_t = ::std::os::raw::c_long;
pub type __u_quad_t = ::std::os::raw::c_ulong;
pub type __intmax_t = ::std::os::raw::c_long;
pub type __uintmax_t = ::std::os::raw::c_ulong;
pub type __dev_t = ::std::os::raw::c_ulong;
pub type __uid_t = ::std::os::raw::c_uint;
pub type __gid_t = ::std::os::raw::c_uint;
pub type __ino_t = ::std::os::raw::c_ulong;
pub type __ino64_t = ::std::os::raw::c_ulong;
pub type __mode_t = ::std::os::raw::c_uint;
pub type __nlink_t = ::std::os::raw::c_ulong;
pub type __off_t = ::std::os::raw::c_long;
pub type __off64_t = ::std::os::raw::c_long;
pub type __pid_t = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __fsid_t {
    pub __val: [::std::os::raw::c_int; 2usize],
}
#[test]
fn bindgen_test_layout___fsid_t() {
    const UNINIT: ::std::mem::MaybeUninit<__fsid_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<__fsid_t>(),
        8usize,
        concat!("Size of: ", stringify!(__fsid_t))
    );
    assert_eq!(
        ::std::mem::align_of::<__fsid_t>(),
        4usize,
        concat!("Alignment of ", stringify!(__fsid_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__val) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__fsid_t),
            "::",
            stringify!(__val)
        )
    );
}
pub type __clock_t = ::std::os::raw::c_long;
pub type __rlim_t = ::std::os::raw::c_ulong;
pub type __rlim64_t = ::std::os::raw::c_ulong;
pub type __id_t = ::std::os::raw::c_uint;
pub type __time_t = ::std::os::raw::c_long;
pub type __useconds_t = ::std::os::raw::c_uint;
pub type __suseconds_t = ::std::os::raw::c_long;
pub type __suseconds64_t = ::std::os::raw::c_long;
pub type __daddr_t = ::std::os::raw::c_int;
pub type __key_t = ::std::os::raw::c_int;
pub type __clockid_t = ::std::os::raw::c_int;
pub type __timer_t = *mut ::std::os::raw::c_void;
pub type __blksize_t = ::std::os::raw::c_long;
pub type __blkcnt_t = ::std::os::raw::c_long;
pub type __blkcnt64_t = ::std::os::raw::c_long;
pub type __fsblkcnt_t = ::std::os::raw::c_ulong;
pub type __fsblkcnt64_t = ::std::os::raw::c_ulong;
pub type __fsfilcnt_t = ::std::os::raw::c_ulong;
pub type __fsfilcnt64_t = ::std::os::raw::c_ulong;
pub type __fsword_t = ::std::os::raw::c_long;
pub type __ssize_t = ::std::os::raw::c_long;
pub type __syscall_slong_t = ::std::os::raw::c_long;
pub type __syscall_ulong_t = ::std::os::raw::c_ulong;
pub type __loff_t = __off64_t;
pub type __caddr_t = *mut ::std::os::raw::c_char;
pub type __intptr_t = ::std::os::raw::c_long;
pub type __socklen_t = ::std::os::raw::c_uint;
pub type __sig_atomic_t = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct __mbstate_t {
    pub __count: ::std::os::raw::c_int,
    pub __value: __mbstate_t__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __mbstate_t__bindgen_ty_1 {
    pub __wch: ::std::os::raw::c_uint,
    pub __wchb: [::std::os::raw::c_char; 4usize],
}
#[test]
fn bindgen_test_layout___mbstate_t__bindgen_ty_1() {
    const UNINIT: ::std::mem::MaybeUninit<__mbstate_t__bindgen_ty_1> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<__mbstate_t__bindgen_ty_1>(),
        4usize,
        concat!("Size of: ", stringify!(__mbstate_t__bindgen_ty_1))
    );
    assert_eq!(
        ::std::mem::align_of::<__mbstate_t__bindgen_ty_1>(),
        4usize,
        concat!("Alignment of ", stringify!(__mbstate_t__bindgen_ty_1))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__wch) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__mbstate_t__bindgen_ty_1),
            "::",
            stringify!(__wch)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__wchb) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__mbstate_t__bindgen_ty_1),
            "::",
            stringify!(__wchb)
        )
    );
}
#[test]
fn bindgen_test_layout___mbstate_t() {
    const UNINIT: ::std::mem::MaybeUninit<__mbstate_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<__mbstate_t>(),
        8usize,
        concat!("Size of: ", stringify!(__mbstate_t))
    );
    assert_eq!(
        ::std::mem::align_of::<__mbstate_t>(),
        4usize,
        concat!("Alignment of ", stringify!(__mbstate_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__count) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__mbstate_t),
            "::",
            stringify!(__count)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__value) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(__mbstate_t),
            "::",
            stringify!(__value)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _G_fpos_t {
    pub __pos: __off_t,
    pub __state: __mbstate_t,
}
#[test]
fn bindgen_test_layout__G_fpos_t() {
    const UNINIT: ::std::mem::MaybeUninit<_G_fpos_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<_G_fpos_t>(),
        16usize,
        concat!("Size of: ", stringify!(_G_fpos_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_G_fpos_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_G_fpos_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__pos) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_G_fpos_t),
            "::",
            stringify!(__pos)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__state) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_G_fpos_t),
            "::",
            stringify!(__state)
        )
    );
}
pub type __fpos_t = _G_fpos_t;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _G_fpos64_t {
    pub __pos: __off64_t,
    pub __state: __mbstate_t,
}
#[test]
fn bindgen_test_layout__G_fpos64_t() {
    const UNINIT: ::std::mem::MaybeUninit<_G_fpos64_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<_G_fpos64_t>(),
        16usize,
        concat!("Size of: ", stringify!(_G_fpos64_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_G_fpos64_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_G_fpos64_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__pos) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_G_fpos64_t),
            "::",
            stringify!(__pos)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__state) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_G_fpos64_t),
            "::",
            stringify!(__state)
        )
    );
}
pub type __fpos64_t = _G_fpos64_t;
pub type __FILE = _IO_FILE;
pub type FILE = _IO_FILE;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_marker {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_codecvt {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_wide_data {
    _unused: [u8; 0],
}
pub type _IO_lock_t = ::std::os::raw::c_void;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_FILE {
    pub _flags: ::std::os::raw::c_int,
    pub _IO_read_ptr: *mut ::std::os::raw::c_char,
    pub _IO_read_end: *mut ::std::os::raw::c_char,
    pub _IO_read_base: *mut ::std::os::raw::c_char,
    pub _IO_write_base: *mut ::std::os::raw::c_char,
    pub _IO_write_ptr: *mut ::std::os::raw::c_char,
    pub _IO_write_end: *mut ::std::os::raw::c_char,
    pub _IO_buf_base: *mut ::std::os::raw::c_char,
    pub _IO_buf_end: *mut ::std::os::raw::c_char,
    pub _IO_save_base: *mut ::std::os::raw::c_char,
    pub _IO_backup_base: *mut ::std::os::raw::c_char,
    pub _IO_save_end: *mut ::std::os::raw::c_char,
    pub _markers: *mut _IO_marker,
    pub _chain: *mut _IO_FILE,
    pub _fileno: ::std::os::raw::c_int,
    pub _flags2: ::std::os::raw::c_int,
    pub _old_offset: __off_t,
    pub _cur_column: ::std::os::raw::c_ushort,
    pub _vtable_offset: ::std::os::raw::c_schar,
    pub _shortbuf: [::std::os::raw::c_char; 1usize],
    pub _lock: *mut _IO_lock_t,
    pub _offset: __off64_t,
    pub _codecvt: *mut _IO_codecvt,
    pub _wide_data: *mut _IO_wide_data,
    pub _freeres_list: *mut _IO_FILE,
    pub _freeres_buf: *mut ::std::os::raw::c_void,
    pub __pad5: usize,
    pub _mode: ::std::os::raw::c_int,
    pub _unused2: [::std::os::raw::c_char; 20usize],
}
#[test]
fn bindgen_test_layout__IO_FILE() {
    const UNINIT: ::std::mem::MaybeUninit<_IO_FILE> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<_IO_FILE>(),
        216usize,
        concat!("Size of: ", stringify!(_IO_FILE))
    );
    assert_eq!(
        ::std::mem::align_of::<_IO_FILE>(),
        8usize,
        concat!("Alignment of ", stringify!(_IO_FILE))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._flags) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_flags)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._IO_read_ptr) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_read_ptr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._IO_read_end) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_read_end)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._IO_read_base) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_read_base)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._IO_write_base) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_write_base)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._IO_write_ptr) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_write_ptr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._IO_write_end) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_write_end)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._IO_buf_base) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_buf_base)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._IO_buf_end) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_buf_end)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._IO_save_base) as usize - ptr as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_save_base)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._IO_backup_base) as usize - ptr as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_backup_base)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._IO_save_end) as usize - ptr as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_save_end)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._markers) as usize - ptr as usize },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_markers)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._chain) as usize - ptr as usize },
        104usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_chain)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._fileno) as usize - ptr as usize },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_fileno)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._flags2) as usize - ptr as usize },
        116usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_flags2)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._old_offset) as usize - ptr as usize },
        120usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_old_offset)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._cur_column) as usize - ptr as usize },
        128usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_cur_column)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._vtable_offset) as usize - ptr as usize },
        130usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_vtable_offset)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._shortbuf) as usize - ptr as usize },
        131usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_shortbuf)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._lock) as usize - ptr as usize },
        136usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_lock)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._offset) as usize - ptr as usize },
        144usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_offset)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._codecvt) as usize - ptr as usize },
        152usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_codecvt)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._wide_data) as usize - ptr as usize },
        160usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_wide_data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._freeres_list) as usize - ptr as usize },
        168usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_freeres_list)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._freeres_buf) as usize - ptr as usize },
        176usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_freeres_buf)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__pad5) as usize - ptr as usize },
        184usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(__pad5)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._mode) as usize - ptr as usize },
        192usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_mode)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr)._unused2) as usize - ptr as usize },
        196usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_unused2)
        )
    );
}
pub type off_t = __off_t;
pub type fpos_t = __fpos_t;
extern "C" {
    pub static mut stdin: *mut FILE;
}
extern "C" {
    pub static mut stdout: *mut FILE;
}
extern "C" {
    pub static mut stderr: *mut FILE;
}
extern "C" {
    pub fn remove(__filename: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn rename(
        __old: *const ::std::os::raw::c_char,
        __new: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn renameat(
        __oldfd: ::std::os::raw::c_int,
        __old: *const ::std::os::raw::c_char,
        __newfd: ::std::os::raw::c_int,
        __new: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn fclose(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn tmpfile() -> *mut FILE;
}
extern "C" {
    pub fn tmpnam(arg1: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn tmpnam_r(__s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn tempnam(
        __dir: *const ::std::os::raw::c_char,
        __pfx: *const ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn fflush(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn fflush_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn fopen(
        __filename: *const ::std::os::raw::c_char,
        __modes: *const ::std::os::raw::c_char,
    ) -> *mut FILE;
}
extern "C" {
    pub fn freopen(
        __filename: *const ::std::os::raw::c_char,
        __modes: *const ::std::os::raw::c_char,
        __stream: *mut FILE,
    ) -> *mut FILE;
}
extern "C" {
    pub fn fdopen(__fd: ::std::os::raw::c_int, __modes: *const ::std::os::raw::c_char)
        -> *mut FILE;
}
extern "C" {
    pub fn fmemopen(
        __s: *mut ::std::os::raw::c_void,
        __len: usize,
        __modes: *const ::std::os::raw::c_char,
    ) -> *mut FILE;
}
extern "C" {
    pub fn open_memstream(
        __bufloc: *mut *mut ::std::os::raw::c_char,
        __sizeloc: *mut usize,
    ) -> *mut FILE;
}
extern "C" {
    pub fn setbuf(__stream: *mut FILE, __buf: *mut ::std::os::raw::c_char);
}
extern "C" {
    pub fn setvbuf(
        __stream: *mut FILE,
        __buf: *mut ::std::os::raw::c_char,
        __modes: ::std::os::raw::c_int,
        __n: usize,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn setbuffer(__stream: *mut FILE, __buf: *mut ::std::os::raw::c_char, __size: usize);
}
extern "C" {
    pub fn setlinebuf(__stream: *mut FILE);
}
extern "C" {
    pub fn fprintf(
        __stream: *mut FILE,
        __format: *const ::std::os::raw::c_char,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn printf(__format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn sprintf(
        __s: *mut ::std::os::raw::c_char,
        __format: *const ::std::os::raw::c_char,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vfprintf(
        __s: *mut FILE,
        __format: *const ::std::os::raw::c_char,
        __arg: *mut __va_list_tag,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vprintf(
        __format: *const ::std::os::raw::c_char,
        __arg: *mut __va_list_tag,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vsprintf(
        __s: *mut ::std::os::raw::c_char,
        __format: *const ::std::os::raw::c_char,
        __arg: *mut __va_list_tag,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snprintf(
        __s: *mut ::std::os::raw::c_char,
        __maxlen: ::std::os::raw::c_ulong,
        __format: *const ::std::os::raw::c_char,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vsnprintf(
        __s: *mut ::std::os::raw::c_char,
        __maxlen: ::std::os::raw::c_ulong,
        __format: *const ::std::os::raw::c_char,
        __arg: *mut __va_list_tag,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vdprintf(
        __fd: ::std::os::raw::c_int,
        __fmt: *const ::std::os::raw::c_char,
        __arg: *mut __va_list_tag,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dprintf(
        __fd: ::std::os::raw::c_int,
        __fmt: *const ::std::os::raw::c_char,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn fscanf(
        __stream: *mut FILE,
        __format: *const ::std::os::raw::c_char,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn scanf(__format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn sscanf(
        __s: *const ::std::os::raw::c_char,
        __format: *const ::std::os::raw::c_char,
        ...
    ) -> ::std::os::raw::c_int;
}
pub type _Float32 = f32;
pub type _Float64 = f64;
pub type _Float32x = f64;
pub type _Float64x = u128;
extern "C" {
    #[link_name = "\u{1}__isoc99_fscanf"]
    pub fn fscanf1(
        __stream: *mut FILE,
        __format: *const ::std::os::raw::c_char,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}__isoc99_scanf"]
    pub fn scanf1(__format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}__isoc99_sscanf"]
    pub fn sscanf1(
        __s: *const ::std::os::raw::c_char,
        __format: *const ::std::os::raw::c_char,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vfscanf(
        __s: *mut FILE,
        __format: *const ::std::os::raw::c_char,
        __arg: *mut __va_list_tag,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vscanf(
        __format: *const ::std::os::raw::c_char,
        __arg: *mut __va_list_tag,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vsscanf(
        __s: *const ::std::os::raw::c_char,
        __format: *const ::std::os::raw::c_char,
        __arg: *mut __va_list_tag,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}__isoc99_vfscanf"]
    pub fn vfscanf1(
        __s: *mut FILE,
        __format: *const ::std::os::raw::c_char,
        __arg: *mut __va_list_tag,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}__isoc99_vscanf"]
    pub fn vscanf1(
        __format: *const ::std::os::raw::c_char,
        __arg: *mut __va_list_tag,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}__isoc99_vsscanf"]
    pub fn vsscanf1(
        __s: *const ::std::os::raw::c_char,
        __format: *const ::std::os::raw::c_char,
        __arg: *mut __va_list_tag,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn fgetc(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn getc(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn getchar() -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn getc_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn getchar_unlocked() -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn fgetc_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn fputc(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn putc(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn putchar(__c: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn fputc_unlocked(__c: ::std::os::raw::c_int, __stream: *mut FILE)
        -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn putc_unlocked(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn putchar_unlocked(__c: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn getw(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn putw(__w: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn fgets(
        __s: *mut ::std::os::raw::c_char,
        __n: ::std::os::raw::c_int,
        __stream: *mut FILE,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn __getdelim(
        __lineptr: *mut *mut ::std::os::raw::c_char,
        __n: *mut usize,
        __delimiter: ::std::os::raw::c_int,
        __stream: *mut FILE,
    ) -> __ssize_t;
}
extern "C" {
    pub fn getdelim(
        __lineptr: *mut *mut ::std::os::raw::c_char,
        __n: *mut usize,
        __delimiter: ::std::os::raw::c_int,
        __stream: *mut FILE,
    ) -> __ssize_t;
}
extern "C" {
    pub fn getline(
        __lineptr: *mut *mut ::std::os::raw::c_char,
        __n: *mut usize,
        __stream: *mut FILE,
    ) -> __ssize_t;
}
extern "C" {
    pub fn fputs(__s: *const ::std::os::raw::c_char, __stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn puts(__s: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn ungetc(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn fread(
        __ptr: *mut ::std::os::raw::c_void,
        __size: ::std::os::raw::c_ulong,
        __n: ::std::os::raw::c_ulong,
        __stream: *mut FILE,
    ) -> ::std::os::raw::c_ulong;
}
extern "C" {
    pub fn fwrite(
        __ptr: *const ::std::os::raw::c_void,
        __size: ::std::os::raw::c_ulong,
        __n: ::std::os::raw::c_ulong,
        __s: *mut FILE,
    ) -> ::std::os::raw::c_ulong;
}
extern "C" {
    pub fn fread_unlocked(
        __ptr: *mut ::std::os::raw::c_void,
        __size: usize,
        __n: usize,
        __stream: *mut FILE,
    ) -> usize;
}
extern "C" {
    pub fn fwrite_unlocked(
        __ptr: *const ::std::os::raw::c_void,
        __size: usize,
        __n: usize,
        __stream: *mut FILE,
    ) -> usize;
}
extern "C" {
    pub fn fseek(
        __stream: *mut FILE,
        __off: ::std::os::raw::c_long,
        __whence: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn ftell(__stream: *mut FILE) -> ::std::os::raw::c_long;
}
extern "C" {
    pub fn rewind(__stream: *mut FILE);
}
extern "C" {
    pub fn fseeko(
        __stream: *mut FILE,
        __off: __off_t,
        __whence: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn ftello(__stream: *mut FILE) -> __off_t;
}
extern "C" {
    pub fn fgetpos(__stream: *mut FILE, __pos: *mut fpos_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn fsetpos(__stream: *mut FILE, __pos: *const fpos_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn clearerr(__stream: *mut FILE);
}
extern "C" {
    pub fn feof(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn ferror(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn clearerr_unlocked(__stream: *mut FILE);
}
extern "C" {
    pub fn feof_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn ferror_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn perror(__s: *const ::std::os::raw::c_char);
}
extern "C" {
    pub fn fileno(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn fileno_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pclose(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn popen(
        __command: *const ::std::os::raw::c_char,
        __modes: *const ::std::os::raw::c_char,
    ) -> *mut FILE;
}
extern "C" {
    pub fn ctermid(__s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn flockfile(__stream: *mut FILE);
}
extern "C" {
    pub fn ftrylockfile(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn funlockfile(__stream: *mut FILE);
}
extern "C" {
    pub fn __uflow(arg1: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn __overflow(arg1: *mut FILE, arg2: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
pub type cst_file = *mut FILE;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cst_filemap_struct {
    pub mem: *mut ::std::os::raw::c_void,
    pub fh: cst_file,
    pub mapsize: usize,
    pub fd: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_cst_filemap_struct() {
    const UNINIT: ::std::mem::MaybeUninit<cst_filemap_struct> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<cst_filemap_struct>(),
        32usize,
        concat!("Size of: ", stringify!(cst_filemap_struct))
    );
    assert_eq!(
        ::std::mem::align_of::<cst_filemap_struct>(),
        8usize,
        concat!("Alignment of ", stringify!(cst_filemap_struct))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mem) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_filemap_struct),
            "::",
            stringify!(mem)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fh) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_filemap_struct),
            "::",
            stringify!(fh)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mapsize) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_filemap_struct),
            "::",
            stringify!(mapsize)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fd) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_filemap_struct),
            "::",
            stringify!(fd)
        )
    );
}
pub type cst_filemap = cst_filemap_struct;
extern "C" {
    pub fn cst_fopen(path: *const ::std::os::raw::c_char, mode: ::std::os::raw::c_int) -> cst_file;
}
extern "C" {
    pub fn cst_fwrite(
        fh: cst_file,
        buf: *const ::std::os::raw::c_void,
        size: ::std::os::raw::c_long,
        count: ::std::os::raw::c_long,
    ) -> ::std::os::raw::c_long;
}
extern "C" {
    pub fn cst_fread(
        fh: cst_file,
        buf: *mut ::std::os::raw::c_void,
        size: ::std::os::raw::c_long,
        count: ::std::os::raw::c_long,
    ) -> ::std::os::raw::c_long;
}
extern "C" {
    pub fn cst_fprintf(
        fh: cst_file,
        fmt: *const ::std::os::raw::c_char,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn cst_sprintf(
        s: *mut ::std::os::raw::c_char,
        fmt: *const ::std::os::raw::c_char,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn cst_fclose(fh: cst_file) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn cst_fgetc(fh: cst_file) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn cst_ftell(fh: cst_file) -> ::std::os::raw::c_long;
}
extern "C" {
    pub fn cst_fseek(
        fh: cst_file,
        pos: ::std::os::raw::c_long,
        whence: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_long;
}
extern "C" {
    pub fn cst_filesize(fh: cst_file) -> ::std::os::raw::c_long;
}
extern "C" {
    pub fn cst_mmap_file(path: *const ::std::os::raw::c_char) -> *mut cst_filemap;
}
extern "C" {
    pub fn cst_munmap_file(map: *mut cst_filemap) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn cst_read_whole_file(path: *const ::std::os::raw::c_char) -> *mut cst_filemap;
}
extern "C" {
    pub fn cst_free_whole_file(map: *mut cst_filemap) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn cst_read_part_file(path: *const ::std::os::raw::c_char) -> *mut cst_filemap;
}
extern "C" {
    pub fn cst_free_part_file(map: *mut cst_filemap) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn cst_urlp(url: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn cst_url_open(url: *const ::std::os::raw::c_char) -> cst_file;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cst_regex_struct {
    pub regstart: ::std::os::raw::c_char,
    pub reganch: ::std::os::raw::c_char,
    pub regmust: *mut ::std::os::raw::c_char,
    pub regmlen: ::std::os::raw::c_int,
    pub regsize: ::std::os::raw::c_int,
    pub program: *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_cst_regex_struct() {
    const UNINIT: ::std::mem::MaybeUninit<cst_regex_struct> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<cst_regex_struct>(),
        32usize,
        concat!("Size of: ", stringify!(cst_regex_struct))
    );
    assert_eq!(
        ::std::mem::align_of::<cst_regex_struct>(),
        8usize,
        concat!("Alignment of ", stringify!(cst_regex_struct))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).regstart) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_regex_struct),
            "::",
            stringify!(regstart)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).reganch) as usize - ptr as usize },
        1usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_regex_struct),
            "::",
            stringify!(reganch)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).regmust) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_regex_struct),
            "::",
            stringify!(regmust)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).regmlen) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_regex_struct),
            "::",
            stringify!(regmlen)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).regsize) as usize - ptr as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_regex_struct),
            "::",
            stringify!(regsize)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).program) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_regex_struct),
            "::",
            stringify!(program)
        )
    );
}
pub type cst_regex = cst_regex_struct;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cst_regstate_struct {
    pub startp: [*const ::std::os::raw::c_char; 10usize],
    pub endp: [*const ::std::os::raw::c_char; 10usize],
    pub input: *const ::std::os::raw::c_char,
    pub bol: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_cst_regstate_struct() {
    const UNINIT: ::std::mem::MaybeUninit<cst_regstate_struct> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<cst_regstate_struct>(),
        176usize,
        concat!("Size of: ", stringify!(cst_regstate_struct))
    );
    assert_eq!(
        ::std::mem::align_of::<cst_regstate_struct>(),
        8usize,
        concat!("Alignment of ", stringify!(cst_regstate_struct))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).startp) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_regstate_struct),
            "::",
            stringify!(startp)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).endp) as usize - ptr as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_regstate_struct),
            "::",
            stringify!(endp)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).input) as usize - ptr as usize },
        160usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_regstate_struct),
            "::",
            stringify!(input)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bol) as usize - ptr as usize },
        168usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_regstate_struct),
            "::",
            stringify!(bol)
        )
    );
}
pub type cst_regstate = cst_regstate_struct;
extern "C" {
    pub fn new_cst_regex(str_: *const ::std::os::raw::c_char) -> *mut cst_regex;
}
extern "C" {
    pub fn delete_cst_regex(r: *mut cst_regex);
}
extern "C" {
    pub fn cst_regex_match(
        r: *const cst_regex,
        str_: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn cst_regex_match_return(
        r: *const cst_regex,
        str_: *const ::std::os::raw::c_char,
    ) -> *mut cst_regstate;
}
extern "C" {
    pub fn hs_regcomp(arg1: *const ::std::os::raw::c_char) -> *mut cst_regex;
}
extern "C" {
    pub fn hs_regexec(
        arg1: *const cst_regex,
        arg2: *const ::std::os::raw::c_char,
    ) -> *mut cst_regstate;
}
extern "C" {
    pub fn hs_regdelete(arg1: *mut cst_regex);
}
extern "C" {
    pub fn cst_regsub(
        r: *const cst_regstate,
        in_: *const ::std::os::raw::c_char,
        out: *mut ::std::os::raw::c_char,
        max: usize,
    ) -> usize;
}
extern "C" {
    pub fn cst_regex_init();
}
extern "C" {
    pub static cst_rx_white: *const cst_regex;
}
extern "C" {
    pub static cst_rx_alpha: *const cst_regex;
}
extern "C" {
    pub static cst_rx_uppercase: *const cst_regex;
}
extern "C" {
    pub static cst_rx_lowercase: *const cst_regex;
}
extern "C" {
    pub static cst_rx_alphanum: *const cst_regex;
}
extern "C" {
    pub static cst_rx_identifier: *const cst_regex;
}
extern "C" {
    pub static cst_rx_int: *const cst_regex;
}
extern "C" {
    pub static cst_rx_double: *const cst_regex;
}
extern "C" {
    pub static cst_rx_commaint: *const cst_regex;
}
extern "C" {
    pub static cst_rx_digits: *const cst_regex;
}
extern "C" {
    pub static cst_rx_dotted_abbrev: *const cst_regex;
}
extern "C" {
    pub static cst_regex_table: [*const cst_regex; 0usize];
}
pub type wchar_t = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct div_t {
    pub quot: ::std::os::raw::c_int,
    pub rem: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_div_t() {
    const UNINIT: ::std::mem::MaybeUninit<div_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<div_t>(),
        8usize,
        concat!("Size of: ", stringify!(div_t))
    );
    assert_eq!(
        ::std::mem::align_of::<div_t>(),
        4usize,
        concat!("Alignment of ", stringify!(div_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).quot) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(div_t),
            "::",
            stringify!(quot)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rem) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(div_t),
            "::",
            stringify!(rem)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ldiv_t {
    pub quot: ::std::os::raw::c_long,
    pub rem: ::std::os::raw::c_long,
}
#[test]
fn bindgen_test_layout_ldiv_t() {
    const UNINIT: ::std::mem::MaybeUninit<ldiv_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<ldiv_t>(),
        16usize,
        concat!("Size of: ", stringify!(ldiv_t))
    );
    assert_eq!(
        ::std::mem::align_of::<ldiv_t>(),
        8usize,
        concat!("Alignment of ", stringify!(ldiv_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).quot) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(ldiv_t),
            "::",
            stringify!(quot)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rem) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(ldiv_t),
            "::",
            stringify!(rem)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lldiv_t {
    pub quot: ::std::os::raw::c_longlong,
    pub rem: ::std::os::raw::c_longlong,
}
#[test]
fn bindgen_test_layout_lldiv_t() {
    const UNINIT: ::std::mem::MaybeUninit<lldiv_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<lldiv_t>(),
        16usize,
        concat!("Size of: ", stringify!(lldiv_t))
    );
    assert_eq!(
        ::std::mem::align_of::<lldiv_t>(),
        8usize,
        concat!("Alignment of ", stringify!(lldiv_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).quot) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(lldiv_t),
            "::",
            stringify!(quot)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rem) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(lldiv_t),
            "::",
            stringify!(rem)
        )
    );
}
extern "C" {
    pub fn __ctype_get_mb_cur_max() -> usize;
}
extern "C" {
    pub fn atof(__nptr: *const ::std::os::raw::c_char) -> f64;
}
extern "C" {
    pub fn atoi(__nptr: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn atol(__nptr: *const ::std::os::raw::c_char) -> ::std::os::raw::c_long;
}
extern "C" {
    pub fn atoll(__nptr: *const ::std::os::raw::c_char) -> ::std::os::raw::c_longlong;
}
extern "C" {
    pub fn strtod(
        __nptr: *const ::std::os::raw::c_char,
        __endptr: *mut *mut ::std::os::raw::c_char,
    ) -> f64;
}
extern "C" {
    pub fn strtof(
        __nptr: *const ::std::os::raw::c_char,
        __endptr: *mut *mut ::std::os::raw::c_char,
    ) -> f32;
}
extern "C" {
    pub fn strtold(
        __nptr: *const ::std::os::raw::c_char,
        __endptr: *mut *mut ::std::os::raw::c_char,
    ) -> u128;
}
extern "C" {
    pub fn strtol(
        __nptr: *const ::std::os::raw::c_char,
        __endptr: *mut *mut ::std::os::raw::c_char,
        __base: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_long;
}
extern "C" {
    pub fn strtoul(
        __nptr: *const ::std::os::raw::c_char,
        __endptr: *mut *mut ::std::os::raw::c_char,
        __base: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_ulong;
}
extern "C" {
    pub fn strtoq(
        __nptr: *const ::std::os::raw::c_char,
        __endptr: *mut *mut ::std::os::raw::c_char,
        __base: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_longlong;
}
extern "C" {
    pub fn strtouq(
        __nptr: *const ::std::os::raw::c_char,
        __endptr: *mut *mut ::std::os::raw::c_char,
        __base: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_ulonglong;
}
extern "C" {
    pub fn strtoll(
        __nptr: *const ::std::os::raw::c_char,
        __endptr: *mut *mut ::std::os::raw::c_char,
        __base: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_longlong;
}
extern "C" {
    pub fn strtoull(
        __nptr: *const ::std::os::raw::c_char,
        __endptr: *mut *mut ::std::os::raw::c_char,
        __base: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_ulonglong;
}
extern "C" {
    pub fn l64a(__n: ::std::os::raw::c_long) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn a64l(__s: *const ::std::os::raw::c_char) -> ::std::os::raw::c_long;
}
pub type u_char = __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 pid_t = __pid_t;
pub type id_t = __id_t;
pub type daddr_t = __daddr_t;
pub type caddr_t = __caddr_t;
pub type key_t = __key_t;
pub type clock_t = __clock_t;
pub type clockid_t = __clockid_t;
pub type time_t = __time_t;
pub type timer_t = __timer_t;
pub type ulong = ::std::os::raw::c_ulong;
pub type ushort = ::std::os::raw::c_ushort;
pub type uint = ::std::os::raw::c_uint;
pub type u_int8_t = __uint8_t;
pub type u_int16_t = __uint16_t;
pub type u_int32_t = __uint32_t;
pub type u_int64_t = __uint64_t;
pub type register_t = ::std::os::raw::c_long;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __sigset_t {
    pub __val: [::std::os::raw::c_ulong; 16usize],
}
#[test]
fn bindgen_test_layout___sigset_t() {
    const UNINIT: ::std::mem::MaybeUninit<__sigset_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<__sigset_t>(),
        128usize,
        concat!("Size of: ", stringify!(__sigset_t))
    );
    assert_eq!(
        ::std::mem::align_of::<__sigset_t>(),
        8usize,
        concat!("Alignment of ", stringify!(__sigset_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__val) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__sigset_t),
            "::",
            stringify!(__val)
        )
    );
}
pub type sigset_t = __sigset_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct timeval {
    pub tv_sec: __time_t,
    pub tv_usec: __suseconds_t,
}
#[test]
fn bindgen_test_layout_timeval() {
    const UNINIT: ::std::mem::MaybeUninit<timeval> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<timeval>(),
        16usize,
        concat!("Size of: ", stringify!(timeval))
    );
    assert_eq!(
        ::std::mem::align_of::<timeval>(),
        8usize,
        concat!("Alignment of ", stringify!(timeval))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).tv_sec) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(timeval),
            "::",
            stringify!(tv_sec)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).tv_usec) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(timeval),
            "::",
            stringify!(tv_usec)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct timespec {
    pub tv_sec: __time_t,
    pub tv_nsec: __syscall_slong_t,
}
#[test]
fn bindgen_test_layout_timespec() {
    const UNINIT: ::std::mem::MaybeUninit<timespec> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<timespec>(),
        16usize,
        concat!("Size of: ", stringify!(timespec))
    );
    assert_eq!(
        ::std::mem::align_of::<timespec>(),
        8usize,
        concat!("Alignment of ", stringify!(timespec))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).tv_sec) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(timespec),
            "::",
            stringify!(tv_sec)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).tv_nsec) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(timespec),
            "::",
            stringify!(tv_nsec)
        )
    );
}
pub type suseconds_t = __suseconds_t;
pub type __fd_mask = ::std::os::raw::c_long;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct fd_set {
    pub __fds_bits: [__fd_mask; 16usize],
}
#[test]
fn bindgen_test_layout_fd_set() {
    const UNINIT: ::std::mem::MaybeUninit<fd_set> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<fd_set>(),
        128usize,
        concat!("Size of: ", stringify!(fd_set))
    );
    assert_eq!(
        ::std::mem::align_of::<fd_set>(),
        8usize,
        concat!("Alignment of ", stringify!(fd_set))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__fds_bits) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(fd_set),
            "::",
            stringify!(__fds_bits)
        )
    );
}
pub type fd_mask = __fd_mask;
extern "C" {
    pub fn select(
        __nfds: ::std::os::raw::c_int,
        __readfds: *mut fd_set,
        __writefds: *mut fd_set,
        __exceptfds: *mut fd_set,
        __timeout: *mut timeval,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn pselect(
        __nfds: ::std::os::raw::c_int,
        __readfds: *mut fd_set,
        __writefds: *mut fd_set,
        __exceptfds: *mut fd_set,
        __timeout: *const timespec,
        __sigmask: *const __sigset_t,
    ) -> ::std::os::raw::c_int;
}
pub type blksize_t = __blksize_t;
pub type blkcnt_t = __blkcnt_t;
pub type fsblkcnt_t = __fsblkcnt_t;
pub type fsfilcnt_t = __fsfilcnt_t;
#[repr(C)]
#[derive(Copy, Clone)]
pub union __atomic_wide_counter {
    pub __value64: ::std::os::raw::c_ulonglong,
    pub __value32: __atomic_wide_counter__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __atomic_wide_counter__bindgen_ty_1 {
    pub __low: ::std::os::raw::c_uint,
    pub __high: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout___atomic_wide_counter__bindgen_ty_1() {
    const UNINIT: ::std::mem::MaybeUninit<__atomic_wide_counter__bindgen_ty_1> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<__atomic_wide_counter__bindgen_ty_1>(),
        8usize,
        concat!("Size of: ", stringify!(__atomic_wide_counter__bindgen_ty_1))
    );
    assert_eq!(
        ::std::mem::align_of::<__atomic_wide_counter__bindgen_ty_1>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(__atomic_wide_counter__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__low) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__atomic_wide_counter__bindgen_ty_1),
            "::",
            stringify!(__low)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__high) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(__atomic_wide_counter__bindgen_ty_1),
            "::",
            stringify!(__high)
        )
    );
}
#[test]
fn bindgen_test_layout___atomic_wide_counter() {
    const UNINIT: ::std::mem::MaybeUninit<__atomic_wide_counter> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<__atomic_wide_counter>(),
        8usize,
        concat!("Size of: ", stringify!(__atomic_wide_counter))
    );
    assert_eq!(
        ::std::mem::align_of::<__atomic_wide_counter>(),
        8usize,
        concat!("Alignment of ", stringify!(__atomic_wide_counter))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__value64) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__atomic_wide_counter),
            "::",
            stringify!(__value64)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__value32) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__atomic_wide_counter),
            "::",
            stringify!(__value32)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_internal_list {
    pub __prev: *mut __pthread_internal_list,
    pub __next: *mut __pthread_internal_list,
}
#[test]
fn bindgen_test_layout___pthread_internal_list() {
    const UNINIT: ::std::mem::MaybeUninit<__pthread_internal_list> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<__pthread_internal_list>(),
        16usize,
        concat!("Size of: ", stringify!(__pthread_internal_list))
    );
    assert_eq!(
        ::std::mem::align_of::<__pthread_internal_list>(),
        8usize,
        concat!("Alignment of ", stringify!(__pthread_internal_list))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__prev) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_internal_list),
            "::",
            stringify!(__prev)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__next) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_internal_list),
            "::",
            stringify!(__next)
        )
    );
}
pub type __pthread_list_t = __pthread_internal_list;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_internal_slist {
    pub __next: *mut __pthread_internal_slist,
}
#[test]
fn bindgen_test_layout___pthread_internal_slist() {
    const UNINIT: ::std::mem::MaybeUninit<__pthread_internal_slist> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<__pthread_internal_slist>(),
        8usize,
        concat!("Size of: ", stringify!(__pthread_internal_slist))
    );
    assert_eq!(
        ::std::mem::align_of::<__pthread_internal_slist>(),
        8usize,
        concat!("Alignment of ", stringify!(__pthread_internal_slist))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__next) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_internal_slist),
            "::",
            stringify!(__next)
        )
    );
}
pub type __pthread_slist_t = __pthread_internal_slist;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_mutex_s {
    pub __lock: ::std::os::raw::c_int,
    pub __count: ::std::os::raw::c_uint,
    pub __owner: ::std::os::raw::c_int,
    pub __nusers: ::std::os::raw::c_uint,
    pub __kind: ::std::os::raw::c_int,
    pub __spins: ::std::os::raw::c_short,
    pub __elision: ::std::os::raw::c_short,
    pub __list: __pthread_list_t,
}
#[test]
fn bindgen_test_layout___pthread_mutex_s() {
    const UNINIT: ::std::mem::MaybeUninit<__pthread_mutex_s> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<__pthread_mutex_s>(),
        40usize,
        concat!("Size of: ", stringify!(__pthread_mutex_s))
    );
    assert_eq!(
        ::std::mem::align_of::<__pthread_mutex_s>(),
        8usize,
        concat!("Alignment of ", stringify!(__pthread_mutex_s))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__lock) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_mutex_s),
            "::",
            stringify!(__lock)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__count) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_mutex_s),
            "::",
            stringify!(__count)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__owner) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_mutex_s),
            "::",
            stringify!(__owner)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__nusers) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_mutex_s),
            "::",
            stringify!(__nusers)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__kind) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_mutex_s),
            "::",
            stringify!(__kind)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__spins) as usize - ptr as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_mutex_s),
            "::",
            stringify!(__spins)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__elision) as usize - ptr as usize },
        22usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_mutex_s),
            "::",
            stringify!(__elision)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__list) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_mutex_s),
            "::",
            stringify!(__list)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_rwlock_arch_t {
    pub __readers: ::std::os::raw::c_uint,
    pub __writers: ::std::os::raw::c_uint,
    pub __wrphase_futex: ::std::os::raw::c_uint,
    pub __writers_futex: ::std::os::raw::c_uint,
    pub __pad3: ::std::os::raw::c_uint,
    pub __pad4: ::std::os::raw::c_uint,
    pub __cur_writer: ::std::os::raw::c_int,
    pub __shared: ::std::os::raw::c_int,
    pub __rwelision: ::std::os::raw::c_schar,
    pub __pad1: [::std::os::raw::c_uchar; 7usize],
    pub __pad2: ::std::os::raw::c_ulong,
    pub __flags: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout___pthread_rwlock_arch_t() {
    const UNINIT: ::std::mem::MaybeUninit<__pthread_rwlock_arch_t> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<__pthread_rwlock_arch_t>(),
        56usize,
        concat!("Size of: ", stringify!(__pthread_rwlock_arch_t))
    );
    assert_eq!(
        ::std::mem::align_of::<__pthread_rwlock_arch_t>(),
        8usize,
        concat!("Alignment of ", stringify!(__pthread_rwlock_arch_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__readers) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_rwlock_arch_t),
            "::",
            stringify!(__readers)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__writers) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_rwlock_arch_t),
            "::",
            stringify!(__writers)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__wrphase_futex) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_rwlock_arch_t),
            "::",
            stringify!(__wrphase_futex)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__writers_futex) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_rwlock_arch_t),
            "::",
            stringify!(__writers_futex)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__pad3) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_rwlock_arch_t),
            "::",
            stringify!(__pad3)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__pad4) as usize - ptr as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_rwlock_arch_t),
            "::",
            stringify!(__pad4)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__cur_writer) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_rwlock_arch_t),
            "::",
            stringify!(__cur_writer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__shared) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_rwlock_arch_t),
            "::",
            stringify!(__shared)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__rwelision) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_rwlock_arch_t),
            "::",
            stringify!(__rwelision)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__pad1) as usize - ptr as usize },
        33usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_rwlock_arch_t),
            "::",
            stringify!(__pad1)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__pad2) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_rwlock_arch_t),
            "::",
            stringify!(__pad2)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__flags) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_rwlock_arch_t),
            "::",
            stringify!(__flags)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct __pthread_cond_s {
    pub __wseq: __atomic_wide_counter,
    pub __g1_start: __atomic_wide_counter,
    pub __g_refs: [::std::os::raw::c_uint; 2usize],
    pub __g_size: [::std::os::raw::c_uint; 2usize],
    pub __g1_orig_size: ::std::os::raw::c_uint,
    pub __wrefs: ::std::os::raw::c_uint,
    pub __g_signals: [::std::os::raw::c_uint; 2usize],
}
#[test]
fn bindgen_test_layout___pthread_cond_s() {
    const UNINIT: ::std::mem::MaybeUninit<__pthread_cond_s> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<__pthread_cond_s>(),
        48usize,
        concat!("Size of: ", stringify!(__pthread_cond_s))
    );
    assert_eq!(
        ::std::mem::align_of::<__pthread_cond_s>(),
        8usize,
        concat!("Alignment of ", stringify!(__pthread_cond_s))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__wseq) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_cond_s),
            "::",
            stringify!(__wseq)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__g1_start) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_cond_s),
            "::",
            stringify!(__g1_start)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__g_refs) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_cond_s),
            "::",
            stringify!(__g_refs)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__g_size) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_cond_s),
            "::",
            stringify!(__g_size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__g1_orig_size) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_cond_s),
            "::",
            stringify!(__g1_orig_size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__wrefs) as usize - ptr as usize },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_cond_s),
            "::",
            stringify!(__wrefs)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__g_signals) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(__pthread_cond_s),
            "::",
            stringify!(__g_signals)
        )
    );
}
pub type __tss_t = ::std::os::raw::c_uint;
pub type __thrd_t = ::std::os::raw::c_ulong;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __once_flag {
    pub __data: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout___once_flag() {
    const UNINIT: ::std::mem::MaybeUninit<__once_flag> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<__once_flag>(),
        4usize,
        concat!("Size of: ", stringify!(__once_flag))
    );
    assert_eq!(
        ::std::mem::align_of::<__once_flag>(),
        4usize,
        concat!("Alignment of ", stringify!(__once_flag))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__once_flag),
            "::",
            stringify!(__data)
        )
    );
}
pub type pthread_t = ::std::os::raw::c_ulong;
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_mutexattr_t {
    pub __size: [::std::os::raw::c_char; 4usize],
    pub __align: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_pthread_mutexattr_t() {
    const UNINIT: ::std::mem::MaybeUninit<pthread_mutexattr_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<pthread_mutexattr_t>(),
        4usize,
        concat!("Size of: ", stringify!(pthread_mutexattr_t))
    );
    assert_eq!(
        ::std::mem::align_of::<pthread_mutexattr_t>(),
        4usize,
        concat!("Alignment of ", stringify!(pthread_mutexattr_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_mutexattr_t),
            "::",
            stringify!(__size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_mutexattr_t),
            "::",
            stringify!(__align)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_condattr_t {
    pub __size: [::std::os::raw::c_char; 4usize],
    pub __align: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_pthread_condattr_t() {
    const UNINIT: ::std::mem::MaybeUninit<pthread_condattr_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<pthread_condattr_t>(),
        4usize,
        concat!("Size of: ", stringify!(pthread_condattr_t))
    );
    assert_eq!(
        ::std::mem::align_of::<pthread_condattr_t>(),
        4usize,
        concat!("Alignment of ", stringify!(pthread_condattr_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_condattr_t),
            "::",
            stringify!(__size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_condattr_t),
            "::",
            stringify!(__align)
        )
    );
}
pub type pthread_key_t = ::std::os::raw::c_uint;
pub type pthread_once_t = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_attr_t {
    pub __size: [::std::os::raw::c_char; 56usize],
    pub __align: ::std::os::raw::c_long,
}
#[test]
fn bindgen_test_layout_pthread_attr_t() {
    const UNINIT: ::std::mem::MaybeUninit<pthread_attr_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<pthread_attr_t>(),
        56usize,
        concat!("Size of: ", stringify!(pthread_attr_t))
    );
    assert_eq!(
        ::std::mem::align_of::<pthread_attr_t>(),
        8usize,
        concat!("Alignment of ", stringify!(pthread_attr_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_attr_t),
            "::",
            stringify!(__size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_attr_t),
            "::",
            stringify!(__align)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_mutex_t {
    pub __data: __pthread_mutex_s,
    pub __size: [::std::os::raw::c_char; 40usize],
    pub __align: ::std::os::raw::c_long,
}
#[test]
fn bindgen_test_layout_pthread_mutex_t() {
    const UNINIT: ::std::mem::MaybeUninit<pthread_mutex_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<pthread_mutex_t>(),
        40usize,
        concat!("Size of: ", stringify!(pthread_mutex_t))
    );
    assert_eq!(
        ::std::mem::align_of::<pthread_mutex_t>(),
        8usize,
        concat!("Alignment of ", stringify!(pthread_mutex_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_mutex_t),
            "::",
            stringify!(__data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_mutex_t),
            "::",
            stringify!(__size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_mutex_t),
            "::",
            stringify!(__align)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_cond_t {
    pub __data: __pthread_cond_s,
    pub __size: [::std::os::raw::c_char; 48usize],
    pub __align: ::std::os::raw::c_longlong,
}
#[test]
fn bindgen_test_layout_pthread_cond_t() {
    const UNINIT: ::std::mem::MaybeUninit<pthread_cond_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<pthread_cond_t>(),
        48usize,
        concat!("Size of: ", stringify!(pthread_cond_t))
    );
    assert_eq!(
        ::std::mem::align_of::<pthread_cond_t>(),
        8usize,
        concat!("Alignment of ", stringify!(pthread_cond_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_cond_t),
            "::",
            stringify!(__data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_cond_t),
            "::",
            stringify!(__size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_cond_t),
            "::",
            stringify!(__align)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_rwlock_t {
    pub __data: __pthread_rwlock_arch_t,
    pub __size: [::std::os::raw::c_char; 56usize],
    pub __align: ::std::os::raw::c_long,
}
#[test]
fn bindgen_test_layout_pthread_rwlock_t() {
    const UNINIT: ::std::mem::MaybeUninit<pthread_rwlock_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<pthread_rwlock_t>(),
        56usize,
        concat!("Size of: ", stringify!(pthread_rwlock_t))
    );
    assert_eq!(
        ::std::mem::align_of::<pthread_rwlock_t>(),
        8usize,
        concat!("Alignment of ", stringify!(pthread_rwlock_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_rwlock_t),
            "::",
            stringify!(__data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_rwlock_t),
            "::",
            stringify!(__size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_rwlock_t),
            "::",
            stringify!(__align)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_rwlockattr_t {
    pub __size: [::std::os::raw::c_char; 8usize],
    pub __align: ::std::os::raw::c_long,
}
#[test]
fn bindgen_test_layout_pthread_rwlockattr_t() {
    const UNINIT: ::std::mem::MaybeUninit<pthread_rwlockattr_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<pthread_rwlockattr_t>(),
        8usize,
        concat!("Size of: ", stringify!(pthread_rwlockattr_t))
    );
    assert_eq!(
        ::std::mem::align_of::<pthread_rwlockattr_t>(),
        8usize,
        concat!("Alignment of ", stringify!(pthread_rwlockattr_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_rwlockattr_t),
            "::",
            stringify!(__size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_rwlockattr_t),
            "::",
            stringify!(__align)
        )
    );
}
pub type pthread_spinlock_t = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_barrier_t {
    pub __size: [::std::os::raw::c_char; 32usize],
    pub __align: ::std::os::raw::c_long,
}
#[test]
fn bindgen_test_layout_pthread_barrier_t() {
    const UNINIT: ::std::mem::MaybeUninit<pthread_barrier_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<pthread_barrier_t>(),
        32usize,
        concat!("Size of: ", stringify!(pthread_barrier_t))
    );
    assert_eq!(
        ::std::mem::align_of::<pthread_barrier_t>(),
        8usize,
        concat!("Alignment of ", stringify!(pthread_barrier_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_barrier_t),
            "::",
            stringify!(__size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_barrier_t),
            "::",
            stringify!(__align)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_barrierattr_t {
    pub __size: [::std::os::raw::c_char; 4usize],
    pub __align: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_pthread_barrierattr_t() {
    const UNINIT: ::std::mem::MaybeUninit<pthread_barrierattr_t> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<pthread_barrierattr_t>(),
        4usize,
        concat!("Size of: ", stringify!(pthread_barrierattr_t))
    );
    assert_eq!(
        ::std::mem::align_of::<pthread_barrierattr_t>(),
        4usize,
        concat!("Alignment of ", stringify!(pthread_barrierattr_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_barrierattr_t),
            "::",
            stringify!(__size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(pthread_barrierattr_t),
            "::",
            stringify!(__align)
        )
    );
}
extern "C" {
    pub fn random() -> ::std::os::raw::c_long;
}
extern "C" {
    pub fn srandom(__seed: ::std::os::raw::c_uint);
}
extern "C" {
    pub fn initstate(
        __seed: ::std::os::raw::c_uint,
        __statebuf: *mut ::std::os::raw::c_char,
        __statelen: usize,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn setstate(__statebuf: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct random_data {
    pub fptr: *mut i32,
    pub rptr: *mut i32,
    pub state: *mut i32,
    pub rand_type: ::std::os::raw::c_int,
    pub rand_deg: ::std::os::raw::c_int,
    pub rand_sep: ::std::os::raw::c_int,
    pub end_ptr: *mut i32,
}
#[test]
fn bindgen_test_layout_random_data() {
    const UNINIT: ::std::mem::MaybeUninit<random_data> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<random_data>(),
        48usize,
        concat!("Size of: ", stringify!(random_data))
    );
    assert_eq!(
        ::std::mem::align_of::<random_data>(),
        8usize,
        concat!("Alignment of ", stringify!(random_data))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fptr) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(random_data),
            "::",
            stringify!(fptr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rptr) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(random_data),
            "::",
            stringify!(rptr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(random_data),
            "::",
            stringify!(state)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rand_type) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(random_data),
            "::",
            stringify!(rand_type)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rand_deg) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(random_data),
            "::",
            stringify!(rand_deg)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rand_sep) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(random_data),
            "::",
            stringify!(rand_sep)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).end_ptr) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(random_data),
            "::",
            stringify!(end_ptr)
        )
    );
}
extern "C" {
    pub fn random_r(__buf: *mut random_data, __result: *mut i32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn srandom_r(
        __seed: ::std::os::raw::c_uint,
        __buf: *mut random_data,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn initstate_r(
        __seed: ::std::os::raw::c_uint,
        __statebuf: *mut ::std::os::raw::c_char,
        __statelen: usize,
        __buf: *mut random_data,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn setstate_r(
        __statebuf: *mut ::std::os::raw::c_char,
        __buf: *mut random_data,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn rand() -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn srand(__seed: ::std::os::raw::c_uint);
}
extern "C" {
    pub fn rand_r(__seed: *mut ::std::os::raw::c_uint) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn drand48() -> f64;
}
extern "C" {
    pub fn erand48(__xsubi: *mut ::std::os::raw::c_ushort) -> f64;
}
extern "C" {
    pub fn lrand48() -> ::std::os::raw::c_long;
}
extern "C" {
    pub fn nrand48(__xsubi: *mut ::std::os::raw::c_ushort) -> ::std::os::raw::c_long;
}
extern "C" {
    pub fn mrand48() -> ::std::os::raw::c_long;
}
extern "C" {
    pub fn jrand48(__xsubi: *mut ::std::os::raw::c_ushort) -> ::std::os::raw::c_long;
}
extern "C" {
    pub fn srand48(__seedval: ::std::os::raw::c_long);
}
extern "C" {
    pub fn seed48(__seed16v: *mut ::std::os::raw::c_ushort) -> *mut ::std::os::raw::c_ushort;
}
extern "C" {
    pub fn lcong48(__param: *mut ::std::os::raw::c_ushort);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct drand48_data {
    pub __x: [::std::os::raw::c_ushort; 3usize],
    pub __old_x: [::std::os::raw::c_ushort; 3usize],
    pub __c: ::std::os::raw::c_ushort,
    pub __init: ::std::os::raw::c_ushort,
    pub __a: ::std::os::raw::c_ulonglong,
}
#[test]
fn bindgen_test_layout_drand48_data() {
    const UNINIT: ::std::mem::MaybeUninit<drand48_data> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<drand48_data>(),
        24usize,
        concat!("Size of: ", stringify!(drand48_data))
    );
    assert_eq!(
        ::std::mem::align_of::<drand48_data>(),
        8usize,
        concat!("Alignment of ", stringify!(drand48_data))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__x) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(drand48_data),
            "::",
            stringify!(__x)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__old_x) as usize - ptr as usize },
        6usize,
        concat!(
            "Offset of field: ",
            stringify!(drand48_data),
            "::",
            stringify!(__old_x)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__c) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(drand48_data),
            "::",
            stringify!(__c)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__init) as usize - ptr as usize },
        14usize,
        concat!(
            "Offset of field: ",
            stringify!(drand48_data),
            "::",
            stringify!(__init)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__a) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(drand48_data),
            "::",
            stringify!(__a)
        )
    );
}
extern "C" {
    pub fn drand48_r(__buffer: *mut drand48_data, __result: *mut f64) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn erand48_r(
        __xsubi: *mut ::std::os::raw::c_ushort,
        __buffer: *mut drand48_data,
        __result: *mut f64,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn lrand48_r(
        __buffer: *mut drand48_data,
        __result: *mut ::std::os::raw::c_long,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn nrand48_r(
        __xsubi: *mut ::std::os::raw::c_ushort,
        __buffer: *mut drand48_data,
        __result: *mut ::std::os::raw::c_long,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mrand48_r(
        __buffer: *mut drand48_data,
        __result: *mut ::std::os::raw::c_long,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn jrand48_r(
        __xsubi: *mut ::std::os::raw::c_ushort,
        __buffer: *mut drand48_data,
        __result: *mut ::std::os::raw::c_long,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn srand48_r(
        __seedval: ::std::os::raw::c_long,
        __buffer: *mut drand48_data,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn seed48_r(
        __seed16v: *mut ::std::os::raw::c_ushort,
        __buffer: *mut drand48_data,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn lcong48_r(
        __param: *mut ::std::os::raw::c_ushort,
        __buffer: *mut drand48_data,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn arc4random() -> __uint32_t;
}
extern "C" {
    pub fn arc4random_buf(__buf: *mut ::std::os::raw::c_void, __size: usize);
}
extern "C" {
    pub fn arc4random_uniform(__upper_bound: __uint32_t) -> __uint32_t;
}
extern "C" {
    pub fn malloc(__size: ::std::os::raw::c_ulong) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn calloc(
        __nmemb: ::std::os::raw::c_ulong,
        __size: ::std::os::raw::c_ulong,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn realloc(
        __ptr: *mut ::std::os::raw::c_void,
        __size: ::std::os::raw::c_ulong,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn free(__ptr: *mut ::std::os::raw::c_void);
}
extern "C" {
    pub fn reallocarray(
        __ptr: *mut ::std::os::raw::c_void,
        __nmemb: usize,
        __size: usize,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn alloca(__size: ::std::os::raw::c_ulong) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn valloc(__size: usize) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn posix_memalign(
        __memptr: *mut *mut ::std::os::raw::c_void,
        __alignment: usize,
        __size: usize,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn aligned_alloc(
        __alignment: ::std::os::raw::c_ulong,
        __size: ::std::os::raw::c_ulong,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn abort() -> !;
}
extern "C" {
    pub fn atexit(__func: ::std::option::Option<unsafe extern "C" fn()>) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn at_quick_exit(
        __func: ::std::option::Option<unsafe extern "C" fn()>,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn on_exit(
        __func: ::std::option::Option<
            unsafe extern "C" fn(
                __status: ::std::os::raw::c_int,
                __arg: *mut ::std::os::raw::c_void,
            ),
        >,
        __arg: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn exit(__status: ::std::os::raw::c_int) -> !;
}
extern "C" {
    pub fn quick_exit(__status: ::std::os::raw::c_int) -> !;
}
extern "C" {
    pub fn _Exit(__status: ::std::os::raw::c_int) -> !;
}
extern "C" {
    pub fn getenv(__name: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn putenv(__string: *mut ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn setenv(
        __name: *const ::std::os::raw::c_char,
        __value: *const ::std::os::raw::c_char,
        __replace: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn unsetenv(__name: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn clearenv() -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mktemp(__template: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn mkstemp(__template: *mut ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mkstemps(
        __template: *mut ::std::os::raw::c_char,
        __suffixlen: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mkdtemp(__template: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn system(__command: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn realpath(
        __name: *const ::std::os::raw::c_char,
        __resolved: *mut ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_char;
}
pub type __compar_fn_t = ::std::option::Option<
    unsafe extern "C" fn(
        arg1: *const ::std::os::raw::c_void,
        arg2: *const ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int,
>;
extern "C" {
    pub fn bsearch(
        __key: *const ::std::os::raw::c_void,
        __base: *const ::std::os::raw::c_void,
        __nmemb: usize,
        __size: usize,
        __compar: __compar_fn_t,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn qsort(
        __base: *mut ::std::os::raw::c_void,
        __nmemb: usize,
        __size: usize,
        __compar: __compar_fn_t,
    );
}
extern "C" {
    pub fn abs(__x: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn labs(__x: ::std::os::raw::c_long) -> ::std::os::raw::c_long;
}
extern "C" {
    pub fn llabs(__x: ::std::os::raw::c_longlong) -> ::std::os::raw::c_longlong;
}
extern "C" {
    pub fn div(__numer: ::std::os::raw::c_int, __denom: ::std::os::raw::c_int) -> div_t;
}
extern "C" {
    pub fn ldiv(__numer: ::std::os::raw::c_long, __denom: ::std::os::raw::c_long) -> ldiv_t;
}
extern "C" {
    pub fn lldiv(
        __numer: ::std::os::raw::c_longlong,
        __denom: ::std::os::raw::c_longlong,
    ) -> lldiv_t;
}
extern "C" {
    pub fn ecvt(
        __value: f64,
        __ndigit: ::std::os::raw::c_int,
        __decpt: *mut ::std::os::raw::c_int,
        __sign: *mut ::std::os::raw::c_int,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn fcvt(
        __value: f64,
        __ndigit: ::std::os::raw::c_int,
        __decpt: *mut ::std::os::raw::c_int,
        __sign: *mut ::std::os::raw::c_int,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn gcvt(
        __value: f64,
        __ndigit: ::std::os::raw::c_int,
        __buf: *mut ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn qecvt(
        __value: u128,
        __ndigit: ::std::os::raw::c_int,
        __decpt: *mut ::std::os::raw::c_int,
        __sign: *mut ::std::os::raw::c_int,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn qfcvt(
        __value: u128,
        __ndigit: ::std::os::raw::c_int,
        __decpt: *mut ::std::os::raw::c_int,
        __sign: *mut ::std::os::raw::c_int,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn qgcvt(
        __value: u128,
        __ndigit: ::std::os::raw::c_int,
        __buf: *mut ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn ecvt_r(
        __value: f64,
        __ndigit: ::std::os::raw::c_int,
        __decpt: *mut ::std::os::raw::c_int,
        __sign: *mut ::std::os::raw::c_int,
        __buf: *mut ::std::os::raw::c_char,
        __len: usize,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn fcvt_r(
        __value: f64,
        __ndigit: ::std::os::raw::c_int,
        __decpt: *mut ::std::os::raw::c_int,
        __sign: *mut ::std::os::raw::c_int,
        __buf: *mut ::std::os::raw::c_char,
        __len: usize,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn qecvt_r(
        __value: u128,
        __ndigit: ::std::os::raw::c_int,
        __decpt: *mut ::std::os::raw::c_int,
        __sign: *mut ::std::os::raw::c_int,
        __buf: *mut ::std::os::raw::c_char,
        __len: usize,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn qfcvt_r(
        __value: u128,
        __ndigit: ::std::os::raw::c_int,
        __decpt: *mut ::std::os::raw::c_int,
        __sign: *mut ::std::os::raw::c_int,
        __buf: *mut ::std::os::raw::c_char,
        __len: usize,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mblen(__s: *const ::std::os::raw::c_char, __n: usize) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mbtowc(
        __pwc: *mut wchar_t,
        __s: *const ::std::os::raw::c_char,
        __n: usize,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn wctomb(__s: *mut ::std::os::raw::c_char, __wchar: wchar_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mbstowcs(__pwcs: *mut wchar_t, __s: *const ::std::os::raw::c_char, __n: usize) -> usize;
}
extern "C" {
    pub fn wcstombs(__s: *mut ::std::os::raw::c_char, __pwcs: *const wchar_t, __n: usize) -> usize;
}
extern "C" {
    pub fn rpmatch(__response: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn getsubopt(
        __optionp: *mut *mut ::std::os::raw::c_char,
        __tokens: *const *mut ::std::os::raw::c_char,
        __valuep: *mut *mut ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn getloadavg(__loadavg: *mut f64, __nelem: ::std::os::raw::c_int)
        -> ::std::os::raw::c_int;
}
pub type __jmp_buf = [::std::os::raw::c_long; 8usize];
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __jmp_buf_tag {
    pub __jmpbuf: __jmp_buf,
    pub __mask_was_saved: ::std::os::raw::c_int,
    pub __saved_mask: __sigset_t,
}
#[test]
fn bindgen_test_layout___jmp_buf_tag() {
    const UNINIT: ::std::mem::MaybeUninit<__jmp_buf_tag> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<__jmp_buf_tag>(),
        200usize,
        concat!("Size of: ", stringify!(__jmp_buf_tag))
    );
    assert_eq!(
        ::std::mem::align_of::<__jmp_buf_tag>(),
        8usize,
        concat!("Alignment of ", stringify!(__jmp_buf_tag))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__jmpbuf) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__jmp_buf_tag),
            "::",
            stringify!(__jmpbuf)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__mask_was_saved) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(__jmp_buf_tag),
            "::",
            stringify!(__mask_was_saved)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).__saved_mask) as usize - ptr as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(__jmp_buf_tag),
            "::",
            stringify!(__saved_mask)
        )
    );
}
pub type jmp_buf = [__jmp_buf_tag; 1usize];
extern "C" {
    pub fn setjmp(__env: *mut __jmp_buf_tag) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn __sigsetjmp(
        __env: *mut __jmp_buf_tag,
        __savemask: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn _setjmp(__env: *mut __jmp_buf_tag) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn longjmp(__env: *mut __jmp_buf_tag, __val: ::std::os::raw::c_int) -> !;
}
extern "C" {
    pub fn _longjmp(__env: *mut __jmp_buf_tag, __val: ::std::os::raw::c_int) -> !;
}
pub type sigjmp_buf = [__jmp_buf_tag; 1usize];
extern "C" {
    pub fn siglongjmp(__env: *mut __jmp_buf_tag, __val: ::std::os::raw::c_int) -> !;
}
extern "C" {
    pub static mut cst_errjmp: *mut jmp_buf;
}
extern "C" {
    pub fn cst_errmsg(fmt: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn cst_safe_alloc(size: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn cst_safe_calloc(size: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn cst_safe_realloc(
        p: *mut ::std::os::raw::c_void,
        size: ::std::os::raw::c_int,
    ) -> *mut ::std::os::raw::c_void;
}
pub type cst_alloc_context = *mut ::std::os::raw::c_void;
extern "C" {
    pub fn cst_free(p: *mut ::std::os::raw::c_void);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cst_val_cons_struct {
    pub car: *mut cst_val_struct,
    pub cdr: *mut cst_val_struct,
}
#[test]
fn bindgen_test_layout_cst_val_cons_struct() {
    const UNINIT: ::std::mem::MaybeUninit<cst_val_cons_struct> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<cst_val_cons_struct>(),
        16usize,
        concat!("Size of: ", stringify!(cst_val_cons_struct))
    );
    assert_eq!(
        ::std::mem::align_of::<cst_val_cons_struct>(),
        8usize,
        concat!("Alignment of ", stringify!(cst_val_cons_struct))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).car) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_val_cons_struct),
            "::",
            stringify!(car)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).cdr) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_val_cons_struct),
            "::",
            stringify!(cdr)
        )
    );
}
pub type cst_val_cons = cst_val_cons_struct;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct cst_val_atom_struct {
    pub type_: ::std::os::raw::c_int,
    pub ref_count: ::std::os::raw::c_int,
    pub v: cst_val_atom_struct__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union cst_val_atom_struct__bindgen_ty_1 {
    pub fval: f64,
    pub ival: ::std::os::raw::c_longlong,
    pub vval: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_cst_val_atom_struct__bindgen_ty_1() {
    const UNINIT: ::std::mem::MaybeUninit<cst_val_atom_struct__bindgen_ty_1> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<cst_val_atom_struct__bindgen_ty_1>(),
        8usize,
        concat!("Size of: ", stringify!(cst_val_atom_struct__bindgen_ty_1))
    );
    assert_eq!(
        ::std::mem::align_of::<cst_val_atom_struct__bindgen_ty_1>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(cst_val_atom_struct__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fval) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_val_atom_struct__bindgen_ty_1),
            "::",
            stringify!(fval)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ival) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_val_atom_struct__bindgen_ty_1),
            "::",
            stringify!(ival)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).vval) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_val_atom_struct__bindgen_ty_1),
            "::",
            stringify!(vval)
        )
    );
}
#[test]
fn bindgen_test_layout_cst_val_atom_struct() {
    const UNINIT: ::std::mem::MaybeUninit<cst_val_atom_struct> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<cst_val_atom_struct>(),
        16usize,
        concat!("Size of: ", stringify!(cst_val_atom_struct))
    );
    assert_eq!(
        ::std::mem::align_of::<cst_val_atom_struct>(),
        8usize,
        concat!("Alignment of ", stringify!(cst_val_atom_struct))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_val_atom_struct),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ref_count) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_val_atom_struct),
            "::",
            stringify!(ref_count)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).v) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_val_atom_struct),
            "::",
            stringify!(v)
        )
    );
}
pub type cst_val_atom = cst_val_atom_struct;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct cst_val_struct {
    pub c: cst_val_struct__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union cst_val_struct__bindgen_ty_1 {
    pub cc: cst_val_cons,
    pub a: cst_val_atom,
}
#[test]
fn bindgen_test_layout_cst_val_struct__bindgen_ty_1() {
    const UNINIT: ::std::mem::MaybeUninit<cst_val_struct__bindgen_ty_1> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<cst_val_struct__bindgen_ty_1>(),
        16usize,
        concat!("Size of: ", stringify!(cst_val_struct__bindgen_ty_1))
    );
    assert_eq!(
        ::std::mem::align_of::<cst_val_struct__bindgen_ty_1>(),
        8usize,
        concat!("Alignment of ", stringify!(cst_val_struct__bindgen_ty_1))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).cc) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_val_struct__bindgen_ty_1),
            "::",
            stringify!(cc)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_val_struct__bindgen_ty_1),
            "::",
            stringify!(a)
        )
    );
}
#[test]
fn bindgen_test_layout_cst_val_struct() {
    const UNINIT: ::std::mem::MaybeUninit<cst_val_struct> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<cst_val_struct>(),
        16usize,
        concat!("Size of: ", stringify!(cst_val_struct))
    );
    assert_eq!(
        ::std::mem::align_of::<cst_val_struct>(),
        8usize,
        concat!("Alignment of ", stringify!(cst_val_struct))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).c) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_val_struct),
            "::",
            stringify!(c)
        )
    );
}
pub type cst_val = cst_val_struct;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cst_val_def_struct {
    pub name: *const ::std::os::raw::c_char,
    pub delete_function:
        ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
}
#[test]
fn bindgen_test_layout_cst_val_def_struct() {
    const UNINIT: ::std::mem::MaybeUninit<cst_val_def_struct> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<cst_val_def_struct>(),
        16usize,
        concat!("Size of: ", stringify!(cst_val_def_struct))
    );
    assert_eq!(
        ::std::mem::align_of::<cst_val_def_struct>(),
        8usize,
        concat!("Alignment of ", stringify!(cst_val_def_struct))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_val_def_struct),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).delete_function) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_val_def_struct),
            "::",
            stringify!(delete_function)
        )
    );
}
pub type cst_val_def = cst_val_def_struct;
extern "C" {
    pub fn int_val(i: ::std::os::raw::c_int) -> *mut cst_val;
}
extern "C" {
    pub fn float_val(f: f32) -> *mut cst_val;
}
extern "C" {
    pub fn string_val(s: *const ::std::os::raw::c_char) -> *mut cst_val;
}
extern "C" {
    pub fn val_new_typed(
        type_: ::std::os::raw::c_int,
        vv: *mut ::std::os::raw::c_void,
    ) -> *mut cst_val;
}
extern "C" {
    pub fn cons_val(a: *const cst_val, b: *const cst_val) -> *mut cst_val;
}
extern "C" {
    pub fn delete_val(val: *mut cst_val);
}
extern "C" {
    pub fn delete_val_list(val: *mut cst_val);
}
extern "C" {
    pub fn val_int(v: *const cst_val) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn val_float(v: *const cst_val) -> f32;
}
extern "C" {
    pub fn val_string(v: *const cst_val) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn val_void(v: *const cst_val) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn val_generic(
        v: *const cst_val,
        type_: ::std::os::raw::c_int,
        stype: *const ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn val_car(v: *const cst_val) -> *const cst_val;
}
extern "C" {
    pub fn val_cdr(v: *const cst_val) -> *const cst_val;
}
extern "C" {
    pub fn set_cdr(v1: *mut cst_val, v2: *const cst_val) -> *const cst_val;
}
extern "C" {
    pub fn set_car(v1: *mut cst_val, v2: *const cst_val) -> *const cst_val;
}
extern "C" {
    pub fn cst_val_consp(v: *const cst_val) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn val_equal(a: *const cst_val, b: *const cst_val) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn val_less(a: *const cst_val, b: *const cst_val) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn val_greater(a: *const cst_val, b: *const cst_val) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn val_member(a: *const cst_val, b: *const cst_val) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn val_member_string(
        a: *const ::std::os::raw::c_char,
        b: *const cst_val,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn val_stringp(a: *const cst_val) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn val_assoc_string(
        v1: *const ::std::os::raw::c_char,
        al: *const cst_val,
    ) -> *const cst_val;
}
extern "C" {
    pub fn val_print(fd: cst_file, v: *const cst_val);
}
extern "C" {
    pub fn val_readlist_string(str_: *const ::std::os::raw::c_char) -> *mut cst_val;
}
extern "C" {
    pub fn val_reverse(v: *mut cst_val) -> *mut cst_val;
}
extern "C" {
    pub fn val_append(a: *mut cst_val, b: *mut cst_val) -> *mut cst_val;
}
extern "C" {
    pub fn val_length(l: *const cst_val) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn cst_utf8_explode(utf8string: *const cst_string) -> *mut cst_val;
}
extern "C" {
    pub fn cst_implode(string_list: *const cst_val) -> *mut cst_string;
}
extern "C" {
    pub fn cst_utf8_ord(utf8_char: *const cst_val) -> *mut cst_val;
}
extern "C" {
    pub fn cst_utf8_chr(ord: *const cst_val) -> *mut cst_val;
}
extern "C" {
    pub fn cst_utf8_ord_string(utf8_char: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn val_dec_refcount(b: *const cst_val) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn val_inc_refcount(b: *const cst_val) -> *mut cst_val;
}
extern "C" {
    pub static val_int_0: cst_val;
}
extern "C" {
    pub static val_int_1: cst_val;
}
extern "C" {
    pub static val_int_2: cst_val;
}
extern "C" {
    pub static val_int_3: cst_val;
}
extern "C" {
    pub static val_int_4: cst_val;
}
extern "C" {
    pub static val_int_5: cst_val;
}
extern "C" {
    pub static val_int_6: cst_val;
}
extern "C" {
    pub static val_int_7: cst_val;
}
extern "C" {
    pub static val_int_8: cst_val;
}
extern "C" {
    pub static val_int_9: cst_val;
}
extern "C" {
    pub static val_int_10: cst_val;
}
extern "C" {
    pub static val_int_11: cst_val;
}
extern "C" {
    pub static val_int_12: cst_val;
}
extern "C" {
    pub static val_int_13: cst_val;
}
extern "C" {
    pub static val_int_14: cst_val;
}
extern "C" {
    pub static val_int_15: cst_val;
}
extern "C" {
    pub static val_int_16: cst_val;
}
extern "C" {
    pub static val_int_17: cst_val;
}
extern "C" {
    pub static val_int_18: cst_val;
}
extern "C" {
    pub static val_int_19: cst_val;
}
extern "C" {
    pub static val_int_20: cst_val;
}
extern "C" {
    pub static val_int_21: cst_val;
}
extern "C" {
    pub static val_int_22: cst_val;
}
extern "C" {
    pub static val_int_23: cst_val;
}
extern "C" {
    pub static val_int_24: cst_val;
}
extern "C" {
    pub static val_string_0: cst_val;
}
extern "C" {
    pub static val_string_1: cst_val;
}
extern "C" {
    pub static val_string_2: cst_val;
}
extern "C" {
    pub static val_string_3: cst_val;
}
extern "C" {
    pub static val_string_4: cst_val;
}
extern "C" {
    pub static val_string_5: cst_val;
}
extern "C" {
    pub static val_string_6: cst_val;
}
extern "C" {
    pub static val_string_7: cst_val;
}
extern "C" {
    pub static val_string_8: cst_val;
}
extern "C" {
    pub static val_string_9: cst_val;
}
extern "C" {
    pub static val_string_10: cst_val;
}
extern "C" {
    pub static val_string_11: cst_val;
}
extern "C" {
    pub static val_string_12: cst_val;
}
extern "C" {
    pub static val_string_13: cst_val;
}
extern "C" {
    pub static val_string_14: cst_val;
}
extern "C" {
    pub static val_string_15: cst_val;
}
extern "C" {
    pub static val_string_16: cst_val;
}
extern "C" {
    pub static val_string_17: cst_val;
}
extern "C" {
    pub static val_string_18: cst_val;
}
extern "C" {
    pub static val_string_19: cst_val;
}
extern "C" {
    pub static val_string_20: cst_val;
}
extern "C" {
    pub static val_string_21: cst_val;
}
extern "C" {
    pub static val_string_22: cst_val;
}
extern "C" {
    pub static val_string_23: cst_val;
}
extern "C" {
    pub static val_string_24: cst_val;
}
extern "C" {
    pub fn val_int_n(n: ::std::os::raw::c_int) -> *const cst_val;
}
extern "C" {
    pub fn val_string_n(n: ::std::os::raw::c_int) -> *const cst_val;
}
extern "C" {
    pub static cst_val_defs: [cst_val_def; 0usize];
}
pub type cst_userdata = ::std::os::raw::c_void;
extern "C" {
    pub static cst_val_type_userdata: ::std::os::raw::c_int;
}
extern "C" {
    pub fn val_userdata(v: *const cst_val) -> *mut cst_userdata;
}
extern "C" {
    pub fn userdata_val(v: *const cst_userdata) -> *mut cst_val;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cst_featvalpair_struct {
    pub name: *const ::std::os::raw::c_char,
    pub val: *mut cst_val,
    pub next: *mut cst_featvalpair_struct,
}
#[test]
fn bindgen_test_layout_cst_featvalpair_struct() {
    const UNINIT: ::std::mem::MaybeUninit<cst_featvalpair_struct> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<cst_featvalpair_struct>(),
        24usize,
        concat!("Size of: ", stringify!(cst_featvalpair_struct))
    );
    assert_eq!(
        ::std::mem::align_of::<cst_featvalpair_struct>(),
        8usize,
        concat!("Alignment of ", stringify!(cst_featvalpair_struct))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_featvalpair_struct),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).val) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_featvalpair_struct),
            "::",
            stringify!(val)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_featvalpair_struct),
            "::",
            stringify!(next)
        )
    );
}
pub type cst_featvalpair = cst_featvalpair_struct;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cst_features_struct {
    pub head: *mut cst_featvalpair_struct,
    pub ctx: cst_alloc_context,
    pub owned_strings: *mut cst_val,
    pub linked: *const cst_features_struct,
}
#[test]
fn bindgen_test_layout_cst_features_struct() {
    const UNINIT: ::std::mem::MaybeUninit<cst_features_struct> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<cst_features_struct>(),
        32usize,
        concat!("Size of: ", stringify!(cst_features_struct))
    );
    assert_eq!(
        ::std::mem::align_of::<cst_features_struct>(),
        8usize,
        concat!("Alignment of ", stringify!(cst_features_struct))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).head) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_features_struct),
            "::",
            stringify!(head)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ctx) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_features_struct),
            "::",
            stringify!(ctx)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).owned_strings) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_features_struct),
            "::",
            stringify!(owned_strings)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).linked) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_features_struct),
            "::",
            stringify!(linked)
        )
    );
}
pub type cst_features = cst_features_struct;
extern "C" {
    pub fn new_features() -> *mut cst_features;
}
extern "C" {
    pub fn new_features_local(ctx: cst_alloc_context) -> *mut cst_features;
}
extern "C" {
    pub fn delete_features(f: *mut cst_features);
}
extern "C" {
    pub fn feat_int(
        f: *const cst_features,
        name: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn feat_float(f: *const cst_features, name: *const ::std::os::raw::c_char) -> f32;
}
extern "C" {
    pub fn feat_string(
        f: *const cst_features,
        name: *const ::std::os::raw::c_char,
    ) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn feat_val(f: *const cst_features, name: *const ::std::os::raw::c_char) -> *const cst_val;
}
extern "C" {
    pub fn get_param_int(
        f: *const cst_features,
        name: *const ::std::os::raw::c_char,
        def: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn get_param_float(
        f: *const cst_features,
        name: *const ::std::os::raw::c_char,
        def: f32,
    ) -> f32;
}
extern "C" {
    pub fn get_param_string(
        f: *const cst_features,
        name: *const ::std::os::raw::c_char,
        def: *const ::std::os::raw::c_char,
    ) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn get_param_val(
        f: *const cst_features,
        name: *const ::std::os::raw::c_char,
        def: *mut cst_val,
    ) -> *const cst_val;
}
extern "C" {
    pub fn feat_set_int(
        f: *mut cst_features,
        name: *const ::std::os::raw::c_char,
        v: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn feat_set_float(f: *mut cst_features, name: *const ::std::os::raw::c_char, v: f32);
}
extern "C" {
    pub fn feat_set_string(
        f: *mut cst_features,
        name: *const ::std::os::raw::c_char,
        v: *const ::std::os::raw::c_char,
    );
}
extern "C" {
    pub fn feat_set(f: *mut cst_features, name: *const ::std::os::raw::c_char, v: *const cst_val);
}
extern "C" {
    pub fn feat_remove(
        f: *mut cst_features,
        name: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn feat_present(
        f: *const cst_features,
        name: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn feat_length(f: *const cst_features) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn feat_own_string(
        f: *mut cst_features,
        name: *const ::std::os::raw::c_char,
    ) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub static cst_val_type_features: ::std::os::raw::c_int;
}
extern "C" {
    pub fn val_features(v: *const cst_val) -> *mut cst_features;
}
extern "C" {
    pub fn features_val(v: *const cst_features) -> *mut cst_val;
}
extern "C" {
    pub fn feat_copy_into(
        from: *const cst_features,
        to: *mut cst_features,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn feat_link_into(
        from: *const cst_features,
        to: *mut cst_features,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn cst_feat_print(fd: cst_file, f: *const cst_features) -> ::std::os::raw::c_int;
}
pub type cst_relation = cst_relation_struct;
pub type cst_utterance = cst_utterance_struct;
pub type cst_item = cst_item_struct;
extern "C" {
    pub static cst_val_type_relation: ::std::os::raw::c_int;
}
extern "C" {
    pub fn val_relation(v: *const cst_val) -> *mut cst_relation;
}
extern "C" {
    pub fn relation_val(v: *const cst_relation) -> *mut cst_val;
}
extern "C" {
    pub static cst_val_type_item: ::std::os::raw::c_int;
}
extern "C" {
    pub fn val_item(v: *const cst_val) -> *mut cst_item;
}
extern "C" {
    pub fn item_val(v: *const cst_item) -> *mut cst_val;
}
extern "C" {
    pub static cst_val_type_utterance: ::std::os::raw::c_int;
}
extern "C" {
    pub fn val_utterance(v: *const cst_val) -> *mut cst_utterance;
}
extern "C" {
    pub fn utterance_val(v: *const cst_utterance) -> *mut cst_val;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cst_item_contents_struct {
    pub features: *mut cst_features,
    pub relations: *mut cst_features,
}
#[test]
fn bindgen_test_layout_cst_item_contents_struct() {
    const UNINIT: ::std::mem::MaybeUninit<cst_item_contents_struct> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<cst_item_contents_struct>(),
        16usize,
        concat!("Size of: ", stringify!(cst_item_contents_struct))
    );
    assert_eq!(
        ::std::mem::align_of::<cst_item_contents_struct>(),
        8usize,
        concat!("Alignment of ", stringify!(cst_item_contents_struct))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).features) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_item_contents_struct),
            "::",
            stringify!(features)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).relations) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_item_contents_struct),
            "::",
            stringify!(relations)
        )
    );
}
pub type cst_item_contents = cst_item_contents_struct;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cst_item_struct {
    pub contents: *mut cst_item_contents,
    pub relation: *mut cst_relation,
    pub n: *mut cst_item,
    pub p: *mut cst_item,
    pub u: *mut cst_item,
    pub d: *mut cst_item,
}
#[test]
fn bindgen_test_layout_cst_item_struct() {
    const UNINIT: ::std::mem::MaybeUninit<cst_item_struct> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<cst_item_struct>(),
        48usize,
        concat!("Size of: ", stringify!(cst_item_struct))
    );
    assert_eq!(
        ::std::mem::align_of::<cst_item_struct>(),
        8usize,
        concat!("Alignment of ", stringify!(cst_item_struct))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).contents) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_item_struct),
            "::",
            stringify!(contents)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).relation) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_item_struct),
            "::",
            stringify!(relation)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).n) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_item_struct),
            "::",
            stringify!(n)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).p) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_item_struct),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).u) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_item_struct),
            "::",
            stringify!(u)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_item_struct),
            "::",
            stringify!(d)
        )
    );
}
extern "C" {
    pub fn new_item_relation(r: *mut cst_relation, i: *mut cst_item) -> *mut cst_item;
}
extern "C" {
    pub fn new_item_contents(i: *mut cst_item) -> *mut cst_item_contents;
}
extern "C" {
    pub fn delete_item(item: *mut cst_item);
}
extern "C" {
    pub fn item_contents_set(current: *mut cst_item, i: *mut cst_item);
}
extern "C" {
    pub fn item_unref_contents(i: *mut cst_item);
}
extern "C" {
    pub fn item_as(i: *const cst_item, rname: *const ::std::os::raw::c_char) -> *mut cst_item;
}
extern "C" {
    pub fn item_utt(i: *const cst_item) -> *mut cst_utterance;
}
extern "C" {
    pub fn item_next(i: *const cst_item) -> *mut cst_item;
}
extern "C" {
    pub fn item_prev(i: *const cst_item) -> *mut cst_item;
}
extern "C" {
    pub fn item_append(i: *mut cst_item, new_item: *mut cst_item) -> *mut cst_item;
}
extern "C" {
    pub fn item_prepend(i: *mut cst_item, new_item: *mut cst_item) -> *mut cst_item;
}
extern "C" {
    pub fn item_parent(i: *const cst_item) -> *mut cst_item;
}
extern "C" {
    pub fn item_nth_daughter(i: *const cst_item, n: ::std::os::raw::c_int) -> *mut cst_item;
}
extern "C" {
    pub fn item_daughter(i: *const cst_item) -> *mut cst_item;
}
extern "C" {
    pub fn item_last_daughter(i: *const cst_item) -> *mut cst_item;
}
extern "C" {
    pub fn item_first(i: *const cst_item) -> *mut cst_item;
}
extern "C" {
    pub fn item_last(i: *const cst_item) -> *mut cst_item;
}
extern "C" {
    pub fn item_add_daughter(i: *mut cst_item, new_item: *mut cst_item) -> *mut cst_item;
}
extern "C" {
    pub fn item_append_sibling(i: *mut cst_item, new_item: *mut cst_item) -> *mut cst_item;
}
extern "C" {
    pub fn item_prepend_sibling(i: *mut cst_item, new_item: *mut cst_item) -> *mut cst_item;
}
extern "C" {
    pub fn item_feat_present(
        i: *const cst_item,
        name: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn item_feat_remove(
        i: *const cst_item,
        name: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn item_feats(i: *const cst_item) -> *mut cst_features;
}
extern "C" {
    pub fn item_feat(i: *const cst_item, name: *const ::std::os::raw::c_char) -> *const cst_val;
}
extern "C" {
    pub fn item_feat_int(
        i: *const cst_item,
        name: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn item_feat_float(i: *const cst_item, name: *const ::std::os::raw::c_char) -> f32;
}
extern "C" {
    pub fn item_feat_string(
        i: *const cst_item,
        name: *const ::std::os::raw::c_char,
    ) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn item_set(i: *const cst_item, name: *const ::std::os::raw::c_char, val: *const cst_val);
}
extern "C" {
    pub fn item_set_int(
        i: *const cst_item,
        name: *const ::std::os::raw::c_char,
        val: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn item_set_float(i: *const cst_item, name: *const ::std::os::raw::c_char, val: f32);
}
extern "C" {
    pub fn item_set_string(
        i: *const cst_item,
        name: *const ::std::os::raw::c_char,
        val: *const ::std::os::raw::c_char,
    );
}
extern "C" {
    pub fn item_equal(a: *const cst_item, b: *const cst_item) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn ffeature_string(
        item: *const cst_item,
        featpath: *const ::std::os::raw::c_char,
    ) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn ffeature_int(
        item: *const cst_item,
        featpath: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn ffeature_float(item: *const cst_item, featpath: *const ::std::os::raw::c_char) -> f32;
}
extern "C" {
    pub fn ffeature(
        item: *const cst_item,
        featpath: *const ::std::os::raw::c_char,
    ) -> *const cst_val;
}
extern "C" {
    pub fn path_to_item(
        item: *const cst_item,
        featpath: *const ::std::os::raw::c_char,
    ) -> *mut cst_item;
}
pub type cst_ffunction =
    ::std::option::Option<unsafe extern "C" fn(i: *const cst_item) -> *const cst_val>;
extern "C" {
    pub static cst_val_type_ffunc: ::std::os::raw::c_int;
}
extern "C" {
    pub fn val_ffunc(v: *const cst_val) -> cst_ffunction;
}
extern "C" {
    pub fn ffunc_val(v: cst_ffunction) -> *mut cst_val;
}
extern "C" {
    pub fn ff_register(
        ffeatures: *mut cst_features,
        name: *const ::std::os::raw::c_char,
        f: cst_ffunction,
    );
}
extern "C" {
    pub fn ff_unregister(ffeatures: *mut cst_features, name: *const ::std::os::raw::c_char);
}
pub type cst_itemfunc =
    ::std::option::Option<unsafe extern "C" fn(i: *mut cst_item) -> *mut cst_val>;
extern "C" {
    pub static cst_val_type_itemfunc: ::std::os::raw::c_int;
}
extern "C" {
    pub fn val_itemfunc(v: *const cst_val) -> cst_itemfunc;
}
extern "C" {
    pub fn itemfunc_val(v: cst_itemfunc) -> *mut cst_val;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cst_utterance_struct {
    pub features: *mut cst_features,
    pub ffunctions: *mut cst_features,
    pub relations: *mut cst_features,
    pub ctx: cst_alloc_context,
}
#[test]
fn bindgen_test_layout_cst_utterance_struct() {
    const UNINIT: ::std::mem::MaybeUninit<cst_utterance_struct> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<cst_utterance_struct>(),
        32usize,
        concat!("Size of: ", stringify!(cst_utterance_struct))
    );
    assert_eq!(
        ::std::mem::align_of::<cst_utterance_struct>(),
        8usize,
        concat!("Alignment of ", stringify!(cst_utterance_struct))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).features) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_utterance_struct),
            "::",
            stringify!(features)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ffunctions) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_utterance_struct),
            "::",
            stringify!(ffunctions)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).relations) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_utterance_struct),
            "::",
            stringify!(relations)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ctx) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_utterance_struct),
            "::",
            stringify!(ctx)
        )
    );
}
extern "C" {
    pub fn new_utterance() -> *mut cst_utterance;
}
extern "C" {
    pub fn delete_utterance(u: *mut cst_utterance);
}
extern "C" {
    pub fn utt_relation(
        u: *const cst_utterance,
        name: *const ::std::os::raw::c_char,
    ) -> *mut cst_relation;
}
extern "C" {
    pub fn utt_relation_create(
        u: *mut cst_utterance,
        name: *const ::std::os::raw::c_char,
    ) -> *mut cst_relation;
}
extern "C" {
    pub fn utt_relation_delete(
        u: *mut cst_utterance,
        name: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn utt_relation_present(
        u: *mut cst_utterance,
        name: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
pub type cst_uttfunc =
    ::std::option::Option<unsafe extern "C" fn(i: *mut cst_utterance) -> *mut cst_utterance>;
extern "C" {
    pub static cst_val_type_uttfunc: ::std::os::raw::c_int;
}
extern "C" {
    pub fn val_uttfunc(v: *const cst_val) -> cst_uttfunc;
}
extern "C" {
    pub fn uttfunc_val(v: cst_uttfunc) -> *mut cst_val;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cst_relation_struct {
    pub name: *mut ::std::os::raw::c_char,
    pub features: *mut cst_features,
    pub utterance: *mut cst_utterance,
    pub head: *mut cst_item,
    pub tail: *mut cst_item,
}
#[test]
fn bindgen_test_layout_cst_relation_struct() {
    const UNINIT: ::std::mem::MaybeUninit<cst_relation_struct> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<cst_relation_struct>(),
        40usize,
        concat!("Size of: ", stringify!(cst_relation_struct))
    );
    assert_eq!(
        ::std::mem::align_of::<cst_relation_struct>(),
        8usize,
        concat!("Alignment of ", stringify!(cst_relation_struct))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_relation_struct),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).features) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_relation_struct),
            "::",
            stringify!(features)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).utterance) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_relation_struct),
            "::",
            stringify!(utterance)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).head) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_relation_struct),
            "::",
            stringify!(head)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).tail) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_relation_struct),
            "::",
            stringify!(tail)
        )
    );
}
extern "C" {
    pub fn new_relation(
        name: *const ::std::os::raw::c_char,
        u: *mut cst_utterance,
    ) -> *mut cst_relation;
}
extern "C" {
    pub fn delete_relation(r: *mut cst_relation);
}
extern "C" {
    pub fn relation_head(r: *mut cst_relation) -> *mut cst_item;
}
extern "C" {
    pub fn relation_tail(r: *mut cst_relation) -> *mut cst_item;
}
extern "C" {
    pub fn relation_name(r: *mut cst_relation) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn relation_append(r: *mut cst_relation, i: *mut cst_item) -> *mut cst_item;
}
extern "C" {
    pub fn relation_prepend(r: *mut cst_relation, i: *mut cst_item) -> *mut cst_item;
}
extern "C" {
    pub fn relation_load(
        r: *mut cst_relation,
        filename: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn relation_save(
        r: *mut cst_relation,
        filename: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub static cst_endian_loc: ::std::os::raw::c_int;
}
extern "C" {
    pub fn swap_bytes_short(b: *mut ::std::os::raw::c_short, n: ::std::os::raw::c_int);
}
extern "C" {
    pub fn swapdouble(d: *mut f64);
}
extern "C" {
    pub fn swapfloat(f: *mut f32);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cst_wave_struct {
    pub type_: *const ::std::os::raw::c_char,
    pub sample_rate: ::std::os::raw::c_int,
    pub num_samples: ::std::os::raw::c_int,
    pub num_channels: ::std::os::raw::c_int,
    pub samples: *mut ::std::os::raw::c_short,
}
#[test]
fn bindgen_test_layout_cst_wave_struct() {
    const UNINIT: ::std::mem::MaybeUninit<cst_wave_struct> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<cst_wave_struct>(),
        32usize,
        concat!("Size of: ", stringify!(cst_wave_struct))
    );
    assert_eq!(
        ::std::mem::align_of::<cst_wave_struct>(),
        8usize,
        concat!("Alignment of ", stringify!(cst_wave_struct))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_wave_struct),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).sample_rate) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_wave_struct),
            "::",
            stringify!(sample_rate)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).num_samples) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_wave_struct),
            "::",
            stringify!(num_samples)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).num_channels) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_wave_struct),
            "::",
            stringify!(num_channels)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).samples) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_wave_struct),
            "::",
            stringify!(samples)
        )
    );
}
pub type cst_wave = cst_wave_struct;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cst_wave_header_struct {
    pub type_: *const ::std::os::raw::c_char,
    pub hsize: ::std::os::raw::c_int,
    pub num_bytes: ::std::os::raw::c_int,
    pub sample_rate: ::std::os::raw::c_int,
    pub num_samples: ::std::os::raw::c_int,
    pub num_channels: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_cst_wave_header_struct() {
    const UNINIT: ::std::mem::MaybeUninit<cst_wave_header_struct> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<cst_wave_header_struct>(),
        32usize,
        concat!("Size of: ", stringify!(cst_wave_header_struct))
    );
    assert_eq!(
        ::std::mem::align_of::<cst_wave_header_struct>(),
        8usize,
        concat!("Alignment of ", stringify!(cst_wave_header_struct))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_wave_header_struct),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hsize) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_wave_header_struct),
            "::",
            stringify!(hsize)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).num_bytes) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_wave_header_struct),
            "::",
            stringify!(num_bytes)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).sample_rate) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_wave_header_struct),
            "::",
            stringify!(sample_rate)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).num_samples) as usize - ptr as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_wave_header_struct),
            "::",
            stringify!(num_samples)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).num_channels) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_wave_header_struct),
            "::",
            stringify!(num_channels)
        )
    );
}
pub type cst_wave_header = cst_wave_header_struct;
extern "C" {
    pub fn new_wave() -> *mut cst_wave;
}
extern "C" {
    pub fn copy_wave(w: *const cst_wave) -> *mut cst_wave;
}
extern "C" {
    pub fn delete_wave(val: *mut cst_wave);
}
extern "C" {
    pub fn concat_wave(dest: *mut cst_wave, src: *const cst_wave) -> *mut cst_wave;
}
extern "C" {
    pub fn cst_wave_save(
        w: *mut cst_wave,
        filename: *const ::std::os::raw::c_char,
        type_: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn cst_wave_save_riff(
        w: *mut cst_wave,
        filename: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn cst_wave_save_raw(
        w: *mut cst_wave,
        filename: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn cst_wave_append_riff(
        w: *mut cst_wave,
        filename: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn cst_wave_save_riff_fd(w: *mut cst_wave, fd: cst_file) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn cst_wave_save_raw_fd(w: *mut cst_wave, fd: cst_file) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn cst_wave_load(
        w: *mut cst_wave,
        filename: *const ::std::os::raw::c_char,
        type_: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn cst_wave_load_riff(
        w: *mut cst_wave,
        filename: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn cst_wave_load_raw(
        w: *mut cst_wave,
        filename: *const ::std::os::raw::c_char,
        bo: *const ::std::os::raw::c_char,
        sample_rate: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn cst_wave_load_riff_header(
        header: *mut cst_wave_header,
        fd: cst_file,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn cst_wave_load_riff_fd(w: *mut cst_wave, fd: cst_file) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn cst_wave_load_raw_fd(
        w: *mut cst_wave,
        fd: cst_file,
        bo: *const ::std::os::raw::c_char,
        sample_rate: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn cst_wave_resize(
        w: *mut cst_wave,
        samples: ::std::os::raw::c_int,
        num_channels: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn cst_wave_resample(w: *mut cst_wave, sample_rate: ::std::os::raw::c_int);
}
extern "C" {
    pub fn cst_wave_rescale(w: *mut cst_wave, factor: ::std::os::raw::c_int);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cst_rateconv_struct {
    pub channels: ::std::os::raw::c_int,
    pub up: ::std::os::raw::c_int,
    pub down: ::std::os::raw::c_int,
    pub gain: f64,
    pub lag: ::std::os::raw::c_int,
    pub sin: *mut ::std::os::raw::c_int,
    pub sout: *mut ::std::os::raw::c_int,
    pub coep: *mut ::std::os::raw::c_int,
    pub insize: ::std::os::raw::c_int,
    pub outsize: ::std::os::raw::c_int,
    pub incount: ::std::os::raw::c_int,
    pub len: ::std::os::raw::c_int,
    pub fsin: f64,
    pub fgk: f64,
    pub fgg: f64,
    pub inbaseidx: ::std::os::raw::c_int,
    pub inoffset: ::std::os::raw::c_int,
    pub cycctr: ::std::os::raw::c_int,
    pub outidx: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_cst_rateconv_struct() {
    const UNINIT: ::std::mem::MaybeUninit<cst_rateconv_struct> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<cst_rateconv_struct>(),
        112usize,
        concat!("Size of: ", stringify!(cst_rateconv_struct))
    );
    assert_eq!(
        ::std::mem::align_of::<cst_rateconv_struct>(),
        8usize,
        concat!("Alignment of ", stringify!(cst_rateconv_struct))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).channels) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_rateconv_struct),
            "::",
            stringify!(channels)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).up) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_rateconv_struct),
            "::",
            stringify!(up)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).down) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_rateconv_struct),
            "::",
            stringify!(down)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).gain) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_rateconv_struct),
            "::",
            stringify!(gain)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).lag) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_rateconv_struct),
            "::",
            stringify!(lag)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).sin) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_rateconv_struct),
            "::",
            stringify!(sin)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).sout) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_rateconv_struct),
            "::",
            stringify!(sout)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).coep) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_rateconv_struct),
            "::",
            stringify!(coep)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).insize) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_rateconv_struct),
            "::",
            stringify!(insize)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).outsize) as usize - ptr as usize },
        60usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_rateconv_struct),
            "::",
            stringify!(outsize)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).incount) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_rateconv_struct),
            "::",
            stringify!(incount)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
        68usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_rateconv_struct),
            "::",
            stringify!(len)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fsin) as usize - ptr as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_rateconv_struct),
            "::",
            stringify!(fsin)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fgk) as usize - ptr as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_rateconv_struct),
            "::",
            stringify!(fgk)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fgg) as usize - ptr as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_rateconv_struct),
            "::",
            stringify!(fgg)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).inbaseidx) as usize - ptr as usize },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_rateconv_struct),
            "::",
            stringify!(inbaseidx)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).inoffset) as usize - ptr as usize },
        100usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_rateconv_struct),
            "::",
            stringify!(inoffset)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).cycctr) as usize - ptr as usize },
        104usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_rateconv_struct),
            "::",
            stringify!(cycctr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).outidx) as usize - ptr as usize },
        108usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_rateconv_struct),
            "::",
            stringify!(outidx)
        )
    );
}
pub type cst_rateconv = cst_rateconv_struct;
extern "C" {
    pub fn new_rateconv(
        up: ::std::os::raw::c_int,
        down: ::std::os::raw::c_int,
        channels: ::std::os::raw::c_int,
    ) -> *mut cst_rateconv;
}
extern "C" {
    pub fn delete_rateconv(filt: *mut cst_rateconv);
}
extern "C" {
    pub fn cst_rateconv_in(
        filt: *mut cst_rateconv,
        inptr: *const ::std::os::raw::c_short,
        max: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn cst_rateconv_leadout(filt: *mut cst_rateconv) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn cst_rateconv_out(
        filt: *mut cst_rateconv,
        outptr: *mut ::std::os::raw::c_short,
        max: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct snd_header {
    pub magic: ::std::os::raw::c_uint,
    pub hdr_size: ::std::os::raw::c_uint,
    pub data_size: ::std::os::raw::c_int,
    pub encoding: ::std::os::raw::c_uint,
    pub sample_rate: ::std::os::raw::c_uint,
    pub channels: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_snd_header() {
    const UNINIT: ::std::mem::MaybeUninit<snd_header> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<snd_header>(),
        24usize,
        concat!("Size of: ", stringify!(snd_header))
    );
    assert_eq!(
        ::std::mem::align_of::<snd_header>(),
        4usize,
        concat!("Alignment of ", stringify!(snd_header))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(snd_header),
            "::",
            stringify!(magic)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hdr_size) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(snd_header),
            "::",
            stringify!(hdr_size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data_size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(snd_header),
            "::",
            stringify!(data_size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).encoding) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(snd_header),
            "::",
            stringify!(encoding)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).sample_rate) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(snd_header),
            "::",
            stringify!(sample_rate)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).channels) as usize - ptr as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(snd_header),
            "::",
            stringify!(channels)
        )
    );
}
extern "C" {
    pub fn cst_short_to_ulaw(sample: ::std::os::raw::c_short) -> ::std::os::raw::c_uchar;
}
extern "C" {
    pub fn cst_ulaw_to_short(ulawbyte: ::std::os::raw::c_uchar) -> ::std::os::raw::c_short;
}
extern "C" {
    pub fn cst_g721_decode(
        actual_size: *mut ::std::os::raw::c_int,
        size: ::std::os::raw::c_int,
        packed_residual: *const ::std::os::raw::c_uchar,
    ) -> *mut ::std::os::raw::c_uchar;
}
extern "C" {
    pub fn cst_g721_encode(
        packed_size: *mut ::std::os::raw::c_int,
        actual_size: ::std::os::raw::c_int,
        unpacked_residual: *const ::std::os::raw::c_uchar,
    ) -> *mut ::std::os::raw::c_uchar;
}
extern "C" {
    pub static cst_val_type_wave: ::std::os::raw::c_int;
}
extern "C" {
    pub fn val_wave(v: *const cst_val) -> *mut cst_wave;
}
extern "C" {
    pub fn wave_val(v: *const cst_wave) -> *mut cst_val;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cst_track_struct {
    pub type_: *const ::std::os::raw::c_char,
    pub num_frames: ::std::os::raw::c_int,
    pub num_channels: ::std::os::raw::c_int,
    pub times: *mut f32,
    pub frames: *mut *mut f32,
}
#[test]
fn bindgen_test_layout_cst_track_struct() {
    const UNINIT: ::std::mem::MaybeUninit<cst_track_struct> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<cst_track_struct>(),
        32usize,
        concat!("Size of: ", stringify!(cst_track_struct))
    );
    assert_eq!(
        ::std::mem::align_of::<cst_track_struct>(),
        8usize,
        concat!("Alignment of ", stringify!(cst_track_struct))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_track_struct),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).num_frames) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_track_struct),
            "::",
            stringify!(num_frames)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).num_channels) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_track_struct),
            "::",
            stringify!(num_channels)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).times) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_track_struct),
            "::",
            stringify!(times)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).frames) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_track_struct),
            "::",
            stringify!(frames)
        )
    );
}
pub type cst_track = cst_track_struct;
extern "C" {
    pub fn new_track() -> *mut cst_track;
}
extern "C" {
    pub fn delete_track(val: *mut cst_track);
}
extern "C" {
    pub fn track_frame_shift(t: *mut cst_track, frame: ::std::os::raw::c_int) -> f32;
}
extern "C" {
    pub fn cst_track_resize(
        t: *mut cst_track,
        num_frames: ::std::os::raw::c_int,
        num_channels: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn cst_track_copy(t: *const cst_track) -> *mut cst_track;
}
extern "C" {
    pub fn cst_track_save_est(
        t: *mut cst_track,
        filename: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn cst_track_save_est_binary(
        t: *mut cst_track,
        filename: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn cst_track_load_est(
        t: *mut cst_track,
        filename: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub static cst_val_type_track: ::std::os::raw::c_int;
}
extern "C" {
    pub fn val_track(v: *const cst_val) -> *mut cst_track;
}
extern "C" {
    pub fn track_val(v: *const cst_track) -> *mut cst_val;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cst_cart_node_struct {
    pub feat: ::std::os::raw::c_uchar,
    pub op: ::std::os::raw::c_uchar,
    pub no_node: ::std::os::raw::c_ushort,
    pub val: *const cst_val,
}
#[test]
fn bindgen_test_layout_cst_cart_node_struct() {
    const UNINIT: ::std::mem::MaybeUninit<cst_cart_node_struct> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<cst_cart_node_struct>(),
        16usize,
        concat!("Size of: ", stringify!(cst_cart_node_struct))
    );
    assert_eq!(
        ::std::mem::align_of::<cst_cart_node_struct>(),
        8usize,
        concat!("Alignment of ", stringify!(cst_cart_node_struct))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).feat) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_cart_node_struct),
            "::",
            stringify!(feat)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).op) as usize - ptr as usize },
        1usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_cart_node_struct),
            "::",
            stringify!(op)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).no_node) as usize - ptr as usize },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_cart_node_struct),
            "::",
            stringify!(no_node)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).val) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_cart_node_struct),
            "::",
            stringify!(val)
        )
    );
}
pub type cst_cart_node = cst_cart_node_struct;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cst_cart_struct {
    pub rule_table: *const cst_cart_node,
    pub feat_table: *const *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_cst_cart_struct() {
    const UNINIT: ::std::mem::MaybeUninit<cst_cart_struct> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<cst_cart_struct>(),
        16usize,
        concat!("Size of: ", stringify!(cst_cart_struct))
    );
    assert_eq!(
        ::std::mem::align_of::<cst_cart_struct>(),
        8usize,
        concat!("Alignment of ", stringify!(cst_cart_struct))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rule_table) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_cart_struct),
            "::",
            stringify!(rule_table)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).feat_table) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_cart_struct),
            "::",
            stringify!(feat_table)
        )
    );
}
pub type cst_cart = cst_cart_struct;
extern "C" {
    pub fn delete_cart(c: *mut cst_cart);
}
extern "C" {
    pub static cst_val_type_cart: ::std::os::raw::c_int;
}
extern "C" {
    pub fn val_cart(v: *const cst_val) -> *mut cst_cart;
}
extern "C" {
    pub fn cart_val(v: *const cst_cart) -> *mut cst_val;
}
extern "C" {
    pub fn cart_interpret(item: *mut cst_item, tree: *const cst_cart) -> *const cst_val;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cst_phoneset_struct {
    pub name: *const ::std::os::raw::c_char,
    pub featnames: *const *const ::std::os::raw::c_char,
    pub featvals: *const *const cst_val,
    pub phonenames: *const *const ::std::os::raw::c_char,
    pub silence: *const ::std::os::raw::c_char,
    pub num_phones: ::std::os::raw::c_int,
    pub fvtable: *const *const ::std::os::raw::c_int,
    pub freeable: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_cst_phoneset_struct() {
    const UNINIT: ::std::mem::MaybeUninit<cst_phoneset_struct> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<cst_phoneset_struct>(),
        64usize,
        concat!("Size of: ", stringify!(cst_phoneset_struct))
    );
    assert_eq!(
        ::std::mem::align_of::<cst_phoneset_struct>(),
        8usize,
        concat!("Alignment of ", stringify!(cst_phoneset_struct))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_phoneset_struct),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).featnames) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_phoneset_struct),
            "::",
            stringify!(featnames)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).featvals) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_phoneset_struct),
            "::",
            stringify!(featvals)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).phonenames) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_phoneset_struct),
            "::",
            stringify!(phonenames)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).silence) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_phoneset_struct),
            "::",
            stringify!(silence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).num_phones) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_phoneset_struct),
            "::",
            stringify!(num_phones)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fvtable) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_phoneset_struct),
            "::",
            stringify!(fvtable)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).freeable) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_phoneset_struct),
            "::",
            stringify!(freeable)
        )
    );
}
pub type cst_phoneset = cst_phoneset_struct;
extern "C" {
    pub fn new_phoneset() -> *mut cst_phoneset;
}
extern "C" {
    pub fn delete_phoneset(u: *const cst_phoneset);
}
extern "C" {
    pub fn phone_feature(
        ps: *const cst_phoneset,
        phonename: *const ::std::os::raw::c_char,
        featname: *const ::std::os::raw::c_char,
    ) -> *const cst_val;
}
extern "C" {
    pub fn phone_feature_string(
        ps: *const cst_phoneset,
        phonename: *const ::std::os::raw::c_char,
        featname: *const ::std::os::raw::c_char,
    ) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn phone_id(
        ps: *const cst_phoneset,
        phonename: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn phone_feat_id(
        ps: *const cst_phoneset,
        featname: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn item_phoneset(i: *const cst_item) -> *const cst_phoneset;
}
extern "C" {
    pub static cst_val_type_phoneset: ::std::os::raw::c_int;
}
extern "C" {
    pub fn val_phoneset(v: *const cst_val) -> *mut cst_phoneset;
}
extern "C" {
    pub fn phoneset_val(v: *const cst_phoneset) -> *mut cst_val;
}
pub type cst_lts_addr = ::std::os::raw::c_ushort;
pub type cst_lts_phone = ::std::os::raw::c_int;
pub type cst_lts_feat = ::std::os::raw::c_uchar;
pub type cst_lts_letter = ::std::os::raw::c_uchar;
pub type cst_lts_model = ::std::os::raw::c_uchar;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cst_lts_rules_struct {
    pub name: *mut ::std::os::raw::c_char,
    pub letter_index: *const cst_lts_addr,
    pub models: *const cst_lts_model,
    pub phone_table: *const *const ::std::os::raw::c_char,
    pub context_window_size: ::std::os::raw::c_int,
    pub context_extra_feats: ::std::os::raw::c_int,
    pub letter_table: *const *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_cst_lts_rules_struct() {
    const UNINIT: ::std::mem::MaybeUninit<cst_lts_rules_struct> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<cst_lts_rules_struct>(),
        48usize,
        concat!("Size of: ", stringify!(cst_lts_rules_struct))
    );
    assert_eq!(
        ::std::mem::align_of::<cst_lts_rules_struct>(),
        8usize,
        concat!("Alignment of ", stringify!(cst_lts_rules_struct))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_lts_rules_struct),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).letter_index) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_lts_rules_struct),
            "::",
            stringify!(letter_index)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).models) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_lts_rules_struct),
            "::",
            stringify!(models)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).phone_table) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_lts_rules_struct),
            "::",
            stringify!(phone_table)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).context_window_size) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_lts_rules_struct),
            "::",
            stringify!(context_window_size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).context_extra_feats) as usize - ptr as usize },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_lts_rules_struct),
            "::",
            stringify!(context_extra_feats)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).letter_table) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_lts_rules_struct),
            "::",
            stringify!(letter_table)
        )
    );
}
pub type cst_lts_rules = cst_lts_rules_struct;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cst_lts_rule_struct {
    pub feat: cst_lts_feat,
    pub val: cst_lts_letter,
    pub qtrue: cst_lts_addr,
    pub qfalse: cst_lts_addr,
}
#[test]
fn bindgen_test_layout_cst_lts_rule_struct() {
    const UNINIT: ::std::mem::MaybeUninit<cst_lts_rule_struct> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<cst_lts_rule_struct>(),
        6usize,
        concat!("Size of: ", stringify!(cst_lts_rule_struct))
    );
    assert_eq!(
        ::std::mem::align_of::<cst_lts_rule_struct>(),
        2usize,
        concat!("Alignment of ", stringify!(cst_lts_rule_struct))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).feat) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_lts_rule_struct),
            "::",
            stringify!(feat)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).val) as usize - ptr as usize },
        1usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_lts_rule_struct),
            "::",
            stringify!(val)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).qtrue) as usize - ptr as usize },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_lts_rule_struct),
            "::",
            stringify!(qtrue)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).qfalse) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_lts_rule_struct),
            "::",
            stringify!(qfalse)
        )
    );
}
pub type cst_lts_rule = cst_lts_rule_struct;
extern "C" {
    pub fn new_lts_rules() -> *mut cst_lts_rules;
}
extern "C" {
    pub fn lts_apply(
        word: *const ::std::os::raw::c_char,
        feats: *const ::std::os::raw::c_char,
        r: *const cst_lts_rules,
    ) -> *mut cst_val;
}
extern "C" {
    pub fn lts_apply_val(
        wlist: *const cst_val,
        feats: *const ::std::os::raw::c_char,
        r: *const cst_lts_rules,
    ) -> *mut cst_val;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lexicon_struct {
    pub name: *const ::std::os::raw::c_char,
    pub num_entries: ::std::os::raw::c_int,
    pub data: *mut ::std::os::raw::c_uchar,
    pub num_bytes: ::std::os::raw::c_int,
    pub phone_table: *mut *mut ::std::os::raw::c_char,
    pub lts_rule_set: *mut cst_lts_rules,
    pub syl_boundary: ::std::option::Option<
        unsafe extern "C" fn(i: *const cst_item, p: *const cst_val) -> ::std::os::raw::c_int,
    >,
    pub lts_function: ::std::option::Option<
        unsafe extern "C" fn(
            l: *const lexicon_struct,
            word: *const ::std::os::raw::c_char,
            pos: *const ::std::os::raw::c_char,
            feats: *const cst_features,
        ) -> *mut cst_val,
    >,
    pub addenda: *mut *mut *mut ::std::os::raw::c_char,
    pub phone_hufftable: *const *const ::std::os::raw::c_char,
    pub entry_hufftable: *const *const ::std::os::raw::c_char,
    pub postlex:
        ::std::option::Option<unsafe extern "C" fn(u: *mut cst_utterance) -> *mut cst_utterance>,
    pub lex_addenda: *mut cst_val,
}
#[test]
fn bindgen_test_layout_lexicon_struct() {
    const UNINIT: ::std::mem::MaybeUninit<lexicon_struct> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<lexicon_struct>(),
        104usize,
        concat!("Size of: ", stringify!(lexicon_struct))
    );
    assert_eq!(
        ::std::mem::align_of::<lexicon_struct>(),
        8usize,
        concat!("Alignment of ", stringify!(lexicon_struct))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(lexicon_struct),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).num_entries) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(lexicon_struct),
            "::",
            stringify!(num_entries)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(lexicon_struct),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).num_bytes) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(lexicon_struct),
            "::",
            stringify!(num_bytes)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).phone_table) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(lexicon_struct),
            "::",
            stringify!(phone_table)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).lts_rule_set) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(lexicon_struct),
            "::",
            stringify!(lts_rule_set)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).syl_boundary) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(lexicon_struct),
            "::",
            stringify!(syl_boundary)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).lts_function) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(lexicon_struct),
            "::",
            stringify!(lts_function)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).addenda) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(lexicon_struct),
            "::",
            stringify!(addenda)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).phone_hufftable) as usize - ptr as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(lexicon_struct),
            "::",
            stringify!(phone_hufftable)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).entry_hufftable) as usize - ptr as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(lexicon_struct),
            "::",
            stringify!(entry_hufftable)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).postlex) as usize - ptr as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(lexicon_struct),
            "::",
            stringify!(postlex)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).lex_addenda) as usize - ptr as usize },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(lexicon_struct),
            "::",
            stringify!(lex_addenda)
        )
    );
}
pub type cst_lexicon = lexicon_struct;
extern "C" {
    pub fn new_lexicon() -> *mut cst_lexicon;
}
extern "C" {
    pub fn delete_lexicon(lex: *mut cst_lexicon);
}
extern "C" {
    pub fn cst_lex_make_entry(lex: *const cst_lexicon, entry: *const cst_string) -> *mut cst_val;
}
extern "C" {
    pub fn cst_lex_load_addenda(
        lex: *const cst_lexicon,
        lexfile: *const ::std::os::raw::c_char,
    ) -> *mut cst_val;
}
extern "C" {
    pub fn lex_lookup(
        l: *const cst_lexicon,
        word: *const ::std::os::raw::c_char,
        pos: *const ::std::os::raw::c_char,
        feats: *const cst_features,
    ) -> *mut cst_val;
}
extern "C" {
    pub fn in_lex(
        l: *const cst_lexicon,
        word: *const ::std::os::raw::c_char,
        pos: *const ::std::os::raw::c_char,
        feats: *const cst_features,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub static cst_val_type_lexicon: ::std::os::raw::c_int;
}
extern "C" {
    pub fn val_lexicon(v: *const cst_val) -> *mut cst_lexicon;
}
extern "C" {
    pub fn lexicon_val(v: *const cst_lexicon) -> *mut cst_val;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cst_voice_struct {
    pub name: *const ::std::os::raw::c_char,
    pub features: *mut cst_features,
    pub ffunctions: *mut cst_features,
    pub utt_init: ::std::option::Option<
        unsafe extern "C" fn(u: *mut cst_utterance, v: *mut cst_voice_struct) -> *mut cst_utterance,
    >,
}
#[test]
fn bindgen_test_layout_cst_voice_struct() {
    const UNINIT: ::std::mem::MaybeUninit<cst_voice_struct> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<cst_voice_struct>(),
        32usize,
        concat!("Size of: ", stringify!(cst_voice_struct))
    );
    assert_eq!(
        ::std::mem::align_of::<cst_voice_struct>(),
        8usize,
        concat!("Alignment of ", stringify!(cst_voice_struct))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_voice_struct),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).features) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_voice_struct),
            "::",
            stringify!(features)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ffunctions) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_voice_struct),
            "::",
            stringify!(ffunctions)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).utt_init) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_voice_struct),
            "::",
            stringify!(utt_init)
        )
    );
}
pub type cst_voice = cst_voice_struct;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cst_lang_struct {
    pub lang: *const ::std::os::raw::c_char,
    pub lang_init: ::std::option::Option<unsafe extern "C" fn(vox: *mut cst_voice)>,
    pub lex_init: ::std::option::Option<unsafe extern "C" fn() -> *mut cst_lexicon>,
}
#[test]
fn bindgen_test_layout_cst_lang_struct() {
    const UNINIT: ::std::mem::MaybeUninit<cst_lang_struct> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<cst_lang_struct>(),
        24usize,
        concat!("Size of: ", stringify!(cst_lang_struct))
    );
    assert_eq!(
        ::std::mem::align_of::<cst_lang_struct>(),
        8usize,
        concat!("Alignment of ", stringify!(cst_lang_struct))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).lang) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_lang_struct),
            "::",
            stringify!(lang)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).lang_init) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_lang_struct),
            "::",
            stringify!(lang_init)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).lex_init) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_lang_struct),
            "::",
            stringify!(lex_init)
        )
    );
}
pub type cst_lang = cst_lang_struct;
extern "C" {
    pub fn new_voice() -> *mut cst_voice;
}
extern "C" {
    pub fn delete_voice(u: *mut cst_voice);
}
extern "C" {
    pub static cst_val_type_voice: ::std::os::raw::c_int;
}
extern "C" {
    pub fn val_voice(v: *const cst_val) -> *mut cst_voice;
}
extern "C" {
    pub fn voice_val(v: *const cst_voice) -> *mut cst_val;
}
pub const cst_audiofmt_CST_AUDIO_LINEAR16: cst_audiofmt = 0;
pub const cst_audiofmt_CST_AUDIO_LINEAR8: cst_audiofmt = 1;
pub const cst_audiofmt_CST_AUDIO_MULAW: cst_audiofmt = 2;
pub type cst_audiofmt = ::std::os::raw::c_uint;
extern "C" {
    pub fn audio_bps(fmt: cst_audiofmt) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cst_audiodev_struct {
    pub sps: ::std::os::raw::c_int,
    pub real_sps: ::std::os::raw::c_int,
    pub channels: ::std::os::raw::c_int,
    pub real_channels: ::std::os::raw::c_int,
    pub fmt: cst_audiofmt,
    pub real_fmt: cst_audiofmt,
    pub byteswap: ::std::os::raw::c_int,
    pub rateconv: *mut cst_rateconv,
    pub platform_data: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_cst_audiodev_struct() {
    const UNINIT: ::std::mem::MaybeUninit<cst_audiodev_struct> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<cst_audiodev_struct>(),
        48usize,
        concat!("Size of: ", stringify!(cst_audiodev_struct))
    );
    assert_eq!(
        ::std::mem::align_of::<cst_audiodev_struct>(),
        8usize,
        concat!("Alignment of ", stringify!(cst_audiodev_struct))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).sps) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_audiodev_struct),
            "::",
            stringify!(sps)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).real_sps) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_audiodev_struct),
            "::",
            stringify!(real_sps)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).channels) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_audiodev_struct),
            "::",
            stringify!(channels)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).real_channels) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_audiodev_struct),
            "::",
            stringify!(real_channels)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fmt) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_audiodev_struct),
            "::",
            stringify!(fmt)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).real_fmt) as usize - ptr as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_audiodev_struct),
            "::",
            stringify!(real_fmt)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).byteswap) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_audiodev_struct),
            "::",
            stringify!(byteswap)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rateconv) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_audiodev_struct),
            "::",
            stringify!(rateconv)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).platform_data) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_audiodev_struct),
            "::",
            stringify!(platform_data)
        )
    );
}
pub type cst_audiodev = cst_audiodev_struct;
extern "C" {
    pub fn audio_open(
        sps: ::std::os::raw::c_int,
        channels: ::std::os::raw::c_int,
        fmt: cst_audiofmt,
    ) -> *mut cst_audiodev;
}
extern "C" {
    pub fn audio_close(ad: *mut cst_audiodev) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn audio_write(
        ad: *mut cst_audiodev,
        buff: *mut ::std::os::raw::c_void,
        num_bytes: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn audio_flush(ad: *mut cst_audiodev) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn audio_drain(ad: *mut cst_audiodev) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn play_wave(w: *mut cst_wave) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn play_wave_sync(
        w: *mut cst_wave,
        rel: *mut cst_relation,
        call_back: ::std::option::Option<
            unsafe extern "C" fn(arg1: *mut cst_item) -> ::std::os::raw::c_int,
        >,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn play_wave_client(
        w: *mut cst_wave,
        servername: *const ::std::os::raw::c_char,
        port: ::std::os::raw::c_int,
        encoding: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn auserver(port: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn play_wave_device(w: *mut cst_wave, ad: *mut cst_audiodev) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn audio_open_file(
        sps: ::std::os::raw::c_int,
        channels: ::std::os::raw::c_int,
        fmt: cst_audiofmt,
        filename: *const ::std::os::raw::c_char,
    ) -> *mut cst_audiodev;
}
extern "C" {
    pub fn audio_close_file(ad: *mut cst_audiodev) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn audio_write_file(
        ad: *mut cst_audiodev,
        buff: *mut ::std::os::raw::c_void,
        num_bytes: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn audio_drain_file(ad: *mut cst_audiodev) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn audio_flush_file(ad: *mut cst_audiodev) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cst_audio_streaming_info_struct {
    pub min_buffsize: ::std::os::raw::c_int,
    pub asc: ::std::option::Option<
        unsafe extern "C" fn(
            w: *const cst_wave,
            start: ::std::os::raw::c_int,
            size: ::std::os::raw::c_int,
            last: ::std::os::raw::c_int,
            asi: *mut cst_audio_streaming_info_struct,
        ) -> ::std::os::raw::c_int,
    >,
    pub utt: *const cst_utterance,
    pub item: *const cst_item,
    pub userdata: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_cst_audio_streaming_info_struct() {
    const UNINIT: ::std::mem::MaybeUninit<cst_audio_streaming_info_struct> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<cst_audio_streaming_info_struct>(),
        40usize,
        concat!("Size of: ", stringify!(cst_audio_streaming_info_struct))
    );
    assert_eq!(
        ::std::mem::align_of::<cst_audio_streaming_info_struct>(),
        8usize,
        concat!("Alignment of ", stringify!(cst_audio_streaming_info_struct))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).min_buffsize) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_audio_streaming_info_struct),
            "::",
            stringify!(min_buffsize)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).asc) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_audio_streaming_info_struct),
            "::",
            stringify!(asc)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).utt) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_audio_streaming_info_struct),
            "::",
            stringify!(utt)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).item) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_audio_streaming_info_struct),
            "::",
            stringify!(item)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).userdata) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_audio_streaming_info_struct),
            "::",
            stringify!(userdata)
        )
    );
}
pub type cst_audio_streaming_info = cst_audio_streaming_info_struct;
extern "C" {
    pub fn new_audio_streaming_info() -> *mut cst_audio_streaming_info;
}
extern "C" {
    pub fn delete_audio_streaming_info(asi: *mut cst_audio_streaming_info);
}
extern "C" {
    pub static cst_val_type_audio_streaming_info: ::std::os::raw::c_int;
}
extern "C" {
    pub fn val_audio_streaming_info(v: *const cst_val) -> *mut cst_audio_streaming_info;
}
extern "C" {
    pub fn audio_streaming_info_val(v: *const cst_audio_streaming_info) -> *mut cst_val;
}
pub type cst_audio_stream_callback = ::std::option::Option<
    unsafe extern "C" fn(
        w: *const cst_wave,
        start: ::std::os::raw::c_int,
        size: ::std::os::raw::c_int,
        last: ::std::os::raw::c_int,
        asi: *mut cst_audio_streaming_info,
    ) -> ::std::os::raw::c_int,
>;
extern "C" {
    pub fn audio_stream_chunk(
        w: *const cst_wave,
        start: ::std::os::raw::c_int,
        size: ::std::os::raw::c_int,
        last: ::std::os::raw::c_int,
        asi: *mut cst_audio_streaming_info,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn utt_set_wave(u: *mut cst_utterance, w: *mut cst_wave) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn utt_wave(u: *mut cst_utterance) -> *mut cst_wave;
}
extern "C" {
    pub fn utt_input_text(u: *mut cst_utterance) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn utt_set_input_text(
        u: *mut cst_utterance,
        text: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cst_tokenstream_struct {
    pub fd: cst_file,
    pub file_pos: ::std::os::raw::c_int,
    pub line_number: ::std::os::raw::c_int,
    pub eof_flag: ::std::os::raw::c_int,
    pub string_buffer: *mut cst_string,
    pub current_char: ::std::os::raw::c_int,
    pub token_pos: ::std::os::raw::c_int,
    pub ws_max: ::std::os::raw::c_int,
    pub whitespace: *mut cst_string,
    pub prep_max: ::std::os::raw::c_int,
    pub prepunctuation: *mut cst_string,
    pub token_max: ::std::os::raw::c_int,
    pub token: *mut cst_string,
    pub postp_max: ::std::os::raw::c_int,
    pub postpunctuation: *mut cst_string,
    pub tags: *mut cst_features,
    pub utf8_explode_mode: ::std::os::raw::c_int,
    pub streamtype_data: *mut ::std::os::raw::c_void,
    pub p_whitespacesymbols: *const cst_string,
    pub p_singlecharsymbols: *const cst_string,
    pub p_prepunctuationsymbols: *const cst_string,
    pub p_postpunctuationsymbols: *const cst_string,
    pub charclass: [cst_string; 256usize],
    pub open: ::std::option::Option<
        unsafe extern "C" fn(
            ts: *mut cst_tokenstream_struct,
            filename: *const ::std::os::raw::c_char,
        ) -> ::std::os::raw::c_int,
    >,
    pub close: ::std::option::Option<unsafe extern "C" fn(ts: *mut cst_tokenstream_struct)>,
    pub eof: ::std::option::Option<
        unsafe extern "C" fn(ts: *mut cst_tokenstream_struct) -> ::std::os::raw::c_int,
    >,
    pub seek: ::std::option::Option<
        unsafe extern "C" fn(
            ts: *mut cst_tokenstream_struct,
            pos: ::std::os::raw::c_int,
        ) -> ::std::os::raw::c_int,
    >,
    pub tell: ::std::option::Option<
        unsafe extern "C" fn(ts: *mut cst_tokenstream_struct) -> ::std::os::raw::c_int,
    >,
    pub size: ::std::option::Option<
        unsafe extern "C" fn(ts: *mut cst_tokenstream_struct) -> ::std::os::raw::c_int,
    >,
    pub getc: ::std::option::Option<
        unsafe extern "C" fn(ts: *mut cst_tokenstream_struct) -> ::std::os::raw::c_int,
    >,
}
#[test]
fn bindgen_test_layout_cst_tokenstream_struct() {
    const UNINIT: ::std::mem::MaybeUninit<cst_tokenstream_struct> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<cst_tokenstream_struct>(),
        472usize,
        concat!("Size of: ", stringify!(cst_tokenstream_struct))
    );
    assert_eq!(
        ::std::mem::align_of::<cst_tokenstream_struct>(),
        8usize,
        concat!("Alignment of ", stringify!(cst_tokenstream_struct))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fd) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_tokenstream_struct),
            "::",
            stringify!(fd)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).file_pos) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_tokenstream_struct),
            "::",
            stringify!(file_pos)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).line_number) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_tokenstream_struct),
            "::",
            stringify!(line_number)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).eof_flag) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_tokenstream_struct),
            "::",
            stringify!(eof_flag)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).string_buffer) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_tokenstream_struct),
            "::",
            stringify!(string_buffer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).current_char) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_tokenstream_struct),
            "::",
            stringify!(current_char)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).token_pos) as usize - ptr as usize },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_tokenstream_struct),
            "::",
            stringify!(token_pos)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ws_max) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_tokenstream_struct),
            "::",
            stringify!(ws_max)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).whitespace) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_tokenstream_struct),
            "::",
            stringify!(whitespace)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).prep_max) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_tokenstream_struct),
            "::",
            stringify!(prep_max)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).prepunctuation) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_tokenstream_struct),
            "::",
            stringify!(prepunctuation)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).token_max) as usize - ptr as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_tokenstream_struct),
            "::",
            stringify!(token_max)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).token) as usize - ptr as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_tokenstream_struct),
            "::",
            stringify!(token)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).postp_max) as usize - ptr as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_tokenstream_struct),
            "::",
            stringify!(postp_max)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).postpunctuation) as usize - ptr as usize },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_tokenstream_struct),
            "::",
            stringify!(postpunctuation)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).tags) as usize - ptr as usize },
        104usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_tokenstream_struct),
            "::",
            stringify!(tags)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).utf8_explode_mode) as usize - ptr as usize },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_tokenstream_struct),
            "::",
            stringify!(utf8_explode_mode)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).streamtype_data) as usize - ptr as usize },
        120usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_tokenstream_struct),
            "::",
            stringify!(streamtype_data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).p_whitespacesymbols) as usize - ptr as usize },
        128usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_tokenstream_struct),
            "::",
            stringify!(p_whitespacesymbols)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).p_singlecharsymbols) as usize - ptr as usize },
        136usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_tokenstream_struct),
            "::",
            stringify!(p_singlecharsymbols)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).p_prepunctuationsymbols) as usize - ptr as usize },
        144usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_tokenstream_struct),
            "::",
            stringify!(p_prepunctuationsymbols)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).p_postpunctuationsymbols) as usize - ptr as usize },
        152usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_tokenstream_struct),
            "::",
            stringify!(p_postpunctuationsymbols)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).charclass) as usize - ptr as usize },
        160usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_tokenstream_struct),
            "::",
            stringify!(charclass)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).open) as usize - ptr as usize },
        416usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_tokenstream_struct),
            "::",
            stringify!(open)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).close) as usize - ptr as usize },
        424usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_tokenstream_struct),
            "::",
            stringify!(close)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).eof) as usize - ptr as usize },
        432usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_tokenstream_struct),
            "::",
            stringify!(eof)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).seek) as usize - ptr as usize },
        440usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_tokenstream_struct),
            "::",
            stringify!(seek)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).tell) as usize - ptr as usize },
        448usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_tokenstream_struct),
            "::",
            stringify!(tell)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        456usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_tokenstream_struct),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).getc) as usize - ptr as usize },
        464usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_tokenstream_struct),
            "::",
            stringify!(getc)
        )
    );
}
pub type cst_tokenstream = cst_tokenstream_struct;
extern "C" {
    pub static cst_ts_default_whitespacesymbols: *const cst_string;
}
extern "C" {
    pub static cst_ts_default_prepunctuationsymbols: *const cst_string;
}
extern "C" {
    pub static cst_ts_default_postpunctuationsymbols: *const cst_string;
}
extern "C" {
    pub static cst_ts_default_singlecharsymbols: *const cst_string;
}
extern "C" {
    pub fn ts_open(
        filename: *const ::std::os::raw::c_char,
        whitespacesymbols: *const cst_string,
        singlecharsymbols: *const cst_string,
        prepunctsymbols: *const cst_string,
        postpunctsymbols: *const cst_string,
    ) -> *mut cst_tokenstream;
}
extern "C" {
    pub fn ts_open_string(
        string: *const cst_string,
        whitespacesymbols: *const cst_string,
        singlecharsymbols: *const cst_string,
        prepunctsymbols: *const cst_string,
        postpunctsymbols: *const cst_string,
    ) -> *mut cst_tokenstream;
}
extern "C" {
    pub fn ts_open_generic(
        filename: *const ::std::os::raw::c_char,
        whitespacesymbols: *const cst_string,
        singlecharsymbols: *const cst_string,
        prepunctsymbols: *const cst_string,
        postpunctsymbols: *const cst_string,
        streamtype_data: *mut ::std::os::raw::c_void,
        open: ::std::option::Option<
            unsafe extern "C" fn(
                ts: *mut cst_tokenstream,
                filename: *const ::std::os::raw::c_char,
            ) -> ::std::os::raw::c_int,
        >,
        close: ::std::option::Option<unsafe extern "C" fn(ts: *mut cst_tokenstream)>,
        eof: ::std::option::Option<
            unsafe extern "C" fn(ts: *mut cst_tokenstream) -> ::std::os::raw::c_int,
        >,
        seek: ::std::option::Option<
            unsafe extern "C" fn(
                ts: *mut cst_tokenstream,
                pos: ::std::os::raw::c_int,
            ) -> ::std::os::raw::c_int,
        >,
        tell: ::std::option::Option<
            unsafe extern "C" fn(ts: *mut cst_tokenstream) -> ::std::os::raw::c_int,
        >,
        size: ::std::option::Option<
            unsafe extern "C" fn(ts: *mut cst_tokenstream) -> ::std::os::raw::c_int,
        >,
        getc: ::std::option::Option<
            unsafe extern "C" fn(ts: *mut cst_tokenstream) -> ::std::os::raw::c_int,
        >,
    ) -> *mut cst_tokenstream;
}
extern "C" {
    pub fn ts_close(ts: *mut cst_tokenstream);
}
extern "C" {
    pub fn ts_utf8_sequence_length(c0: ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn ts_eof(ts: *mut cst_tokenstream) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn ts_get(ts: *mut cst_tokenstream) -> *const cst_string;
}
extern "C" {
    pub fn ts_get_quoted_token(
        ts: *mut cst_tokenstream,
        quote: ::std::os::raw::c_char,
        escape: ::std::os::raw::c_char,
    ) -> *const cst_string;
}
extern "C" {
    pub fn private_ts_getc(ts: *mut cst_tokenstream) -> cst_string;
}
extern "C" {
    pub fn set_charclasses(
        ts: *mut cst_tokenstream,
        whitespace: *const cst_string,
        singlecharsymbols: *const cst_string,
        prepunctuation: *const cst_string,
        postpunctuation: *const cst_string,
    );
}
extern "C" {
    pub fn ts_read(
        buff: *mut ::std::os::raw::c_void,
        size: ::std::os::raw::c_int,
        num: ::std::os::raw::c_int,
        ts: *mut cst_tokenstream,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn ts_set_stream_pos(
        ts: *mut cst_tokenstream,
        pos: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn ts_get_stream_pos(ts: *mut cst_tokenstream) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn ts_get_stream_size(ts: *mut cst_tokenstream) -> ::std::os::raw::c_int;
}
pub type cst_breakfunc = ::std::option::Option<
    unsafe extern "C" fn(
        ts: *mut cst_tokenstream,
        token: *const ::std::os::raw::c_char,
        tokens: *mut cst_relation,
    ) -> ::std::os::raw::c_int,
>;
extern "C" {
    pub static cst_val_type_breakfunc: ::std::os::raw::c_int;
}
extern "C" {
    pub fn val_breakfunc(v: *const cst_val) -> cst_breakfunc;
}
extern "C" {
    pub fn breakfunc_val(v: cst_breakfunc) -> *mut cst_val;
}
extern "C" {
    pub fn default_utt_break(
        ts: *mut cst_tokenstream,
        token: *const ::std::os::raw::c_char,
        tokens: *mut cst_relation,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn utt_init(u: *mut cst_utterance, vox: *mut cst_voice) -> *mut cst_utterance;
}
extern "C" {
    pub fn utt_synth(u: *mut cst_utterance) -> *mut cst_utterance;
}
extern "C" {
    pub fn utt_synth_phones(u: *mut cst_utterance) -> *mut cst_utterance;
}
extern "C" {
    pub fn utt_synth_tokens(u: *mut cst_utterance) -> *mut cst_utterance;
}
extern "C" {
    pub fn utt_synth_wave(w: *mut cst_wave, v: *mut cst_voice) -> *mut cst_utterance;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cst_dur_stats_struct {
    pub phone: *const ::std::os::raw::c_char,
    pub mean: f32,
    pub stddev: f32,
}
#[test]
fn bindgen_test_layout_cst_dur_stats_struct() {
    const UNINIT: ::std::mem::MaybeUninit<cst_dur_stats_struct> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<cst_dur_stats_struct>(),
        16usize,
        concat!("Size of: ", stringify!(cst_dur_stats_struct))
    );
    assert_eq!(
        ::std::mem::align_of::<cst_dur_stats_struct>(),
        8usize,
        concat!("Alignment of ", stringify!(cst_dur_stats_struct))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).phone) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_dur_stats_struct),
            "::",
            stringify!(phone)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mean) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_dur_stats_struct),
            "::",
            stringify!(mean)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).stddev) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_dur_stats_struct),
            "::",
            stringify!(stddev)
        )
    );
}
pub type dur_stat = cst_dur_stats_struct;
pub type dur_stats = *mut dur_stat;
extern "C" {
    pub static cst_val_type_dur_stats: ::std::os::raw::c_int;
}
extern "C" {
    pub fn val_dur_stats(v: *const cst_val) -> *mut dur_stats;
}
extern "C" {
    pub fn dur_stats_val(v: *const dur_stats) -> *mut cst_val;
}
extern "C" {
    pub fn default_segmentanalysis(u: *mut cst_utterance) -> *mut cst_utterance;
}
extern "C" {
    pub fn default_tokenization(u: *mut cst_utterance) -> *mut cst_utterance;
}
extern "C" {
    pub fn default_textanalysis(u: *mut cst_utterance) -> *mut cst_utterance;
}
extern "C" {
    pub fn default_tokentowords(i: *mut cst_item) -> *mut cst_val;
}
extern "C" {
    pub fn default_phrasing(u: *mut cst_utterance) -> *mut cst_utterance;
}
extern "C" {
    pub fn default_pos_tagger(u: *mut cst_utterance) -> *mut cst_utterance;
}
extern "C" {
    pub fn default_lexical_insertion(u: *mut cst_utterance) -> *mut cst_utterance;
}
extern "C" {
    pub fn default_pause_insertion(u: *mut cst_utterance) -> *mut cst_utterance;
}
extern "C" {
    pub fn cart_intonation(u: *mut cst_utterance) -> *mut cst_utterance;
}
extern "C" {
    pub fn cart_duration(u: *mut cst_utterance) -> *mut cst_utterance;
}
extern "C" {
    pub fn flat_prosody(u: *mut cst_utterance) -> *mut cst_utterance;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cst_synth_module_struct {
    pub hookname: *const ::std::os::raw::c_char,
    pub defhook: cst_uttfunc,
}
#[test]
fn bindgen_test_layout_cst_synth_module_struct() {
    const UNINIT: ::std::mem::MaybeUninit<cst_synth_module_struct> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<cst_synth_module_struct>(),
        16usize,
        concat!("Size of: ", stringify!(cst_synth_module_struct))
    );
    assert_eq!(
        ::std::mem::align_of::<cst_synth_module_struct>(),
        8usize,
        concat!("Alignment of ", stringify!(cst_synth_module_struct))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hookname) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_synth_module_struct),
            "::",
            stringify!(hookname)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).defhook) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_synth_module_struct),
            "::",
            stringify!(defhook)
        )
    );
}
pub type cst_synth_module = cst_synth_module_struct;
extern "C" {
    pub fn apply_synth_module(
        u: *mut cst_utterance,
        mod_: *const cst_synth_module,
    ) -> *mut cst_utterance;
}
extern "C" {
    pub fn apply_synth_method(
        u: *mut cst_utterance,
        meth: *const cst_synth_module,
    ) -> *mut cst_utterance;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cst_sts_struct {
    pub frame: *const ::std::os::raw::c_ushort,
    pub size: ::std::os::raw::c_int,
    pub residual: *const ::std::os::raw::c_uchar,
}
#[test]
fn bindgen_test_layout_cst_sts_struct() {
    const UNINIT: ::std::mem::MaybeUninit<cst_sts_struct> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<cst_sts_struct>(),
        24usize,
        concat!("Size of: ", stringify!(cst_sts_struct))
    );
    assert_eq!(
        ::std::mem::align_of::<cst_sts_struct>(),
        8usize,
        concat!("Alignment of ", stringify!(cst_sts_struct))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).frame) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_sts_struct),
            "::",
            stringify!(frame)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_sts_struct),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).residual) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_sts_struct),
            "::",
            stringify!(residual)
        )
    );
}
pub type cst_sts = cst_sts_struct;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cst_sts_paged_struct {
    pub frame_offset: ::std::os::raw::c_uint,
    pub res_size: ::std::os::raw::c_ushort,
    pub res_offset: ::std::os::raw::c_uint,
    pub frame_page: *const ::std::os::raw::c_ushort,
    pub res_page: *const ::std::os::raw::c_uchar,
}
#[test]
fn bindgen_test_layout_cst_sts_paged_struct() {
    const UNINIT: ::std::mem::MaybeUninit<cst_sts_paged_struct> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<cst_sts_paged_struct>(),
        32usize,
        concat!("Size of: ", stringify!(cst_sts_paged_struct))
    );
    assert_eq!(
        ::std::mem::align_of::<cst_sts_paged_struct>(),
        8usize,
        concat!("Alignment of ", stringify!(cst_sts_paged_struct))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).frame_offset) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_sts_paged_struct),
            "::",
            stringify!(frame_offset)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).res_size) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_sts_paged_struct),
            "::",
            stringify!(res_size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).res_offset) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_sts_paged_struct),
            "::",
            stringify!(res_offset)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).frame_page) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_sts_paged_struct),
            "::",
            stringify!(frame_page)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).res_page) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_sts_paged_struct),
            "::",
            stringify!(res_page)
        )
    );
}
pub type cst_sts_paged = cst_sts_paged_struct;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cst_sts_list_struct {
    pub sts: *const cst_sts,
    pub sts_paged: *const cst_sts_paged,
    pub frames: *const ::std::os::raw::c_ushort,
    pub residuals: *const ::std::os::raw::c_uchar,
    pub resoffs: *const ::std::os::raw::c_uint,
    pub ressizes: *const ::std::os::raw::c_uchar,
    pub num_sts: ::std::os::raw::c_int,
    pub num_channels: ::std::os::raw::c_int,
    pub sample_rate: ::std::os::raw::c_int,
    pub coeff_min: f32,
    pub coeff_range: f32,
    pub codec: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_cst_sts_list_struct() {
    const UNINIT: ::std::mem::MaybeUninit<cst_sts_list_struct> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<cst_sts_list_struct>(),
        80usize,
        concat!("Size of: ", stringify!(cst_sts_list_struct))
    );
    assert_eq!(
        ::std::mem::align_of::<cst_sts_list_struct>(),
        8usize,
        concat!("Alignment of ", stringify!(cst_sts_list_struct))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).sts) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_sts_list_struct),
            "::",
            stringify!(sts)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).sts_paged) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_sts_list_struct),
            "::",
            stringify!(sts_paged)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).frames) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_sts_list_struct),
            "::",
            stringify!(frames)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).residuals) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_sts_list_struct),
            "::",
            stringify!(residuals)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).resoffs) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_sts_list_struct),
            "::",
            stringify!(resoffs)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ressizes) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_sts_list_struct),
            "::",
            stringify!(ressizes)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).num_sts) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_sts_list_struct),
            "::",
            stringify!(num_sts)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).num_channels) as usize - ptr as usize },
        52usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_sts_list_struct),
            "::",
            stringify!(num_channels)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).sample_rate) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_sts_list_struct),
            "::",
            stringify!(sample_rate)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).coeff_min) as usize - ptr as usize },
        60usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_sts_list_struct),
            "::",
            stringify!(coeff_min)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).coeff_range) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_sts_list_struct),
            "::",
            stringify!(coeff_range)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).codec) as usize - ptr as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_sts_list_struct),
            "::",
            stringify!(codec)
        )
    );
}
pub type cst_sts_list = cst_sts_list_struct;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cst_lpcres_struct {
    pub frames: *mut *const ::std::os::raw::c_ushort,
    pub times: *mut ::std::os::raw::c_int,
    pub num_frames: ::std::os::raw::c_int,
    pub num_channels: ::std::os::raw::c_int,
    pub lpc_min: f32,
    pub lpc_range: f32,
    pub num_samples: ::std::os::raw::c_int,
    pub sample_rate: ::std::os::raw::c_int,
    pub sizes: *mut ::std::os::raw::c_int,
    pub residual: *mut ::std::os::raw::c_uchar,
    pub asi: *mut cst_audio_streaming_info,
    pub packed_residuals: *mut *const ::std::os::raw::c_uchar,
    pub delayed_decoding: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_cst_lpcres_struct() {
    const UNINIT: ::std::mem::MaybeUninit<cst_lpcres_struct> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<cst_lpcres_struct>(),
        80usize,
        concat!("Size of: ", stringify!(cst_lpcres_struct))
    );
    assert_eq!(
        ::std::mem::align_of::<cst_lpcres_struct>(),
        8usize,
        concat!("Alignment of ", stringify!(cst_lpcres_struct))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).frames) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_lpcres_struct),
            "::",
            stringify!(frames)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).times) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_lpcres_struct),
            "::",
            stringify!(times)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).num_frames) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_lpcres_struct),
            "::",
            stringify!(num_frames)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).num_channels) as usize - ptr as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_lpcres_struct),
            "::",
            stringify!(num_channels)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).lpc_min) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_lpcres_struct),
            "::",
            stringify!(lpc_min)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).lpc_range) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_lpcres_struct),
            "::",
            stringify!(lpc_range)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).num_samples) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_lpcres_struct),
            "::",
            stringify!(num_samples)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).sample_rate) as usize - ptr as usize },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_lpcres_struct),
            "::",
            stringify!(sample_rate)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).sizes) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_lpcres_struct),
            "::",
            stringify!(sizes)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).residual) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_lpcres_struct),
            "::",
            stringify!(residual)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).asi) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_lpcres_struct),
            "::",
            stringify!(asi)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).packed_residuals) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_lpcres_struct),
            "::",
            stringify!(packed_residuals)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).delayed_decoding) as usize - ptr as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(cst_lpcres_struct),
            "::",
            stringify!(delayed_decoding)
        )
    );
}
pub type cst_lpcres = cst_lpcres_struct;
extern "C" {
    pub fn new_lpcres() -> *mut cst_lpcres;
}
extern "C" {
    pub fn delete_lpcres(l: *mut cst_lpcres);
}
extern "C" {
    pub fn lpcres_frame_shift(t: *mut cst_lpcres, frame: ::std::os::raw::c_int) -> f32;
}
extern "C" {
    pub fn lpcres_resize_frames(l: *mut cst_lpcres, num_frames: ::std::os::raw::c_int);
}
extern "C" {
    pub fn lpcres_resize_samples(l: *mut cst_lpcres, num_samples: ::std::os::raw::c_int);
}
extern "C" {
    pub fn new_sts_list() -> *mut cst_sts_list;
}
extern "C" {
    pub fn delete_sts_list(l: *mut cst_sts_list);
}
extern "C" {
    pub fn get_sts_frame(
        sts_list: *const cst_sts_list,
        frame: ::std::os::raw::c_int,
    ) -> *const ::std::os::raw::c_ushort;
}
extern "C" {
    pub fn get_sts_residual(
        sts_list: *const cst_sts_list,
        frame: ::std::os::raw::c_int,
    ) -> *const ::std::os::raw::c_uchar;
}
extern "C" {
    pub fn get_sts_residual_fixed(
        sts_list: *const cst_sts_list,
        frame: ::std::os::raw::c_int,
    ) -> *const ::std::os::raw::c_uchar;
}
extern "C" {
    pub fn get_frame_size(
        sts_list: *const cst_sts_list,
        frame: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn get_unit_size(
        s: *const cst_sts_list,
        start: ::std::os::raw::c_int,
        end: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub static cst_val_type_lpcres: ::std::os::raw::c_int;
}
extern "C" {
    pub fn val_lpcres(v: *const cst_val) -> *mut cst_lpcres;
}
extern "C" {
    pub fn lpcres_val(v: *const cst_lpcres) -> *mut cst_val;
}
extern "C" {
    pub static cst_val_type_sts_list: ::std::os::raw::c_int;
}
extern "C" {
    pub fn val_sts_list(v: *const cst_val) -> *mut cst_sts_list;
}
extern "C" {
    pub fn sts_list_val(v: *const cst_sts_list) -> *mut cst_val;
}
extern "C" {
    pub fn join_units(utt: *mut cst_utterance) -> *mut cst_utterance;
}
extern "C" {
    pub fn join_units_windowed(utt: *mut cst_utterance) -> *mut cst_utterance;
}
extern "C" {
    pub fn join_units_simple(utt: *mut cst_utterance) -> *mut cst_utterance;
}
extern "C" {
    pub fn join_units_modified_lpc(utt: *mut cst_utterance) -> *mut cst_utterance;
}
extern "C" {
    pub fn asis_to_pm(utt: *mut cst_utterance) -> *mut cst_utterance;
}
extern "C" {
    pub fn f0_targets_to_pm(utt: *mut cst_utterance) -> *mut cst_utterance;
}
extern "C" {
    pub fn concat_units(utt: *mut cst_utterance) -> *mut cst_utterance;
}
extern "C" {
    pub fn add_residual(
        targ_size: ::std::os::raw::c_int,
        targ_residual: *mut ::std::os::raw::c_uchar,
        unit_size: ::std::os::raw::c_int,
        unit_residual: *const ::std::os::raw::c_uchar,
    );
}
extern "C" {
    pub fn add_residual_pulse(
        targ_size: ::std::os::raw::c_int,
        targ_residual: *mut ::std::os::raw::c_uchar,
        unit_size: ::std::os::raw::c_int,
        unit_residual: *const ::std::os::raw::c_uchar,
    );
}
extern "C" {
    pub static mut flite_voice_list: *mut cst_val;
}
extern "C" {
    pub static mut flite_lang_list: [cst_lang; 20usize];
}
extern "C" {
    pub static mut flite_lang_list_length: ::std::os::raw::c_int;
}
extern "C" {
    pub fn flite_init() -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn flite_voice_select(name: *const ::std::os::raw::c_char) -> *mut cst_voice;
}
extern "C" {
    pub fn flite_voice_load(voice_filename: *const ::std::os::raw::c_char) -> *mut cst_voice;
}
extern "C" {
    pub fn flite_voice_dump(
        voice: *mut cst_voice,
        voice_filename: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn flite_file_to_speech(
        filename: *const ::std::os::raw::c_char,
        voice: *mut cst_voice,
        outtype: *const ::std::os::raw::c_char,
    ) -> f32;
}
extern "C" {
    pub fn flite_text_to_speech(
        text: *const ::std::os::raw::c_char,
        voice: *mut cst_voice,
        outtype: *const ::std::os::raw::c_char,
    ) -> f32;
}
extern "C" {
    pub fn flite_phones_to_speech(
        text: *const ::std::os::raw::c_char,
        voice: *mut cst_voice,
        outtype: *const ::std::os::raw::c_char,
    ) -> f32;
}
extern "C" {
    pub fn flite_ssml_file_to_speech(
        filename: *const ::std::os::raw::c_char,
        voice: *mut cst_voice,
        outtype: *const ::std::os::raw::c_char,
    ) -> f32;
}
extern "C" {
    pub fn flite_ssml_text_to_speech(
        text: *const ::std::os::raw::c_char,
        voice: *mut cst_voice,
        outtype: *const ::std::os::raw::c_char,
    ) -> f32;
}
extern "C" {
    pub fn flite_voice_add_lex_addenda(
        v: *mut cst_voice,
        lexfile: *const cst_string,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn flite_text_to_wave(
        text: *const ::std::os::raw::c_char,
        voice: *mut cst_voice,
    ) -> *mut cst_wave;
}
extern "C" {
    pub fn flite_synth_text(
        text: *const ::std::os::raw::c_char,
        voice: *mut cst_voice,
    ) -> *mut cst_utterance;
}
extern "C" {
    pub fn flite_synth_phones(
        phones: *const ::std::os::raw::c_char,
        voice: *mut cst_voice,
    ) -> *mut cst_utterance;
}
extern "C" {
    pub fn flite_ts_to_speech(
        ts: *mut cst_tokenstream,
        voice: *mut cst_voice,
        outtype: *const ::std::os::raw::c_char,
    ) -> f32;
}
extern "C" {
    pub fn flite_do_synth(
        u: *mut cst_utterance,
        voice: *mut cst_voice,
        synth: cst_uttfunc,
    ) -> *mut cst_utterance;
}
extern "C" {
    pub fn flite_process_output(
        u: *mut cst_utterance,
        outtype: *const ::std::os::raw::c_char,
        append: ::std::os::raw::c_int,
    ) -> f32;
}
extern "C" {
    pub fn flite_mmap_clunit_voxdata(
        voxdir: *const ::std::os::raw::c_char,
        voice: *mut cst_voice,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn flite_munmap_clunit_voxdata(voice: *mut cst_voice) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn flite_get_param_int(
        f: *const cst_features,
        name: *const ::std::os::raw::c_char,
        def: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn flite_get_param_float(
        f: *const cst_features,
        name: *const ::std::os::raw::c_char,
        def: f32,
    ) -> f32;
}
extern "C" {
    pub fn flite_get_param_string(
        f: *const cst_features,
        name: *const ::std::os::raw::c_char,
        def: *const ::std::os::raw::c_char,
    ) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn flite_get_param_val(
        f: *const cst_features,
        name: *const ::std::os::raw::c_char,
        def: *mut cst_val,
    ) -> *const cst_val;
}
extern "C" {
    pub fn flite_feat_set_int(
        f: *mut cst_features,
        name: *const ::std::os::raw::c_char,
        v: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn flite_feat_set_float(f: *mut cst_features, name: *const ::std::os::raw::c_char, v: f32);
}
extern "C" {
    pub fn flite_feat_set_string(
        f: *mut cst_features,
        name: *const ::std::os::raw::c_char,
        v: *const ::std::os::raw::c_char,
    );
}
extern "C" {
    pub fn flite_feat_set(
        f: *mut cst_features,
        name: *const ::std::os::raw::c_char,
        v: *const cst_val,
    );
}
extern "C" {
    pub fn flite_feat_remove(
        f: *mut cst_features,
        name: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn flite_ffeature_string(
        item: *const cst_item,
        featpath: *const ::std::os::raw::c_char,
    ) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn flite_ffeature_int(
        item: *const cst_item,
        featpath: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn flite_ffeature_float(
        item: *const cst_item,
        featpath: *const ::std::os::raw::c_char,
    ) -> f32;
}
extern "C" {
    pub fn flite_ffeature(
        item: *const cst_item,
        featpath: *const ::std::os::raw::c_char,
    ) -> *const cst_val;
}
extern "C" {
    pub fn flite_path_to_item(
        item: *const cst_item,
        featpath: *const ::std::os::raw::c_char,
    ) -> *mut cst_item;
}
extern "C" {
    pub fn flite_add_voice(voice: *mut cst_voice) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn flite_add_lang(
        langname: *const ::std::os::raw::c_char,
        lang_init: ::std::option::Option<unsafe extern "C" fn(vox: *mut cst_voice)>,
        lex_init: ::std::option::Option<unsafe extern "C" fn() -> *mut cst_lexicon>,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn utf8_grapheme_lang_init(v: *mut cst_voice);
}
extern "C" {
    pub fn utf8_grapheme_lex_init() -> *mut cst_lexicon;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __locale_data {
    pub _address: u8,
}
pub type __builtin_va_list = [__va_list_tag; 1usize];
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __va_list_tag {
    pub gp_offset: ::std::os::raw::c_uint,
    pub fp_offset: ::std::os::raw::c_uint,
    pub overflow_arg_area: *mut ::std::os::raw::c_void,
    pub reg_save_area: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout___va_list_tag() {
    const UNINIT: ::std::mem::MaybeUninit<__va_list_tag> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<__va_list_tag>(),
        24usize,
        concat!("Size of: ", stringify!(__va_list_tag))
    );
    assert_eq!(
        ::std::mem::align_of::<__va_list_tag>(),
        8usize,
        concat!("Alignment of ", stringify!(__va_list_tag))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).gp_offset) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__va_list_tag),
            "::",
            stringify!(gp_offset)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fp_offset) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(__va_list_tag),
            "::",
            stringify!(fp_offset)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).overflow_arg_area) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(__va_list_tag),
            "::",
            stringify!(overflow_arg_area)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).reg_save_area) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(__va_list_tag),
            "::",
            stringify!(reg_save_area)
        )
    );
}