/* automatically generated by rust-bindgen 0.56.0 */

#![allow(non_upper_case_globals)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]

pub const _STDINT_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 __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_559_COMPLEX__: u32 = 1;
pub const __STDC_ISO_10646__: u32 = 201706;
pub const __GNU_LIBRARY__: u32 = 6;
pub const __GLIBC__: u32 = 2;
pub const __GLIBC_MINOR__: u32 = 32;
pub const _SYS_CDEFS_H: u32 = 1;
pub const __glibc_c99_flexarr_available: u32 = 1;
pub const __WORDSIZE: u32 = 64;
pub const __WORDSIZE_TIME64_COMPAT32: u32 = 1;
pub const __SYSCALL_WORDSIZE: u32 = 64;
pub const __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_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_H: u32 = 1;
pub const __TIMESIZE: u32 = 64;
pub const _BITS_TYPESIZES_H: u32 = 1;
pub const __OFF_T_MATCHES_OFF64_T: u32 = 1;
pub const __INO_T_MATCHES_INO64_T: u32 = 1;
pub const __RLIM_T_MATCHES_RLIM64_T: u32 = 1;
pub const __STATFS_MATCHES_STATFS64: u32 = 1;
pub const __KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64: u32 = 1;
pub const __FD_SETSIZE: u32 = 1024;
pub const _BITS_TIME64_H: u32 = 1;
pub const _BITS_WCHAR_H: u32 = 1;
pub const _BITS_STDINT_INTN_H: u32 = 1;
pub const _BITS_STDINT_UINTN_H: u32 = 1;
pub const INT8_MIN: i32 = -128;
pub const INT16_MIN: i32 = -32768;
pub const INT32_MIN: i32 = -2147483648;
pub const INT8_MAX: u32 = 127;
pub const INT16_MAX: u32 = 32767;
pub const INT32_MAX: u32 = 2147483647;
pub const UINT8_MAX: u32 = 255;
pub const UINT16_MAX: u32 = 65535;
pub const UINT32_MAX: u32 = 4294967295;
pub const INT_LEAST8_MIN: i32 = -128;
pub const INT_LEAST16_MIN: i32 = -32768;
pub const INT_LEAST32_MIN: i32 = -2147483648;
pub const INT_LEAST8_MAX: u32 = 127;
pub const INT_LEAST16_MAX: u32 = 32767;
pub const INT_LEAST32_MAX: u32 = 2147483647;
pub const UINT_LEAST8_MAX: u32 = 255;
pub const UINT_LEAST16_MAX: u32 = 65535;
pub const UINT_LEAST32_MAX: u32 = 4294967295;
pub const INT_FAST8_MIN: i32 = -128;
pub const INT_FAST16_MIN: i64 = -9223372036854775808;
pub const INT_FAST32_MIN: i64 = -9223372036854775808;
pub const INT_FAST8_MAX: u32 = 127;
pub const INT_FAST16_MAX: u64 = 9223372036854775807;
pub const INT_FAST32_MAX: u64 = 9223372036854775807;
pub const UINT_FAST8_MAX: u32 = 255;
pub const UINT_FAST16_MAX: i32 = -1;
pub const UINT_FAST32_MAX: i32 = -1;
pub const INTPTR_MIN: i64 = -9223372036854775808;
pub const INTPTR_MAX: u64 = 9223372036854775807;
pub const UINTPTR_MAX: i32 = -1;
pub const PTRDIFF_MIN: i64 = -9223372036854775808;
pub const PTRDIFF_MAX: u64 = 9223372036854775807;
pub const SIG_ATOMIC_MIN: i32 = -2147483648;
pub const SIG_ATOMIC_MAX: u32 = 2147483647;
pub const SIZE_MAX: i32 = -1;
pub const WINT_MIN: u32 = 0;
pub const WINT_MAX: u32 = 4294967295;
pub const _STDIO_H: u32 = 1;
pub const __GNUC_VA_LIST: u32 = 1;
pub const _____fpos_t_defined: u32 = 1;
pub const ____mbstate_t_defined: u32 = 1;
pub const _____fpos64_t_defined: u32 = 1;
pub const ____FILE_defined: u32 = 1;
pub const __FILE_defined: u32 = 1;
pub const __struct_FILE_defined: u32 = 1;
pub const _IO_EOF_SEEN: u32 = 16;
pub const _IO_ERR_SEEN: u32 = 32;
pub const _IO_USER_LOCK: u32 = 32768;
pub const _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: &'static [u8; 5usize] = b"/tmp\0";
pub const _BITS_STDIO_LIM_H: u32 = 1;
pub const L_tmpnam: u32 = 20;
pub const TMP_MAX: u32 = 238328;
pub const FILENAME_MAX: u32 = 4096;
pub const L_ctermid: u32 = 9;
pub const 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 true_: u32 = 1;
pub const false_: u32 = 0;
pub const __bool_true_false_are_defined: u32 = 1;
pub type size_t = ::std::os::raw::c_ulong;
pub type wchar_t = ::std::os::raw::c_int;
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Copy, Clone)]
pub struct max_align_t {
    pub __clang_max_align_nonce1: ::std::os::raw::c_longlong,
    pub __bindgen_padding_0: u64,
    pub __clang_max_align_nonce2: u128,
}
#[test]
fn bindgen_test_layout_max_align_t() {
    assert_eq!(
        ::std::mem::size_of::<max_align_t>(),
        32usize,
        concat!("Size of: ", stringify!(max_align_t))
    );
    assert_eq!(
        ::std::mem::align_of::<max_align_t>(),
        16usize,
        concat!("Alignment of ", stringify!(max_align_t))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<max_align_t>())).__clang_max_align_nonce1 as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(max_align_t),
            "::",
            stringify!(__clang_max_align_nonce1)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<max_align_t>())).__clang_max_align_nonce2 as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(max_align_t),
            "::",
            stringify!(__clang_max_align_nonce2)
        )
    );
}
pub type __u_char = ::std::os::raw::c_uchar;
pub type __u_short = ::std::os::raw::c_ushort;
pub type __u_int = ::std::os::raw::c_uint;
pub type __u_long = ::std::os::raw::c_ulong;
pub type __int8_t = ::std::os::raw::c_schar;
pub type __uint8_t = ::std::os::raw::c_uchar;
pub type __int16_t = ::std::os::raw::c_short;
pub type __uint16_t = ::std::os::raw::c_ushort;
pub type __int32_t = ::std::os::raw::c_int;
pub type __uint32_t = ::std::os::raw::c_uint;
pub type __int64_t = ::std::os::raw::c_long;
pub type __uint64_t = ::std::os::raw::c_ulong;
pub type __int_least8_t = __int8_t;
pub type __uint_least8_t = __uint8_t;
pub type __int_least16_t = __int16_t;
pub type __uint_least16_t = __uint16_t;
pub type __int_least32_t = __int32_t;
pub type __uint_least32_t = __uint32_t;
pub type __int_least64_t = __int64_t;
pub type __uint_least64_t = __uint64_t;
pub type __quad_t = ::std::os::raw::c_long;
pub type __u_quad_t = ::std::os::raw::c_ulong;
pub type __intmax_t = ::std::os::raw::c_long;
pub type __uintmax_t = ::std::os::raw::c_ulong;
pub type __dev_t = ::std::os::raw::c_ulong;
pub type __uid_t = ::std::os::raw::c_uint;
pub type __gid_t = ::std::os::raw::c_uint;
pub type __ino_t = ::std::os::raw::c_ulong;
pub type __ino64_t = ::std::os::raw::c_ulong;
pub type __mode_t = ::std::os::raw::c_uint;
pub type __nlink_t = ::std::os::raw::c_ulong;
pub type __off_t = ::std::os::raw::c_long;
pub type __off64_t = ::std::os::raw::c_long;
pub type __pid_t = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __fsid_t {
    pub __val: [::std::os::raw::c_int; 2usize],
}
#[test]
fn bindgen_test_layout___fsid_t() {
    assert_eq!(
        ::std::mem::size_of::<__fsid_t>(),
        8usize,
        concat!("Size of: ", stringify!(__fsid_t))
    );
    assert_eq!(
        ::std::mem::align_of::<__fsid_t>(),
        4usize,
        concat!("Alignment of ", stringify!(__fsid_t))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<__fsid_t>())).__val as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__fsid_t),
            "::",
            stringify!(__val)
        )
    );
}
pub type __clock_t = ::std::os::raw::c_long;
pub type __rlim_t = ::std::os::raw::c_ulong;
pub type __rlim64_t = ::std::os::raw::c_ulong;
pub type __id_t = ::std::os::raw::c_uint;
pub type __time_t = ::std::os::raw::c_long;
pub type __useconds_t = ::std::os::raw::c_uint;
pub type __suseconds_t = ::std::os::raw::c_long;
pub type __suseconds64_t = ::std::os::raw::c_long;
pub type __daddr_t = ::std::os::raw::c_int;
pub type __key_t = ::std::os::raw::c_int;
pub type __clockid_t = ::std::os::raw::c_int;
pub type __timer_t = *mut ::std::os::raw::c_void;
pub type __blksize_t = ::std::os::raw::c_long;
pub type __blkcnt_t = ::std::os::raw::c_long;
pub type __blkcnt64_t = ::std::os::raw::c_long;
pub type __fsblkcnt_t = ::std::os::raw::c_ulong;
pub type __fsblkcnt64_t = ::std::os::raw::c_ulong;
pub type __fsfilcnt_t = ::std::os::raw::c_ulong;
pub type __fsfilcnt64_t = ::std::os::raw::c_ulong;
pub type __fsword_t = ::std::os::raw::c_long;
pub type __ssize_t = ::std::os::raw::c_long;
pub type __syscall_slong_t = ::std::os::raw::c_long;
pub type __syscall_ulong_t = ::std::os::raw::c_ulong;
pub type __loff_t = __off64_t;
pub type __caddr_t = *mut ::std::os::raw::c_char;
pub type __intptr_t = ::std::os::raw::c_long;
pub type __socklen_t = ::std::os::raw::c_uint;
pub type __sig_atomic_t = ::std::os::raw::c_int;
pub type int_least8_t = __int_least8_t;
pub type int_least16_t = __int_least16_t;
pub type int_least32_t = __int_least32_t;
pub type int_least64_t = __int_least64_t;
pub type uint_least8_t = __uint_least8_t;
pub type uint_least16_t = __uint_least16_t;
pub type uint_least32_t = __uint_least32_t;
pub type uint_least64_t = __uint_least64_t;
pub type int_fast8_t = ::std::os::raw::c_schar;
pub type int_fast16_t = ::std::os::raw::c_long;
pub type int_fast32_t = ::std::os::raw::c_long;
pub type int_fast64_t = ::std::os::raw::c_long;
pub type uint_fast8_t = ::std::os::raw::c_uchar;
pub type uint_fast16_t = ::std::os::raw::c_ulong;
pub type uint_fast32_t = ::std::os::raw::c_ulong;
pub type uint_fast64_t = ::std::os::raw::c_ulong;
pub type intmax_t = __intmax_t;
pub type uintmax_t = __uintmax_t;
pub type va_list = __builtin_va_list;
pub type __gnuc_va_list = __builtin_va_list;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct __mbstate_t {
    pub __count: ::std::os::raw::c_int,
    pub __value: __mbstate_t__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __mbstate_t__bindgen_ty_1 {
    pub __wch: ::std::os::raw::c_uint,
    pub __wchb: [::std::os::raw::c_char; 4usize],
    _bindgen_union_align: u32,
}
#[test]
fn bindgen_test_layout___mbstate_t__bindgen_ty_1() {
    assert_eq!(
        ::std::mem::size_of::<__mbstate_t__bindgen_ty_1>(),
        4usize,
        concat!("Size of: ", stringify!(__mbstate_t__bindgen_ty_1))
    );
    assert_eq!(
        ::std::mem::align_of::<__mbstate_t__bindgen_ty_1>(),
        4usize,
        concat!("Alignment of ", stringify!(__mbstate_t__bindgen_ty_1))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<__mbstate_t__bindgen_ty_1>())).__wch as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__mbstate_t__bindgen_ty_1),
            "::",
            stringify!(__wch)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<__mbstate_t__bindgen_ty_1>())).__wchb as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__mbstate_t__bindgen_ty_1),
            "::",
            stringify!(__wchb)
        )
    );
}
#[test]
fn bindgen_test_layout___mbstate_t() {
    assert_eq!(
        ::std::mem::size_of::<__mbstate_t>(),
        8usize,
        concat!("Size of: ", stringify!(__mbstate_t))
    );
    assert_eq!(
        ::std::mem::align_of::<__mbstate_t>(),
        4usize,
        concat!("Alignment of ", stringify!(__mbstate_t))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<__mbstate_t>())).__count as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__mbstate_t),
            "::",
            stringify!(__count)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<__mbstate_t>())).__value as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(__mbstate_t),
            "::",
            stringify!(__value)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _G_fpos_t {
    pub __pos: __off_t,
    pub __state: __mbstate_t,
}
#[test]
fn bindgen_test_layout__G_fpos_t() {
    assert_eq!(
        ::std::mem::size_of::<_G_fpos_t>(),
        16usize,
        concat!("Size of: ", stringify!(_G_fpos_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_G_fpos_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_G_fpos_t))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_G_fpos_t>())).__pos as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_G_fpos_t),
            "::",
            stringify!(__pos)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_G_fpos_t>())).__state as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_G_fpos_t),
            "::",
            stringify!(__state)
        )
    );
}
pub type __fpos_t = _G_fpos_t;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _G_fpos64_t {
    pub __pos: __off64_t,
    pub __state: __mbstate_t,
}
#[test]
fn bindgen_test_layout__G_fpos64_t() {
    assert_eq!(
        ::std::mem::size_of::<_G_fpos64_t>(),
        16usize,
        concat!("Size of: ", stringify!(_G_fpos64_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_G_fpos64_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_G_fpos64_t))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_G_fpos64_t>())).__pos as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_G_fpos64_t),
            "::",
            stringify!(__pos)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_G_fpos64_t>())).__state as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_G_fpos64_t),
            "::",
            stringify!(__state)
        )
    );
}
pub type __fpos64_t = _G_fpos64_t;
pub type __FILE = _IO_FILE;
pub type FILE = _IO_FILE;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_marker {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_codecvt {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_wide_data {
    _unused: [u8; 0],
}
pub type _IO_lock_t = ::std::os::raw::c_void;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_FILE {
    pub _flags: ::std::os::raw::c_int,
    pub _IO_read_ptr: *mut ::std::os::raw::c_char,
    pub _IO_read_end: *mut ::std::os::raw::c_char,
    pub _IO_read_base: *mut ::std::os::raw::c_char,
    pub _IO_write_base: *mut ::std::os::raw::c_char,
    pub _IO_write_ptr: *mut ::std::os::raw::c_char,
    pub _IO_write_end: *mut ::std::os::raw::c_char,
    pub _IO_buf_base: *mut ::std::os::raw::c_char,
    pub _IO_buf_end: *mut ::std::os::raw::c_char,
    pub _IO_save_base: *mut ::std::os::raw::c_char,
    pub _IO_backup_base: *mut ::std::os::raw::c_char,
    pub _IO_save_end: *mut ::std::os::raw::c_char,
    pub _markers: *mut _IO_marker,
    pub _chain: *mut _IO_FILE,
    pub _fileno: ::std::os::raw::c_int,
    pub _flags2: ::std::os::raw::c_int,
    pub _old_offset: __off_t,
    pub _cur_column: ::std::os::raw::c_ushort,
    pub _vtable_offset: ::std::os::raw::c_schar,
    pub _shortbuf: [::std::os::raw::c_char; 1usize],
    pub _lock: *mut _IO_lock_t,
    pub _offset: __off64_t,
    pub _codecvt: *mut _IO_codecvt,
    pub _wide_data: *mut _IO_wide_data,
    pub _freeres_list: *mut _IO_FILE,
    pub _freeres_buf: *mut ::std::os::raw::c_void,
    pub __pad5: size_t,
    pub _mode: ::std::os::raw::c_int,
    pub _unused2: [::std::os::raw::c_char; 20usize],
}
#[test]
fn bindgen_test_layout__IO_FILE() {
    assert_eq!(
        ::std::mem::size_of::<_IO_FILE>(),
        216usize,
        concat!("Size of: ", stringify!(_IO_FILE))
    );
    assert_eq!(
        ::std::mem::align_of::<_IO_FILE>(),
        8usize,
        concat!("Alignment of ", stringify!(_IO_FILE))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._flags as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_flags)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_read_ptr as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_read_ptr)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_read_end as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_read_end)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_read_base as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_read_base)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_write_base as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_write_base)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_write_ptr as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_write_ptr)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_write_end as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_write_end)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_buf_base as *const _ as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_buf_base)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_buf_end as *const _ as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_buf_end)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_save_base as *const _ as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_save_base)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_backup_base as *const _ as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_backup_base)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_save_end as *const _ as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_save_end)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._markers as *const _ as usize },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_markers)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._chain as *const _ as usize },
        104usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_chain)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._fileno as *const _ as usize },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_fileno)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._flags2 as *const _ as usize },
        116usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_flags2)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._old_offset as *const _ as usize },
        120usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_old_offset)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._cur_column as *const _ as usize },
        128usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_cur_column)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._vtable_offset as *const _ as usize },
        130usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_vtable_offset)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._shortbuf as *const _ as usize },
        131usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_shortbuf)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._lock as *const _ as usize },
        136usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_lock)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._offset as *const _ as usize },
        144usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_offset)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._codecvt as *const _ as usize },
        152usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_codecvt)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._wide_data as *const _ as usize },
        160usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_wide_data)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._freeres_list as *const _ as usize },
        168usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_freeres_list)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._freeres_buf as *const _ as usize },
        176usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_freeres_buf)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>())).__pad5 as *const _ as usize },
        184usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(__pad5)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._mode as *const _ as usize },
        192usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_mode)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._unused2 as *const _ as usize },
        196usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_unused2)
        )
    );
}
pub type off_t = __off_t;
pub type ssize_t = __ssize_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;
}
pub type _Float32 = f32;
pub type _Float64 = f64;
pub type _Float32x = f64;
pub type _Float64x = u128;
pub const PD_DataType_PD_FLOAT32: PD_DataType = 0;
pub const PD_DataType_PD_INT32: PD_DataType = 1;
pub const PD_DataType_PD_INT64: PD_DataType = 2;
pub const PD_DataType_PD_UINT8: PD_DataType = 3;
pub const PD_DataType_PD_UNKDTYPE: PD_DataType = 4;
pub type PD_DataType = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct PD_PaddleBuf {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct PD_AnalysisConfig {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct PD_Predictor {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct PD_Buffer {
    pub data: *mut ::std::os::raw::c_void,
    pub length: size_t,
    pub capacity: size_t,
}
#[test]
fn bindgen_test_layout_PD_Buffer() {
    assert_eq!(
        ::std::mem::size_of::<PD_Buffer>(),
        24usize,
        concat!("Size of: ", stringify!(PD_Buffer))
    );
    assert_eq!(
        ::std::mem::align_of::<PD_Buffer>(),
        8usize,
        concat!("Alignment of ", stringify!(PD_Buffer))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<PD_Buffer>())).data as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(PD_Buffer),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<PD_Buffer>())).length as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(PD_Buffer),
            "::",
            stringify!(length)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<PD_Buffer>())).capacity as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(PD_Buffer),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct PD_ZeroCopyTensor {
    pub data: PD_Buffer,
    pub shape: PD_Buffer,
    pub lod: PD_Buffer,
    pub dtype: PD_DataType,
    pub name: *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_PD_ZeroCopyTensor() {
    assert_eq!(
        ::std::mem::size_of::<PD_ZeroCopyTensor>(),
        88usize,
        concat!("Size of: ", stringify!(PD_ZeroCopyTensor))
    );
    assert_eq!(
        ::std::mem::align_of::<PD_ZeroCopyTensor>(),
        8usize,
        concat!("Alignment of ", stringify!(PD_ZeroCopyTensor))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<PD_ZeroCopyTensor>())).data as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(PD_ZeroCopyTensor),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<PD_ZeroCopyTensor>())).shape as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(PD_ZeroCopyTensor),
            "::",
            stringify!(shape)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<PD_ZeroCopyTensor>())).lod as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(PD_ZeroCopyTensor),
            "::",
            stringify!(lod)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<PD_ZeroCopyTensor>())).dtype as *const _ as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(PD_ZeroCopyTensor),
            "::",
            stringify!(dtype)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<PD_ZeroCopyTensor>())).name as *const _ as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(PD_ZeroCopyTensor),
            "::",
            stringify!(name)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct PD_ZeroCopyData {
    pub name: *mut ::std::os::raw::c_char,
    pub data: *mut ::std::os::raw::c_void,
    pub dtype: PD_DataType,
    pub shape: *mut ::std::os::raw::c_int,
    pub shape_size: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_PD_ZeroCopyData() {
    assert_eq!(
        ::std::mem::size_of::<PD_ZeroCopyData>(),
        40usize,
        concat!("Size of: ", stringify!(PD_ZeroCopyData))
    );
    assert_eq!(
        ::std::mem::align_of::<PD_ZeroCopyData>(),
        8usize,
        concat!("Alignment of ", stringify!(PD_ZeroCopyData))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<PD_ZeroCopyData>())).name as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(PD_ZeroCopyData),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<PD_ZeroCopyData>())).data as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(PD_ZeroCopyData),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<PD_ZeroCopyData>())).dtype as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(PD_ZeroCopyData),
            "::",
            stringify!(dtype)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<PD_ZeroCopyData>())).shape as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(PD_ZeroCopyData),
            "::",
            stringify!(shape)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<PD_ZeroCopyData>())).shape_size as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(PD_ZeroCopyData),
            "::",
            stringify!(shape_size)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct InTensorShape {
    pub name: *mut ::std::os::raw::c_char,
    pub tensor_shape: *mut ::std::os::raw::c_int,
    pub shape_size: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_InTensorShape() {
    assert_eq!(
        ::std::mem::size_of::<InTensorShape>(),
        24usize,
        concat!("Size of: ", stringify!(InTensorShape))
    );
    assert_eq!(
        ::std::mem::align_of::<InTensorShape>(),
        8usize,
        concat!("Alignment of ", stringify!(InTensorShape))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<InTensorShape>())).name as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(InTensorShape),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<InTensorShape>())).tensor_shape as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(InTensorShape),
            "::",
            stringify!(tensor_shape)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<InTensorShape>())).shape_size as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(InTensorShape),
            "::",
            stringify!(shape_size)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct PD_Tensor {
    _unused: [u8; 0],
}
pub const Precision_kFloat32: Precision = 0;
pub const Precision_kInt8: Precision = 1;
pub const Precision_kHalf: Precision = 2;
pub type Precision = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct PD_MaxInputShape {
    pub name: *mut ::std::os::raw::c_char,
    pub shape: *mut ::std::os::raw::c_int,
    pub shape_size: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_PD_MaxInputShape() {
    assert_eq!(
        ::std::mem::size_of::<PD_MaxInputShape>(),
        24usize,
        concat!("Size of: ", stringify!(PD_MaxInputShape))
    );
    assert_eq!(
        ::std::mem::align_of::<PD_MaxInputShape>(),
        8usize,
        concat!("Alignment of ", stringify!(PD_MaxInputShape))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<PD_MaxInputShape>())).name as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(PD_MaxInputShape),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<PD_MaxInputShape>())).shape as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(PD_MaxInputShape),
            "::",
            stringify!(shape)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<PD_MaxInputShape>())).shape_size as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(PD_MaxInputShape),
            "::",
            stringify!(shape_size)
        )
    );
}
pub type __builtin_va_list = [__va_list_tag; 1usize];
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __va_list_tag {
    pub gp_offset: ::std::os::raw::c_uint,
    pub fp_offset: ::std::os::raw::c_uint,
    pub overflow_arg_area: *mut ::std::os::raw::c_void,
    pub reg_save_area: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout___va_list_tag() {
    assert_eq!(
        ::std::mem::size_of::<__va_list_tag>(),
        24usize,
        concat!("Size of: ", stringify!(__va_list_tag))
    );
    assert_eq!(
        ::std::mem::align_of::<__va_list_tag>(),
        8usize,
        concat!("Alignment of ", stringify!(__va_list_tag))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__va_list_tag),
            "::",
            stringify!(gp_offset)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(__va_list_tag),
            "::",
            stringify!(fp_offset)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(__va_list_tag),
            "::",
            stringify!(overflow_arg_area)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(__va_list_tag),
            "::",
            stringify!(reg_save_area)
        )
    );
}
extern crate libloading;
pub struct paddle_fluid_c {
    __library: ::libloading::Library,
    pub remove: Result<
        unsafe extern "C" fn(__filename: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub rename: Result<
        unsafe extern "C" fn(
            __old: *const ::std::os::raw::c_char,
            __new: *const ::std::os::raw::c_char,
        ) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub renameat: Result<
        unsafe extern "C" fn(
            __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,
        ::libloading::Error,
    >,
    pub tmpfile: Result<unsafe extern "C" fn() -> *mut FILE, ::libloading::Error>,
    pub tmpnam: Result<
        unsafe extern "C" fn(__s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char,
        ::libloading::Error,
    >,
    pub tmpnam_r: Result<
        unsafe extern "C" fn(__s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char,
        ::libloading::Error,
    >,
    pub tempnam: Result<
        unsafe extern "C" fn(
            __dir: *const ::std::os::raw::c_char,
            __pfx: *const ::std::os::raw::c_char,
        ) -> *mut ::std::os::raw::c_char,
        ::libloading::Error,
    >,
    pub fclose: Result<
        unsafe extern "C" fn(__stream: *mut FILE) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub fflush: Result<
        unsafe extern "C" fn(__stream: *mut FILE) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub fflush_unlocked: Result<
        unsafe extern "C" fn(__stream: *mut FILE) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub fopen: Result<
        unsafe extern "C" fn(
            __filename: *const ::std::os::raw::c_char,
            __modes: *const ::std::os::raw::c_char,
        ) -> *mut FILE,
        ::libloading::Error,
    >,
    pub freopen: Result<
        unsafe extern "C" fn(
            __filename: *const ::std::os::raw::c_char,
            __modes: *const ::std::os::raw::c_char,
            __stream: *mut FILE,
        ) -> *mut FILE,
        ::libloading::Error,
    >,
    pub fdopen: Result<
        unsafe extern "C" fn(
            __fd: ::std::os::raw::c_int,
            __modes: *const ::std::os::raw::c_char,
        ) -> *mut FILE,
        ::libloading::Error,
    >,
    pub fmemopen: Result<
        unsafe extern "C" fn(
            __s: *mut ::std::os::raw::c_void,
            __len: size_t,
            __modes: *const ::std::os::raw::c_char,
        ) -> *mut FILE,
        ::libloading::Error,
    >,
    pub open_memstream: Result<
        unsafe extern "C" fn(
            __bufloc: *mut *mut ::std::os::raw::c_char,
            __sizeloc: *mut size_t,
        ) -> *mut FILE,
        ::libloading::Error,
    >,
    pub setbuf: Result<
        unsafe extern "C" fn(__stream: *mut FILE, __buf: *mut ::std::os::raw::c_char),
        ::libloading::Error,
    >,
    pub setvbuf: Result<
        unsafe extern "C" fn(
            __stream: *mut FILE,
            __buf: *mut ::std::os::raw::c_char,
            __modes: ::std::os::raw::c_int,
            __n: size_t,
        ) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub setbuffer: Result<
        unsafe extern "C" fn(
            __stream: *mut FILE,
            __buf: *mut ::std::os::raw::c_char,
            __size: size_t,
        ),
        ::libloading::Error,
    >,
    pub setlinebuf: Result<unsafe extern "C" fn(__stream: *mut FILE), ::libloading::Error>,
    pub fprintf: Result<
        unsafe extern "C" fn(
            __stream: *mut FILE,
            __format: *const ::std::os::raw::c_char,
            ...
        ) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub printf: Result<
        unsafe extern "C" fn(__format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub sprintf: Result<
        unsafe extern "C" fn(
            __s: *mut ::std::os::raw::c_char,
            __format: *const ::std::os::raw::c_char,
            ...
        ) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub vfprintf: Result<
        unsafe extern "C" fn(
            __s: *mut FILE,
            __format: *const ::std::os::raw::c_char,
            __arg: *mut __va_list_tag,
        ) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub vprintf: Result<
        unsafe extern "C" fn(
            __format: *const ::std::os::raw::c_char,
            __arg: *mut __va_list_tag,
        ) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub vsprintf: Result<
        unsafe extern "C" fn(
            __s: *mut ::std::os::raw::c_char,
            __format: *const ::std::os::raw::c_char,
            __arg: *mut __va_list_tag,
        ) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub snprintf: Result<
        unsafe extern "C" fn(
            __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,
        ::libloading::Error,
    >,
    pub vsnprintf: Result<
        unsafe extern "C" fn(
            __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,
        ::libloading::Error,
    >,
    pub vdprintf: Result<
        unsafe extern "C" fn(
            __fd: ::std::os::raw::c_int,
            __fmt: *const ::std::os::raw::c_char,
            __arg: *mut __va_list_tag,
        ) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub dprintf: Result<
        unsafe extern "C" fn(
            __fd: ::std::os::raw::c_int,
            __fmt: *const ::std::os::raw::c_char,
            ...
        ) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub fscanf: Result<
        unsafe extern "C" fn(
            __stream: *mut FILE,
            __format: *const ::std::os::raw::c_char,
            ...
        ) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub scanf: Result<
        unsafe extern "C" fn(__format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub sscanf: Result<
        unsafe extern "C" fn(
            __s: *const ::std::os::raw::c_char,
            __format: *const ::std::os::raw::c_char,
            ...
        ) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub fscanf1: Result<
        unsafe extern "C" fn(
            __stream: *mut FILE,
            __format: *const ::std::os::raw::c_char,
            ...
        ) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub scanf1: Result<
        unsafe extern "C" fn(__format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub sscanf1: Result<
        unsafe extern "C" fn(
            __s: *const ::std::os::raw::c_char,
            __format: *const ::std::os::raw::c_char,
            ...
        ) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub vfscanf: Result<
        unsafe extern "C" fn(
            __s: *mut FILE,
            __format: *const ::std::os::raw::c_char,
            __arg: *mut __va_list_tag,
        ) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub vscanf: Result<
        unsafe extern "C" fn(
            __format: *const ::std::os::raw::c_char,
            __arg: *mut __va_list_tag,
        ) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub vsscanf: Result<
        unsafe extern "C" fn(
            __s: *const ::std::os::raw::c_char,
            __format: *const ::std::os::raw::c_char,
            __arg: *mut __va_list_tag,
        ) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub vfscanf1: Result<
        unsafe extern "C" fn(
            __s: *mut FILE,
            __format: *const ::std::os::raw::c_char,
            __arg: *mut __va_list_tag,
        ) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub vscanf1: Result<
        unsafe extern "C" fn(
            __format: *const ::std::os::raw::c_char,
            __arg: *mut __va_list_tag,
        ) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub vsscanf1: Result<
        unsafe extern "C" fn(
            __s: *const ::std::os::raw::c_char,
            __format: *const ::std::os::raw::c_char,
            __arg: *mut __va_list_tag,
        ) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub fgetc: Result<
        unsafe extern "C" fn(__stream: *mut FILE) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub getc: Result<
        unsafe extern "C" fn(__stream: *mut FILE) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub getchar: Result<unsafe extern "C" fn() -> ::std::os::raw::c_int, ::libloading::Error>,
    pub getc_unlocked: Result<
        unsafe extern "C" fn(__stream: *mut FILE) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub getchar_unlocked:
        Result<unsafe extern "C" fn() -> ::std::os::raw::c_int, ::libloading::Error>,
    pub fgetc_unlocked: Result<
        unsafe extern "C" fn(__stream: *mut FILE) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub fputc: Result<
        unsafe extern "C" fn(
            __c: ::std::os::raw::c_int,
            __stream: *mut FILE,
        ) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub putc: Result<
        unsafe extern "C" fn(
            __c: ::std::os::raw::c_int,
            __stream: *mut FILE,
        ) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub putchar: Result<
        unsafe extern "C" fn(__c: ::std::os::raw::c_int) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub fputc_unlocked: Result<
        unsafe extern "C" fn(
            __c: ::std::os::raw::c_int,
            __stream: *mut FILE,
        ) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub putc_unlocked: Result<
        unsafe extern "C" fn(
            __c: ::std::os::raw::c_int,
            __stream: *mut FILE,
        ) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub putchar_unlocked: Result<
        unsafe extern "C" fn(__c: ::std::os::raw::c_int) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub getw: Result<
        unsafe extern "C" fn(__stream: *mut FILE) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub putw: Result<
        unsafe extern "C" fn(
            __w: ::std::os::raw::c_int,
            __stream: *mut FILE,
        ) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub fgets: Result<
        unsafe extern "C" fn(
            __s: *mut ::std::os::raw::c_char,
            __n: ::std::os::raw::c_int,
            __stream: *mut FILE,
        ) -> *mut ::std::os::raw::c_char,
        ::libloading::Error,
    >,
    pub __getdelim: Result<
        unsafe extern "C" fn(
            __lineptr: *mut *mut ::std::os::raw::c_char,
            __n: *mut size_t,
            __delimiter: ::std::os::raw::c_int,
            __stream: *mut FILE,
        ) -> __ssize_t,
        ::libloading::Error,
    >,
    pub getdelim: Result<
        unsafe extern "C" fn(
            __lineptr: *mut *mut ::std::os::raw::c_char,
            __n: *mut size_t,
            __delimiter: ::std::os::raw::c_int,
            __stream: *mut FILE,
        ) -> __ssize_t,
        ::libloading::Error,
    >,
    pub getline: Result<
        unsafe extern "C" fn(
            __lineptr: *mut *mut ::std::os::raw::c_char,
            __n: *mut size_t,
            __stream: *mut FILE,
        ) -> __ssize_t,
        ::libloading::Error,
    >,
    pub fputs: Result<
        unsafe extern "C" fn(
            __s: *const ::std::os::raw::c_char,
            __stream: *mut FILE,
        ) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub puts: Result<
        unsafe extern "C" fn(__s: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub ungetc: Result<
        unsafe extern "C" fn(
            __c: ::std::os::raw::c_int,
            __stream: *mut FILE,
        ) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub fread: Result<
        unsafe extern "C" fn(
            __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,
        ::libloading::Error,
    >,
    pub fwrite: Result<
        unsafe extern "C" fn(
            __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,
        ::libloading::Error,
    >,
    pub fread_unlocked: Result<
        unsafe extern "C" fn(
            __ptr: *mut ::std::os::raw::c_void,
            __size: size_t,
            __n: size_t,
            __stream: *mut FILE,
        ) -> size_t,
        ::libloading::Error,
    >,
    pub fwrite_unlocked: Result<
        unsafe extern "C" fn(
            __ptr: *const ::std::os::raw::c_void,
            __size: size_t,
            __n: size_t,
            __stream: *mut FILE,
        ) -> size_t,
        ::libloading::Error,
    >,
    pub fseek: Result<
        unsafe extern "C" fn(
            __stream: *mut FILE,
            __off: ::std::os::raw::c_long,
            __whence: ::std::os::raw::c_int,
        ) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub ftell: Result<
        unsafe extern "C" fn(__stream: *mut FILE) -> ::std::os::raw::c_long,
        ::libloading::Error,
    >,
    pub rewind: Result<unsafe extern "C" fn(__stream: *mut FILE), ::libloading::Error>,
    pub fseeko: Result<
        unsafe extern "C" fn(
            __stream: *mut FILE,
            __off: __off_t,
            __whence: ::std::os::raw::c_int,
        ) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub ftello: Result<unsafe extern "C" fn(__stream: *mut FILE) -> __off_t, ::libloading::Error>,
    pub fgetpos: Result<
        unsafe extern "C" fn(__stream: *mut FILE, __pos: *mut fpos_t) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub fsetpos: Result<
        unsafe extern "C" fn(__stream: *mut FILE, __pos: *const fpos_t) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub clearerr: Result<unsafe extern "C" fn(__stream: *mut FILE), ::libloading::Error>,
    pub feof: Result<
        unsafe extern "C" fn(__stream: *mut FILE) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub ferror: Result<
        unsafe extern "C" fn(__stream: *mut FILE) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub clearerr_unlocked: Result<unsafe extern "C" fn(__stream: *mut FILE), ::libloading::Error>,
    pub feof_unlocked: Result<
        unsafe extern "C" fn(__stream: *mut FILE) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub ferror_unlocked: Result<
        unsafe extern "C" fn(__stream: *mut FILE) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub perror:
        Result<unsafe extern "C" fn(__s: *const ::std::os::raw::c_char), ::libloading::Error>,
    pub fileno: Result<
        unsafe extern "C" fn(__stream: *mut FILE) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub fileno_unlocked: Result<
        unsafe extern "C" fn(__stream: *mut FILE) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub popen: Result<
        unsafe extern "C" fn(
            __command: *const ::std::os::raw::c_char,
            __modes: *const ::std::os::raw::c_char,
        ) -> *mut FILE,
        ::libloading::Error,
    >,
    pub pclose: Result<
        unsafe extern "C" fn(__stream: *mut FILE) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub ctermid: Result<
        unsafe extern "C" fn(__s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char,
        ::libloading::Error,
    >,
    pub flockfile: Result<unsafe extern "C" fn(__stream: *mut FILE), ::libloading::Error>,
    pub ftrylockfile: Result<
        unsafe extern "C" fn(__stream: *mut FILE) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub funlockfile: Result<unsafe extern "C" fn(__stream: *mut FILE), ::libloading::Error>,
    pub __uflow:
        Result<unsafe extern "C" fn(arg1: *mut FILE) -> ::std::os::raw::c_int, ::libloading::Error>,
    pub __overflow: Result<
        unsafe extern "C" fn(arg1: *mut FILE, arg2: ::std::os::raw::c_int) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub PD_NewZeroCopyTensor:
        Result<unsafe extern "C" fn() -> *mut PD_ZeroCopyTensor, ::libloading::Error>,
    pub PD_DeleteZeroCopyTensor:
        Result<unsafe extern "C" fn(arg1: *mut PD_ZeroCopyTensor), ::libloading::Error>,
    pub PD_InitZeroCopyTensor:
        Result<unsafe extern "C" fn(arg1: *mut PD_ZeroCopyTensor), ::libloading::Error>,
    pub PD_DestroyZeroCopyTensor:
        Result<unsafe extern "C" fn(arg1: *mut PD_ZeroCopyTensor), ::libloading::Error>,
    pub PD_NewPaddleBuf: Result<unsafe extern "C" fn() -> *mut PD_PaddleBuf, ::libloading::Error>,
    pub PD_DeletePaddleBuf:
        Result<unsafe extern "C" fn(buf: *mut PD_PaddleBuf), ::libloading::Error>,
    pub PD_PaddleBufResize:
        Result<unsafe extern "C" fn(buf: *mut PD_PaddleBuf, length: size_t), ::libloading::Error>,
    pub PD_PaddleBufReset: Result<
        unsafe extern "C" fn(
            buf: *mut PD_PaddleBuf,
            data: *mut ::std::os::raw::c_void,
            length: size_t,
        ),
        ::libloading::Error,
    >,
    pub PD_PaddleBufEmpty:
        Result<unsafe extern "C" fn(buf: *mut PD_PaddleBuf) -> bool, ::libloading::Error>,
    pub PD_PaddleBufData: Result<
        unsafe extern "C" fn(buf: *mut PD_PaddleBuf) -> *mut ::std::os::raw::c_void,
        ::libloading::Error,
    >,
    pub PD_PaddleBufLength:
        Result<unsafe extern "C" fn(buf: *mut PD_PaddleBuf) -> size_t, ::libloading::Error>,
    pub PD_NewPaddleTensor: Result<unsafe extern "C" fn() -> *mut PD_Tensor, ::libloading::Error>,
    pub PD_DeletePaddleTensor:
        Result<unsafe extern "C" fn(tensor: *mut PD_Tensor), ::libloading::Error>,
    pub PD_SetPaddleTensorName: Result<
        unsafe extern "C" fn(tensor: *mut PD_Tensor, name: *mut ::std::os::raw::c_char),
        ::libloading::Error,
    >,
    pub PD_SetPaddleTensorDType: Result<
        unsafe extern "C" fn(tensor: *mut PD_Tensor, dtype: PD_DataType),
        ::libloading::Error,
    >,
    pub PD_SetPaddleTensorData: Result<
        unsafe extern "C" fn(tensor: *mut PD_Tensor, buf: *mut PD_PaddleBuf),
        ::libloading::Error,
    >,
    pub PD_SetPaddleTensorShape: Result<
        unsafe extern "C" fn(
            tensor: *mut PD_Tensor,
            shape: *mut ::std::os::raw::c_int,
            size: ::std::os::raw::c_int,
        ),
        ::libloading::Error,
    >,
    pub PD_GetPaddleTensorName: Result<
        unsafe extern "C" fn(tensor: *const PD_Tensor) -> *const ::std::os::raw::c_char,
        ::libloading::Error,
    >,
    pub PD_GetPaddleTensorDType:
        Result<unsafe extern "C" fn(tensor: *const PD_Tensor) -> PD_DataType, ::libloading::Error>,
    pub PD_GetPaddleTensorData: Result<
        unsafe extern "C" fn(tensor: *const PD_Tensor) -> *mut PD_PaddleBuf,
        ::libloading::Error,
    >,
    pub PD_GetPaddleTensorShape: Result<
        unsafe extern "C" fn(
            tensor: *const PD_Tensor,
            size: *mut ::std::os::raw::c_int,
        ) -> *const ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub PD_PredictorRun: Result<
        unsafe extern "C" fn(
            config: *const PD_AnalysisConfig,
            inputs: *mut PD_Tensor,
            in_size: ::std::os::raw::c_int,
            output_data: *mut *mut PD_Tensor,
            out_size: *mut ::std::os::raw::c_int,
            batch_size: ::std::os::raw::c_int,
        ) -> bool,
        ::libloading::Error,
    >,
    pub PD_PredictorZeroCopyRun: Result<
        unsafe extern "C" fn(
            config: *const PD_AnalysisConfig,
            inputs: *mut PD_ZeroCopyData,
            in_size: ::std::os::raw::c_int,
            output: *mut *mut PD_ZeroCopyData,
            out_size: *mut ::std::os::raw::c_int,
        ) -> bool,
        ::libloading::Error,
    >,
    pub PD_NewAnalysisConfig:
        Result<unsafe extern "C" fn() -> *mut PD_AnalysisConfig, ::libloading::Error>,
    pub PD_DeleteAnalysisConfig:
        Result<unsafe extern "C" fn(config: *mut PD_AnalysisConfig), ::libloading::Error>,
    pub PD_SetModel: Result<
        unsafe extern "C" fn(
            config: *mut PD_AnalysisConfig,
            model_dir: *const ::std::os::raw::c_char,
            params_path: *const ::std::os::raw::c_char,
        ),
        ::libloading::Error,
    >,
    pub PD_SetProgFile: Result<
        unsafe extern "C" fn(config: *mut PD_AnalysisConfig, x: *const ::std::os::raw::c_char),
        ::libloading::Error,
    >,
    pub PD_SetParamsFile: Result<
        unsafe extern "C" fn(config: *mut PD_AnalysisConfig, x: *const ::std::os::raw::c_char),
        ::libloading::Error,
    >,
    pub PD_SetOptimCacheDir: Result<
        unsafe extern "C" fn(
            config: *mut PD_AnalysisConfig,
            opt_cache_dir: *const ::std::os::raw::c_char,
        ),
        ::libloading::Error,
    >,
    pub PD_ModelDir: Result<
        unsafe extern "C" fn(config: *const PD_AnalysisConfig) -> *const ::std::os::raw::c_char,
        ::libloading::Error,
    >,
    pub PD_ProgFile: Result<
        unsafe extern "C" fn(config: *const PD_AnalysisConfig) -> *const ::std::os::raw::c_char,
        ::libloading::Error,
    >,
    pub PD_ParamsFile: Result<
        unsafe extern "C" fn(config: *const PD_AnalysisConfig) -> *const ::std::os::raw::c_char,
        ::libloading::Error,
    >,
    pub PD_EnableUseGpu: Result<
        unsafe extern "C" fn(
            config: *mut PD_AnalysisConfig,
            memory_pool_init_size_mb: ::std::os::raw::c_int,
            device_id: ::std::os::raw::c_int,
        ),
        ::libloading::Error,
    >,
    pub PD_DisableGpu:
        Result<unsafe extern "C" fn(config: *mut PD_AnalysisConfig), ::libloading::Error>,
    pub PD_UseGpu:
        Result<unsafe extern "C" fn(config: *const PD_AnalysisConfig) -> bool, ::libloading::Error>,
    pub PD_GpuDeviceId: Result<
        unsafe extern "C" fn(config: *const PD_AnalysisConfig) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub PD_MemoryPoolInitSizeMb: Result<
        unsafe extern "C" fn(config: *const PD_AnalysisConfig) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub PD_FractionOfGpuMemoryForPool:
        Result<unsafe extern "C" fn(config: *const PD_AnalysisConfig) -> f32, ::libloading::Error>,
    pub PD_EnableCUDNN:
        Result<unsafe extern "C" fn(config: *mut PD_AnalysisConfig), ::libloading::Error>,
    pub PD_CudnnEnabled:
        Result<unsafe extern "C" fn(config: *const PD_AnalysisConfig) -> bool, ::libloading::Error>,
    pub PD_SwitchIrOptim:
        Result<unsafe extern "C" fn(config: *mut PD_AnalysisConfig, x: bool), ::libloading::Error>,
    pub PD_IrOptim:
        Result<unsafe extern "C" fn(config: *const PD_AnalysisConfig) -> bool, ::libloading::Error>,
    pub PD_SwitchUseFeedFetchOps:
        Result<unsafe extern "C" fn(config: *mut PD_AnalysisConfig, x: bool), ::libloading::Error>,
    pub PD_UseFeedFetchOpsEnabled:
        Result<unsafe extern "C" fn(config: *const PD_AnalysisConfig) -> bool, ::libloading::Error>,
    pub PD_SwitchSpecifyInputNames:
        Result<unsafe extern "C" fn(config: *mut PD_AnalysisConfig, x: bool), ::libloading::Error>,
    pub PD_SpecifyInputName:
        Result<unsafe extern "C" fn(config: *const PD_AnalysisConfig) -> bool, ::libloading::Error>,
    pub PD_EnableTensorRtEngine: Result<
        unsafe extern "C" fn(
            config: *mut PD_AnalysisConfig,
            workspace_size: ::std::os::raw::c_int,
            max_batch_size: ::std::os::raw::c_int,
            min_subgraph_size: ::std::os::raw::c_int,
            precision: Precision,
            use_static: bool,
            use_calib_mode: bool,
        ),
        ::libloading::Error,
    >,
    pub PD_TensorrtEngineEnabled:
        Result<unsafe extern "C" fn(config: *const PD_AnalysisConfig) -> bool, ::libloading::Error>,
    pub PD_SwitchIrDebug:
        Result<unsafe extern "C" fn(config: *mut PD_AnalysisConfig, x: bool), ::libloading::Error>,
    pub PD_EnableMKLDNN:
        Result<unsafe extern "C" fn(config: *mut PD_AnalysisConfig), ::libloading::Error>,
    pub PD_SetMkldnnCacheCapacity: Result<
        unsafe extern "C" fn(config: *mut PD_AnalysisConfig, capacity: ::std::os::raw::c_int),
        ::libloading::Error,
    >,
    pub PD_MkldnnEnabled:
        Result<unsafe extern "C" fn(config: *const PD_AnalysisConfig) -> bool, ::libloading::Error>,
    pub PD_SetCpuMathLibraryNumThreads: Result<
        unsafe extern "C" fn(
            config: *mut PD_AnalysisConfig,
            cpu_math_library_num_threads: ::std::os::raw::c_int,
        ),
        ::libloading::Error,
    >,
    pub PD_CpuMathLibraryNumThreads: Result<
        unsafe extern "C" fn(config: *const PD_AnalysisConfig) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub PD_EnableMkldnnQuantizer:
        Result<unsafe extern "C" fn(config: *mut PD_AnalysisConfig), ::libloading::Error>,
    pub PD_MkldnnQuantizerEnabled:
        Result<unsafe extern "C" fn(config: *const PD_AnalysisConfig) -> bool, ::libloading::Error>,
    pub PD_EnableMkldnnBfloat16:
        Result<unsafe extern "C" fn(config: *mut PD_AnalysisConfig), ::libloading::Error>,
    pub PD_MkldnnBfloat16Enabled:
        Result<unsafe extern "C" fn(config: *const PD_AnalysisConfig) -> bool, ::libloading::Error>,
    pub PD_SetModelBuffer: Result<
        unsafe extern "C" fn(
            config: *mut PD_AnalysisConfig,
            prog_buffer: *const ::std::os::raw::c_char,
            prog_buffer_size: size_t,
            params_buffer: *const ::std::os::raw::c_char,
            params_buffer_size: size_t,
        ),
        ::libloading::Error,
    >,
    pub PD_ModelFromMemory:
        Result<unsafe extern "C" fn(config: *const PD_AnalysisConfig) -> bool, ::libloading::Error>,
    pub PD_EnableMemoryOptim:
        Result<unsafe extern "C" fn(config: *mut PD_AnalysisConfig), ::libloading::Error>,
    pub PD_MemoryOptimEnabled:
        Result<unsafe extern "C" fn(config: *const PD_AnalysisConfig) -> bool, ::libloading::Error>,
    pub PD_EnableProfile:
        Result<unsafe extern "C" fn(config: *mut PD_AnalysisConfig), ::libloading::Error>,
    pub PD_ProfileEnabled:
        Result<unsafe extern "C" fn(config: *const PD_AnalysisConfig) -> bool, ::libloading::Error>,
    pub PD_SetInValid:
        Result<unsafe extern "C" fn(config: *mut PD_AnalysisConfig), ::libloading::Error>,
    pub PD_IsValid:
        Result<unsafe extern "C" fn(config: *const PD_AnalysisConfig) -> bool, ::libloading::Error>,
    pub PD_DisableGlogInfo:
        Result<unsafe extern "C" fn(config: *mut PD_AnalysisConfig), ::libloading::Error>,
    pub PD_DeletePass: Result<
        unsafe extern "C" fn(
            config: *mut PD_AnalysisConfig,
            pass_name: *mut ::std::os::raw::c_char,
        ),
        ::libloading::Error,
    >,
    pub PD_NewPredictor: Result<
        unsafe extern "C" fn(config: *const PD_AnalysisConfig) -> *mut PD_Predictor,
        ::libloading::Error,
    >,
    pub PD_DeletePredictor:
        Result<unsafe extern "C" fn(predictor: *mut PD_Predictor), ::libloading::Error>,
    pub PD_GetInputNum: Result<
        unsafe extern "C" fn(arg1: *const PD_Predictor) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub PD_GetOutputNum: Result<
        unsafe extern "C" fn(arg1: *const PD_Predictor) -> ::std::os::raw::c_int,
        ::libloading::Error,
    >,
    pub PD_GetInputName: Result<
        unsafe extern "C" fn(
            arg1: *const PD_Predictor,
            arg2: ::std::os::raw::c_int,
        ) -> *const ::std::os::raw::c_char,
        ::libloading::Error,
    >,
    pub PD_GetOutputName: Result<
        unsafe extern "C" fn(
            arg1: *const PD_Predictor,
            arg2: ::std::os::raw::c_int,
        ) -> *const ::std::os::raw::c_char,
        ::libloading::Error,
    >,
    pub PD_SetZeroCopyInput: Result<
        unsafe extern "C" fn(predictor: *mut PD_Predictor, tensor: *const PD_ZeroCopyTensor),
        ::libloading::Error,
    >,
    pub PD_GetZeroCopyOutput: Result<
        unsafe extern "C" fn(predictor: *mut PD_Predictor, tensor: *mut PD_ZeroCopyTensor),
        ::libloading::Error,
    >,
    pub PD_ZeroCopyRun:
        Result<unsafe extern "C" fn(predictor: *mut PD_Predictor), ::libloading::Error>,
}
impl paddle_fluid_c {
    pub unsafe fn new<P>(path: P) -> Result<Self, ::libloading::Error>
    where
        P: AsRef<::std::ffi::OsStr>,
    {
        let __library = ::libloading::Library::new(path)?;
        let remove = __library.get("remove".as_bytes()).map(|sym| *sym);
        let rename = __library.get("rename".as_bytes()).map(|sym| *sym);
        let renameat = __library.get("renameat".as_bytes()).map(|sym| *sym);
        let tmpfile = __library.get("tmpfile".as_bytes()).map(|sym| *sym);
        let tmpnam = __library.get("tmpnam".as_bytes()).map(|sym| *sym);
        let tmpnam_r = __library.get("tmpnam_r".as_bytes()).map(|sym| *sym);
        let tempnam = __library.get("tempnam".as_bytes()).map(|sym| *sym);
        let fclose = __library.get("fclose".as_bytes()).map(|sym| *sym);
        let fflush = __library.get("fflush".as_bytes()).map(|sym| *sym);
        let fflush_unlocked = __library.get("fflush_unlocked".as_bytes()).map(|sym| *sym);
        let fopen = __library.get("fopen".as_bytes()).map(|sym| *sym);
        let freopen = __library.get("freopen".as_bytes()).map(|sym| *sym);
        let fdopen = __library.get("fdopen".as_bytes()).map(|sym| *sym);
        let fmemopen = __library.get("fmemopen".as_bytes()).map(|sym| *sym);
        let open_memstream = __library.get("open_memstream".as_bytes()).map(|sym| *sym);
        let setbuf = __library.get("setbuf".as_bytes()).map(|sym| *sym);
        let setvbuf = __library.get("setvbuf".as_bytes()).map(|sym| *sym);
        let setbuffer = __library.get("setbuffer".as_bytes()).map(|sym| *sym);
        let setlinebuf = __library.get("setlinebuf".as_bytes()).map(|sym| *sym);
        let fprintf = __library.get("fprintf".as_bytes()).map(|sym| *sym);
        let printf = __library.get("printf".as_bytes()).map(|sym| *sym);
        let sprintf = __library.get("sprintf".as_bytes()).map(|sym| *sym);
        let vfprintf = __library.get("vfprintf".as_bytes()).map(|sym| *sym);
        let vprintf = __library.get("vprintf".as_bytes()).map(|sym| *sym);
        let vsprintf = __library.get("vsprintf".as_bytes()).map(|sym| *sym);
        let snprintf = __library.get("snprintf".as_bytes()).map(|sym| *sym);
        let vsnprintf = __library.get("vsnprintf".as_bytes()).map(|sym| *sym);
        let vdprintf = __library.get("vdprintf".as_bytes()).map(|sym| *sym);
        let dprintf = __library.get("dprintf".as_bytes()).map(|sym| *sym);
        let fscanf = __library.get("fscanf".as_bytes()).map(|sym| *sym);
        let scanf = __library.get("scanf".as_bytes()).map(|sym| *sym);
        let sscanf = __library.get("sscanf".as_bytes()).map(|sym| *sym);
        let fscanf1 = __library.get("fscanf1".as_bytes()).map(|sym| *sym);
        let scanf1 = __library.get("scanf1".as_bytes()).map(|sym| *sym);
        let sscanf1 = __library.get("sscanf1".as_bytes()).map(|sym| *sym);
        let vfscanf = __library.get("vfscanf".as_bytes()).map(|sym| *sym);
        let vscanf = __library.get("vscanf".as_bytes()).map(|sym| *sym);
        let vsscanf = __library.get("vsscanf".as_bytes()).map(|sym| *sym);
        let vfscanf1 = __library.get("vfscanf1".as_bytes()).map(|sym| *sym);
        let vscanf1 = __library.get("vscanf1".as_bytes()).map(|sym| *sym);
        let vsscanf1 = __library.get("vsscanf1".as_bytes()).map(|sym| *sym);
        let fgetc = __library.get("fgetc".as_bytes()).map(|sym| *sym);
        let getc = __library.get("getc".as_bytes()).map(|sym| *sym);
        let getchar = __library.get("getchar".as_bytes()).map(|sym| *sym);
        let getc_unlocked = __library.get("getc_unlocked".as_bytes()).map(|sym| *sym);
        let getchar_unlocked = __library.get("getchar_unlocked".as_bytes()).map(|sym| *sym);
        let fgetc_unlocked = __library.get("fgetc_unlocked".as_bytes()).map(|sym| *sym);
        let fputc = __library.get("fputc".as_bytes()).map(|sym| *sym);
        let putc = __library.get("putc".as_bytes()).map(|sym| *sym);
        let putchar = __library.get("putchar".as_bytes()).map(|sym| *sym);
        let fputc_unlocked = __library.get("fputc_unlocked".as_bytes()).map(|sym| *sym);
        let putc_unlocked = __library.get("putc_unlocked".as_bytes()).map(|sym| *sym);
        let putchar_unlocked = __library.get("putchar_unlocked".as_bytes()).map(|sym| *sym);
        let getw = __library.get("getw".as_bytes()).map(|sym| *sym);
        let putw = __library.get("putw".as_bytes()).map(|sym| *sym);
        let fgets = __library.get("fgets".as_bytes()).map(|sym| *sym);
        let __getdelim = __library.get("__getdelim".as_bytes()).map(|sym| *sym);
        let getdelim = __library.get("getdelim".as_bytes()).map(|sym| *sym);
        let getline = __library.get("getline".as_bytes()).map(|sym| *sym);
        let fputs = __library.get("fputs".as_bytes()).map(|sym| *sym);
        let puts = __library.get("puts".as_bytes()).map(|sym| *sym);
        let ungetc = __library.get("ungetc".as_bytes()).map(|sym| *sym);
        let fread = __library.get("fread".as_bytes()).map(|sym| *sym);
        let fwrite = __library.get("fwrite".as_bytes()).map(|sym| *sym);
        let fread_unlocked = __library.get("fread_unlocked".as_bytes()).map(|sym| *sym);
        let fwrite_unlocked = __library.get("fwrite_unlocked".as_bytes()).map(|sym| *sym);
        let fseek = __library.get("fseek".as_bytes()).map(|sym| *sym);
        let ftell = __library.get("ftell".as_bytes()).map(|sym| *sym);
        let rewind = __library.get("rewind".as_bytes()).map(|sym| *sym);
        let fseeko = __library.get("fseeko".as_bytes()).map(|sym| *sym);
        let ftello = __library.get("ftello".as_bytes()).map(|sym| *sym);
        let fgetpos = __library.get("fgetpos".as_bytes()).map(|sym| *sym);
        let fsetpos = __library.get("fsetpos".as_bytes()).map(|sym| *sym);
        let clearerr = __library.get("clearerr".as_bytes()).map(|sym| *sym);
        let feof = __library.get("feof".as_bytes()).map(|sym| *sym);
        let ferror = __library.get("ferror".as_bytes()).map(|sym| *sym);
        let clearerr_unlocked = __library
            .get("clearerr_unlocked".as_bytes())
            .map(|sym| *sym);
        let feof_unlocked = __library.get("feof_unlocked".as_bytes()).map(|sym| *sym);
        let ferror_unlocked = __library.get("ferror_unlocked".as_bytes()).map(|sym| *sym);
        let perror = __library.get("perror".as_bytes()).map(|sym| *sym);
        let fileno = __library.get("fileno".as_bytes()).map(|sym| *sym);
        let fileno_unlocked = __library.get("fileno_unlocked".as_bytes()).map(|sym| *sym);
        let popen = __library.get("popen".as_bytes()).map(|sym| *sym);
        let pclose = __library.get("pclose".as_bytes()).map(|sym| *sym);
        let ctermid = __library.get("ctermid".as_bytes()).map(|sym| *sym);
        let flockfile = __library.get("flockfile".as_bytes()).map(|sym| *sym);
        let ftrylockfile = __library.get("ftrylockfile".as_bytes()).map(|sym| *sym);
        let funlockfile = __library.get("funlockfile".as_bytes()).map(|sym| *sym);
        let __uflow = __library.get("__uflow".as_bytes()).map(|sym| *sym);
        let __overflow = __library.get("__overflow".as_bytes()).map(|sym| *sym);
        let PD_NewZeroCopyTensor = __library
            .get("PD_NewZeroCopyTensor".as_bytes())
            .map(|sym| *sym);
        let PD_DeleteZeroCopyTensor = __library
            .get("PD_DeleteZeroCopyTensor".as_bytes())
            .map(|sym| *sym);
        let PD_InitZeroCopyTensor = __library
            .get("PD_InitZeroCopyTensor".as_bytes())
            .map(|sym| *sym);
        let PD_DestroyZeroCopyTensor = __library
            .get("PD_DestroyZeroCopyTensor".as_bytes())
            .map(|sym| *sym);
        let PD_NewPaddleBuf = __library.get("PD_NewPaddleBuf".as_bytes()).map(|sym| *sym);
        let PD_DeletePaddleBuf = __library
            .get("PD_DeletePaddleBuf".as_bytes())
            .map(|sym| *sym);
        let PD_PaddleBufResize = __library
            .get("PD_PaddleBufResize".as_bytes())
            .map(|sym| *sym);
        let PD_PaddleBufReset = __library
            .get("PD_PaddleBufReset".as_bytes())
            .map(|sym| *sym);
        let PD_PaddleBufEmpty = __library
            .get("PD_PaddleBufEmpty".as_bytes())
            .map(|sym| *sym);
        let PD_PaddleBufData = __library.get("PD_PaddleBufData".as_bytes()).map(|sym| *sym);
        let PD_PaddleBufLength = __library
            .get("PD_PaddleBufLength".as_bytes())
            .map(|sym| *sym);
        let PD_NewPaddleTensor = __library
            .get("PD_NewPaddleTensor".as_bytes())
            .map(|sym| *sym);
        let PD_DeletePaddleTensor = __library
            .get("PD_DeletePaddleTensor".as_bytes())
            .map(|sym| *sym);
        let PD_SetPaddleTensorName = __library
            .get("PD_SetPaddleTensorName".as_bytes())
            .map(|sym| *sym);
        let PD_SetPaddleTensorDType = __library
            .get("PD_SetPaddleTensorDType".as_bytes())
            .map(|sym| *sym);
        let PD_SetPaddleTensorData = __library
            .get("PD_SetPaddleTensorData".as_bytes())
            .map(|sym| *sym);
        let PD_SetPaddleTensorShape = __library
            .get("PD_SetPaddleTensorShape".as_bytes())
            .map(|sym| *sym);
        let PD_GetPaddleTensorName = __library
            .get("PD_GetPaddleTensorName".as_bytes())
            .map(|sym| *sym);
        let PD_GetPaddleTensorDType = __library
            .get("PD_GetPaddleTensorDType".as_bytes())
            .map(|sym| *sym);
        let PD_GetPaddleTensorData = __library
            .get("PD_GetPaddleTensorData".as_bytes())
            .map(|sym| *sym);
        let PD_GetPaddleTensorShape = __library
            .get("PD_GetPaddleTensorShape".as_bytes())
            .map(|sym| *sym);
        let PD_PredictorRun = __library.get("PD_PredictorRun".as_bytes()).map(|sym| *sym);
        let PD_PredictorZeroCopyRun = __library
            .get("PD_PredictorZeroCopyRun".as_bytes())
            .map(|sym| *sym);
        let PD_NewAnalysisConfig = __library
            .get("PD_NewAnalysisConfig".as_bytes())
            .map(|sym| *sym);
        let PD_DeleteAnalysisConfig = __library
            .get("PD_DeleteAnalysisConfig".as_bytes())
            .map(|sym| *sym);
        let PD_SetModel = __library.get("PD_SetModel".as_bytes()).map(|sym| *sym);
        let PD_SetProgFile = __library.get("PD_SetProgFile".as_bytes()).map(|sym| *sym);
        let PD_SetParamsFile = __library.get("PD_SetParamsFile".as_bytes()).map(|sym| *sym);
        let PD_SetOptimCacheDir = __library
            .get("PD_SetOptimCacheDir".as_bytes())
            .map(|sym| *sym);
        let PD_ModelDir = __library.get("PD_ModelDir".as_bytes()).map(|sym| *sym);
        let PD_ProgFile = __library.get("PD_ProgFile".as_bytes()).map(|sym| *sym);
        let PD_ParamsFile = __library.get("PD_ParamsFile".as_bytes()).map(|sym| *sym);
        let PD_EnableUseGpu = __library.get("PD_EnableUseGpu".as_bytes()).map(|sym| *sym);
        let PD_DisableGpu = __library.get("PD_DisableGpu".as_bytes()).map(|sym| *sym);
        let PD_UseGpu = __library.get("PD_UseGpu".as_bytes()).map(|sym| *sym);
        let PD_GpuDeviceId = __library.get("PD_GpuDeviceId".as_bytes()).map(|sym| *sym);
        let PD_MemoryPoolInitSizeMb = __library
            .get("PD_MemoryPoolInitSizeMb".as_bytes())
            .map(|sym| *sym);
        let PD_FractionOfGpuMemoryForPool = __library
            .get("PD_FractionOfGpuMemoryForPool".as_bytes())
            .map(|sym| *sym);
        let PD_EnableCUDNN = __library.get("PD_EnableCUDNN".as_bytes()).map(|sym| *sym);
        let PD_CudnnEnabled = __library.get("PD_CudnnEnabled".as_bytes()).map(|sym| *sym);
        let PD_SwitchIrOptim = __library.get("PD_SwitchIrOptim".as_bytes()).map(|sym| *sym);
        let PD_IrOptim = __library.get("PD_IrOptim".as_bytes()).map(|sym| *sym);
        let PD_SwitchUseFeedFetchOps = __library
            .get("PD_SwitchUseFeedFetchOps".as_bytes())
            .map(|sym| *sym);
        let PD_UseFeedFetchOpsEnabled = __library
            .get("PD_UseFeedFetchOpsEnabled".as_bytes())
            .map(|sym| *sym);
        let PD_SwitchSpecifyInputNames = __library
            .get("PD_SwitchSpecifyInputNames".as_bytes())
            .map(|sym| *sym);
        let PD_SpecifyInputName = __library
            .get("PD_SpecifyInputName".as_bytes())
            .map(|sym| *sym);
        let PD_EnableTensorRtEngine = __library
            .get("PD_EnableTensorRtEngine".as_bytes())
            .map(|sym| *sym);
        let PD_TensorrtEngineEnabled = __library
            .get("PD_TensorrtEngineEnabled".as_bytes())
            .map(|sym| *sym);
        let PD_SwitchIrDebug = __library.get("PD_SwitchIrDebug".as_bytes()).map(|sym| *sym);
        let PD_EnableMKLDNN = __library.get("PD_EnableMKLDNN".as_bytes()).map(|sym| *sym);
        let PD_SetMkldnnCacheCapacity = __library
            .get("PD_SetMkldnnCacheCapacity".as_bytes())
            .map(|sym| *sym);
        let PD_MkldnnEnabled = __library.get("PD_MkldnnEnabled".as_bytes()).map(|sym| *sym);
        let PD_SetCpuMathLibraryNumThreads = __library
            .get("PD_SetCpuMathLibraryNumThreads".as_bytes())
            .map(|sym| *sym);
        let PD_CpuMathLibraryNumThreads = __library
            .get("PD_CpuMathLibraryNumThreads".as_bytes())
            .map(|sym| *sym);
        let PD_EnableMkldnnQuantizer = __library
            .get("PD_EnableMkldnnQuantizer".as_bytes())
            .map(|sym| *sym);
        let PD_MkldnnQuantizerEnabled = __library
            .get("PD_MkldnnQuantizerEnabled".as_bytes())
            .map(|sym| *sym);
        let PD_EnableMkldnnBfloat16 = __library
            .get("PD_EnableMkldnnBfloat16".as_bytes())
            .map(|sym| *sym);
        let PD_MkldnnBfloat16Enabled = __library
            .get("PD_MkldnnBfloat16Enabled".as_bytes())
            .map(|sym| *sym);
        let PD_SetModelBuffer = __library
            .get("PD_SetModelBuffer".as_bytes())
            .map(|sym| *sym);
        let PD_ModelFromMemory = __library
            .get("PD_ModelFromMemory".as_bytes())
            .map(|sym| *sym);
        let PD_EnableMemoryOptim = __library
            .get("PD_EnableMemoryOptim".as_bytes())
            .map(|sym| *sym);
        let PD_MemoryOptimEnabled = __library
            .get("PD_MemoryOptimEnabled".as_bytes())
            .map(|sym| *sym);
        let PD_EnableProfile = __library.get("PD_EnableProfile".as_bytes()).map(|sym| *sym);
        let PD_ProfileEnabled = __library
            .get("PD_ProfileEnabled".as_bytes())
            .map(|sym| *sym);
        let PD_SetInValid = __library.get("PD_SetInValid".as_bytes()).map(|sym| *sym);
        let PD_IsValid = __library.get("PD_IsValid".as_bytes()).map(|sym| *sym);
        let PD_DisableGlogInfo = __library
            .get("PD_DisableGlogInfo".as_bytes())
            .map(|sym| *sym);
        let PD_DeletePass = __library.get("PD_DeletePass".as_bytes()).map(|sym| *sym);
        let PD_NewPredictor = __library.get("PD_NewPredictor".as_bytes()).map(|sym| *sym);
        let PD_DeletePredictor = __library
            .get("PD_DeletePredictor".as_bytes())
            .map(|sym| *sym);
        let PD_GetInputNum = __library.get("PD_GetInputNum".as_bytes()).map(|sym| *sym);
        let PD_GetOutputNum = __library.get("PD_GetOutputNum".as_bytes()).map(|sym| *sym);
        let PD_GetInputName = __library.get("PD_GetInputName".as_bytes()).map(|sym| *sym);
        let PD_GetOutputName = __library.get("PD_GetOutputName".as_bytes()).map(|sym| *sym);
        let PD_SetZeroCopyInput = __library
            .get("PD_SetZeroCopyInput".as_bytes())
            .map(|sym| *sym);
        let PD_GetZeroCopyOutput = __library
            .get("PD_GetZeroCopyOutput".as_bytes())
            .map(|sym| *sym);
        let PD_ZeroCopyRun = __library.get("PD_ZeroCopyRun".as_bytes()).map(|sym| *sym);
        Ok(paddle_fluid_c {
            __library,
            remove,
            rename,
            renameat,
            tmpfile,
            tmpnam,
            tmpnam_r,
            tempnam,
            fclose,
            fflush,
            fflush_unlocked,
            fopen,
            freopen,
            fdopen,
            fmemopen,
            open_memstream,
            setbuf,
            setvbuf,
            setbuffer,
            setlinebuf,
            fprintf,
            printf,
            sprintf,
            vfprintf,
            vprintf,
            vsprintf,
            snprintf,
            vsnprintf,
            vdprintf,
            dprintf,
            fscanf,
            scanf,
            sscanf,
            fscanf1,
            scanf1,
            sscanf1,
            vfscanf,
            vscanf,
            vsscanf,
            vfscanf1,
            vscanf1,
            vsscanf1,
            fgetc,
            getc,
            getchar,
            getc_unlocked,
            getchar_unlocked,
            fgetc_unlocked,
            fputc,
            putc,
            putchar,
            fputc_unlocked,
            putc_unlocked,
            putchar_unlocked,
            getw,
            putw,
            fgets,
            __getdelim,
            getdelim,
            getline,
            fputs,
            puts,
            ungetc,
            fread,
            fwrite,
            fread_unlocked,
            fwrite_unlocked,
            fseek,
            ftell,
            rewind,
            fseeko,
            ftello,
            fgetpos,
            fsetpos,
            clearerr,
            feof,
            ferror,
            clearerr_unlocked,
            feof_unlocked,
            ferror_unlocked,
            perror,
            fileno,
            fileno_unlocked,
            popen,
            pclose,
            ctermid,
            flockfile,
            ftrylockfile,
            funlockfile,
            __uflow,
            __overflow,
            PD_NewZeroCopyTensor,
            PD_DeleteZeroCopyTensor,
            PD_InitZeroCopyTensor,
            PD_DestroyZeroCopyTensor,
            PD_NewPaddleBuf,
            PD_DeletePaddleBuf,
            PD_PaddleBufResize,
            PD_PaddleBufReset,
            PD_PaddleBufEmpty,
            PD_PaddleBufData,
            PD_PaddleBufLength,
            PD_NewPaddleTensor,
            PD_DeletePaddleTensor,
            PD_SetPaddleTensorName,
            PD_SetPaddleTensorDType,
            PD_SetPaddleTensorData,
            PD_SetPaddleTensorShape,
            PD_GetPaddleTensorName,
            PD_GetPaddleTensorDType,
            PD_GetPaddleTensorData,
            PD_GetPaddleTensorShape,
            PD_PredictorRun,
            PD_PredictorZeroCopyRun,
            PD_NewAnalysisConfig,
            PD_DeleteAnalysisConfig,
            PD_SetModel,
            PD_SetProgFile,
            PD_SetParamsFile,
            PD_SetOptimCacheDir,
            PD_ModelDir,
            PD_ProgFile,
            PD_ParamsFile,
            PD_EnableUseGpu,
            PD_DisableGpu,
            PD_UseGpu,
            PD_GpuDeviceId,
            PD_MemoryPoolInitSizeMb,
            PD_FractionOfGpuMemoryForPool,
            PD_EnableCUDNN,
            PD_CudnnEnabled,
            PD_SwitchIrOptim,
            PD_IrOptim,
            PD_SwitchUseFeedFetchOps,
            PD_UseFeedFetchOpsEnabled,
            PD_SwitchSpecifyInputNames,
            PD_SpecifyInputName,
            PD_EnableTensorRtEngine,
            PD_TensorrtEngineEnabled,
            PD_SwitchIrDebug,
            PD_EnableMKLDNN,
            PD_SetMkldnnCacheCapacity,
            PD_MkldnnEnabled,
            PD_SetCpuMathLibraryNumThreads,
            PD_CpuMathLibraryNumThreads,
            PD_EnableMkldnnQuantizer,
            PD_MkldnnQuantizerEnabled,
            PD_EnableMkldnnBfloat16,
            PD_MkldnnBfloat16Enabled,
            PD_SetModelBuffer,
            PD_ModelFromMemory,
            PD_EnableMemoryOptim,
            PD_MemoryOptimEnabled,
            PD_EnableProfile,
            PD_ProfileEnabled,
            PD_SetInValid,
            PD_IsValid,
            PD_DisableGlogInfo,
            PD_DeletePass,
            PD_NewPredictor,
            PD_DeletePredictor,
            PD_GetInputNum,
            PD_GetOutputNum,
            PD_GetInputName,
            PD_GetOutputName,
            PD_SetZeroCopyInput,
            PD_GetZeroCopyOutput,
            PD_ZeroCopyRun,
        })
    }
    pub unsafe fn remove(
        &self,
        __filename: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int {
        let sym = self.remove.as_ref().expect("Expected function, got error.");
        (sym)(__filename)
    }
    pub unsafe fn rename(
        &self,
        __old: *const ::std::os::raw::c_char,
        __new: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int {
        let sym = self.rename.as_ref().expect("Expected function, got error.");
        (sym)(__old, __new)
    }
    pub unsafe fn renameat(
        &self,
        __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 {
        let sym = self
            .renameat
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__oldfd, __old, __newfd, __new)
    }
    pub unsafe fn tmpfile(&self) -> *mut FILE {
        let sym = self
            .tmpfile
            .as_ref()
            .expect("Expected function, got error.");
        (sym)()
    }
    pub unsafe fn tmpnam(&self, __s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char {
        let sym = self.tmpnam.as_ref().expect("Expected function, got error.");
        (sym)(__s)
    }
    pub unsafe fn tmpnam_r(&self, __s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char {
        let sym = self
            .tmpnam_r
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__s)
    }
    pub unsafe fn tempnam(
        &self,
        __dir: *const ::std::os::raw::c_char,
        __pfx: *const ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_char {
        let sym = self
            .tempnam
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__dir, __pfx)
    }
    pub unsafe fn fclose(&self, __stream: *mut FILE) -> ::std::os::raw::c_int {
        let sym = self.fclose.as_ref().expect("Expected function, got error.");
        (sym)(__stream)
    }
    pub unsafe fn fflush(&self, __stream: *mut FILE) -> ::std::os::raw::c_int {
        let sym = self.fflush.as_ref().expect("Expected function, got error.");
        (sym)(__stream)
    }
    pub unsafe fn fflush_unlocked(&self, __stream: *mut FILE) -> ::std::os::raw::c_int {
        let sym = self
            .fflush_unlocked
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__stream)
    }
    pub unsafe fn fopen(
        &self,
        __filename: *const ::std::os::raw::c_char,
        __modes: *const ::std::os::raw::c_char,
    ) -> *mut FILE {
        let sym = self.fopen.as_ref().expect("Expected function, got error.");
        (sym)(__filename, __modes)
    }
    pub unsafe fn freopen(
        &self,
        __filename: *const ::std::os::raw::c_char,
        __modes: *const ::std::os::raw::c_char,
        __stream: *mut FILE,
    ) -> *mut FILE {
        let sym = self
            .freopen
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__filename, __modes, __stream)
    }
    pub unsafe fn fdopen(
        &self,
        __fd: ::std::os::raw::c_int,
        __modes: *const ::std::os::raw::c_char,
    ) -> *mut FILE {
        let sym = self.fdopen.as_ref().expect("Expected function, got error.");
        (sym)(__fd, __modes)
    }
    pub unsafe fn fmemopen(
        &self,
        __s: *mut ::std::os::raw::c_void,
        __len: size_t,
        __modes: *const ::std::os::raw::c_char,
    ) -> *mut FILE {
        let sym = self
            .fmemopen
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__s, __len, __modes)
    }
    pub unsafe fn open_memstream(
        &self,
        __bufloc: *mut *mut ::std::os::raw::c_char,
        __sizeloc: *mut size_t,
    ) -> *mut FILE {
        let sym = self
            .open_memstream
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__bufloc, __sizeloc)
    }
    pub unsafe fn setbuf(&self, __stream: *mut FILE, __buf: *mut ::std::os::raw::c_char) -> () {
        let sym = self.setbuf.as_ref().expect("Expected function, got error.");
        (sym)(__stream, __buf)
    }
    pub unsafe fn setvbuf(
        &self,
        __stream: *mut FILE,
        __buf: *mut ::std::os::raw::c_char,
        __modes: ::std::os::raw::c_int,
        __n: size_t,
    ) -> ::std::os::raw::c_int {
        let sym = self
            .setvbuf
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__stream, __buf, __modes, __n)
    }
    pub unsafe fn setbuffer(
        &self,
        __stream: *mut FILE,
        __buf: *mut ::std::os::raw::c_char,
        __size: size_t,
    ) -> () {
        let sym = self
            .setbuffer
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__stream, __buf, __size)
    }
    pub unsafe fn setlinebuf(&self, __stream: *mut FILE) -> () {
        let sym = self
            .setlinebuf
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__stream)
    }
    pub unsafe fn vfprintf(
        &self,
        __s: *mut FILE,
        __format: *const ::std::os::raw::c_char,
        __arg: *mut __va_list_tag,
    ) -> ::std::os::raw::c_int {
        let sym = self
            .vfprintf
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__s, __format, __arg)
    }
    pub unsafe fn vprintf(
        &self,
        __format: *const ::std::os::raw::c_char,
        __arg: *mut __va_list_tag,
    ) -> ::std::os::raw::c_int {
        let sym = self
            .vprintf
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__format, __arg)
    }
    pub unsafe fn vsprintf(
        &self,
        __s: *mut ::std::os::raw::c_char,
        __format: *const ::std::os::raw::c_char,
        __arg: *mut __va_list_tag,
    ) -> ::std::os::raw::c_int {
        let sym = self
            .vsprintf
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__s, __format, __arg)
    }
    pub unsafe fn vsnprintf(
        &self,
        __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 {
        let sym = self
            .vsnprintf
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__s, __maxlen, __format, __arg)
    }
    pub unsafe fn vdprintf(
        &self,
        __fd: ::std::os::raw::c_int,
        __fmt: *const ::std::os::raw::c_char,
        __arg: *mut __va_list_tag,
    ) -> ::std::os::raw::c_int {
        let sym = self
            .vdprintf
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__fd, __fmt, __arg)
    }
    pub unsafe fn vfscanf(
        &self,
        __s: *mut FILE,
        __format: *const ::std::os::raw::c_char,
        __arg: *mut __va_list_tag,
    ) -> ::std::os::raw::c_int {
        let sym = self
            .vfscanf
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__s, __format, __arg)
    }
    pub unsafe fn vscanf(
        &self,
        __format: *const ::std::os::raw::c_char,
        __arg: *mut __va_list_tag,
    ) -> ::std::os::raw::c_int {
        let sym = self.vscanf.as_ref().expect("Expected function, got error.");
        (sym)(__format, __arg)
    }
    pub unsafe fn vsscanf(
        &self,
        __s: *const ::std::os::raw::c_char,
        __format: *const ::std::os::raw::c_char,
        __arg: *mut __va_list_tag,
    ) -> ::std::os::raw::c_int {
        let sym = self
            .vsscanf
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__s, __format, __arg)
    }
    pub unsafe fn vfscanf1(
        &self,
        __s: *mut FILE,
        __format: *const ::std::os::raw::c_char,
        __arg: *mut __va_list_tag,
    ) -> ::std::os::raw::c_int {
        let sym = self
            .vfscanf1
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__s, __format, __arg)
    }
    pub unsafe fn vscanf1(
        &self,
        __format: *const ::std::os::raw::c_char,
        __arg: *mut __va_list_tag,
    ) -> ::std::os::raw::c_int {
        let sym = self
            .vscanf1
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__format, __arg)
    }
    pub unsafe fn vsscanf1(
        &self,
        __s: *const ::std::os::raw::c_char,
        __format: *const ::std::os::raw::c_char,
        __arg: *mut __va_list_tag,
    ) -> ::std::os::raw::c_int {
        let sym = self
            .vsscanf1
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__s, __format, __arg)
    }
    pub unsafe fn fgetc(&self, __stream: *mut FILE) -> ::std::os::raw::c_int {
        let sym = self.fgetc.as_ref().expect("Expected function, got error.");
        (sym)(__stream)
    }
    pub unsafe fn getc(&self, __stream: *mut FILE) -> ::std::os::raw::c_int {
        let sym = self.getc.as_ref().expect("Expected function, got error.");
        (sym)(__stream)
    }
    pub unsafe fn getchar(&self) -> ::std::os::raw::c_int {
        let sym = self
            .getchar
            .as_ref()
            .expect("Expected function, got error.");
        (sym)()
    }
    pub unsafe fn getc_unlocked(&self, __stream: *mut FILE) -> ::std::os::raw::c_int {
        let sym = self
            .getc_unlocked
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__stream)
    }
    pub unsafe fn getchar_unlocked(&self) -> ::std::os::raw::c_int {
        let sym = self
            .getchar_unlocked
            .as_ref()
            .expect("Expected function, got error.");
        (sym)()
    }
    pub unsafe fn fgetc_unlocked(&self, __stream: *mut FILE) -> ::std::os::raw::c_int {
        let sym = self
            .fgetc_unlocked
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__stream)
    }
    pub unsafe fn fputc(
        &self,
        __c: ::std::os::raw::c_int,
        __stream: *mut FILE,
    ) -> ::std::os::raw::c_int {
        let sym = self.fputc.as_ref().expect("Expected function, got error.");
        (sym)(__c, __stream)
    }
    pub unsafe fn putc(
        &self,
        __c: ::std::os::raw::c_int,
        __stream: *mut FILE,
    ) -> ::std::os::raw::c_int {
        let sym = self.putc.as_ref().expect("Expected function, got error.");
        (sym)(__c, __stream)
    }
    pub unsafe fn putchar(&self, __c: ::std::os::raw::c_int) -> ::std::os::raw::c_int {
        let sym = self
            .putchar
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__c)
    }
    pub unsafe fn fputc_unlocked(
        &self,
        __c: ::std::os::raw::c_int,
        __stream: *mut FILE,
    ) -> ::std::os::raw::c_int {
        let sym = self
            .fputc_unlocked
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__c, __stream)
    }
    pub unsafe fn putc_unlocked(
        &self,
        __c: ::std::os::raw::c_int,
        __stream: *mut FILE,
    ) -> ::std::os::raw::c_int {
        let sym = self
            .putc_unlocked
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__c, __stream)
    }
    pub unsafe fn putchar_unlocked(&self, __c: ::std::os::raw::c_int) -> ::std::os::raw::c_int {
        let sym = self
            .putchar_unlocked
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__c)
    }
    pub unsafe fn getw(&self, __stream: *mut FILE) -> ::std::os::raw::c_int {
        let sym = self.getw.as_ref().expect("Expected function, got error.");
        (sym)(__stream)
    }
    pub unsafe fn putw(
        &self,
        __w: ::std::os::raw::c_int,
        __stream: *mut FILE,
    ) -> ::std::os::raw::c_int {
        let sym = self.putw.as_ref().expect("Expected function, got error.");
        (sym)(__w, __stream)
    }
    pub unsafe fn fgets(
        &self,
        __s: *mut ::std::os::raw::c_char,
        __n: ::std::os::raw::c_int,
        __stream: *mut FILE,
    ) -> *mut ::std::os::raw::c_char {
        let sym = self.fgets.as_ref().expect("Expected function, got error.");
        (sym)(__s, __n, __stream)
    }
    pub unsafe fn __getdelim(
        &self,
        __lineptr: *mut *mut ::std::os::raw::c_char,
        __n: *mut size_t,
        __delimiter: ::std::os::raw::c_int,
        __stream: *mut FILE,
    ) -> __ssize_t {
        let sym = self
            .__getdelim
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__lineptr, __n, __delimiter, __stream)
    }
    pub unsafe fn getdelim(
        &self,
        __lineptr: *mut *mut ::std::os::raw::c_char,
        __n: *mut size_t,
        __delimiter: ::std::os::raw::c_int,
        __stream: *mut FILE,
    ) -> __ssize_t {
        let sym = self
            .getdelim
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__lineptr, __n, __delimiter, __stream)
    }
    pub unsafe fn getline(
        &self,
        __lineptr: *mut *mut ::std::os::raw::c_char,
        __n: *mut size_t,
        __stream: *mut FILE,
    ) -> __ssize_t {
        let sym = self
            .getline
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__lineptr, __n, __stream)
    }
    pub unsafe fn fputs(
        &self,
        __s: *const ::std::os::raw::c_char,
        __stream: *mut FILE,
    ) -> ::std::os::raw::c_int {
        let sym = self.fputs.as_ref().expect("Expected function, got error.");
        (sym)(__s, __stream)
    }
    pub unsafe fn puts(&self, __s: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int {
        let sym = self.puts.as_ref().expect("Expected function, got error.");
        (sym)(__s)
    }
    pub unsafe fn ungetc(
        &self,
        __c: ::std::os::raw::c_int,
        __stream: *mut FILE,
    ) -> ::std::os::raw::c_int {
        let sym = self.ungetc.as_ref().expect("Expected function, got error.");
        (sym)(__c, __stream)
    }
    pub unsafe fn fread(
        &self,
        __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 {
        let sym = self.fread.as_ref().expect("Expected function, got error.");
        (sym)(__ptr, __size, __n, __stream)
    }
    pub unsafe fn fwrite(
        &self,
        __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 {
        let sym = self.fwrite.as_ref().expect("Expected function, got error.");
        (sym)(__ptr, __size, __n, __s)
    }
    pub unsafe fn fread_unlocked(
        &self,
        __ptr: *mut ::std::os::raw::c_void,
        __size: size_t,
        __n: size_t,
        __stream: *mut FILE,
    ) -> size_t {
        let sym = self
            .fread_unlocked
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__ptr, __size, __n, __stream)
    }
    pub unsafe fn fwrite_unlocked(
        &self,
        __ptr: *const ::std::os::raw::c_void,
        __size: size_t,
        __n: size_t,
        __stream: *mut FILE,
    ) -> size_t {
        let sym = self
            .fwrite_unlocked
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__ptr, __size, __n, __stream)
    }
    pub unsafe fn fseek(
        &self,
        __stream: *mut FILE,
        __off: ::std::os::raw::c_long,
        __whence: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int {
        let sym = self.fseek.as_ref().expect("Expected function, got error.");
        (sym)(__stream, __off, __whence)
    }
    pub unsafe fn ftell(&self, __stream: *mut FILE) -> ::std::os::raw::c_long {
        let sym = self.ftell.as_ref().expect("Expected function, got error.");
        (sym)(__stream)
    }
    pub unsafe fn rewind(&self, __stream: *mut FILE) -> () {
        let sym = self.rewind.as_ref().expect("Expected function, got error.");
        (sym)(__stream)
    }
    pub unsafe fn fseeko(
        &self,
        __stream: *mut FILE,
        __off: __off_t,
        __whence: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int {
        let sym = self.fseeko.as_ref().expect("Expected function, got error.");
        (sym)(__stream, __off, __whence)
    }
    pub unsafe fn ftello(&self, __stream: *mut FILE) -> __off_t {
        let sym = self.ftello.as_ref().expect("Expected function, got error.");
        (sym)(__stream)
    }
    pub unsafe fn fgetpos(&self, __stream: *mut FILE, __pos: *mut fpos_t) -> ::std::os::raw::c_int {
        let sym = self
            .fgetpos
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__stream, __pos)
    }
    pub unsafe fn fsetpos(
        &self,
        __stream: *mut FILE,
        __pos: *const fpos_t,
    ) -> ::std::os::raw::c_int {
        let sym = self
            .fsetpos
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__stream, __pos)
    }
    pub unsafe fn clearerr(&self, __stream: *mut FILE) -> () {
        let sym = self
            .clearerr
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__stream)
    }
    pub unsafe fn feof(&self, __stream: *mut FILE) -> ::std::os::raw::c_int {
        let sym = self.feof.as_ref().expect("Expected function, got error.");
        (sym)(__stream)
    }
    pub unsafe fn ferror(&self, __stream: *mut FILE) -> ::std::os::raw::c_int {
        let sym = self.ferror.as_ref().expect("Expected function, got error.");
        (sym)(__stream)
    }
    pub unsafe fn clearerr_unlocked(&self, __stream: *mut FILE) -> () {
        let sym = self
            .clearerr_unlocked
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__stream)
    }
    pub unsafe fn feof_unlocked(&self, __stream: *mut FILE) -> ::std::os::raw::c_int {
        let sym = self
            .feof_unlocked
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__stream)
    }
    pub unsafe fn ferror_unlocked(&self, __stream: *mut FILE) -> ::std::os::raw::c_int {
        let sym = self
            .ferror_unlocked
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__stream)
    }
    pub unsafe fn perror(&self, __s: *const ::std::os::raw::c_char) -> () {
        let sym = self.perror.as_ref().expect("Expected function, got error.");
        (sym)(__s)
    }
    pub unsafe fn fileno(&self, __stream: *mut FILE) -> ::std::os::raw::c_int {
        let sym = self.fileno.as_ref().expect("Expected function, got error.");
        (sym)(__stream)
    }
    pub unsafe fn fileno_unlocked(&self, __stream: *mut FILE) -> ::std::os::raw::c_int {
        let sym = self
            .fileno_unlocked
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__stream)
    }
    pub unsafe fn popen(
        &self,
        __command: *const ::std::os::raw::c_char,
        __modes: *const ::std::os::raw::c_char,
    ) -> *mut FILE {
        let sym = self.popen.as_ref().expect("Expected function, got error.");
        (sym)(__command, __modes)
    }
    pub unsafe fn pclose(&self, __stream: *mut FILE) -> ::std::os::raw::c_int {
        let sym = self.pclose.as_ref().expect("Expected function, got error.");
        (sym)(__stream)
    }
    pub unsafe fn ctermid(&self, __s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char {
        let sym = self
            .ctermid
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__s)
    }
    pub unsafe fn flockfile(&self, __stream: *mut FILE) -> () {
        let sym = self
            .flockfile
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__stream)
    }
    pub unsafe fn ftrylockfile(&self, __stream: *mut FILE) -> ::std::os::raw::c_int {
        let sym = self
            .ftrylockfile
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__stream)
    }
    pub unsafe fn funlockfile(&self, __stream: *mut FILE) -> () {
        let sym = self
            .funlockfile
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(__stream)
    }
    pub unsafe fn __uflow(&self, arg1: *mut FILE) -> ::std::os::raw::c_int {
        let sym = self
            .__uflow
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(arg1)
    }
    pub unsafe fn __overflow(
        &self,
        arg1: *mut FILE,
        arg2: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int {
        let sym = self
            .__overflow
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(arg1, arg2)
    }
    pub unsafe fn PD_NewZeroCopyTensor(&self) -> *mut PD_ZeroCopyTensor {
        let sym = self
            .PD_NewZeroCopyTensor
            .as_ref()
            .expect("Expected function, got error.");
        (sym)()
    }
    pub unsafe fn PD_DeleteZeroCopyTensor(&self, arg1: *mut PD_ZeroCopyTensor) -> () {
        let sym = self
            .PD_DeleteZeroCopyTensor
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(arg1)
    }
    pub unsafe fn PD_InitZeroCopyTensor(&self, arg1: *mut PD_ZeroCopyTensor) -> () {
        let sym = self
            .PD_InitZeroCopyTensor
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(arg1)
    }
    pub unsafe fn PD_DestroyZeroCopyTensor(&self, arg1: *mut PD_ZeroCopyTensor) -> () {
        let sym = self
            .PD_DestroyZeroCopyTensor
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(arg1)
    }
    pub unsafe fn PD_NewPaddleBuf(&self) -> *mut PD_PaddleBuf {
        let sym = self
            .PD_NewPaddleBuf
            .as_ref()
            .expect("Expected function, got error.");
        (sym)()
    }
    pub unsafe fn PD_DeletePaddleBuf(&self, buf: *mut PD_PaddleBuf) -> () {
        let sym = self
            .PD_DeletePaddleBuf
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(buf)
    }
    pub unsafe fn PD_PaddleBufResize(&self, buf: *mut PD_PaddleBuf, length: size_t) -> () {
        let sym = self
            .PD_PaddleBufResize
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(buf, length)
    }
    pub unsafe fn PD_PaddleBufReset(
        &self,
        buf: *mut PD_PaddleBuf,
        data: *mut ::std::os::raw::c_void,
        length: size_t,
    ) -> () {
        let sym = self
            .PD_PaddleBufReset
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(buf, data, length)
    }
    pub unsafe fn PD_PaddleBufEmpty(&self, buf: *mut PD_PaddleBuf) -> bool {
        let sym = self
            .PD_PaddleBufEmpty
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(buf)
    }
    pub unsafe fn PD_PaddleBufData(&self, buf: *mut PD_PaddleBuf) -> *mut ::std::os::raw::c_void {
        let sym = self
            .PD_PaddleBufData
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(buf)
    }
    pub unsafe fn PD_PaddleBufLength(&self, buf: *mut PD_PaddleBuf) -> size_t {
        let sym = self
            .PD_PaddleBufLength
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(buf)
    }
    pub unsafe fn PD_NewPaddleTensor(&self) -> *mut PD_Tensor {
        let sym = self
            .PD_NewPaddleTensor
            .as_ref()
            .expect("Expected function, got error.");
        (sym)()
    }
    pub unsafe fn PD_DeletePaddleTensor(&self, tensor: *mut PD_Tensor) -> () {
        let sym = self
            .PD_DeletePaddleTensor
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(tensor)
    }
    pub unsafe fn PD_SetPaddleTensorName(
        &self,
        tensor: *mut PD_Tensor,
        name: *mut ::std::os::raw::c_char,
    ) -> () {
        let sym = self
            .PD_SetPaddleTensorName
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(tensor, name)
    }
    pub unsafe fn PD_SetPaddleTensorDType(&self, tensor: *mut PD_Tensor, dtype: PD_DataType) -> () {
        let sym = self
            .PD_SetPaddleTensorDType
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(tensor, dtype)
    }
    pub unsafe fn PD_SetPaddleTensorData(
        &self,
        tensor: *mut PD_Tensor,
        buf: *mut PD_PaddleBuf,
    ) -> () {
        let sym = self
            .PD_SetPaddleTensorData
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(tensor, buf)
    }
    pub unsafe fn PD_SetPaddleTensorShape(
        &self,
        tensor: *mut PD_Tensor,
        shape: *mut ::std::os::raw::c_int,
        size: ::std::os::raw::c_int,
    ) -> () {
        let sym = self
            .PD_SetPaddleTensorShape
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(tensor, shape, size)
    }
    pub unsafe fn PD_GetPaddleTensorName(
        &self,
        tensor: *const PD_Tensor,
    ) -> *const ::std::os::raw::c_char {
        let sym = self
            .PD_GetPaddleTensorName
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(tensor)
    }
    pub unsafe fn PD_GetPaddleTensorDType(&self, tensor: *const PD_Tensor) -> PD_DataType {
        let sym = self
            .PD_GetPaddleTensorDType
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(tensor)
    }
    pub unsafe fn PD_GetPaddleTensorData(&self, tensor: *const PD_Tensor) -> *mut PD_PaddleBuf {
        let sym = self
            .PD_GetPaddleTensorData
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(tensor)
    }
    pub unsafe fn PD_GetPaddleTensorShape(
        &self,
        tensor: *const PD_Tensor,
        size: *mut ::std::os::raw::c_int,
    ) -> *const ::std::os::raw::c_int {
        let sym = self
            .PD_GetPaddleTensorShape
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(tensor, size)
    }
    pub unsafe fn PD_PredictorRun(
        &self,
        config: *const PD_AnalysisConfig,
        inputs: *mut PD_Tensor,
        in_size: ::std::os::raw::c_int,
        output_data: *mut *mut PD_Tensor,
        out_size: *mut ::std::os::raw::c_int,
        batch_size: ::std::os::raw::c_int,
    ) -> bool {
        let sym = self
            .PD_PredictorRun
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config, inputs, in_size, output_data, out_size, batch_size)
    }
    pub unsafe fn PD_PredictorZeroCopyRun(
        &self,
        config: *const PD_AnalysisConfig,
        inputs: *mut PD_ZeroCopyData,
        in_size: ::std::os::raw::c_int,
        output: *mut *mut PD_ZeroCopyData,
        out_size: *mut ::std::os::raw::c_int,
    ) -> bool {
        let sym = self
            .PD_PredictorZeroCopyRun
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config, inputs, in_size, output, out_size)
    }
    pub unsafe fn PD_NewAnalysisConfig(&self) -> *mut PD_AnalysisConfig {
        let sym = self
            .PD_NewAnalysisConfig
            .as_ref()
            .expect("Expected function, got error.");
        (sym)()
    }
    pub unsafe fn PD_DeleteAnalysisConfig(&self, config: *mut PD_AnalysisConfig) -> () {
        let sym = self
            .PD_DeleteAnalysisConfig
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config)
    }
    pub unsafe fn PD_SetModel(
        &self,
        config: *mut PD_AnalysisConfig,
        model_dir: *const ::std::os::raw::c_char,
        params_path: *const ::std::os::raw::c_char,
    ) -> () {
        let sym = self
            .PD_SetModel
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config, model_dir, params_path)
    }
    pub unsafe fn PD_SetProgFile(
        &self,
        config: *mut PD_AnalysisConfig,
        x: *const ::std::os::raw::c_char,
    ) -> () {
        let sym = self
            .PD_SetProgFile
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config, x)
    }
    pub unsafe fn PD_SetParamsFile(
        &self,
        config: *mut PD_AnalysisConfig,
        x: *const ::std::os::raw::c_char,
    ) -> () {
        let sym = self
            .PD_SetParamsFile
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config, x)
    }
    pub unsafe fn PD_SetOptimCacheDir(
        &self,
        config: *mut PD_AnalysisConfig,
        opt_cache_dir: *const ::std::os::raw::c_char,
    ) -> () {
        let sym = self
            .PD_SetOptimCacheDir
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config, opt_cache_dir)
    }
    pub unsafe fn PD_ModelDir(
        &self,
        config: *const PD_AnalysisConfig,
    ) -> *const ::std::os::raw::c_char {
        let sym = self
            .PD_ModelDir
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config)
    }
    pub unsafe fn PD_ProgFile(
        &self,
        config: *const PD_AnalysisConfig,
    ) -> *const ::std::os::raw::c_char {
        let sym = self
            .PD_ProgFile
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config)
    }
    pub unsafe fn PD_ParamsFile(
        &self,
        config: *const PD_AnalysisConfig,
    ) -> *const ::std::os::raw::c_char {
        let sym = self
            .PD_ParamsFile
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config)
    }
    pub unsafe fn PD_EnableUseGpu(
        &self,
        config: *mut PD_AnalysisConfig,
        memory_pool_init_size_mb: ::std::os::raw::c_int,
        device_id: ::std::os::raw::c_int,
    ) -> () {
        let sym = self
            .PD_EnableUseGpu
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config, memory_pool_init_size_mb, device_id)
    }
    pub unsafe fn PD_DisableGpu(&self, config: *mut PD_AnalysisConfig) -> () {
        let sym = self
            .PD_DisableGpu
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config)
    }
    pub unsafe fn PD_UseGpu(&self, config: *const PD_AnalysisConfig) -> bool {
        let sym = self
            .PD_UseGpu
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config)
    }
    pub unsafe fn PD_GpuDeviceId(&self, config: *const PD_AnalysisConfig) -> ::std::os::raw::c_int {
        let sym = self
            .PD_GpuDeviceId
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config)
    }
    pub unsafe fn PD_MemoryPoolInitSizeMb(
        &self,
        config: *const PD_AnalysisConfig,
    ) -> ::std::os::raw::c_int {
        let sym = self
            .PD_MemoryPoolInitSizeMb
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config)
    }
    pub unsafe fn PD_FractionOfGpuMemoryForPool(&self, config: *const PD_AnalysisConfig) -> f32 {
        let sym = self
            .PD_FractionOfGpuMemoryForPool
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config)
    }
    pub unsafe fn PD_EnableCUDNN(&self, config: *mut PD_AnalysisConfig) -> () {
        let sym = self
            .PD_EnableCUDNN
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config)
    }
    pub unsafe fn PD_CudnnEnabled(&self, config: *const PD_AnalysisConfig) -> bool {
        let sym = self
            .PD_CudnnEnabled
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config)
    }
    pub unsafe fn PD_SwitchIrOptim(&self, config: *mut PD_AnalysisConfig, x: bool) -> () {
        let sym = self
            .PD_SwitchIrOptim
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config, x)
    }
    pub unsafe fn PD_IrOptim(&self, config: *const PD_AnalysisConfig) -> bool {
        let sym = self
            .PD_IrOptim
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config)
    }
    pub unsafe fn PD_SwitchUseFeedFetchOps(&self, config: *mut PD_AnalysisConfig, x: bool) -> () {
        let sym = self
            .PD_SwitchUseFeedFetchOps
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config, x)
    }
    pub unsafe fn PD_UseFeedFetchOpsEnabled(&self, config: *const PD_AnalysisConfig) -> bool {
        let sym = self
            .PD_UseFeedFetchOpsEnabled
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config)
    }
    pub unsafe fn PD_SwitchSpecifyInputNames(&self, config: *mut PD_AnalysisConfig, x: bool) -> () {
        let sym = self
            .PD_SwitchSpecifyInputNames
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config, x)
    }
    pub unsafe fn PD_SpecifyInputName(&self, config: *const PD_AnalysisConfig) -> bool {
        let sym = self
            .PD_SpecifyInputName
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config)
    }
    pub unsafe fn PD_EnableTensorRtEngine(
        &self,
        config: *mut PD_AnalysisConfig,
        workspace_size: ::std::os::raw::c_int,
        max_batch_size: ::std::os::raw::c_int,
        min_subgraph_size: ::std::os::raw::c_int,
        precision: Precision,
        use_static: bool,
        use_calib_mode: bool,
    ) -> () {
        let sym = self
            .PD_EnableTensorRtEngine
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(
            config,
            workspace_size,
            max_batch_size,
            min_subgraph_size,
            precision,
            use_static,
            use_calib_mode,
        )
    }
    pub unsafe fn PD_TensorrtEngineEnabled(&self, config: *const PD_AnalysisConfig) -> bool {
        let sym = self
            .PD_TensorrtEngineEnabled
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config)
    }
    pub unsafe fn PD_SwitchIrDebug(&self, config: *mut PD_AnalysisConfig, x: bool) -> () {
        let sym = self
            .PD_SwitchIrDebug
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config, x)
    }
    pub unsafe fn PD_EnableMKLDNN(&self, config: *mut PD_AnalysisConfig) -> () {
        let sym = self
            .PD_EnableMKLDNN
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config)
    }
    pub unsafe fn PD_SetMkldnnCacheCapacity(
        &self,
        config: *mut PD_AnalysisConfig,
        capacity: ::std::os::raw::c_int,
    ) -> () {
        let sym = self
            .PD_SetMkldnnCacheCapacity
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config, capacity)
    }
    pub unsafe fn PD_MkldnnEnabled(&self, config: *const PD_AnalysisConfig) -> bool {
        let sym = self
            .PD_MkldnnEnabled
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config)
    }
    pub unsafe fn PD_SetCpuMathLibraryNumThreads(
        &self,
        config: *mut PD_AnalysisConfig,
        cpu_math_library_num_threads: ::std::os::raw::c_int,
    ) -> () {
        let sym = self
            .PD_SetCpuMathLibraryNumThreads
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config, cpu_math_library_num_threads)
    }
    pub unsafe fn PD_CpuMathLibraryNumThreads(
        &self,
        config: *const PD_AnalysisConfig,
    ) -> ::std::os::raw::c_int {
        let sym = self
            .PD_CpuMathLibraryNumThreads
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config)
    }
    pub unsafe fn PD_EnableMkldnnQuantizer(&self, config: *mut PD_AnalysisConfig) -> () {
        let sym = self
            .PD_EnableMkldnnQuantizer
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config)
    }
    pub unsafe fn PD_MkldnnQuantizerEnabled(&self, config: *const PD_AnalysisConfig) -> bool {
        let sym = self
            .PD_MkldnnQuantizerEnabled
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config)
    }
    pub unsafe fn PD_EnableMkldnnBfloat16(&self, config: *mut PD_AnalysisConfig) -> () {
        let sym = self
            .PD_EnableMkldnnBfloat16
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config)
    }
    pub unsafe fn PD_MkldnnBfloat16Enabled(&self, config: *const PD_AnalysisConfig) -> bool {
        let sym = self
            .PD_MkldnnBfloat16Enabled
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config)
    }
    pub unsafe fn PD_SetModelBuffer(
        &self,
        config: *mut PD_AnalysisConfig,
        prog_buffer: *const ::std::os::raw::c_char,
        prog_buffer_size: size_t,
        params_buffer: *const ::std::os::raw::c_char,
        params_buffer_size: size_t,
    ) -> () {
        let sym = self
            .PD_SetModelBuffer
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(
            config,
            prog_buffer,
            prog_buffer_size,
            params_buffer,
            params_buffer_size,
        )
    }
    pub unsafe fn PD_ModelFromMemory(&self, config: *const PD_AnalysisConfig) -> bool {
        let sym = self
            .PD_ModelFromMemory
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config)
    }
    pub unsafe fn PD_EnableMemoryOptim(&self, config: *mut PD_AnalysisConfig) -> () {
        let sym = self
            .PD_EnableMemoryOptim
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config)
    }
    pub unsafe fn PD_MemoryOptimEnabled(&self, config: *const PD_AnalysisConfig) -> bool {
        let sym = self
            .PD_MemoryOptimEnabled
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config)
    }
    pub unsafe fn PD_EnableProfile(&self, config: *mut PD_AnalysisConfig) -> () {
        let sym = self
            .PD_EnableProfile
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config)
    }
    pub unsafe fn PD_ProfileEnabled(&self, config: *const PD_AnalysisConfig) -> bool {
        let sym = self
            .PD_ProfileEnabled
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config)
    }
    pub unsafe fn PD_SetInValid(&self, config: *mut PD_AnalysisConfig) -> () {
        let sym = self
            .PD_SetInValid
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config)
    }
    pub unsafe fn PD_IsValid(&self, config: *const PD_AnalysisConfig) -> bool {
        let sym = self
            .PD_IsValid
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config)
    }
    pub unsafe fn PD_DisableGlogInfo(&self, config: *mut PD_AnalysisConfig) -> () {
        let sym = self
            .PD_DisableGlogInfo
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config)
    }
    pub unsafe fn PD_DeletePass(
        &self,
        config: *mut PD_AnalysisConfig,
        pass_name: *mut ::std::os::raw::c_char,
    ) -> () {
        let sym = self
            .PD_DeletePass
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config, pass_name)
    }
    pub unsafe fn PD_NewPredictor(&self, config: *const PD_AnalysisConfig) -> *mut PD_Predictor {
        let sym = self
            .PD_NewPredictor
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(config)
    }
    pub unsafe fn PD_DeletePredictor(&self, predictor: *mut PD_Predictor) -> () {
        let sym = self
            .PD_DeletePredictor
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(predictor)
    }
    pub unsafe fn PD_GetInputNum(&self, arg1: *const PD_Predictor) -> ::std::os::raw::c_int {
        let sym = self
            .PD_GetInputNum
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(arg1)
    }
    pub unsafe fn PD_GetOutputNum(&self, arg1: *const PD_Predictor) -> ::std::os::raw::c_int {
        let sym = self
            .PD_GetOutputNum
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(arg1)
    }
    pub unsafe fn PD_GetInputName(
        &self,
        arg1: *const PD_Predictor,
        arg2: ::std::os::raw::c_int,
    ) -> *const ::std::os::raw::c_char {
        let sym = self
            .PD_GetInputName
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(arg1, arg2)
    }
    pub unsafe fn PD_GetOutputName(
        &self,
        arg1: *const PD_Predictor,
        arg2: ::std::os::raw::c_int,
    ) -> *const ::std::os::raw::c_char {
        let sym = self
            .PD_GetOutputName
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(arg1, arg2)
    }
    pub unsafe fn PD_SetZeroCopyInput(
        &self,
        predictor: *mut PD_Predictor,
        tensor: *const PD_ZeroCopyTensor,
    ) -> () {
        let sym = self
            .PD_SetZeroCopyInput
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(predictor, tensor)
    }
    pub unsafe fn PD_GetZeroCopyOutput(
        &self,
        predictor: *mut PD_Predictor,
        tensor: *mut PD_ZeroCopyTensor,
    ) -> () {
        let sym = self
            .PD_GetZeroCopyOutput
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(predictor, tensor)
    }
    pub unsafe fn PD_ZeroCopyRun(&self, predictor: *mut PD_Predictor) -> () {
        let sym = self
            .PD_ZeroCopyRun
            .as_ref()
            .expect("Expected function, got error.");
        (sym)(predictor)
    }
}
