paddle_sys/

bindings.rs

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

/* automatically generated by rust-bindgen 0.58.1 */

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 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 size_t = ::std::os::raw::c_ulong;
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],
}
#[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 type PD_Bool = i8;
pub type PD_PrecisionType = i32;
pub const PD_PRECISION_FLOAT32: ::std::os::raw::c_uint = 0;
pub const PD_PRECISION_INT8: ::std::os::raw::c_uint = 1;
pub const PD_PRECISION_HALF: ::std::os::raw::c_uint = 2;
pub type _bindgen_ty_1 = ::std::os::raw::c_uint;
pub type PD_PlaceType = i32;
pub const PD_PLACE_UNK: ::std::os::raw::c_int = -1;
pub const PD_PLACE_CPU: ::std::os::raw::c_int = 0;
pub const PD_PLACE_GPU: ::std::os::raw::c_int = 1;
pub const PD_PLACE_XPU: ::std::os::raw::c_int = 2;
pub type _bindgen_ty_2 = ::std::os::raw::c_int;
pub type PD_DataType = i32;
pub const PD_DATA_UNK: ::std::os::raw::c_int = -1;
pub const PD_DATA_FLOAT32: ::std::os::raw::c_int = 0;
pub const PD_DATA_INT32: ::std::os::raw::c_int = 1;
pub const PD_DATA_INT64: ::std::os::raw::c_int = 2;
pub const PD_DATA_UINT8: ::std::os::raw::c_int = 3;
pub type _bindgen_ty_3 = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct PD_Config {
    _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_Tensor {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct PD_OneDimArrayInt32 {
    pub size: size_t,
    pub data: *mut i32,
}
#[test]
fn bindgen_test_layout_PD_OneDimArrayInt32() {
    assert_eq!(
        ::std::mem::size_of::<PD_OneDimArrayInt32>(),
        16usize,
        concat!("Size of: ", stringify!(PD_OneDimArrayInt32))
    );
    assert_eq!(
        ::std::mem::align_of::<PD_OneDimArrayInt32>(),
        8usize,
        concat!("Alignment of ", stringify!(PD_OneDimArrayInt32))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<PD_OneDimArrayInt32>())).size as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(PD_OneDimArrayInt32),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<PD_OneDimArrayInt32>())).data as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(PD_OneDimArrayInt32),
            "::",
            stringify!(data)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct PD_OneDimArraySize {
    pub size: size_t,
    pub data: *mut size_t,
}
#[test]
fn bindgen_test_layout_PD_OneDimArraySize() {
    assert_eq!(
        ::std::mem::size_of::<PD_OneDimArraySize>(),
        16usize,
        concat!("Size of: ", stringify!(PD_OneDimArraySize))
    );
    assert_eq!(
        ::std::mem::align_of::<PD_OneDimArraySize>(),
        8usize,
        concat!("Alignment of ", stringify!(PD_OneDimArraySize))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<PD_OneDimArraySize>())).size as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(PD_OneDimArraySize),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<PD_OneDimArraySize>())).data as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(PD_OneDimArraySize),
            "::",
            stringify!(data)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct PD_OneDimArrayCstr {
    pub size: size_t,
    pub data: *mut *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_PD_OneDimArrayCstr() {
    assert_eq!(
        ::std::mem::size_of::<PD_OneDimArrayCstr>(),
        16usize,
        concat!("Size of: ", stringify!(PD_OneDimArrayCstr))
    );
    assert_eq!(
        ::std::mem::align_of::<PD_OneDimArrayCstr>(),
        8usize,
        concat!("Alignment of ", stringify!(PD_OneDimArrayCstr))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<PD_OneDimArrayCstr>())).size as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(PD_OneDimArrayCstr),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<PD_OneDimArrayCstr>())).data as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(PD_OneDimArrayCstr),
            "::",
            stringify!(data)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct PD_TwoDimArraySize {
    pub size: size_t,
    pub data: *mut *mut PD_OneDimArraySize,
}
#[test]
fn bindgen_test_layout_PD_TwoDimArraySize() {
    assert_eq!(
        ::std::mem::size_of::<PD_TwoDimArraySize>(),
        16usize,
        concat!("Size of: ", stringify!(PD_TwoDimArraySize))
    );
    assert_eq!(
        ::std::mem::align_of::<PD_TwoDimArraySize>(),
        8usize,
        concat!("Alignment of ", stringify!(PD_TwoDimArraySize))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<PD_TwoDimArraySize>())).size as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(PD_TwoDimArraySize),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<PD_TwoDimArraySize>())).data as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(PD_TwoDimArraySize),
            "::",
            stringify!(data)
        )
    );
}
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_inference_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_ConfigCreate: Result<unsafe extern "C" fn() -> *mut PD_Config, ::libloading::Error>,
    pub PD_ConfigDestroy:
        Result<unsafe extern "C" fn(pd_config: *mut PD_Config), ::libloading::Error>,
    pub PD_ConfigSetModel: Result<
        unsafe extern "C" fn(
            pd_config: *mut PD_Config,
            prog_file_path: *const ::std::os::raw::c_char,
            params_file_path: *const ::std::os::raw::c_char,
        ),
        ::libloading::Error,
    >,
    pub PD_ConfigSetProgFile: Result<
        unsafe extern "C" fn(
            pd_config: *mut PD_Config,
            prog_file_path: *const ::std::os::raw::c_char,
        ),
        ::libloading::Error,
    >,
    pub PD_ConfigSetParamsFile: Result<
        unsafe extern "C" fn(
            pd_config: *mut PD_Config,
            params_file_path: *const ::std::os::raw::c_char,
        ),
        ::libloading::Error,
    >,
    pub PD_ConfigSetOptimCacheDir: Result<
        unsafe extern "C" fn(
            pd_config: *mut PD_Config,
            opt_cache_dir: *const ::std::os::raw::c_char,
        ),
        ::libloading::Error,
    >,
    pub PD_ConfigSetModelDir: Result<
        unsafe extern "C" fn(pd_config: *mut PD_Config, model_dir: *const ::std::os::raw::c_char),
        ::libloading::Error,
    >,
    pub PD_ConfigGetModelDir: Result<
        unsafe extern "C" fn(pd_config: *mut PD_Config) -> *const ::std::os::raw::c_char,
        ::libloading::Error,
    >,
    pub PD_ConfigGetProgFile: Result<
        unsafe extern "C" fn(pd_config: *mut PD_Config) -> *const ::std::os::raw::c_char,
        ::libloading::Error,
    >,
    pub PD_ConfigGetParamsFile: Result<
        unsafe extern "C" fn(pd_config: *mut PD_Config) -> *const ::std::os::raw::c_char,
        ::libloading::Error,
    >,
    pub PD_ConfigDisableFCPadding:
        Result<unsafe extern "C" fn(pd_config: *mut PD_Config), ::libloading::Error>,
    pub PD_ConfigUseFcPadding:
        Result<unsafe extern "C" fn(pd_config: *mut PD_Config) -> PD_Bool, ::libloading::Error>,
    pub PD_ConfigEnableUseGpu: Result<
        unsafe extern "C" fn(
            pd_config: *mut PD_Config,
            memory_pool_init_size_mb: u64,
            device_id: i32,
        ),
        ::libloading::Error,
    >,
    pub PD_ConfigDisableGpu:
        Result<unsafe extern "C" fn(pd_config: *mut PD_Config), ::libloading::Error>,
    pub PD_ConfigUseGpu:
        Result<unsafe extern "C" fn(pd_config: *mut PD_Config) -> PD_Bool, ::libloading::Error>,
    pub PD_ConfigEnableXpu: Result<
        unsafe extern "C" fn(pd_config: *mut PD_Config, l3_workspace_size: i32),
        ::libloading::Error,
    >,
    pub PD_ConfigUseXpu:
        Result<unsafe extern "C" fn(pd_config: *mut PD_Config) -> PD_Bool, ::libloading::Error>,
    pub PD_ConfigGpuDeviceId:
        Result<unsafe extern "C" fn(pd_config: *mut PD_Config) -> i32, ::libloading::Error>,
    pub PD_ConfigXpuDeviceId:
        Result<unsafe extern "C" fn(pd_config: *mut PD_Config) -> i32, ::libloading::Error>,
    pub PD_ConfigMemoryPoolInitSizeMb:
        Result<unsafe extern "C" fn(pd_config: *mut PD_Config) -> i32, ::libloading::Error>,
    pub PD_ConfigFractionOfGpuMemoryForPool:
        Result<unsafe extern "C" fn(pd_config: *mut PD_Config) -> f32, ::libloading::Error>,
    pub PD_ConfigEnableCudnn:
        Result<unsafe extern "C" fn(pd_config: *mut PD_Config), ::libloading::Error>,
    pub PD_ConfigCudnnEnabled:
        Result<unsafe extern "C" fn(pd_config: *mut PD_Config) -> PD_Bool, ::libloading::Error>,
    pub PD_ConfigSwitchIrOptim:
        Result<unsafe extern "C" fn(pd_config: *mut PD_Config, x: PD_Bool), ::libloading::Error>,
    pub PD_ConfigIrOptim:
        Result<unsafe extern "C" fn(pd_config: *mut PD_Config) -> PD_Bool, ::libloading::Error>,
    pub PD_ConfigEnableTensorRtEngine: Result<
        unsafe extern "C" fn(
            pd_config: *mut PD_Config,
            workspace_size: i32,
            max_batch_size: i32,
            min_subgraph_size: i32,
            precision: PD_PrecisionType,
            use_static: PD_Bool,
            use_calib_mode: PD_Bool,
        ),
        ::libloading::Error,
    >,
    pub PD_ConfigTensorRtEngineEnabled:
        Result<unsafe extern "C" fn(pd_config: *mut PD_Config) -> PD_Bool, ::libloading::Error>,
    pub PD_ConfigSetTrtDynamicShapeInfo: Result<
        unsafe extern "C" fn(
            pd_config: *mut PD_Config,
            tensor_num: size_t,
            tensor_name: *mut *const ::std::os::raw::c_char,
            shapes_num: *mut size_t,
            min_shape: *mut *mut i32,
            max_shape: *mut *mut i32,
            optim_shape: *mut *mut i32,
            disable_trt_plugin_fp16: PD_Bool,
        ),
        ::libloading::Error,
    >,
    pub PD_ConfigDisableTensorRtOPs: Result<
        unsafe extern "C" fn(
            pd_config: *mut PD_Config,
            ops_num: size_t,
            ops_name: *mut *const ::std::os::raw::c_char,
        ),
        ::libloading::Error,
    >,
    pub PD_ConfigEnableTensorRtOSS:
        Result<unsafe extern "C" fn(pd_config: *mut PD_Config), ::libloading::Error>,
    pub PD_ConfigTensorRtOssEnabled:
        Result<unsafe extern "C" fn(pd_config: *mut PD_Config) -> PD_Bool, ::libloading::Error>,
    pub PD_ConfigEnableTensorRtDla:
        Result<unsafe extern "C" fn(pd_config: *mut PD_Config, dla_core: i32), ::libloading::Error>,
    pub PD_ConfigTensorRtDlaEnabled:
        Result<unsafe extern "C" fn(pd_config: *mut PD_Config) -> PD_Bool, ::libloading::Error>,
    pub PD_ConfigEnableLiteEngine: Result<
        unsafe extern "C" fn(
            pd_config: *mut PD_Config,
            precision: PD_PrecisionType,
            zero_copy: PD_Bool,
            passes_filter_num: size_t,
            passes_filter: *mut *const ::std::os::raw::c_char,
            ops_filter_num: size_t,
            ops_filter: *mut *const ::std::os::raw::c_char,
        ),
        ::libloading::Error,
    >,
    pub PD_ConfigLiteEngineEnabled:
        Result<unsafe extern "C" fn(pd_config: *mut PD_Config) -> PD_Bool, ::libloading::Error>,
    pub PD_ConfigSwitchIrDebug:
        Result<unsafe extern "C" fn(pd_config: *mut PD_Config, x: PD_Bool), ::libloading::Error>,
    pub PD_ConfigEnableMKLDNN:
        Result<unsafe extern "C" fn(pd_config: *mut PD_Config), ::libloading::Error>,
    pub PD_ConfigSetMkldnnCacheCapacity:
        Result<unsafe extern "C" fn(pd_config: *mut PD_Config, capacity: i32), ::libloading::Error>,
    pub PD_ConfigMkldnnEnabled:
        Result<unsafe extern "C" fn(pd_config: *mut PD_Config) -> PD_Bool, ::libloading::Error>,
    pub PD_ConfigSetCpuMathLibraryNumThreads: Result<
        unsafe extern "C" fn(pd_config: *mut PD_Config, cpu_math_library_num_threads: i32),
        ::libloading::Error,
    >,
    pub PD_ConfigGetCpuMathLibraryNumThreads:
        Result<unsafe extern "C" fn(pd_config: *mut PD_Config) -> i32, ::libloading::Error>,
    pub PD_ConfigSetMkldnnOp: Result<
        unsafe extern "C" fn(
            pd_config: *mut PD_Config,
            ops_num: size_t,
            op_list: *mut *const ::std::os::raw::c_char,
        ),
        ::libloading::Error,
    >,
    pub PD_ConfigEnableMkldnnQuantizer:
        Result<unsafe extern "C" fn(pd_config: *mut PD_Config), ::libloading::Error>,
    pub PD_ConfigMkldnnQuantizerEnabled:
        Result<unsafe extern "C" fn(pd_config: *mut PD_Config) -> PD_Bool, ::libloading::Error>,
    pub PD_ConfigEnableMkldnnBfloat16:
        Result<unsafe extern "C" fn(pd_config: *mut PD_Config), ::libloading::Error>,
    pub PD_ConfigMkldnnBfloat16Enabled:
        Result<unsafe extern "C" fn(pd_config: *mut PD_Config) -> PD_Bool, ::libloading::Error>,
    pub PD_ConfigSetBfloat16Op: Result<
        unsafe extern "C" fn(
            pd_config: *mut PD_Config,
            ops_num: size_t,
            op_list: *mut *const ::std::os::raw::c_char,
        ),
        ::libloading::Error,
    >,
    pub PD_ConfigEnableGpuMultiStream:
        Result<unsafe extern "C" fn(pd_config: *mut PD_Config), ::libloading::Error>,
    pub PD_ConfigThreadLocalStreamEnabled:
        Result<unsafe extern "C" fn(pd_config: *mut PD_Config) -> PD_Bool, ::libloading::Error>,
    pub PD_ConfigSetModelBuffer: Result<
        unsafe extern "C" fn(
            pd_config: *mut PD_Config,
            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_ConfigModelFromMemory:
        Result<unsafe extern "C" fn(pd_config: *mut PD_Config) -> PD_Bool, ::libloading::Error>,
    pub PD_ConfigEnableMemoryOptim:
        Result<unsafe extern "C" fn(pd_config: *mut PD_Config), ::libloading::Error>,
    pub PD_ConfigMemoryOptimEnabled:
        Result<unsafe extern "C" fn(pd_config: *mut PD_Config) -> PD_Bool, ::libloading::Error>,
    pub PD_ConfigEnableProfile:
        Result<unsafe extern "C" fn(pd_config: *mut PD_Config), ::libloading::Error>,
    pub PD_ConfigProfileEnabled:
        Result<unsafe extern "C" fn(pd_config: *mut PD_Config) -> PD_Bool, ::libloading::Error>,
    pub PD_ConfigDisableGlogInfo:
        Result<unsafe extern "C" fn(pd_config: *mut PD_Config), ::libloading::Error>,
    pub PD_ConfigGlogInfoDisabled:
        Result<unsafe extern "C" fn(pd_config: *mut PD_Config) -> PD_Bool, ::libloading::Error>,
    pub PD_ConfigSetInvalid:
        Result<unsafe extern "C" fn(pd_config: *mut PD_Config), ::libloading::Error>,
    pub PD_ConfigIsValid:
        Result<unsafe extern "C" fn(pd_config: *mut PD_Config) -> PD_Bool, ::libloading::Error>,
    pub PD_ConfigPartiallyRelease:
        Result<unsafe extern "C" fn(pd_config: *mut PD_Config), ::libloading::Error>,
    pub PD_PredictorCreate: Result<
        unsafe extern "C" fn(pd_config: *mut PD_Config) -> *mut PD_Predictor,
        ::libloading::Error,
    >,
    pub PD_PredictorClone: Result<
        unsafe extern "C" fn(pd_predictor: *mut PD_Predictor) -> *mut PD_Predictor,
        ::libloading::Error,
    >,
    pub PD_PredictorGetInputNames: Result<
        unsafe extern "C" fn(pd_predictor: *mut PD_Predictor) -> *mut PD_OneDimArrayCstr,
        ::libloading::Error,
    >,
    pub PD_PredictorGetOutputNames: Result<
        unsafe extern "C" fn(pd_predictor: *mut PD_Predictor) -> *mut PD_OneDimArrayCstr,
        ::libloading::Error,
    >,
    pub PD_PredictorGetInputNum: Result<
        unsafe extern "C" fn(pd_predictor: *mut PD_Predictor) -> size_t,
        ::libloading::Error,
    >,
    pub PD_PredictorGetOutputNum: Result<
        unsafe extern "C" fn(pd_predictor: *mut PD_Predictor) -> size_t,
        ::libloading::Error,
    >,
    pub PD_PredictorGetInputHandle: Result<
        unsafe extern "C" fn(
            pd_predictor: *mut PD_Predictor,
            name: *const ::std::os::raw::c_char,
        ) -> *mut PD_Tensor,
        ::libloading::Error,
    >,
    pub PD_PredictorGetOutputHandle: Result<
        unsafe extern "C" fn(
            pd_predictor: *mut PD_Predictor,
            name: *const ::std::os::raw::c_char,
        ) -> *mut PD_Tensor,
        ::libloading::Error,
    >,
    pub PD_PredictorRun: Result<
        unsafe extern "C" fn(pd_predictor: *mut PD_Predictor) -> PD_Bool,
        ::libloading::Error,
    >,
    pub PD_PredictorClearIntermediateTensor:
        Result<unsafe extern "C" fn(pd_predictor: *mut PD_Predictor), ::libloading::Error>,
    pub PD_PredictorTryShrinkMemory:
        Result<unsafe extern "C" fn(pd_predictor: *mut PD_Predictor) -> u64, ::libloading::Error>,
    pub PD_PredictorDestroy:
        Result<unsafe extern "C" fn(pd_predictor: *mut PD_Predictor), ::libloading::Error>,
    pub PD_TensorDestroy:
        Result<unsafe extern "C" fn(pd_tensor: *mut PD_Tensor), ::libloading::Error>,
    pub PD_TensorReshape: Result<
        unsafe extern "C" fn(pd_tensor: *mut PD_Tensor, shape_size: size_t, shape: *mut i32),
        ::libloading::Error,
    >,
    pub PD_TensorMutableDataFloat: Result<
        unsafe extern "C" fn(pd_tensor: *mut PD_Tensor, place: PD_PlaceType) -> *mut f32,
        ::libloading::Error,
    >,
    pub PD_TensorMutableDataInt64: Result<
        unsafe extern "C" fn(pd_tensor: *mut PD_Tensor, place: PD_PlaceType) -> *mut i64,
        ::libloading::Error,
    >,
    pub PD_TensorMutableDataInt32: Result<
        unsafe extern "C" fn(pd_tensor: *mut PD_Tensor, place: PD_PlaceType) -> *mut i32,
        ::libloading::Error,
    >,
    pub PD_TensorMutableDataUint8: Result<
        unsafe extern "C" fn(pd_tensor: *mut PD_Tensor, place: PD_PlaceType) -> *mut u8,
        ::libloading::Error,
    >,
    pub PD_TensorMutableDataInt8: Result<
        unsafe extern "C" fn(pd_tensor: *mut PD_Tensor, place: PD_PlaceType) -> *mut i8,
        ::libloading::Error,
    >,
    pub PD_TensorDataFloat: Result<
        unsafe extern "C" fn(
            pd_tensor: *mut PD_Tensor,
            place: *mut PD_PlaceType,
            size: *mut i32,
        ) -> *mut f32,
        ::libloading::Error,
    >,
    pub PD_TensorDataInt64: Result<
        unsafe extern "C" fn(
            pd_tensor: *mut PD_Tensor,
            place: *mut PD_PlaceType,
            size: *mut i32,
        ) -> *mut i64,
        ::libloading::Error,
    >,
    pub PD_TensorDataInt32: Result<
        unsafe extern "C" fn(
            pd_tensor: *mut PD_Tensor,
            place: *mut PD_PlaceType,
            size: *mut i32,
        ) -> *mut i32,
        ::libloading::Error,
    >,
    pub PD_TensorDataUint8: Result<
        unsafe extern "C" fn(
            pd_tensor: *mut PD_Tensor,
            place: *mut PD_PlaceType,
            size: *mut i32,
        ) -> *mut u8,
        ::libloading::Error,
    >,
    pub PD_TensorDataInt8: Result<
        unsafe extern "C" fn(
            pd_tensor: *mut PD_Tensor,
            place: *mut PD_PlaceType,
            size: *mut i32,
        ) -> *mut i8,
        ::libloading::Error,
    >,
    pub PD_TensorCopyFromCpuFloat: Result<
        unsafe extern "C" fn(pd_tensor: *mut PD_Tensor, data: *const f32),
        ::libloading::Error,
    >,
    pub PD_TensorCopyFromCpuInt64: Result<
        unsafe extern "C" fn(pd_tensor: *mut PD_Tensor, data: *const i64),
        ::libloading::Error,
    >,
    pub PD_TensorCopyFromCpuInt32: Result<
        unsafe extern "C" fn(pd_tensor: *mut PD_Tensor, data: *const i32),
        ::libloading::Error,
    >,
    pub PD_TensorCopyFromCpuUint8: Result<
        unsafe extern "C" fn(pd_tensor: *mut PD_Tensor, data: *const u8),
        ::libloading::Error,
    >,
    pub PD_TensorCopyFromCpuInt8: Result<
        unsafe extern "C" fn(pd_tensor: *mut PD_Tensor, data: *const i8),
        ::libloading::Error,
    >,
    pub PD_TensorCopyToCpuFloat: Result<
        unsafe extern "C" fn(pd_tensor: *mut PD_Tensor, data: *mut f32),
        ::libloading::Error,
    >,
    pub PD_TensorCopyToCpuInt64: Result<
        unsafe extern "C" fn(pd_tensor: *mut PD_Tensor, data: *mut i64),
        ::libloading::Error,
    >,
    pub PD_TensorCopyToCpuInt32: Result<
        unsafe extern "C" fn(pd_tensor: *mut PD_Tensor, data: *mut i32),
        ::libloading::Error,
    >,
    pub PD_TensorCopyToCpuUint8:
        Result<unsafe extern "C" fn(pd_tensor: *mut PD_Tensor, data: *mut u8), ::libloading::Error>,
    pub PD_TensorCopyToCpuInt8:
        Result<unsafe extern "C" fn(pd_tensor: *mut PD_Tensor, data: *mut i8), ::libloading::Error>,
    pub PD_TensorGetShape: Result<
        unsafe extern "C" fn(pd_tensor: *mut PD_Tensor) -> *mut PD_OneDimArrayInt32,
        ::libloading::Error,
    >,
    pub PD_TensorSetLod: Result<
        unsafe extern "C" fn(pd_tensor: *mut PD_Tensor, lod: *mut PD_TwoDimArraySize),
        ::libloading::Error,
    >,
    pub PD_TensorGetLod: Result<
        unsafe extern "C" fn(pd_tensor: *mut PD_Tensor) -> *mut PD_TwoDimArraySize,
        ::libloading::Error,
    >,
    pub PD_TensorGetName: Result<
        unsafe extern "C" fn(pd_tensor: *mut PD_Tensor) -> *const ::std::os::raw::c_char,
        ::libloading::Error,
    >,
    pub PD_TensorGetDataType:
        Result<unsafe extern "C" fn(pd_tensor: *mut PD_Tensor) -> PD_DataType, ::libloading::Error>,
    pub PD_OneDimArrayInt32Destroy:
        Result<unsafe extern "C" fn(array: *mut PD_OneDimArrayInt32), ::libloading::Error>,
    pub PD_OneDimArrayCstrDestroy:
        Result<unsafe extern "C" fn(array: *mut PD_OneDimArrayCstr), ::libloading::Error>,
    pub PD_OneDimArraySizeDestroy:
        Result<unsafe extern "C" fn(array: *mut PD_OneDimArraySize), ::libloading::Error>,
    pub PD_TwoDimArraySizeDestroy:
        Result<unsafe extern "C" fn(array: *mut PD_TwoDimArraySize), ::libloading::Error>,
}
impl paddle_inference_c {
    pub unsafe fn new<P>(path: P) -> Result<Self, ::libloading::Error>
    where
        P: AsRef<::std::ffi::OsStr>,
    {
        let library = ::libloading::Library::new(path)?;
        Self::from_library(library)
    }
    pub unsafe fn from_library<L>(library: L) -> Result<Self, ::libloading::Error>
    where
        L: Into<::libloading::Library>,
    {
        let __library = library.into();
        let remove = __library.get(b"remove\0").map(|sym| *sym);
        let rename = __library.get(b"rename\0").map(|sym| *sym);
        let renameat = __library.get(b"renameat\0").map(|sym| *sym);
        let tmpfile = __library.get(b"tmpfile\0").map(|sym| *sym);
        let tmpnam = __library.get(b"tmpnam\0").map(|sym| *sym);
        let tmpnam_r = __library.get(b"tmpnam_r\0").map(|sym| *sym);
        let tempnam = __library.get(b"tempnam\0").map(|sym| *sym);
        let fclose = __library.get(b"fclose\0").map(|sym| *sym);
        let fflush = __library.get(b"fflush\0").map(|sym| *sym);
        let fflush_unlocked = __library.get(b"fflush_unlocked\0").map(|sym| *sym);
        let fopen = __library.get(b"fopen\0").map(|sym| *sym);
        let freopen = __library.get(b"freopen\0").map(|sym| *sym);
        let fdopen = __library.get(b"fdopen\0").map(|sym| *sym);
        let fmemopen = __library.get(b"fmemopen\0").map(|sym| *sym);
        let open_memstream = __library.get(b"open_memstream\0").map(|sym| *sym);
        let setbuf = __library.get(b"setbuf\0").map(|sym| *sym);
        let setvbuf = __library.get(b"setvbuf\0").map(|sym| *sym);
        let setbuffer = __library.get(b"setbuffer\0").map(|sym| *sym);
        let setlinebuf = __library.get(b"setlinebuf\0").map(|sym| *sym);
        let fprintf = __library.get(b"fprintf\0").map(|sym| *sym);
        let printf = __library.get(b"printf\0").map(|sym| *sym);
        let sprintf = __library.get(b"sprintf\0").map(|sym| *sym);
        let vfprintf = __library.get(b"vfprintf\0").map(|sym| *sym);
        let vprintf = __library.get(b"vprintf\0").map(|sym| *sym);
        let vsprintf = __library.get(b"vsprintf\0").map(|sym| *sym);
        let snprintf = __library.get(b"snprintf\0").map(|sym| *sym);
        let vsnprintf = __library.get(b"vsnprintf\0").map(|sym| *sym);
        let vdprintf = __library.get(b"vdprintf\0").map(|sym| *sym);
        let dprintf = __library.get(b"dprintf\0").map(|sym| *sym);
        let fscanf = __library.get(b"fscanf\0").map(|sym| *sym);
        let scanf = __library.get(b"scanf\0").map(|sym| *sym);
        let sscanf = __library.get(b"sscanf\0").map(|sym| *sym);
        let fscanf1 = __library.get(b"fscanf1\0").map(|sym| *sym);
        let scanf1 = __library.get(b"scanf1\0").map(|sym| *sym);
        let sscanf1 = __library.get(b"sscanf1\0").map(|sym| *sym);
        let vfscanf = __library.get(b"vfscanf\0").map(|sym| *sym);
        let vscanf = __library.get(b"vscanf\0").map(|sym| *sym);
        let vsscanf = __library.get(b"vsscanf\0").map(|sym| *sym);
        let vfscanf1 = __library.get(b"vfscanf1\0").map(|sym| *sym);
        let vscanf1 = __library.get(b"vscanf1\0").map(|sym| *sym);
        let vsscanf1 = __library.get(b"vsscanf1\0").map(|sym| *sym);
        let fgetc = __library.get(b"fgetc\0").map(|sym| *sym);
        let getc = __library.get(b"getc\0").map(|sym| *sym);
        let getchar = __library.get(b"getchar\0").map(|sym| *sym);
        let getc_unlocked = __library.get(b"getc_unlocked\0").map(|sym| *sym);
        let getchar_unlocked = __library.get(b"getchar_unlocked\0").map(|sym| *sym);
        let fgetc_unlocked = __library.get(b"fgetc_unlocked\0").map(|sym| *sym);
        let fputc = __library.get(b"fputc\0").map(|sym| *sym);
        let putc = __library.get(b"putc\0").map(|sym| *sym);
        let putchar = __library.get(b"putchar\0").map(|sym| *sym);
        let fputc_unlocked = __library.get(b"fputc_unlocked\0").map(|sym| *sym);
        let putc_unlocked = __library.get(b"putc_unlocked\0").map(|sym| *sym);
        let putchar_unlocked = __library.get(b"putchar_unlocked\0").map(|sym| *sym);
        let getw = __library.get(b"getw\0").map(|sym| *sym);
        let putw = __library.get(b"putw\0").map(|sym| *sym);
        let fgets = __library.get(b"fgets\0").map(|sym| *sym);
        let __getdelim = __library.get(b"__getdelim\0").map(|sym| *sym);
        let getdelim = __library.get(b"getdelim\0").map(|sym| *sym);
        let getline = __library.get(b"getline\0").map(|sym| *sym);
        let fputs = __library.get(b"fputs\0").map(|sym| *sym);
        let puts = __library.get(b"puts\0").map(|sym| *sym);
        let ungetc = __library.get(b"ungetc\0").map(|sym| *sym);
        let fread = __library.get(b"fread\0").map(|sym| *sym);
        let fwrite = __library.get(b"fwrite\0").map(|sym| *sym);
        let fread_unlocked = __library.get(b"fread_unlocked\0").map(|sym| *sym);
        let fwrite_unlocked = __library.get(b"fwrite_unlocked\0").map(|sym| *sym);
        let fseek = __library.get(b"fseek\0").map(|sym| *sym);
        let ftell = __library.get(b"ftell\0").map(|sym| *sym);
        let rewind = __library.get(b"rewind\0").map(|sym| *sym);
        let fseeko = __library.get(b"fseeko\0").map(|sym| *sym);
        let ftello = __library.get(b"ftello\0").map(|sym| *sym);
        let fgetpos = __library.get(b"fgetpos\0").map(|sym| *sym);
        let fsetpos = __library.get(b"fsetpos\0").map(|sym| *sym);
        let clearerr = __library.get(b"clearerr\0").map(|sym| *sym);
        let feof = __library.get(b"feof\0").map(|sym| *sym);
        let ferror = __library.get(b"ferror\0").map(|sym| *sym);
        let clearerr_unlocked = __library.get(b"clearerr_unlocked\0").map(|sym| *sym);
        let feof_unlocked = __library.get(b"feof_unlocked\0").map(|sym| *sym);
        let ferror_unlocked = __library.get(b"ferror_unlocked\0").map(|sym| *sym);
        let perror = __library.get(b"perror\0").map(|sym| *sym);
        let fileno = __library.get(b"fileno\0").map(|sym| *sym);
        let fileno_unlocked = __library.get(b"fileno_unlocked\0").map(|sym| *sym);
        let popen = __library.get(b"popen\0").map(|sym| *sym);
        let pclose = __library.get(b"pclose\0").map(|sym| *sym);
        let ctermid = __library.get(b"ctermid\0").map(|sym| *sym);
        let flockfile = __library.get(b"flockfile\0").map(|sym| *sym);
        let ftrylockfile = __library.get(b"ftrylockfile\0").map(|sym| *sym);
        let funlockfile = __library.get(b"funlockfile\0").map(|sym| *sym);
        let __uflow = __library.get(b"__uflow\0").map(|sym| *sym);
        let __overflow = __library.get(b"__overflow\0").map(|sym| *sym);
        let PD_ConfigCreate = __library.get(b"PD_ConfigCreate\0").map(|sym| *sym);
        let PD_ConfigDestroy = __library.get(b"PD_ConfigDestroy\0").map(|sym| *sym);
        let PD_ConfigSetModel = __library.get(b"PD_ConfigSetModel\0").map(|sym| *sym);
        let PD_ConfigSetProgFile = __library.get(b"PD_ConfigSetProgFile\0").map(|sym| *sym);
        let PD_ConfigSetParamsFile = __library.get(b"PD_ConfigSetParamsFile\0").map(|sym| *sym);
        let PD_ConfigSetOptimCacheDir = __library
            .get(b"PD_ConfigSetOptimCacheDir\0")
            .map(|sym| *sym);
        let PD_ConfigSetModelDir = __library.get(b"PD_ConfigSetModelDir\0").map(|sym| *sym);
        let PD_ConfigGetModelDir = __library.get(b"PD_ConfigGetModelDir\0").map(|sym| *sym);
        let PD_ConfigGetProgFile = __library.get(b"PD_ConfigGetProgFile\0").map(|sym| *sym);
        let PD_ConfigGetParamsFile = __library.get(b"PD_ConfigGetParamsFile\0").map(|sym| *sym);
        let PD_ConfigDisableFCPadding = __library
            .get(b"PD_ConfigDisableFCPadding\0")
            .map(|sym| *sym);
        let PD_ConfigUseFcPadding = __library.get(b"PD_ConfigUseFcPadding\0").map(|sym| *sym);
        let PD_ConfigEnableUseGpu = __library.get(b"PD_ConfigEnableUseGpu\0").map(|sym| *sym);
        let PD_ConfigDisableGpu = __library.get(b"PD_ConfigDisableGpu\0").map(|sym| *sym);
        let PD_ConfigUseGpu = __library.get(b"PD_ConfigUseGpu\0").map(|sym| *sym);
        let PD_ConfigEnableXpu = __library.get(b"PD_ConfigEnableXpu\0").map(|sym| *sym);
        let PD_ConfigUseXpu = __library.get(b"PD_ConfigUseXpu\0").map(|sym| *sym);
        let PD_ConfigGpuDeviceId = __library.get(b"PD_ConfigGpuDeviceId\0").map(|sym| *sym);
        let PD_ConfigXpuDeviceId = __library.get(b"PD_ConfigXpuDeviceId\0").map(|sym| *sym);
        let PD_ConfigMemoryPoolInitSizeMb = __library
            .get(b"PD_ConfigMemoryPoolInitSizeMb\0")
            .map(|sym| *sym);
        let PD_ConfigFractionOfGpuMemoryForPool = __library
            .get(b"PD_ConfigFractionOfGpuMemoryForPool\0")
            .map(|sym| *sym);
        let PD_ConfigEnableCudnn = __library.get(b"PD_ConfigEnableCudnn\0").map(|sym| *sym);
        let PD_ConfigCudnnEnabled = __library.get(b"PD_ConfigCudnnEnabled\0").map(|sym| *sym);
        let PD_ConfigSwitchIrOptim = __library.get(b"PD_ConfigSwitchIrOptim\0").map(|sym| *sym);
        let PD_ConfigIrOptim = __library.get(b"PD_ConfigIrOptim\0").map(|sym| *sym);
        let PD_ConfigEnableTensorRtEngine = __library
            .get(b"PD_ConfigEnableTensorRtEngine\0")
            .map(|sym| *sym);
        let PD_ConfigTensorRtEngineEnabled = __library
            .get(b"PD_ConfigTensorRtEngineEnabled\0")
            .map(|sym| *sym);
        let PD_ConfigSetTrtDynamicShapeInfo = __library
            .get(b"PD_ConfigSetTrtDynamicShapeInfo\0")
            .map(|sym| *sym);
        let PD_ConfigDisableTensorRtOPs = __library
            .get(b"PD_ConfigDisableTensorRtOPs\0")
            .map(|sym| *sym);
        let PD_ConfigEnableTensorRtOSS = __library
            .get(b"PD_ConfigEnableTensorRtOSS\0")
            .map(|sym| *sym);
        let PD_ConfigTensorRtOssEnabled = __library
            .get(b"PD_ConfigTensorRtOssEnabled\0")
            .map(|sym| *sym);
        let PD_ConfigEnableTensorRtDla = __library
            .get(b"PD_ConfigEnableTensorRtDla\0")
            .map(|sym| *sym);
        let PD_ConfigTensorRtDlaEnabled = __library
            .get(b"PD_ConfigTensorRtDlaEnabled\0")
            .map(|sym| *sym);
        let PD_ConfigEnableLiteEngine = __library
            .get(b"PD_ConfigEnableLiteEngine\0")
            .map(|sym| *sym);
        let PD_ConfigLiteEngineEnabled = __library
            .get(b"PD_ConfigLiteEngineEnabled\0")
            .map(|sym| *sym);
        let PD_ConfigSwitchIrDebug = __library.get(b"PD_ConfigSwitchIrDebug\0").map(|sym| *sym);
        let PD_ConfigEnableMKLDNN = __library.get(b"PD_ConfigEnableMKLDNN\0").map(|sym| *sym);
        let PD_ConfigSetMkldnnCacheCapacity = __library
            .get(b"PD_ConfigSetMkldnnCacheCapacity\0")
            .map(|sym| *sym);
        let PD_ConfigMkldnnEnabled = __library.get(b"PD_ConfigMkldnnEnabled\0").map(|sym| *sym);
        let PD_ConfigSetCpuMathLibraryNumThreads = __library
            .get(b"PD_ConfigSetCpuMathLibraryNumThreads\0")
            .map(|sym| *sym);
        let PD_ConfigGetCpuMathLibraryNumThreads = __library
            .get(b"PD_ConfigGetCpuMathLibraryNumThreads\0")
            .map(|sym| *sym);
        let PD_ConfigSetMkldnnOp = __library.get(b"PD_ConfigSetMkldnnOp\0").map(|sym| *sym);
        let PD_ConfigEnableMkldnnQuantizer = __library
            .get(b"PD_ConfigEnableMkldnnQuantizer\0")
            .map(|sym| *sym);
        let PD_ConfigMkldnnQuantizerEnabled = __library
            .get(b"PD_ConfigMkldnnQuantizerEnabled\0")
            .map(|sym| *sym);
        let PD_ConfigEnableMkldnnBfloat16 = __library
            .get(b"PD_ConfigEnableMkldnnBfloat16\0")
            .map(|sym| *sym);
        let PD_ConfigMkldnnBfloat16Enabled = __library
            .get(b"PD_ConfigMkldnnBfloat16Enabled\0")
            .map(|sym| *sym);
        let PD_ConfigSetBfloat16Op = __library.get(b"PD_ConfigSetBfloat16Op\0").map(|sym| *sym);
        let PD_ConfigEnableGpuMultiStream = __library
            .get(b"PD_ConfigEnableGpuMultiStream\0")
            .map(|sym| *sym);
        let PD_ConfigThreadLocalStreamEnabled = __library
            .get(b"PD_ConfigThreadLocalStreamEnabled\0")
            .map(|sym| *sym);
        let PD_ConfigSetModelBuffer = __library.get(b"PD_ConfigSetModelBuffer\0").map(|sym| *sym);
        let PD_ConfigModelFromMemory = __library.get(b"PD_ConfigModelFromMemory\0").map(|sym| *sym);
        let PD_ConfigEnableMemoryOptim = __library
            .get(b"PD_ConfigEnableMemoryOptim\0")
            .map(|sym| *sym);
        let PD_ConfigMemoryOptimEnabled = __library
            .get(b"PD_ConfigMemoryOptimEnabled\0")
            .map(|sym| *sym);
        let PD_ConfigEnableProfile = __library.get(b"PD_ConfigEnableProfile\0").map(|sym| *sym);
        let PD_ConfigProfileEnabled = __library.get(b"PD_ConfigProfileEnabled\0").map(|sym| *sym);
        let PD_ConfigDisableGlogInfo = __library.get(b"PD_ConfigDisableGlogInfo\0").map(|sym| *sym);
        let PD_ConfigGlogInfoDisabled = __library
            .get(b"PD_ConfigGlogInfoDisabled\0")
            .map(|sym| *sym);
        let PD_ConfigSetInvalid = __library.get(b"PD_ConfigSetInvalid\0").map(|sym| *sym);
        let PD_ConfigIsValid = __library.get(b"PD_ConfigIsValid\0").map(|sym| *sym);
        let PD_ConfigPartiallyRelease = __library
            .get(b"PD_ConfigPartiallyRelease\0")
            .map(|sym| *sym);
        let PD_PredictorCreate = __library.get(b"PD_PredictorCreate\0").map(|sym| *sym);
        let PD_PredictorClone = __library.get(b"PD_PredictorClone\0").map(|sym| *sym);
        let PD_PredictorGetInputNames = __library
            .get(b"PD_PredictorGetInputNames\0")
            .map(|sym| *sym);
        let PD_PredictorGetOutputNames = __library
            .get(b"PD_PredictorGetOutputNames\0")
            .map(|sym| *sym);
        let PD_PredictorGetInputNum = __library.get(b"PD_PredictorGetInputNum\0").map(|sym| *sym);
        let PD_PredictorGetOutputNum = __library.get(b"PD_PredictorGetOutputNum\0").map(|sym| *sym);
        let PD_PredictorGetInputHandle = __library
            .get(b"PD_PredictorGetInputHandle\0")
            .map(|sym| *sym);
        let PD_PredictorGetOutputHandle = __library
            .get(b"PD_PredictorGetOutputHandle\0")
            .map(|sym| *sym);
        let PD_PredictorRun = __library.get(b"PD_PredictorRun\0").map(|sym| *sym);
        let PD_PredictorClearIntermediateTensor = __library
            .get(b"PD_PredictorClearIntermediateTensor\0")
            .map(|sym| *sym);
        let PD_PredictorTryShrinkMemory = __library
            .get(b"PD_PredictorTryShrinkMemory\0")
            .map(|sym| *sym);
        let PD_PredictorDestroy = __library.get(b"PD_PredictorDestroy\0").map(|sym| *sym);
        let PD_TensorDestroy = __library.get(b"PD_TensorDestroy\0").map(|sym| *sym);
        let PD_TensorReshape = __library.get(b"PD_TensorReshape\0").map(|sym| *sym);
        let PD_TensorMutableDataFloat = __library
            .get(b"PD_TensorMutableDataFloat\0")
            .map(|sym| *sym);
        let PD_TensorMutableDataInt64 = __library
            .get(b"PD_TensorMutableDataInt64\0")
            .map(|sym| *sym);
        let PD_TensorMutableDataInt32 = __library
            .get(b"PD_TensorMutableDataInt32\0")
            .map(|sym| *sym);
        let PD_TensorMutableDataUint8 = __library
            .get(b"PD_TensorMutableDataUint8\0")
            .map(|sym| *sym);
        let PD_TensorMutableDataInt8 = __library.get(b"PD_TensorMutableDataInt8\0").map(|sym| *sym);
        let PD_TensorDataFloat = __library.get(b"PD_TensorDataFloat\0").map(|sym| *sym);
        let PD_TensorDataInt64 = __library.get(b"PD_TensorDataInt64\0").map(|sym| *sym);
        let PD_TensorDataInt32 = __library.get(b"PD_TensorDataInt32\0").map(|sym| *sym);
        let PD_TensorDataUint8 = __library.get(b"PD_TensorDataUint8\0").map(|sym| *sym);
        let PD_TensorDataInt8 = __library.get(b"PD_TensorDataInt8\0").map(|sym| *sym);
        let PD_TensorCopyFromCpuFloat = __library
            .get(b"PD_TensorCopyFromCpuFloat\0")
            .map(|sym| *sym);
        let PD_TensorCopyFromCpuInt64 = __library
            .get(b"PD_TensorCopyFromCpuInt64\0")
            .map(|sym| *sym);
        let PD_TensorCopyFromCpuInt32 = __library
            .get(b"PD_TensorCopyFromCpuInt32\0")
            .map(|sym| *sym);
        let PD_TensorCopyFromCpuUint8 = __library
            .get(b"PD_TensorCopyFromCpuUint8\0")
            .map(|sym| *sym);
        let PD_TensorCopyFromCpuInt8 = __library.get(b"PD_TensorCopyFromCpuInt8\0").map(|sym| *sym);
        let PD_TensorCopyToCpuFloat = __library.get(b"PD_TensorCopyToCpuFloat\0").map(|sym| *sym);
        let PD_TensorCopyToCpuInt64 = __library.get(b"PD_TensorCopyToCpuInt64\0").map(|sym| *sym);
        let PD_TensorCopyToCpuInt32 = __library.get(b"PD_TensorCopyToCpuInt32\0").map(|sym| *sym);
        let PD_TensorCopyToCpuUint8 = __library.get(b"PD_TensorCopyToCpuUint8\0").map(|sym| *sym);
        let PD_TensorCopyToCpuInt8 = __library.get(b"PD_TensorCopyToCpuInt8\0").map(|sym| *sym);
        let PD_TensorGetShape = __library.get(b"PD_TensorGetShape\0").map(|sym| *sym);
        let PD_TensorSetLod = __library.get(b"PD_TensorSetLod\0").map(|sym| *sym);
        let PD_TensorGetLod = __library.get(b"PD_TensorGetLod\0").map(|sym| *sym);
        let PD_TensorGetName = __library.get(b"PD_TensorGetName\0").map(|sym| *sym);
        let PD_TensorGetDataType = __library.get(b"PD_TensorGetDataType\0").map(|sym| *sym);
        let PD_OneDimArrayInt32Destroy = __library
            .get(b"PD_OneDimArrayInt32Destroy\0")
            .map(|sym| *sym);
        let PD_OneDimArrayCstrDestroy = __library
            .get(b"PD_OneDimArrayCstrDestroy\0")
            .map(|sym| *sym);
        let PD_OneDimArraySizeDestroy = __library
            .get(b"PD_OneDimArraySizeDestroy\0")
            .map(|sym| *sym);
        let PD_TwoDimArraySizeDestroy = __library
            .get(b"PD_TwoDimArraySizeDestroy\0")
            .map(|sym| *sym);
        Ok(paddle_inference_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_ConfigCreate,
            PD_ConfigDestroy,
            PD_ConfigSetModel,
            PD_ConfigSetProgFile,
            PD_ConfigSetParamsFile,
            PD_ConfigSetOptimCacheDir,
            PD_ConfigSetModelDir,
            PD_ConfigGetModelDir,
            PD_ConfigGetProgFile,
            PD_ConfigGetParamsFile,
            PD_ConfigDisableFCPadding,
            PD_ConfigUseFcPadding,
            PD_ConfigEnableUseGpu,
            PD_ConfigDisableGpu,
            PD_ConfigUseGpu,
            PD_ConfigEnableXpu,
            PD_ConfigUseXpu,
            PD_ConfigGpuDeviceId,
            PD_ConfigXpuDeviceId,
            PD_ConfigMemoryPoolInitSizeMb,
            PD_ConfigFractionOfGpuMemoryForPool,
            PD_ConfigEnableCudnn,
            PD_ConfigCudnnEnabled,
            PD_ConfigSwitchIrOptim,
            PD_ConfigIrOptim,
            PD_ConfigEnableTensorRtEngine,
            PD_ConfigTensorRtEngineEnabled,
            PD_ConfigSetTrtDynamicShapeInfo,
            PD_ConfigDisableTensorRtOPs,
            PD_ConfigEnableTensorRtOSS,
            PD_ConfigTensorRtOssEnabled,
            PD_ConfigEnableTensorRtDla,
            PD_ConfigTensorRtDlaEnabled,
            PD_ConfigEnableLiteEngine,
            PD_ConfigLiteEngineEnabled,
            PD_ConfigSwitchIrDebug,
            PD_ConfigEnableMKLDNN,
            PD_ConfigSetMkldnnCacheCapacity,
            PD_ConfigMkldnnEnabled,
            PD_ConfigSetCpuMathLibraryNumThreads,
            PD_ConfigGetCpuMathLibraryNumThreads,
            PD_ConfigSetMkldnnOp,
            PD_ConfigEnableMkldnnQuantizer,
            PD_ConfigMkldnnQuantizerEnabled,
            PD_ConfigEnableMkldnnBfloat16,
            PD_ConfigMkldnnBfloat16Enabled,
            PD_ConfigSetBfloat16Op,
            PD_ConfigEnableGpuMultiStream,
            PD_ConfigThreadLocalStreamEnabled,
            PD_ConfigSetModelBuffer,
            PD_ConfigModelFromMemory,
            PD_ConfigEnableMemoryOptim,
            PD_ConfigMemoryOptimEnabled,
            PD_ConfigEnableProfile,
            PD_ConfigProfileEnabled,
            PD_ConfigDisableGlogInfo,
            PD_ConfigGlogInfoDisabled,
            PD_ConfigSetInvalid,
            PD_ConfigIsValid,
            PD_ConfigPartiallyRelease,
            PD_PredictorCreate,
            PD_PredictorClone,
            PD_PredictorGetInputNames,
            PD_PredictorGetOutputNames,
            PD_PredictorGetInputNum,
            PD_PredictorGetOutputNum,
            PD_PredictorGetInputHandle,
            PD_PredictorGetOutputHandle,
            PD_PredictorRun,
            PD_PredictorClearIntermediateTensor,
            PD_PredictorTryShrinkMemory,
            PD_PredictorDestroy,
            PD_TensorDestroy,
            PD_TensorReshape,
            PD_TensorMutableDataFloat,
            PD_TensorMutableDataInt64,
            PD_TensorMutableDataInt32,
            PD_TensorMutableDataUint8,
            PD_TensorMutableDataInt8,
            PD_TensorDataFloat,
            PD_TensorDataInt64,
            PD_TensorDataInt32,
            PD_TensorDataUint8,
            PD_TensorDataInt8,
            PD_TensorCopyFromCpuFloat,
            PD_TensorCopyFromCpuInt64,
            PD_TensorCopyFromCpuInt32,
            PD_TensorCopyFromCpuUint8,
            PD_TensorCopyFromCpuInt8,
            PD_TensorCopyToCpuFloat,
            PD_TensorCopyToCpuInt64,
            PD_TensorCopyToCpuInt32,
            PD_TensorCopyToCpuUint8,
            PD_TensorCopyToCpuInt8,
            PD_TensorGetShape,
            PD_TensorSetLod,
            PD_TensorGetLod,
            PD_TensorGetName,
            PD_TensorGetDataType,
            PD_OneDimArrayInt32Destroy,
            PD_OneDimArrayCstrDestroy,
            PD_OneDimArraySizeDestroy,
            PD_TwoDimArraySizeDestroy,
        })
    }
    pub unsafe fn remove(
        &self,
        __filename: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int {
        (self.remove.as_ref().expect("Expected function, got error."))(__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 {
        (self.rename.as_ref().expect("Expected function, got error."))(__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 {
        (self
            .renameat
            .as_ref()
            .expect("Expected function, got error."))(__oldfd, __old, __newfd, __new)
    }
    pub unsafe fn tmpfile(&self) -> *mut FILE {
        (self
            .tmpfile
            .as_ref()
            .expect("Expected function, got error."))()
    }
    pub unsafe fn tmpnam(&self, __s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char {
        (self.tmpnam.as_ref().expect("Expected function, got error."))(__s)
    }
    pub unsafe fn tmpnam_r(&self, __s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char {
        (self
            .tmpnam_r
            .as_ref()
            .expect("Expected function, got error."))(__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 {
        (self
            .tempnam
            .as_ref()
            .expect("Expected function, got error."))(__dir, __pfx)
    }
    pub unsafe fn fclose(&self, __stream: *mut FILE) -> ::std::os::raw::c_int {
        (self.fclose.as_ref().expect("Expected function, got error."))(__stream)
    }
    pub unsafe fn fflush(&self, __stream: *mut FILE) -> ::std::os::raw::c_int {
        (self.fflush.as_ref().expect("Expected function, got error."))(__stream)
    }
    pub unsafe fn fflush_unlocked(&self, __stream: *mut FILE) -> ::std::os::raw::c_int {
        (self
            .fflush_unlocked
            .as_ref()
            .expect("Expected function, got error."))(__stream)
    }
    pub unsafe fn fopen(
        &self,
        __filename: *const ::std::os::raw::c_char,
        __modes: *const ::std::os::raw::c_char,
    ) -> *mut FILE {
        (self.fopen.as_ref().expect("Expected function, got error."))(__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 {
        (self
            .freopen
            .as_ref()
            .expect("Expected function, got error."))(__filename, __modes, __stream)
    }
    pub unsafe fn fdopen(
        &self,
        __fd: ::std::os::raw::c_int,
        __modes: *const ::std::os::raw::c_char,
    ) -> *mut FILE {
        (self.fdopen.as_ref().expect("Expected function, got error."))(__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 {
        (self
            .fmemopen
            .as_ref()
            .expect("Expected function, got error."))(__s, __len, __modes)
    }
    pub unsafe fn open_memstream(
        &self,
        __bufloc: *mut *mut ::std::os::raw::c_char,
        __sizeloc: *mut size_t,
    ) -> *mut FILE {
        (self
            .open_memstream
            .as_ref()
            .expect("Expected function, got error."))(__bufloc, __sizeloc)
    }
    pub unsafe fn setbuf(&self, __stream: *mut FILE, __buf: *mut ::std::os::raw::c_char) -> () {
        (self.setbuf.as_ref().expect("Expected function, got error."))(__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 {
        (self
            .setvbuf
            .as_ref()
            .expect("Expected function, got error."))(__stream, __buf, __modes, __n)
    }
    pub unsafe fn setbuffer(
        &self,
        __stream: *mut FILE,
        __buf: *mut ::std::os::raw::c_char,
        __size: size_t,
    ) -> () {
        (self
            .setbuffer
            .as_ref()
            .expect("Expected function, got error."))(__stream, __buf, __size)
    }
    pub unsafe fn setlinebuf(&self, __stream: *mut FILE) -> () {
        (self
            .setlinebuf
            .as_ref()
            .expect("Expected function, got error."))(__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 {
        (self
            .vfprintf
            .as_ref()
            .expect("Expected function, got error."))(__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 {
        (self
            .vprintf
            .as_ref()
            .expect("Expected function, got error."))(__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 {
        (self
            .vsprintf
            .as_ref()
            .expect("Expected function, got error."))(__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 {
        (self
            .vsnprintf
            .as_ref()
            .expect("Expected function, got error."))(__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 {
        (self
            .vdprintf
            .as_ref()
            .expect("Expected function, got error."))(__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 {
        (self
            .vfscanf
            .as_ref()
            .expect("Expected function, got error."))(__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 {
        (self.vscanf.as_ref().expect("Expected function, got error."))(__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 {
        (self
            .vsscanf
            .as_ref()
            .expect("Expected function, got error."))(__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 {
        (self
            .vfscanf1
            .as_ref()
            .expect("Expected function, got error."))(__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 {
        (self
            .vscanf1
            .as_ref()
            .expect("Expected function, got error."))(__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 {
        (self
            .vsscanf1
            .as_ref()
            .expect("Expected function, got error."))(__s, __format, __arg)
    }
    pub unsafe fn fgetc(&self, __stream: *mut FILE) -> ::std::os::raw::c_int {
        (self.fgetc.as_ref().expect("Expected function, got error."))(__stream)
    }
    pub unsafe fn getc(&self, __stream: *mut FILE) -> ::std::os::raw::c_int {
        (self.getc.as_ref().expect("Expected function, got error."))(__stream)
    }
    pub unsafe fn getchar(&self) -> ::std::os::raw::c_int {
        (self
            .getchar
            .as_ref()
            .expect("Expected function, got error."))()
    }
    pub unsafe fn getc_unlocked(&self, __stream: *mut FILE) -> ::std::os::raw::c_int {
        (self
            .getc_unlocked
            .as_ref()
            .expect("Expected function, got error."))(__stream)
    }
    pub unsafe fn getchar_unlocked(&self) -> ::std::os::raw::c_int {
        (self
            .getchar_unlocked
            .as_ref()
            .expect("Expected function, got error."))()
    }
    pub unsafe fn fgetc_unlocked(&self, __stream: *mut FILE) -> ::std::os::raw::c_int {
        (self
            .fgetc_unlocked
            .as_ref()
            .expect("Expected function, got error."))(__stream)
    }
    pub unsafe fn fputc(
        &self,
        __c: ::std::os::raw::c_int,
        __stream: *mut FILE,
    ) -> ::std::os::raw::c_int {
        (self.fputc.as_ref().expect("Expected function, got error."))(__c, __stream)
    }
    pub unsafe fn putc(
        &self,
        __c: ::std::os::raw::c_int,
        __stream: *mut FILE,
    ) -> ::std::os::raw::c_int {
        (self.putc.as_ref().expect("Expected function, got error."))(__c, __stream)
    }
    pub unsafe fn putchar(&self, __c: ::std::os::raw::c_int) -> ::std::os::raw::c_int {
        (self
            .putchar
            .as_ref()
            .expect("Expected function, got error."))(__c)
    }
    pub unsafe fn fputc_unlocked(
        &self,
        __c: ::std::os::raw::c_int,
        __stream: *mut FILE,
    ) -> ::std::os::raw::c_int {
        (self
            .fputc_unlocked
            .as_ref()
            .expect("Expected function, got error."))(__c, __stream)
    }
    pub unsafe fn putc_unlocked(
        &self,
        __c: ::std::os::raw::c_int,
        __stream: *mut FILE,
    ) -> ::std::os::raw::c_int {
        (self
            .putc_unlocked
            .as_ref()
            .expect("Expected function, got error."))(__c, __stream)
    }
    pub unsafe fn putchar_unlocked(&self, __c: ::std::os::raw::c_int) -> ::std::os::raw::c_int {
        (self
            .putchar_unlocked
            .as_ref()
            .expect("Expected function, got error."))(__c)
    }
    pub unsafe fn getw(&self, __stream: *mut FILE) -> ::std::os::raw::c_int {
        (self.getw.as_ref().expect("Expected function, got error."))(__stream)
    }
    pub unsafe fn putw(
        &self,
        __w: ::std::os::raw::c_int,
        __stream: *mut FILE,
    ) -> ::std::os::raw::c_int {
        (self.putw.as_ref().expect("Expected function, got error."))(__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 {
        (self.fgets.as_ref().expect("Expected function, got error."))(__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 {
        (self
            .__getdelim
            .as_ref()
            .expect("Expected function, got error."))(__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 {
        (self
            .getdelim
            .as_ref()
            .expect("Expected function, got error."))(__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 {
        (self
            .getline
            .as_ref()
            .expect("Expected function, got error."))(__lineptr, __n, __stream)
    }
    pub unsafe fn fputs(
        &self,
        __s: *const ::std::os::raw::c_char,
        __stream: *mut FILE,
    ) -> ::std::os::raw::c_int {
        (self.fputs.as_ref().expect("Expected function, got error."))(__s, __stream)
    }
    pub unsafe fn puts(&self, __s: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int {
        (self.puts.as_ref().expect("Expected function, got error."))(__s)
    }
    pub unsafe fn ungetc(
        &self,
        __c: ::std::os::raw::c_int,
        __stream: *mut FILE,
    ) -> ::std::os::raw::c_int {
        (self.ungetc.as_ref().expect("Expected function, got error."))(__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 {
        (self.fread.as_ref().expect("Expected function, got error."))(__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 {
        (self.fwrite.as_ref().expect("Expected function, got error."))(__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 {
        (self
            .fread_unlocked
            .as_ref()
            .expect("Expected function, got error."))(__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 {
        (self
            .fwrite_unlocked
            .as_ref()
            .expect("Expected function, got error."))(__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 {
        (self.fseek.as_ref().expect("Expected function, got error."))(__stream, __off, __whence)
    }
    pub unsafe fn ftell(&self, __stream: *mut FILE) -> ::std::os::raw::c_long {
        (self.ftell.as_ref().expect("Expected function, got error."))(__stream)
    }
    pub unsafe fn rewind(&self, __stream: *mut FILE) -> () {
        (self.rewind.as_ref().expect("Expected function, got error."))(__stream)
    }
    pub unsafe fn fseeko(
        &self,
        __stream: *mut FILE,
        __off: __off_t,
        __whence: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int {
        (self.fseeko.as_ref().expect("Expected function, got error."))(__stream, __off, __whence)
    }
    pub unsafe fn ftello(&self, __stream: *mut FILE) -> __off_t {
        (self.ftello.as_ref().expect("Expected function, got error."))(__stream)
    }
    pub unsafe fn fgetpos(&self, __stream: *mut FILE, __pos: *mut fpos_t) -> ::std::os::raw::c_int {
        (self
            .fgetpos
            .as_ref()
            .expect("Expected function, got error."))(__stream, __pos)
    }
    pub unsafe fn fsetpos(
        &self,
        __stream: *mut FILE,
        __pos: *const fpos_t,
    ) -> ::std::os::raw::c_int {
        (self
            .fsetpos
            .as_ref()
            .expect("Expected function, got error."))(__stream, __pos)
    }
    pub unsafe fn clearerr(&self, __stream: *mut FILE) -> () {
        (self
            .clearerr
            .as_ref()
            .expect("Expected function, got error."))(__stream)
    }
    pub unsafe fn feof(&self, __stream: *mut FILE) -> ::std::os::raw::c_int {
        (self.feof.as_ref().expect("Expected function, got error."))(__stream)
    }
    pub unsafe fn ferror(&self, __stream: *mut FILE) -> ::std::os::raw::c_int {
        (self.ferror.as_ref().expect("Expected function, got error."))(__stream)
    }
    pub unsafe fn clearerr_unlocked(&self, __stream: *mut FILE) -> () {
        (self
            .clearerr_unlocked
            .as_ref()
            .expect("Expected function, got error."))(__stream)
    }
    pub unsafe fn feof_unlocked(&self, __stream: *mut FILE) -> ::std::os::raw::c_int {
        (self
            .feof_unlocked
            .as_ref()
            .expect("Expected function, got error."))(__stream)
    }
    pub unsafe fn ferror_unlocked(&self, __stream: *mut FILE) -> ::std::os::raw::c_int {
        (self
            .ferror_unlocked
            .as_ref()
            .expect("Expected function, got error."))(__stream)
    }
    pub unsafe fn perror(&self, __s: *const ::std::os::raw::c_char) -> () {
        (self.perror.as_ref().expect("Expected function, got error."))(__s)
    }
    pub unsafe fn fileno(&self, __stream: *mut FILE) -> ::std::os::raw::c_int {
        (self.fileno.as_ref().expect("Expected function, got error."))(__stream)
    }
    pub unsafe fn fileno_unlocked(&self, __stream: *mut FILE) -> ::std::os::raw::c_int {
        (self
            .fileno_unlocked
            .as_ref()
            .expect("Expected function, got error."))(__stream)
    }
    pub unsafe fn popen(
        &self,
        __command: *const ::std::os::raw::c_char,
        __modes: *const ::std::os::raw::c_char,
    ) -> *mut FILE {
        (self.popen.as_ref().expect("Expected function, got error."))(__command, __modes)
    }
    pub unsafe fn pclose(&self, __stream: *mut FILE) -> ::std::os::raw::c_int {
        (self.pclose.as_ref().expect("Expected function, got error."))(__stream)
    }
    pub unsafe fn ctermid(&self, __s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char {
        (self
            .ctermid
            .as_ref()
            .expect("Expected function, got error."))(__s)
    }
    pub unsafe fn flockfile(&self, __stream: *mut FILE) -> () {
        (self
            .flockfile
            .as_ref()
            .expect("Expected function, got error."))(__stream)
    }
    pub unsafe fn ftrylockfile(&self, __stream: *mut FILE) -> ::std::os::raw::c_int {
        (self
            .ftrylockfile
            .as_ref()
            .expect("Expected function, got error."))(__stream)
    }
    pub unsafe fn funlockfile(&self, __stream: *mut FILE) -> () {
        (self
            .funlockfile
            .as_ref()
            .expect("Expected function, got error."))(__stream)
    }
    pub unsafe fn __uflow(&self, arg1: *mut FILE) -> ::std::os::raw::c_int {
        (self
            .__uflow
            .as_ref()
            .expect("Expected function, got error."))(arg1)
    }
    pub unsafe fn __overflow(
        &self,
        arg1: *mut FILE,
        arg2: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int {
        (self
            .__overflow
            .as_ref()
            .expect("Expected function, got error."))(arg1, arg2)
    }
    pub unsafe fn PD_ConfigCreate(&self) -> *mut PD_Config {
        (self
            .PD_ConfigCreate
            .as_ref()
            .expect("Expected function, got error."))()
    }
    pub unsafe fn PD_ConfigDestroy(&self, pd_config: *mut PD_Config) -> () {
        (self
            .PD_ConfigDestroy
            .as_ref()
            .expect("Expected function, got error."))(pd_config)
    }
    pub unsafe fn PD_ConfigSetModel(
        &self,
        pd_config: *mut PD_Config,
        prog_file_path: *const ::std::os::raw::c_char,
        params_file_path: *const ::std::os::raw::c_char,
    ) -> () {
        (self
            .PD_ConfigSetModel
            .as_ref()
            .expect("Expected function, got error."))(
            pd_config, prog_file_path, params_file_path
        )
    }
    pub unsafe fn PD_ConfigSetProgFile(
        &self,
        pd_config: *mut PD_Config,
        prog_file_path: *const ::std::os::raw::c_char,
    ) -> () {
        (self
            .PD_ConfigSetProgFile
            .as_ref()
            .expect("Expected function, got error."))(pd_config, prog_file_path)
    }
    pub unsafe fn PD_ConfigSetParamsFile(
        &self,
        pd_config: *mut PD_Config,
        params_file_path: *const ::std::os::raw::c_char,
    ) -> () {
        (self
            .PD_ConfigSetParamsFile
            .as_ref()
            .expect("Expected function, got error."))(pd_config, params_file_path)
    }
    pub unsafe fn PD_ConfigSetOptimCacheDir(
        &self,
        pd_config: *mut PD_Config,
        opt_cache_dir: *const ::std::os::raw::c_char,
    ) -> () {
        (self
            .PD_ConfigSetOptimCacheDir
            .as_ref()
            .expect("Expected function, got error."))(pd_config, opt_cache_dir)
    }
    pub unsafe fn PD_ConfigSetModelDir(
        &self,
        pd_config: *mut PD_Config,
        model_dir: *const ::std::os::raw::c_char,
    ) -> () {
        (self
            .PD_ConfigSetModelDir
            .as_ref()
            .expect("Expected function, got error."))(pd_config, model_dir)
    }
    pub unsafe fn PD_ConfigGetModelDir(
        &self,
        pd_config: *mut PD_Config,
    ) -> *const ::std::os::raw::c_char {
        (self
            .PD_ConfigGetModelDir
            .as_ref()
            .expect("Expected function, got error."))(pd_config)
    }
    pub unsafe fn PD_ConfigGetProgFile(
        &self,
        pd_config: *mut PD_Config,
    ) -> *const ::std::os::raw::c_char {
        (self
            .PD_ConfigGetProgFile
            .as_ref()
            .expect("Expected function, got error."))(pd_config)
    }
    pub unsafe fn PD_ConfigGetParamsFile(
        &self,
        pd_config: *mut PD_Config,
    ) -> *const ::std::os::raw::c_char {
        (self
            .PD_ConfigGetParamsFile
            .as_ref()
            .expect("Expected function, got error."))(pd_config)
    }
    pub unsafe fn PD_ConfigDisableFCPadding(&self, pd_config: *mut PD_Config) -> () {
        (self
            .PD_ConfigDisableFCPadding
            .as_ref()
            .expect("Expected function, got error."))(pd_config)
    }
    pub unsafe fn PD_ConfigUseFcPadding(&self, pd_config: *mut PD_Config) -> PD_Bool {
        (self
            .PD_ConfigUseFcPadding
            .as_ref()
            .expect("Expected function, got error."))(pd_config)
    }
    pub unsafe fn PD_ConfigEnableUseGpu(
        &self,
        pd_config: *mut PD_Config,
        memory_pool_init_size_mb: u64,
        device_id: i32,
    ) -> () {
        (self
            .PD_ConfigEnableUseGpu
            .as_ref()
            .expect("Expected function, got error."))(
            pd_config,
            memory_pool_init_size_mb,
            device_id,
        )
    }
    pub unsafe fn PD_ConfigDisableGpu(&self, pd_config: *mut PD_Config) -> () {
        (self
            .PD_ConfigDisableGpu
            .as_ref()
            .expect("Expected function, got error."))(pd_config)
    }
    pub unsafe fn PD_ConfigUseGpu(&self, pd_config: *mut PD_Config) -> PD_Bool {
        (self
            .PD_ConfigUseGpu
            .as_ref()
            .expect("Expected function, got error."))(pd_config)
    }
    pub unsafe fn PD_ConfigEnableXpu(
        &self,
        pd_config: *mut PD_Config,
        l3_workspace_size: i32,
    ) -> () {
        (self
            .PD_ConfigEnableXpu
            .as_ref()
            .expect("Expected function, got error."))(pd_config, l3_workspace_size)
    }
    pub unsafe fn PD_ConfigUseXpu(&self, pd_config: *mut PD_Config) -> PD_Bool {
        (self
            .PD_ConfigUseXpu
            .as_ref()
            .expect("Expected function, got error."))(pd_config)
    }
    pub unsafe fn PD_ConfigGpuDeviceId(&self, pd_config: *mut PD_Config) -> i32 {
        (self
            .PD_ConfigGpuDeviceId
            .as_ref()
            .expect("Expected function, got error."))(pd_config)
    }
    pub unsafe fn PD_ConfigXpuDeviceId(&self, pd_config: *mut PD_Config) -> i32 {
        (self
            .PD_ConfigXpuDeviceId
            .as_ref()
            .expect("Expected function, got error."))(pd_config)
    }
    pub unsafe fn PD_ConfigMemoryPoolInitSizeMb(&self, pd_config: *mut PD_Config) -> i32 {
        (self
            .PD_ConfigMemoryPoolInitSizeMb
            .as_ref()
            .expect("Expected function, got error."))(pd_config)
    }
    pub unsafe fn PD_ConfigFractionOfGpuMemoryForPool(&self, pd_config: *mut PD_Config) -> f32 {
        (self
            .PD_ConfigFractionOfGpuMemoryForPool
            .as_ref()
            .expect("Expected function, got error."))(pd_config)
    }
    pub unsafe fn PD_ConfigEnableCudnn(&self, pd_config: *mut PD_Config) -> () {
        (self
            .PD_ConfigEnableCudnn
            .as_ref()
            .expect("Expected function, got error."))(pd_config)
    }
    pub unsafe fn PD_ConfigCudnnEnabled(&self, pd_config: *mut PD_Config) -> PD_Bool {
        (self
            .PD_ConfigCudnnEnabled
            .as_ref()
            .expect("Expected function, got error."))(pd_config)
    }
    pub unsafe fn PD_ConfigSwitchIrOptim(&self, pd_config: *mut PD_Config, x: PD_Bool) -> () {
        (self
            .PD_ConfigSwitchIrOptim
            .as_ref()
            .expect("Expected function, got error."))(pd_config, x)
    }
    pub unsafe fn PD_ConfigIrOptim(&self, pd_config: *mut PD_Config) -> PD_Bool {
        (self
            .PD_ConfigIrOptim
            .as_ref()
            .expect("Expected function, got error."))(pd_config)
    }
    pub unsafe fn PD_ConfigEnableTensorRtEngine(
        &self,
        pd_config: *mut PD_Config,
        workspace_size: i32,
        max_batch_size: i32,
        min_subgraph_size: i32,
        precision: PD_PrecisionType,
        use_static: PD_Bool,
        use_calib_mode: PD_Bool,
    ) -> () {
        (self
            .PD_ConfigEnableTensorRtEngine
            .as_ref()
            .expect("Expected function, got error."))(
            pd_config,
            workspace_size,
            max_batch_size,
            min_subgraph_size,
            precision,
            use_static,
            use_calib_mode,
        )
    }
    pub unsafe fn PD_ConfigTensorRtEngineEnabled(&self, pd_config: *mut PD_Config) -> PD_Bool {
        (self
            .PD_ConfigTensorRtEngineEnabled
            .as_ref()
            .expect("Expected function, got error."))(pd_config)
    }
    pub unsafe fn PD_ConfigSetTrtDynamicShapeInfo(
        &self,
        pd_config: *mut PD_Config,
        tensor_num: size_t,
        tensor_name: *mut *const ::std::os::raw::c_char,
        shapes_num: *mut size_t,
        min_shape: *mut *mut i32,
        max_shape: *mut *mut i32,
        optim_shape: *mut *mut i32,
        disable_trt_plugin_fp16: PD_Bool,
    ) -> () {
        (self
            .PD_ConfigSetTrtDynamicShapeInfo
            .as_ref()
            .expect("Expected function, got error."))(
            pd_config,
            tensor_num,
            tensor_name,
            shapes_num,
            min_shape,
            max_shape,
            optim_shape,
            disable_trt_plugin_fp16,
        )
    }
    pub unsafe fn PD_ConfigDisableTensorRtOPs(
        &self,
        pd_config: *mut PD_Config,
        ops_num: size_t,
        ops_name: *mut *const ::std::os::raw::c_char,
    ) -> () {
        (self
            .PD_ConfigDisableTensorRtOPs
            .as_ref()
            .expect("Expected function, got error."))(pd_config, ops_num, ops_name)
    }
    pub unsafe fn PD_ConfigEnableTensorRtOSS(&self, pd_config: *mut PD_Config) -> () {
        (self
            .PD_ConfigEnableTensorRtOSS
            .as_ref()
            .expect("Expected function, got error."))(pd_config)
    }
    pub unsafe fn PD_ConfigTensorRtOssEnabled(&self, pd_config: *mut PD_Config) -> PD_Bool {
        (self
            .PD_ConfigTensorRtOssEnabled
            .as_ref()
            .expect("Expected function, got error."))(pd_config)
    }
    pub unsafe fn PD_ConfigEnableTensorRtDla(
        &self,
        pd_config: *mut PD_Config,
        dla_core: i32,
    ) -> () {
        (self
            .PD_ConfigEnableTensorRtDla
            .as_ref()
            .expect("Expected function, got error."))(pd_config, dla_core)
    }
    pub unsafe fn PD_ConfigTensorRtDlaEnabled(&self, pd_config: *mut PD_Config) -> PD_Bool {
        (self
            .PD_ConfigTensorRtDlaEnabled
            .as_ref()
            .expect("Expected function, got error."))(pd_config)
    }
    pub unsafe fn PD_ConfigEnableLiteEngine(
        &self,
        pd_config: *mut PD_Config,
        precision: PD_PrecisionType,
        zero_copy: PD_Bool,
        passes_filter_num: size_t,
        passes_filter: *mut *const ::std::os::raw::c_char,
        ops_filter_num: size_t,
        ops_filter: *mut *const ::std::os::raw::c_char,
    ) -> () {
        (self
            .PD_ConfigEnableLiteEngine
            .as_ref()
            .expect("Expected function, got error."))(
            pd_config,
            precision,
            zero_copy,
            passes_filter_num,
            passes_filter,
            ops_filter_num,
            ops_filter,
        )
    }
    pub unsafe fn PD_ConfigLiteEngineEnabled(&self, pd_config: *mut PD_Config) -> PD_Bool {
        (self
            .PD_ConfigLiteEngineEnabled
            .as_ref()
            .expect("Expected function, got error."))(pd_config)
    }
    pub unsafe fn PD_ConfigSwitchIrDebug(&self, pd_config: *mut PD_Config, x: PD_Bool) -> () {
        (self
            .PD_ConfigSwitchIrDebug
            .as_ref()
            .expect("Expected function, got error."))(pd_config, x)
    }
    pub unsafe fn PD_ConfigEnableMKLDNN(&self, pd_config: *mut PD_Config) -> () {
        (self
            .PD_ConfigEnableMKLDNN
            .as_ref()
            .expect("Expected function, got error."))(pd_config)
    }
    pub unsafe fn PD_ConfigSetMkldnnCacheCapacity(
        &self,
        pd_config: *mut PD_Config,
        capacity: i32,
    ) -> () {
        (self
            .PD_ConfigSetMkldnnCacheCapacity
            .as_ref()
            .expect("Expected function, got error."))(pd_config, capacity)
    }
    pub unsafe fn PD_ConfigMkldnnEnabled(&self, pd_config: *mut PD_Config) -> PD_Bool {
        (self
            .PD_ConfigMkldnnEnabled
            .as_ref()
            .expect("Expected function, got error."))(pd_config)
    }
    pub unsafe fn PD_ConfigSetCpuMathLibraryNumThreads(
        &self,
        pd_config: *mut PD_Config,
        cpu_math_library_num_threads: i32,
    ) -> () {
        (self
            .PD_ConfigSetCpuMathLibraryNumThreads
            .as_ref()
            .expect("Expected function, got error."))(
            pd_config, cpu_math_library_num_threads
        )
    }
    pub unsafe fn PD_ConfigGetCpuMathLibraryNumThreads(&self, pd_config: *mut PD_Config) -> i32 {
        (self
            .PD_ConfigGetCpuMathLibraryNumThreads
            .as_ref()
            .expect("Expected function, got error."))(pd_config)
    }
    pub unsafe fn PD_ConfigSetMkldnnOp(
        &self,
        pd_config: *mut PD_Config,
        ops_num: size_t,
        op_list: *mut *const ::std::os::raw::c_char,
    ) -> () {
        (self
            .PD_ConfigSetMkldnnOp
            .as_ref()
            .expect("Expected function, got error."))(pd_config, ops_num, op_list)
    }
    pub unsafe fn PD_ConfigEnableMkldnnQuantizer(&self, pd_config: *mut PD_Config) -> () {
        (self
            .PD_ConfigEnableMkldnnQuantizer
            .as_ref()
            .expect("Expected function, got error."))(pd_config)
    }
    pub unsafe fn PD_ConfigMkldnnQuantizerEnabled(&self, pd_config: *mut PD_Config) -> PD_Bool {
        (self
            .PD_ConfigMkldnnQuantizerEnabled
            .as_ref()
            .expect("Expected function, got error."))(pd_config)
    }
    pub unsafe fn PD_ConfigEnableMkldnnBfloat16(&self, pd_config: *mut PD_Config) -> () {
        (self
            .PD_ConfigEnableMkldnnBfloat16
            .as_ref()
            .expect("Expected function, got error."))(pd_config)
    }
    pub unsafe fn PD_ConfigMkldnnBfloat16Enabled(&self, pd_config: *mut PD_Config) -> PD_Bool {
        (self
            .PD_ConfigMkldnnBfloat16Enabled
            .as_ref()
            .expect("Expected function, got error."))(pd_config)
    }
    pub unsafe fn PD_ConfigSetBfloat16Op(
        &self,
        pd_config: *mut PD_Config,
        ops_num: size_t,
        op_list: *mut *const ::std::os::raw::c_char,
    ) -> () {
        (self
            .PD_ConfigSetBfloat16Op
            .as_ref()
            .expect("Expected function, got error."))(pd_config, ops_num, op_list)
    }
    pub unsafe fn PD_ConfigEnableGpuMultiStream(&self, pd_config: *mut PD_Config) -> () {
        (self
            .PD_ConfigEnableGpuMultiStream
            .as_ref()
            .expect("Expected function, got error."))(pd_config)
    }
    pub unsafe fn PD_ConfigThreadLocalStreamEnabled(&self, pd_config: *mut PD_Config) -> PD_Bool {
        (self
            .PD_ConfigThreadLocalStreamEnabled
            .as_ref()
            .expect("Expected function, got error."))(pd_config)
    }
    pub unsafe fn PD_ConfigSetModelBuffer(
        &self,
        pd_config: *mut PD_Config,
        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,
    ) -> () {
        (self
            .PD_ConfigSetModelBuffer
            .as_ref()
            .expect("Expected function, got error."))(
            pd_config,
            prog_buffer,
            prog_buffer_size,
            params_buffer,
            params_buffer_size,
        )
    }
    pub unsafe fn PD_ConfigModelFromMemory(&self, pd_config: *mut PD_Config) -> PD_Bool {
        (self
            .PD_ConfigModelFromMemory
            .as_ref()
            .expect("Expected function, got error."))(pd_config)
    }
    pub unsafe fn PD_ConfigEnableMemoryOptim(&self, pd_config: *mut PD_Config) -> () {
        (self
            .PD_ConfigEnableMemoryOptim
            .as_ref()
            .expect("Expected function, got error."))(pd_config)
    }
    pub unsafe fn PD_ConfigMemoryOptimEnabled(&self, pd_config: *mut PD_Config) -> PD_Bool {
        (self
            .PD_ConfigMemoryOptimEnabled
            .as_ref()
            .expect("Expected function, got error."))(pd_config)
    }
    pub unsafe fn PD_ConfigEnableProfile(&self, pd_config: *mut PD_Config) -> () {
        (self
            .PD_ConfigEnableProfile
            .as_ref()
            .expect("Expected function, got error."))(pd_config)
    }
    pub unsafe fn PD_ConfigProfileEnabled(&self, pd_config: *mut PD_Config) -> PD_Bool {
        (self
            .PD_ConfigProfileEnabled
            .as_ref()
            .expect("Expected function, got error."))(pd_config)
    }
    pub unsafe fn PD_ConfigDisableGlogInfo(&self, pd_config: *mut PD_Config) -> () {
        (self
            .PD_ConfigDisableGlogInfo
            .as_ref()
            .expect("Expected function, got error."))(pd_config)
    }
    pub unsafe fn PD_ConfigGlogInfoDisabled(&self, pd_config: *mut PD_Config) -> PD_Bool {
        (self
            .PD_ConfigGlogInfoDisabled
            .as_ref()
            .expect("Expected function, got error."))(pd_config)
    }
    pub unsafe fn PD_ConfigSetInvalid(&self, pd_config: *mut PD_Config) -> () {
        (self
            .PD_ConfigSetInvalid
            .as_ref()
            .expect("Expected function, got error."))(pd_config)
    }
    pub unsafe fn PD_ConfigIsValid(&self, pd_config: *mut PD_Config) -> PD_Bool {
        (self
            .PD_ConfigIsValid
            .as_ref()
            .expect("Expected function, got error."))(pd_config)
    }
    pub unsafe fn PD_ConfigPartiallyRelease(&self, pd_config: *mut PD_Config) -> () {
        (self
            .PD_ConfigPartiallyRelease
            .as_ref()
            .expect("Expected function, got error."))(pd_config)
    }
    pub unsafe fn PD_PredictorCreate(&self, pd_config: *mut PD_Config) -> *mut PD_Predictor {
        (self
            .PD_PredictorCreate
            .as_ref()
            .expect("Expected function, got error."))(pd_config)
    }
    pub unsafe fn PD_PredictorClone(&self, pd_predictor: *mut PD_Predictor) -> *mut PD_Predictor {
        (self
            .PD_PredictorClone
            .as_ref()
            .expect("Expected function, got error."))(pd_predictor)
    }
    pub unsafe fn PD_PredictorGetInputNames(
        &self,
        pd_predictor: *mut PD_Predictor,
    ) -> *mut PD_OneDimArrayCstr {
        (self
            .PD_PredictorGetInputNames
            .as_ref()
            .expect("Expected function, got error."))(pd_predictor)
    }
    pub unsafe fn PD_PredictorGetOutputNames(
        &self,
        pd_predictor: *mut PD_Predictor,
    ) -> *mut PD_OneDimArrayCstr {
        (self
            .PD_PredictorGetOutputNames
            .as_ref()
            .expect("Expected function, got error."))(pd_predictor)
    }
    pub unsafe fn PD_PredictorGetInputNum(&self, pd_predictor: *mut PD_Predictor) -> size_t {
        (self
            .PD_PredictorGetInputNum
            .as_ref()
            .expect("Expected function, got error."))(pd_predictor)
    }
    pub unsafe fn PD_PredictorGetOutputNum(&self, pd_predictor: *mut PD_Predictor) -> size_t {
        (self
            .PD_PredictorGetOutputNum
            .as_ref()
            .expect("Expected function, got error."))(pd_predictor)
    }
    pub unsafe fn PD_PredictorGetInputHandle(
        &self,
        pd_predictor: *mut PD_Predictor,
        name: *const ::std::os::raw::c_char,
    ) -> *mut PD_Tensor {
        (self
            .PD_PredictorGetInputHandle
            .as_ref()
            .expect("Expected function, got error."))(pd_predictor, name)
    }
    pub unsafe fn PD_PredictorGetOutputHandle(
        &self,
        pd_predictor: *mut PD_Predictor,
        name: *const ::std::os::raw::c_char,
    ) -> *mut PD_Tensor {
        (self
            .PD_PredictorGetOutputHandle
            .as_ref()
            .expect("Expected function, got error."))(pd_predictor, name)
    }
    pub unsafe fn PD_PredictorRun(&self, pd_predictor: *mut PD_Predictor) -> PD_Bool {
        (self
            .PD_PredictorRun
            .as_ref()
            .expect("Expected function, got error."))(pd_predictor)
    }
    pub unsafe fn PD_PredictorClearIntermediateTensor(
        &self,
        pd_predictor: *mut PD_Predictor,
    ) -> () {
        (self
            .PD_PredictorClearIntermediateTensor
            .as_ref()
            .expect("Expected function, got error."))(pd_predictor)
    }
    pub unsafe fn PD_PredictorTryShrinkMemory(&self, pd_predictor: *mut PD_Predictor) -> u64 {
        (self
            .PD_PredictorTryShrinkMemory
            .as_ref()
            .expect("Expected function, got error."))(pd_predictor)
    }
    pub unsafe fn PD_PredictorDestroy(&self, pd_predictor: *mut PD_Predictor) -> () {
        (self
            .PD_PredictorDestroy
            .as_ref()
            .expect("Expected function, got error."))(pd_predictor)
    }
    pub unsafe fn PD_TensorDestroy(&self, pd_tensor: *mut PD_Tensor) -> () {
        (self
            .PD_TensorDestroy
            .as_ref()
            .expect("Expected function, got error."))(pd_tensor)
    }
    pub unsafe fn PD_TensorReshape(
        &self,
        pd_tensor: *mut PD_Tensor,
        shape_size: size_t,
        shape: *mut i32,
    ) -> () {
        (self
            .PD_TensorReshape
            .as_ref()
            .expect("Expected function, got error."))(pd_tensor, shape_size, shape)
    }
    pub unsafe fn PD_TensorMutableDataFloat(
        &self,
        pd_tensor: *mut PD_Tensor,
        place: PD_PlaceType,
    ) -> *mut f32 {
        (self
            .PD_TensorMutableDataFloat
            .as_ref()
            .expect("Expected function, got error."))(pd_tensor, place)
    }
    pub unsafe fn PD_TensorMutableDataInt64(
        &self,
        pd_tensor: *mut PD_Tensor,
        place: PD_PlaceType,
    ) -> *mut i64 {
        (self
            .PD_TensorMutableDataInt64
            .as_ref()
            .expect("Expected function, got error."))(pd_tensor, place)
    }
    pub unsafe fn PD_TensorMutableDataInt32(
        &self,
        pd_tensor: *mut PD_Tensor,
        place: PD_PlaceType,
    ) -> *mut i32 {
        (self
            .PD_TensorMutableDataInt32
            .as_ref()
            .expect("Expected function, got error."))(pd_tensor, place)
    }
    pub unsafe fn PD_TensorMutableDataUint8(
        &self,
        pd_tensor: *mut PD_Tensor,
        place: PD_PlaceType,
    ) -> *mut u8 {
        (self
            .PD_TensorMutableDataUint8
            .as_ref()
            .expect("Expected function, got error."))(pd_tensor, place)
    }
    pub unsafe fn PD_TensorMutableDataInt8(
        &self,
        pd_tensor: *mut PD_Tensor,
        place: PD_PlaceType,
    ) -> *mut i8 {
        (self
            .PD_TensorMutableDataInt8
            .as_ref()
            .expect("Expected function, got error."))(pd_tensor, place)
    }
    pub unsafe fn PD_TensorDataFloat(
        &self,
        pd_tensor: *mut PD_Tensor,
        place: *mut PD_PlaceType,
        size: *mut i32,
    ) -> *mut f32 {
        (self
            .PD_TensorDataFloat
            .as_ref()
            .expect("Expected function, got error."))(pd_tensor, place, size)
    }
    pub unsafe fn PD_TensorDataInt64(
        &self,
        pd_tensor: *mut PD_Tensor,
        place: *mut PD_PlaceType,
        size: *mut i32,
    ) -> *mut i64 {
        (self
            .PD_TensorDataInt64
            .as_ref()
            .expect("Expected function, got error."))(pd_tensor, place, size)
    }
    pub unsafe fn PD_TensorDataInt32(
        &self,
        pd_tensor: *mut PD_Tensor,
        place: *mut PD_PlaceType,
        size: *mut i32,
    ) -> *mut i32 {
        (self
            .PD_TensorDataInt32
            .as_ref()
            .expect("Expected function, got error."))(pd_tensor, place, size)
    }
    pub unsafe fn PD_TensorDataUint8(
        &self,
        pd_tensor: *mut PD_Tensor,
        place: *mut PD_PlaceType,
        size: *mut i32,
    ) -> *mut u8 {
        (self
            .PD_TensorDataUint8
            .as_ref()
            .expect("Expected function, got error."))(pd_tensor, place, size)
    }
    pub unsafe fn PD_TensorDataInt8(
        &self,
        pd_tensor: *mut PD_Tensor,
        place: *mut PD_PlaceType,
        size: *mut i32,
    ) -> *mut i8 {
        (self
            .PD_TensorDataInt8
            .as_ref()
            .expect("Expected function, got error."))(pd_tensor, place, size)
    }
    pub unsafe fn PD_TensorCopyFromCpuFloat(
        &self,
        pd_tensor: *mut PD_Tensor,
        data: *const f32,
    ) -> () {
        (self
            .PD_TensorCopyFromCpuFloat
            .as_ref()
            .expect("Expected function, got error."))(pd_tensor, data)
    }
    pub unsafe fn PD_TensorCopyFromCpuInt64(
        &self,
        pd_tensor: *mut PD_Tensor,
        data: *const i64,
    ) -> () {
        (self
            .PD_TensorCopyFromCpuInt64
            .as_ref()
            .expect("Expected function, got error."))(pd_tensor, data)
    }
    pub unsafe fn PD_TensorCopyFromCpuInt32(
        &self,
        pd_tensor: *mut PD_Tensor,
        data: *const i32,
    ) -> () {
        (self
            .PD_TensorCopyFromCpuInt32
            .as_ref()
            .expect("Expected function, got error."))(pd_tensor, data)
    }
    pub unsafe fn PD_TensorCopyFromCpuUint8(
        &self,
        pd_tensor: *mut PD_Tensor,
        data: *const u8,
    ) -> () {
        (self
            .PD_TensorCopyFromCpuUint8
            .as_ref()
            .expect("Expected function, got error."))(pd_tensor, data)
    }
    pub unsafe fn PD_TensorCopyFromCpuInt8(
        &self,
        pd_tensor: *mut PD_Tensor,
        data: *const i8,
    ) -> () {
        (self
            .PD_TensorCopyFromCpuInt8
            .as_ref()
            .expect("Expected function, got error."))(pd_tensor, data)
    }
    pub unsafe fn PD_TensorCopyToCpuFloat(&self, pd_tensor: *mut PD_Tensor, data: *mut f32) -> () {
        (self
            .PD_TensorCopyToCpuFloat
            .as_ref()
            .expect("Expected function, got error."))(pd_tensor, data)
    }
    pub unsafe fn PD_TensorCopyToCpuInt64(&self, pd_tensor: *mut PD_Tensor, data: *mut i64) -> () {
        (self
            .PD_TensorCopyToCpuInt64
            .as_ref()
            .expect("Expected function, got error."))(pd_tensor, data)
    }
    pub unsafe fn PD_TensorCopyToCpuInt32(&self, pd_tensor: *mut PD_Tensor, data: *mut i32) -> () {
        (self
            .PD_TensorCopyToCpuInt32
            .as_ref()
            .expect("Expected function, got error."))(pd_tensor, data)
    }
    pub unsafe fn PD_TensorCopyToCpuUint8(&self, pd_tensor: *mut PD_Tensor, data: *mut u8) -> () {
        (self
            .PD_TensorCopyToCpuUint8
            .as_ref()
            .expect("Expected function, got error."))(pd_tensor, data)
    }
    pub unsafe fn PD_TensorCopyToCpuInt8(&self, pd_tensor: *mut PD_Tensor, data: *mut i8) -> () {
        (self
            .PD_TensorCopyToCpuInt8
            .as_ref()
            .expect("Expected function, got error."))(pd_tensor, data)
    }
    pub unsafe fn PD_TensorGetShape(&self, pd_tensor: *mut PD_Tensor) -> *mut PD_OneDimArrayInt32 {
        (self
            .PD_TensorGetShape
            .as_ref()
            .expect("Expected function, got error."))(pd_tensor)
    }
    pub unsafe fn PD_TensorSetLod(
        &self,
        pd_tensor: *mut PD_Tensor,
        lod: *mut PD_TwoDimArraySize,
    ) -> () {
        (self
            .PD_TensorSetLod
            .as_ref()
            .expect("Expected function, got error."))(pd_tensor, lod)
    }
    pub unsafe fn PD_TensorGetLod(&self, pd_tensor: *mut PD_Tensor) -> *mut PD_TwoDimArraySize {
        (self
            .PD_TensorGetLod
            .as_ref()
            .expect("Expected function, got error."))(pd_tensor)
    }
    pub unsafe fn PD_TensorGetName(
        &self,
        pd_tensor: *mut PD_Tensor,
    ) -> *const ::std::os::raw::c_char {
        (self
            .PD_TensorGetName
            .as_ref()
            .expect("Expected function, got error."))(pd_tensor)
    }
    pub unsafe fn PD_TensorGetDataType(&self, pd_tensor: *mut PD_Tensor) -> PD_DataType {
        (self
            .PD_TensorGetDataType
            .as_ref()
            .expect("Expected function, got error."))(pd_tensor)
    }
    pub unsafe fn PD_OneDimArrayInt32Destroy(&self, array: *mut PD_OneDimArrayInt32) -> () {
        (self
            .PD_OneDimArrayInt32Destroy
            .as_ref()
            .expect("Expected function, got error."))(array)
    }
    pub unsafe fn PD_OneDimArrayCstrDestroy(&self, array: *mut PD_OneDimArrayCstr) -> () {
        (self
            .PD_OneDimArrayCstrDestroy
            .as_ref()
            .expect("Expected function, got error."))(array)
    }
    pub unsafe fn PD_OneDimArraySizeDestroy(&self, array: *mut PD_OneDimArraySize) -> () {
        (self
            .PD_OneDimArraySizeDestroy
            .as_ref()
            .expect("Expected function, got error."))(array)
    }
    pub unsafe fn PD_TwoDimArraySizeDestroy(&self, array: *mut PD_TwoDimArraySize) -> () {
        (self
            .PD_TwoDimArraySizeDestroy
            .as_ref()
            .expect("Expected function, got error."))(array)
    }
}