libsqlite3-sys-le 0.21.0

/* automatically generated by rust-bindgen */

pub const SQLITE_VERSION: &'static [u8; 6usize] = b"3.6.8\0";
pub const SQLITE_VERSION_NUMBER: i32 = 3006008;
pub const SQLITE_OK: i32 = 0;
pub const SQLITE_ERROR: i32 = 1;
pub const SQLITE_INTERNAL: i32 = 2;
pub const SQLITE_PERM: i32 = 3;
pub const SQLITE_ABORT: i32 = 4;
pub const SQLITE_BUSY: i32 = 5;
pub const SQLITE_LOCKED: i32 = 6;
pub const SQLITE_NOMEM: i32 = 7;
pub const SQLITE_READONLY: i32 = 8;
pub const SQLITE_INTERRUPT: i32 = 9;
pub const SQLITE_IOERR: i32 = 10;
pub const SQLITE_CORRUPT: i32 = 11;
pub const SQLITE_NOTFOUND: i32 = 12;
pub const SQLITE_FULL: i32 = 13;
pub const SQLITE_CANTOPEN: i32 = 14;
pub const SQLITE_PROTOCOL: i32 = 15;
pub const SQLITE_EMPTY: i32 = 16;
pub const SQLITE_SCHEMA: i32 = 17;
pub const SQLITE_TOOBIG: i32 = 18;
pub const SQLITE_CONSTRAINT: i32 = 19;
pub const SQLITE_MISMATCH: i32 = 20;
pub const SQLITE_MISUSE: i32 = 21;
pub const SQLITE_NOLFS: i32 = 22;
pub const SQLITE_AUTH: i32 = 23;
pub const SQLITE_FORMAT: i32 = 24;
pub const SQLITE_RANGE: i32 = 25;
pub const SQLITE_NOTADB: i32 = 26;
pub const SQLITE_ROW: i32 = 100;
pub const SQLITE_DONE: i32 = 101;
pub const SQLITE_IOERR_READ: i32 = 266;
pub const SQLITE_IOERR_SHORT_READ: i32 = 522;
pub const SQLITE_IOERR_WRITE: i32 = 778;
pub const SQLITE_IOERR_FSYNC: i32 = 1034;
pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290;
pub const SQLITE_IOERR_TRUNCATE: i32 = 1546;
pub const SQLITE_IOERR_FSTAT: i32 = 1802;
pub const SQLITE_IOERR_UNLOCK: i32 = 2058;
pub const SQLITE_IOERR_RDLOCK: i32 = 2314;
pub const SQLITE_IOERR_DELETE: i32 = 2570;
pub const SQLITE_IOERR_BLOCKED: i32 = 2826;
pub const SQLITE_IOERR_NOMEM: i32 = 3082;
pub const SQLITE_IOERR_ACCESS: i32 = 3338;
pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594;
pub const SQLITE_IOERR_LOCK: i32 = 3850;
pub const SQLITE_IOERR_CLOSE: i32 = 4106;
pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362;
pub const SQLITE_OPEN_READONLY: i32 = 1;
pub const SQLITE_OPEN_READWRITE: i32 = 2;
pub const SQLITE_OPEN_CREATE: i32 = 4;
pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8;
pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16;
pub const SQLITE_OPEN_MAIN_DB: i32 = 256;
pub const SQLITE_OPEN_TEMP_DB: i32 = 512;
pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024;
pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048;
pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096;
pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192;
pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384;
pub const SQLITE_OPEN_NOMUTEX: i32 = 32768;
pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536;
pub const SQLITE_IOCAP_ATOMIC: i32 = 1;
pub const SQLITE_IOCAP_ATOMIC512: i32 = 2;
pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4;
pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8;
pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16;
pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32;
pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64;
pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128;
pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256;
pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512;
pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024;
pub const SQLITE_LOCK_NONE: i32 = 0;
pub const SQLITE_LOCK_SHARED: i32 = 1;
pub const SQLITE_LOCK_RESERVED: i32 = 2;
pub const SQLITE_LOCK_PENDING: i32 = 3;
pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4;
pub const SQLITE_SYNC_NORMAL: i32 = 2;
pub const SQLITE_SYNC_FULL: i32 = 3;
pub const SQLITE_SYNC_DATAONLY: i32 = 16;
pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1;
pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2;
pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3;
pub const SQLITE_LAST_ERRNO: i32 = 4;
pub const SQLITE_ACCESS_EXISTS: i32 = 0;
pub const SQLITE_ACCESS_READWRITE: i32 = 1;
pub const SQLITE_ACCESS_READ: i32 = 2;
pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1;
pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2;
pub const SQLITE_CONFIG_SERIALIZED: i32 = 3;
pub const SQLITE_CONFIG_MALLOC: i32 = 4;
pub const SQLITE_CONFIG_GETMALLOC: i32 = 5;
pub const SQLITE_CONFIG_SCRATCH: i32 = 6;
pub const SQLITE_CONFIG_PAGECACHE: i32 = 7;
pub const SQLITE_CONFIG_HEAP: i32 = 8;
pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9;
pub const SQLITE_CONFIG_MUTEX: i32 = 10;
pub const SQLITE_CONFIG_GETMUTEX: i32 = 11;
pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13;
pub const SQLITE_CONFIG_PCACHE: i32 = 14;
pub const SQLITE_CONFIG_GETPCACHE: i32 = 15;
pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001;
pub const SQLITE_DENY: i32 = 1;
pub const SQLITE_IGNORE: i32 = 2;
pub const SQLITE_CREATE_INDEX: i32 = 1;
pub const SQLITE_CREATE_TABLE: i32 = 2;
pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3;
pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4;
pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5;
pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6;
pub const SQLITE_CREATE_TRIGGER: i32 = 7;
pub const SQLITE_CREATE_VIEW: i32 = 8;
pub const SQLITE_DELETE: i32 = 9;
pub const SQLITE_DROP_INDEX: i32 = 10;
pub const SQLITE_DROP_TABLE: i32 = 11;
pub const SQLITE_DROP_TEMP_INDEX: i32 = 12;
pub const SQLITE_DROP_TEMP_TABLE: i32 = 13;
pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14;
pub const SQLITE_DROP_TEMP_VIEW: i32 = 15;
pub const SQLITE_DROP_TRIGGER: i32 = 16;
pub const SQLITE_DROP_VIEW: i32 = 17;
pub const SQLITE_INSERT: i32 = 18;
pub const SQLITE_PRAGMA: i32 = 19;
pub const SQLITE_READ: i32 = 20;
pub const SQLITE_SELECT: i32 = 21;
pub const SQLITE_TRANSACTION: i32 = 22;
pub const SQLITE_UPDATE: i32 = 23;
pub const SQLITE_ATTACH: i32 = 24;
pub const SQLITE_DETACH: i32 = 25;
pub const SQLITE_ALTER_TABLE: i32 = 26;
pub const SQLITE_REINDEX: i32 = 27;
pub const SQLITE_ANALYZE: i32 = 28;
pub const SQLITE_CREATE_VTABLE: i32 = 29;
pub const SQLITE_DROP_VTABLE: i32 = 30;
pub const SQLITE_FUNCTION: i32 = 31;
pub const SQLITE_SAVEPOINT: i32 = 32;
pub const SQLITE_COPY: i32 = 0;
pub const SQLITE_LIMIT_LENGTH: i32 = 0;
pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1;
pub const SQLITE_LIMIT_COLUMN: i32 = 2;
pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3;
pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4;
pub const SQLITE_LIMIT_VDBE_OP: i32 = 5;
pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6;
pub const SQLITE_LIMIT_ATTACHED: i32 = 7;
pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8;
pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9;
pub const SQLITE_INTEGER: i32 = 1;
pub const SQLITE_FLOAT: i32 = 2;
pub const SQLITE_BLOB: i32 = 4;
pub const SQLITE_NULL: i32 = 5;
pub const SQLITE_TEXT: i32 = 3;
pub const SQLITE3_TEXT: i32 = 3;
pub const SQLITE_UTF8: i32 = 1;
pub const SQLITE_UTF16LE: i32 = 2;
pub const SQLITE_UTF16BE: i32 = 3;
pub const SQLITE_UTF16: i32 = 4;
pub const SQLITE_ANY: i32 = 5;
pub const SQLITE_UTF16_ALIGNED: i32 = 8;
pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2;
pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4;
pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8;
pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16;
pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32;
pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64;
pub const SQLITE_MUTEX_FAST: i32 = 0;
pub const SQLITE_MUTEX_RECURSIVE: i32 = 1;
pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2;
pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3;
pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4;
pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5;
pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6;
pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7;
pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5;
pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6;
pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7;
pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8;
pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9;
pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10;
pub const SQLITE_STATUS_MEMORY_USED: i32 = 0;
pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1;
pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2;
pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3;
pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4;
pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5;
pub const SQLITE_STATUS_PARSER_STACK: i32 = 6;
pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7;
pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8;
pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0;
pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1;
pub const SQLITE_STMTSTATUS_SORT: i32 = 2;
extern "C" {
    #[link_name = "\u{1}sqlite3_version"]
    pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize];
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sqlite3 {
    _unused: [u8; 0],
}
pub type sqlite_int64 = ::std::os::raw::c_longlong;
pub type sqlite_uint64 = ::std::os::raw::c_ulonglong;
pub type sqlite3_int64 = sqlite_int64;
pub type sqlite3_uint64 = sqlite_uint64;
pub type sqlite3_callback = ::std::option::Option<
    unsafe extern "C" fn(
        arg1: *mut ::std::os::raw::c_void,
        arg2: ::std::os::raw::c_int,
        arg3: *mut *mut ::std::os::raw::c_char,
        arg4: *mut *mut ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sqlite3_file {
    pub pMethods: *const sqlite3_io_methods,
}
#[test]
fn bindgen_test_layout_sqlite3_file() {
    assert_eq!(
        ::std::mem::size_of::<sqlite3_file>(),
        8usize,
        concat!("Size of: ", stringify!(sqlite3_file))
    );
    assert_eq!(
        ::std::mem::align_of::<sqlite3_file>(),
        8usize,
        concat!("Alignment of ", stringify!(sqlite3_file))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_file>())).pMethods as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_file),
            "::",
            stringify!(pMethods)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sqlite3_io_methods {
    pub iVersion: ::std::os::raw::c_int,
    pub xClose: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int,
    >,
    pub xRead: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_file,
            arg2: *mut ::std::os::raw::c_void,
            iAmt: ::std::os::raw::c_int,
            iOfst: sqlite3_int64,
        ) -> ::std::os::raw::c_int,
    >,
    pub xWrite: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_file,
            arg2: *const ::std::os::raw::c_void,
            iAmt: ::std::os::raw::c_int,
            iOfst: sqlite3_int64,
        ) -> ::std::os::raw::c_int,
    >,
    pub xTruncate: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int,
    >,
    pub xSync: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_file,
            flags: ::std::os::raw::c_int,
        ) -> ::std::os::raw::c_int,
    >,
    pub xFileSize: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_file,
            pSize: *mut sqlite3_int64,
        ) -> ::std::os::raw::c_int,
    >,
    pub xLock: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_file,
            arg2: ::std::os::raw::c_int,
        ) -> ::std::os::raw::c_int,
    >,
    pub xUnlock: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_file,
            arg2: ::std::os::raw::c_int,
        ) -> ::std::os::raw::c_int,
    >,
    pub xCheckReservedLock: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_file,
            pResOut: *mut ::std::os::raw::c_int,
        ) -> ::std::os::raw::c_int,
    >,
    pub xFileControl: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_file,
            op: ::std::os::raw::c_int,
            pArg: *mut ::std::os::raw::c_void,
        ) -> ::std::os::raw::c_int,
    >,
    pub xSectorSize: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int,
    >,
    pub xDeviceCharacteristics: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int,
    >,
}
#[test]
fn bindgen_test_layout_sqlite3_io_methods() {
    assert_eq!(
        ::std::mem::size_of::<sqlite3_io_methods>(),
        104usize,
        concat!("Size of: ", stringify!(sqlite3_io_methods))
    );
    assert_eq!(
        ::std::mem::align_of::<sqlite3_io_methods>(),
        8usize,
        concat!("Alignment of ", stringify!(sqlite3_io_methods))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_io_methods>())).iVersion as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_io_methods),
            "::",
            stringify!(iVersion)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_io_methods>())).xClose as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_io_methods),
            "::",
            stringify!(xClose)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_io_methods>())).xRead as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_io_methods),
            "::",
            stringify!(xRead)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_io_methods>())).xWrite as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_io_methods),
            "::",
            stringify!(xWrite)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_io_methods>())).xTruncate as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_io_methods),
            "::",
            stringify!(xTruncate)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_io_methods>())).xSync as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_io_methods),
            "::",
            stringify!(xSync)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_io_methods>())).xFileSize as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_io_methods),
            "::",
            stringify!(xFileSize)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_io_methods>())).xLock as *const _ as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_io_methods),
            "::",
            stringify!(xLock)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_io_methods>())).xUnlock as *const _ as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_io_methods),
            "::",
            stringify!(xUnlock)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_io_methods>())).xCheckReservedLock as *const _ as usize
        },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_io_methods),
            "::",
            stringify!(xCheckReservedLock)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_io_methods>())).xFileControl as *const _ as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_io_methods),
            "::",
            stringify!(xFileControl)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_io_methods>())).xSectorSize as *const _ as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_io_methods),
            "::",
            stringify!(xSectorSize)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_io_methods>())).xDeviceCharacteristics as *const _
                as usize
        },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_io_methods),
            "::",
            stringify!(xDeviceCharacteristics)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sqlite3_mutex {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sqlite3_vfs {
    pub iVersion: ::std::os::raw::c_int,
    pub szOsFile: ::std::os::raw::c_int,
    pub mxPathname: ::std::os::raw::c_int,
    pub pNext: *mut sqlite3_vfs,
    pub zName: *const ::std::os::raw::c_char,
    pub pAppData: *mut ::std::os::raw::c_void,
    pub xOpen: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_vfs,
            zName: *const ::std::os::raw::c_char,
            arg2: *mut sqlite3_file,
            flags: ::std::os::raw::c_int,
            pOutFlags: *mut ::std::os::raw::c_int,
        ) -> ::std::os::raw::c_int,
    >,
    pub xDelete: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_vfs,
            zName: *const ::std::os::raw::c_char,
            syncDir: ::std::os::raw::c_int,
        ) -> ::std::os::raw::c_int,
    >,
    pub xAccess: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_vfs,
            zName: *const ::std::os::raw::c_char,
            flags: ::std::os::raw::c_int,
            pResOut: *mut ::std::os::raw::c_int,
        ) -> ::std::os::raw::c_int,
    >,
    pub xFullPathname: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_vfs,
            zName: *const ::std::os::raw::c_char,
            nOut: ::std::os::raw::c_int,
            zOut: *mut ::std::os::raw::c_char,
        ) -> ::std::os::raw::c_int,
    >,
    pub xDlOpen: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_vfs,
            zFilename: *const ::std::os::raw::c_char,
        ) -> *mut ::std::os::raw::c_void,
    >,
    pub xDlError: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_vfs,
            nByte: ::std::os::raw::c_int,
            zErrMsg: *mut ::std::os::raw::c_char,
        ),
    >,
    pub xDlSym: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_vfs,
            arg2: *mut ::std::os::raw::c_void,
            zSymbol: *const ::std::os::raw::c_char,
        ) -> ::std::option::Option<
            unsafe extern "C" fn(
                arg1: *mut sqlite3_vfs,
                arg2: *mut ::std::os::raw::c_void,
                zSymbol: *const ::std::os::raw::c_char,
            ),
        >,
    >,
    pub xDlClose: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void),
    >,
    pub xRandomness: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_vfs,
            nByte: ::std::os::raw::c_int,
            zOut: *mut ::std::os::raw::c_char,
        ) -> ::std::os::raw::c_int,
    >,
    pub xSleep: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_vfs,
            microseconds: ::std::os::raw::c_int,
        ) -> ::std::os::raw::c_int,
    >,
    pub xCurrentTime: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int,
    >,
    pub xGetLastError: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_vfs,
            arg2: ::std::os::raw::c_int,
            arg3: *mut ::std::os::raw::c_char,
        ) -> ::std::os::raw::c_int,
    >,
}
#[test]
fn bindgen_test_layout_sqlite3_vfs() {
    assert_eq!(
        ::std::mem::size_of::<sqlite3_vfs>(),
        136usize,
        concat!("Size of: ", stringify!(sqlite3_vfs))
    );
    assert_eq!(
        ::std::mem::align_of::<sqlite3_vfs>(),
        8usize,
        concat!("Alignment of ", stringify!(sqlite3_vfs))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_vfs>())).iVersion as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_vfs),
            "::",
            stringify!(iVersion)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_vfs>())).szOsFile as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_vfs),
            "::",
            stringify!(szOsFile)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_vfs>())).mxPathname as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_vfs),
            "::",
            stringify!(mxPathname)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_vfs>())).pNext as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_vfs),
            "::",
            stringify!(pNext)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_vfs>())).zName as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_vfs),
            "::",
            stringify!(zName)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_vfs>())).pAppData as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_vfs),
            "::",
            stringify!(pAppData)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_vfs>())).xOpen as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_vfs),
            "::",
            stringify!(xOpen)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_vfs>())).xDelete as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_vfs),
            "::",
            stringify!(xDelete)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_vfs>())).xAccess as *const _ as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_vfs),
            "::",
            stringify!(xAccess)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_vfs>())).xFullPathname as *const _ as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_vfs),
            "::",
            stringify!(xFullPathname)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_vfs>())).xDlOpen as *const _ as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_vfs),
            "::",
            stringify!(xDlOpen)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_vfs>())).xDlError as *const _ as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_vfs),
            "::",
            stringify!(xDlError)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_vfs>())).xDlSym as *const _ as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_vfs),
            "::",
            stringify!(xDlSym)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_vfs>())).xDlClose as *const _ as usize },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_vfs),
            "::",
            stringify!(xDlClose)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_vfs>())).xRandomness as *const _ as usize },
        104usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_vfs),
            "::",
            stringify!(xRandomness)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_vfs>())).xSleep as *const _ as usize },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_vfs),
            "::",
            stringify!(xSleep)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_vfs>())).xCurrentTime as *const _ as usize },
        120usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_vfs),
            "::",
            stringify!(xCurrentTime)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_vfs>())).xGetLastError as *const _ as usize },
        128usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_vfs),
            "::",
            stringify!(xGetLastError)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sqlite3_mem_methods {
    pub xMalloc: ::std::option::Option<
        unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void,
    >,
    pub xFree: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
    pub xRealloc: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut ::std::os::raw::c_void,
            arg2: ::std::os::raw::c_int,
        ) -> *mut ::std::os::raw::c_void,
    >,
    pub xSize: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int,
    >,
    pub xRoundup: ::std::option::Option<
        unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int,
    >,
    pub xInit: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int,
    >,
    pub xShutdown: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
    pub pAppData: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_sqlite3_mem_methods() {
    assert_eq!(
        ::std::mem::size_of::<sqlite3_mem_methods>(),
        64usize,
        concat!("Size of: ", stringify!(sqlite3_mem_methods))
    );
    assert_eq!(
        ::std::mem::align_of::<sqlite3_mem_methods>(),
        8usize,
        concat!("Alignment of ", stringify!(sqlite3_mem_methods))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_mem_methods>())).xMalloc as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_mem_methods),
            "::",
            stringify!(xMalloc)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_mem_methods>())).xFree as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_mem_methods),
            "::",
            stringify!(xFree)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_mem_methods>())).xRealloc as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_mem_methods),
            "::",
            stringify!(xRealloc)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_mem_methods>())).xSize as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_mem_methods),
            "::",
            stringify!(xSize)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_mem_methods>())).xRoundup as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_mem_methods),
            "::",
            stringify!(xRoundup)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_mem_methods>())).xInit as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_mem_methods),
            "::",
            stringify!(xInit)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_mem_methods>())).xShutdown as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_mem_methods),
            "::",
            stringify!(xShutdown)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_mem_methods>())).pAppData as *const _ as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_mem_methods),
            "::",
            stringify!(pAppData)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sqlite3_stmt {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Mem {
    _unused: [u8; 0],
}
pub type sqlite3_value = Mem;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sqlite3_context {
    _unused: [u8; 0],
}
pub type sqlite3_destructor_type =
    ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>;
extern "C" {
    #[link_name = "\u{1}sqlite3_temp_directory"]
    pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sqlite3_module {
    pub iVersion: ::std::os::raw::c_int,
    pub xCreate: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3,
            pAux: *mut ::std::os::raw::c_void,
            argc: ::std::os::raw::c_int,
            argv: *const *const ::std::os::raw::c_char,
            ppVTab: *mut *mut sqlite3_vtab,
            arg2: *mut *mut ::std::os::raw::c_char,
        ) -> ::std::os::raw::c_int,
    >,
    pub xConnect: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3,
            pAux: *mut ::std::os::raw::c_void,
            argc: ::std::os::raw::c_int,
            argv: *const *const ::std::os::raw::c_char,
            ppVTab: *mut *mut sqlite3_vtab,
            arg2: *mut *mut ::std::os::raw::c_char,
        ) -> ::std::os::raw::c_int,
    >,
    pub xBestIndex: ::std::option::Option<
        unsafe extern "C" fn(
            pVTab: *mut sqlite3_vtab,
            arg1: *mut sqlite3_index_info,
        ) -> ::std::os::raw::c_int,
    >,
    pub xDisconnect: ::std::option::Option<
        unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int,
    >,
    pub xDestroy: ::std::option::Option<
        unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int,
    >,
    pub xOpen: ::std::option::Option<
        unsafe extern "C" fn(
            pVTab: *mut sqlite3_vtab,
            ppCursor: *mut *mut sqlite3_vtab_cursor,
        ) -> ::std::os::raw::c_int,
    >,
    pub xClose: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int,
    >,
    pub xFilter: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_vtab_cursor,
            idxNum: ::std::os::raw::c_int,
            idxStr: *const ::std::os::raw::c_char,
            argc: ::std::os::raw::c_int,
            argv: *mut *mut sqlite3_value,
        ) -> ::std::os::raw::c_int,
    >,
    pub xNext: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int,
    >,
    pub xEof: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int,
    >,
    pub xColumn: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_vtab_cursor,
            arg2: *mut sqlite3_context,
            arg3: ::std::os::raw::c_int,
        ) -> ::std::os::raw::c_int,
    >,
    pub xRowid: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_vtab_cursor,
            pRowid: *mut sqlite3_int64,
        ) -> ::std::os::raw::c_int,
    >,
    pub xUpdate: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_vtab,
            arg2: ::std::os::raw::c_int,
            arg3: *mut *mut sqlite3_value,
            arg4: *mut sqlite3_int64,
        ) -> ::std::os::raw::c_int,
    >,
    pub xBegin: ::std::option::Option<
        unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int,
    >,
    pub xSync: ::std::option::Option<
        unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int,
    >,
    pub xCommit: ::std::option::Option<
        unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int,
    >,
    pub xRollback: ::std::option::Option<
        unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int,
    >,
    pub xFindFunction: ::std::option::Option<
        unsafe extern "C" fn(
            pVtab: *mut sqlite3_vtab,
            nArg: ::std::os::raw::c_int,
            zName: *const ::std::os::raw::c_char,
            pxFunc: *mut ::std::option::Option<
                unsafe extern "C" fn(
                    arg1: *mut sqlite3_context,
                    arg2: ::std::os::raw::c_int,
                    arg3: *mut *mut sqlite3_value,
                ),
            >,
            ppArg: *mut *mut ::std::os::raw::c_void,
        ) -> ::std::os::raw::c_int,
    >,
    pub xRename: ::std::option::Option<
        unsafe extern "C" fn(
            pVtab: *mut sqlite3_vtab,
            zNew: *const ::std::os::raw::c_char,
        ) -> ::std::os::raw::c_int,
    >,
}
#[test]
fn bindgen_test_layout_sqlite3_module() {
    assert_eq!(
        ::std::mem::size_of::<sqlite3_module>(),
        160usize,
        concat!("Size of: ", stringify!(sqlite3_module))
    );
    assert_eq!(
        ::std::mem::align_of::<sqlite3_module>(),
        8usize,
        concat!("Alignment of ", stringify!(sqlite3_module))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_module>())).iVersion as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_module),
            "::",
            stringify!(iVersion)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_module>())).xCreate as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_module),
            "::",
            stringify!(xCreate)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_module>())).xConnect as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_module),
            "::",
            stringify!(xConnect)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_module>())).xBestIndex as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_module),
            "::",
            stringify!(xBestIndex)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_module>())).xDisconnect as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_module),
            "::",
            stringify!(xDisconnect)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_module>())).xDestroy as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_module),
            "::",
            stringify!(xDestroy)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_module>())).xOpen as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_module),
            "::",
            stringify!(xOpen)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_module>())).xClose as *const _ as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_module),
            "::",
            stringify!(xClose)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_module>())).xFilter as *const _ as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_module),
            "::",
            stringify!(xFilter)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_module>())).xNext as *const _ as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_module),
            "::",
            stringify!(xNext)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_module>())).xEof as *const _ as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_module),
            "::",
            stringify!(xEof)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_module>())).xColumn as *const _ as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_module),
            "::",
            stringify!(xColumn)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_module>())).xRowid as *const _ as usize },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_module),
            "::",
            stringify!(xRowid)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_module>())).xUpdate as *const _ as usize },
        104usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_module),
            "::",
            stringify!(xUpdate)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_module>())).xBegin as *const _ as usize },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_module),
            "::",
            stringify!(xBegin)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_module>())).xSync as *const _ as usize },
        120usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_module),
            "::",
            stringify!(xSync)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_module>())).xCommit as *const _ as usize },
        128usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_module),
            "::",
            stringify!(xCommit)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_module>())).xRollback as *const _ as usize },
        136usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_module),
            "::",
            stringify!(xRollback)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_module>())).xFindFunction as *const _ as usize },
        144usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_module),
            "::",
            stringify!(xFindFunction)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_module>())).xRename as *const _ as usize },
        152usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_module),
            "::",
            stringify!(xRename)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sqlite3_index_info {
    pub nConstraint: ::std::os::raw::c_int,
    pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint,
    pub nOrderBy: ::std::os::raw::c_int,
    pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby,
    pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage,
    pub idxNum: ::std::os::raw::c_int,
    pub idxStr: *mut ::std::os::raw::c_char,
    pub needToFreeIdxStr: ::std::os::raw::c_int,
    pub orderByConsumed: ::std::os::raw::c_int,
    pub estimatedCost: f64,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sqlite3_index_info_sqlite3_index_constraint {
    pub iColumn: ::std::os::raw::c_int,
    pub op: ::std::os::raw::c_uchar,
    pub usable: ::std::os::raw::c_uchar,
    pub iTermOffset: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() {
    assert_eq!(
        ::std::mem::size_of::<sqlite3_index_info_sqlite3_index_constraint>(),
        12usize,
        concat!(
            "Size of: ",
            stringify!(sqlite3_index_info_sqlite3_index_constraint)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<sqlite3_index_info_sqlite3_index_constraint>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(sqlite3_index_info_sqlite3_index_constraint)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_index_info_sqlite3_index_constraint>())).iColumn
                as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_index_info_sqlite3_index_constraint),
            "::",
            stringify!(iColumn)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_index_info_sqlite3_index_constraint>())).op as *const _
                as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_index_info_sqlite3_index_constraint),
            "::",
            stringify!(op)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_index_info_sqlite3_index_constraint>())).usable
                as *const _ as usize
        },
        5usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_index_info_sqlite3_index_constraint),
            "::",
            stringify!(usable)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_index_info_sqlite3_index_constraint>())).iTermOffset
                as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_index_info_sqlite3_index_constraint),
            "::",
            stringify!(iTermOffset)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sqlite3_index_info_sqlite3_index_orderby {
    pub iColumn: ::std::os::raw::c_int,
    pub desc: ::std::os::raw::c_uchar,
}
#[test]
fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() {
    assert_eq!(
        ::std::mem::size_of::<sqlite3_index_info_sqlite3_index_orderby>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(sqlite3_index_info_sqlite3_index_orderby)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<sqlite3_index_info_sqlite3_index_orderby>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(sqlite3_index_info_sqlite3_index_orderby)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_index_info_sqlite3_index_orderby>())).iColumn as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_index_info_sqlite3_index_orderby),
            "::",
            stringify!(iColumn)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_index_info_sqlite3_index_orderby>())).desc as *const _
                as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_index_info_sqlite3_index_orderby),
            "::",
            stringify!(desc)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sqlite3_index_info_sqlite3_index_constraint_usage {
    pub argvIndex: ::std::os::raw::c_int,
    pub omit: ::std::os::raw::c_uchar,
}
#[test]
fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() {
    assert_eq!(
        ::std::mem::size_of::<sqlite3_index_info_sqlite3_index_constraint_usage>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(sqlite3_index_info_sqlite3_index_constraint_usage)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<sqlite3_index_info_sqlite3_index_constraint_usage>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(sqlite3_index_info_sqlite3_index_constraint_usage)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_index_info_sqlite3_index_constraint_usage>())).argvIndex
                as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_index_info_sqlite3_index_constraint_usage),
            "::",
            stringify!(argvIndex)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_index_info_sqlite3_index_constraint_usage>())).omit
                as *const _ as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_index_info_sqlite3_index_constraint_usage),
            "::",
            stringify!(omit)
        )
    );
}
#[test]
fn bindgen_test_layout_sqlite3_index_info() {
    assert_eq!(
        ::std::mem::size_of::<sqlite3_index_info>(),
        72usize,
        concat!("Size of: ", stringify!(sqlite3_index_info))
    );
    assert_eq!(
        ::std::mem::align_of::<sqlite3_index_info>(),
        8usize,
        concat!("Alignment of ", stringify!(sqlite3_index_info))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_index_info>())).nConstraint as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_index_info),
            "::",
            stringify!(nConstraint)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_index_info>())).aConstraint as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_index_info),
            "::",
            stringify!(aConstraint)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_index_info>())).nOrderBy as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_index_info),
            "::",
            stringify!(nOrderBy)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_index_info>())).aOrderBy as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_index_info),
            "::",
            stringify!(aOrderBy)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_index_info>())).aConstraintUsage as *const _ as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_index_info),
            "::",
            stringify!(aConstraintUsage)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_index_info>())).idxNum as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_index_info),
            "::",
            stringify!(idxNum)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_index_info>())).idxStr as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_index_info),
            "::",
            stringify!(idxStr)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_index_info>())).needToFreeIdxStr as *const _ as usize
        },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_index_info),
            "::",
            stringify!(needToFreeIdxStr)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_index_info>())).orderByConsumed as *const _ as usize
        },
        60usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_index_info),
            "::",
            stringify!(orderByConsumed)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_index_info>())).estimatedCost as *const _ as usize
        },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_index_info),
            "::",
            stringify!(estimatedCost)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sqlite3_vtab {
    pub pModule: *const sqlite3_module,
    pub nRef: ::std::os::raw::c_int,
    pub zErrMsg: *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_sqlite3_vtab() {
    assert_eq!(
        ::std::mem::size_of::<sqlite3_vtab>(),
        24usize,
        concat!("Size of: ", stringify!(sqlite3_vtab))
    );
    assert_eq!(
        ::std::mem::align_of::<sqlite3_vtab>(),
        8usize,
        concat!("Alignment of ", stringify!(sqlite3_vtab))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_vtab>())).pModule as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_vtab),
            "::",
            stringify!(pModule)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_vtab>())).nRef as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_vtab),
            "::",
            stringify!(nRef)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_vtab>())).zErrMsg as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_vtab),
            "::",
            stringify!(zErrMsg)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sqlite3_vtab_cursor {
    pub pVtab: *mut sqlite3_vtab,
}
#[test]
fn bindgen_test_layout_sqlite3_vtab_cursor() {
    assert_eq!(
        ::std::mem::size_of::<sqlite3_vtab_cursor>(),
        8usize,
        concat!("Size of: ", stringify!(sqlite3_vtab_cursor))
    );
    assert_eq!(
        ::std::mem::align_of::<sqlite3_vtab_cursor>(),
        8usize,
        concat!("Alignment of ", stringify!(sqlite3_vtab_cursor))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_vtab_cursor>())).pVtab as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_vtab_cursor),
            "::",
            stringify!(pVtab)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sqlite3_blob {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sqlite3_mutex_methods {
    pub xMutexInit: ::std::option::Option<unsafe extern "C" fn() -> ::std::os::raw::c_int>,
    pub xMutexEnd: ::std::option::Option<unsafe extern "C" fn() -> ::std::os::raw::c_int>,
    pub xMutexAlloc: ::std::option::Option<
        unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex,
    >,
    pub xMutexFree: ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_mutex)>,
    pub xMutexEnter: ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_mutex)>,
    pub xMutexTry: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int,
    >,
    pub xMutexLeave: ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_mutex)>,
    pub xMutexHeld: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int,
    >,
    pub xMutexNotheld: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int,
    >,
}
#[test]
fn bindgen_test_layout_sqlite3_mutex_methods() {
    assert_eq!(
        ::std::mem::size_of::<sqlite3_mutex_methods>(),
        72usize,
        concat!("Size of: ", stringify!(sqlite3_mutex_methods))
    );
    assert_eq!(
        ::std::mem::align_of::<sqlite3_mutex_methods>(),
        8usize,
        concat!("Alignment of ", stringify!(sqlite3_mutex_methods))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_mutex_methods>())).xMutexInit as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_mutex_methods),
            "::",
            stringify!(xMutexInit)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_mutex_methods>())).xMutexEnd as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_mutex_methods),
            "::",
            stringify!(xMutexEnd)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_mutex_methods>())).xMutexAlloc as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_mutex_methods),
            "::",
            stringify!(xMutexAlloc)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_mutex_methods>())).xMutexFree as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_mutex_methods),
            "::",
            stringify!(xMutexFree)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_mutex_methods>())).xMutexEnter as *const _ as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_mutex_methods),
            "::",
            stringify!(xMutexEnter)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_mutex_methods>())).xMutexTry as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_mutex_methods),
            "::",
            stringify!(xMutexTry)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_mutex_methods>())).xMutexLeave as *const _ as usize
        },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_mutex_methods),
            "::",
            stringify!(xMutexLeave)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_mutex_methods>())).xMutexHeld as *const _ as usize
        },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_mutex_methods),
            "::",
            stringify!(xMutexHeld)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_mutex_methods>())).xMutexNotheld as *const _ as usize
        },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_mutex_methods),
            "::",
            stringify!(xMutexNotheld)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sqlite3_pcache {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sqlite3_pcache_methods {
    pub pArg: *mut ::std::os::raw::c_void,
    pub xInit: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int,
    >,
    pub xShutdown: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
    pub xCreate: ::std::option::Option<
        unsafe extern "C" fn(
            szPage: ::std::os::raw::c_int,
            bPurgeable: ::std::os::raw::c_int,
        ) -> *mut sqlite3_pcache,
    >,
    pub xCachesize: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int),
    >,
    pub xPagecount: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int,
    >,
    pub xFetch: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_pcache,
            key: ::std::os::raw::c_uint,
            createFlag: ::std::os::raw::c_int,
        ) -> *mut ::std::os::raw::c_void,
    >,
    pub xUnpin: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_pcache,
            arg2: *mut ::std::os::raw::c_void,
            discard: ::std::os::raw::c_int,
        ),
    >,
    pub xRekey: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_pcache,
            arg2: *mut ::std::os::raw::c_void,
            oldKey: ::std::os::raw::c_uint,
            newKey: ::std::os::raw::c_uint,
        ),
    >,
    pub xTruncate: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint),
    >,
    pub xDestroy: ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_pcache)>,
}
#[test]
fn bindgen_test_layout_sqlite3_pcache_methods() {
    assert_eq!(
        ::std::mem::size_of::<sqlite3_pcache_methods>(),
        88usize,
        concat!("Size of: ", stringify!(sqlite3_pcache_methods))
    );
    assert_eq!(
        ::std::mem::align_of::<sqlite3_pcache_methods>(),
        8usize,
        concat!("Alignment of ", stringify!(sqlite3_pcache_methods))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_pcache_methods>())).pArg as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_pcache_methods),
            "::",
            stringify!(pArg)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_pcache_methods>())).xInit as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_pcache_methods),
            "::",
            stringify!(xInit)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_pcache_methods>())).xShutdown as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_pcache_methods),
            "::",
            stringify!(xShutdown)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_pcache_methods>())).xCreate as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_pcache_methods),
            "::",
            stringify!(xCreate)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_pcache_methods>())).xCachesize as *const _ as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_pcache_methods),
            "::",
            stringify!(xCachesize)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_pcache_methods>())).xPagecount as *const _ as usize
        },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_pcache_methods),
            "::",
            stringify!(xPagecount)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_pcache_methods>())).xFetch as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_pcache_methods),
            "::",
            stringify!(xFetch)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_pcache_methods>())).xUnpin as *const _ as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_pcache_methods),
            "::",
            stringify!(xUnpin)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_pcache_methods>())).xRekey as *const _ as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_pcache_methods),
            "::",
            stringify!(xRekey)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_pcache_methods>())).xTruncate as *const _ as usize
        },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_pcache_methods),
            "::",
            stringify!(xTruncate)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_pcache_methods>())).xDestroy as *const _ as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_pcache_methods),
            "::",
            stringify!(xDestroy)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sqlite3_api_routines {
    pub aggregate_context: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_context,
            nBytes: ::std::os::raw::c_int,
        ) -> *mut ::std::os::raw::c_void,
    >,
    pub aggregate_count: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int,
    >,
    pub bind_blob: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_stmt,
            arg2: ::std::os::raw::c_int,
            arg3: *const ::std::os::raw::c_void,
            n: ::std::os::raw::c_int,
            arg4: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
        ) -> ::std::os::raw::c_int,
    >,
    pub bind_double: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_stmt,
            arg2: ::std::os::raw::c_int,
            arg3: f64,
        ) -> ::std::os::raw::c_int,
    >,
    pub bind_int: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_stmt,
            arg2: ::std::os::raw::c_int,
            arg3: ::std::os::raw::c_int,
        ) -> ::std::os::raw::c_int,
    >,
    pub bind_int64: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_stmt,
            arg2: ::std::os::raw::c_int,
            arg3: sqlite_int64,
        ) -> ::std::os::raw::c_int,
    >,
    pub bind_null: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_stmt,
            arg2: ::std::os::raw::c_int,
        ) -> ::std::os::raw::c_int,
    >,
    pub bind_parameter_count: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int,
    >,
    pub bind_parameter_index: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_stmt,
            zName: *const ::std::os::raw::c_char,
        ) -> ::std::os::raw::c_int,
    >,
    pub bind_parameter_name: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_stmt,
            arg2: ::std::os::raw::c_int,
        ) -> *const ::std::os::raw::c_char,
    >,
    pub bind_text: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_stmt,
            arg2: ::std::os::raw::c_int,
            arg3: *const ::std::os::raw::c_char,
            n: ::std::os::raw::c_int,
            arg4: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
        ) -> ::std::os::raw::c_int,
    >,
    pub bind_text16: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_stmt,
            arg2: ::std::os::raw::c_int,
            arg3: *const ::std::os::raw::c_void,
            arg4: ::std::os::raw::c_int,
            arg5: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
        ) -> ::std::os::raw::c_int,
    >,
    pub bind_value: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_stmt,
            arg2: ::std::os::raw::c_int,
            arg3: *const sqlite3_value,
        ) -> ::std::os::raw::c_int,
    >,
    pub busy_handler: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3,
            arg2: ::std::option::Option<
                unsafe extern "C" fn(
                    arg1: *mut ::std::os::raw::c_void,
                    arg2: ::std::os::raw::c_int,
                ) -> ::std::os::raw::c_int,
            >,
            arg3: *mut ::std::os::raw::c_void,
        ) -> ::std::os::raw::c_int,
    >,
    pub busy_timeout: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3,
            ms: ::std::os::raw::c_int,
        ) -> ::std::os::raw::c_int,
    >,
    pub changes:
        ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3) -> ::std::os::raw::c_int>,
    pub close:
        ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3) -> ::std::os::raw::c_int>,
    pub collation_needed: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3,
            arg2: *mut ::std::os::raw::c_void,
            arg3: ::std::option::Option<
                unsafe extern "C" fn(
                    arg1: *mut ::std::os::raw::c_void,
                    arg2: *mut sqlite3,
                    eTextRep: ::std::os::raw::c_int,
                    arg3: *const ::std::os::raw::c_char,
                ),
            >,
        ) -> ::std::os::raw::c_int,
    >,
    pub collation_needed16: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3,
            arg2: *mut ::std::os::raw::c_void,
            arg3: ::std::option::Option<
                unsafe extern "C" fn(
                    arg1: *mut ::std::os::raw::c_void,
                    arg2: *mut sqlite3,
                    eTextRep: ::std::os::raw::c_int,
                    arg3: *const ::std::os::raw::c_void,
                ),
            >,
        ) -> ::std::os::raw::c_int,
    >,
    pub column_blob: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_stmt,
            iCol: ::std::os::raw::c_int,
        ) -> *const ::std::os::raw::c_void,
    >,
    pub column_bytes: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_stmt,
            iCol: ::std::os::raw::c_int,
        ) -> ::std::os::raw::c_int,
    >,
    pub column_bytes16: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_stmt,
            iCol: ::std::os::raw::c_int,
        ) -> ::std::os::raw::c_int,
    >,
    pub column_count: ::std::option::Option<
        unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int,
    >,
    pub column_database_name: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_stmt,
            arg2: ::std::os::raw::c_int,
        ) -> *const ::std::os::raw::c_char,
    >,
    pub column_database_name16: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_stmt,
            arg2: ::std::os::raw::c_int,
        ) -> *const ::std::os::raw::c_void,
    >,
    pub column_decltype: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_stmt,
            i: ::std::os::raw::c_int,
        ) -> *const ::std::os::raw::c_char,
    >,
    pub column_decltype16: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_stmt,
            arg2: ::std::os::raw::c_int,
        ) -> *const ::std::os::raw::c_void,
    >,
    pub column_double: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64,
    >,
    pub column_int: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_stmt,
            iCol: ::std::os::raw::c_int,
        ) -> ::std::os::raw::c_int,
    >,
    pub column_int64: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> sqlite_int64,
    >,
    pub column_name: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_stmt,
            arg2: ::std::os::raw::c_int,
        ) -> *const ::std::os::raw::c_char,
    >,
    pub column_name16: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_stmt,
            arg2: ::std::os::raw::c_int,
        ) -> *const ::std::os::raw::c_void,
    >,
    pub column_origin_name: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_stmt,
            arg2: ::std::os::raw::c_int,
        ) -> *const ::std::os::raw::c_char,
    >,
    pub column_origin_name16: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_stmt,
            arg2: ::std::os::raw::c_int,
        ) -> *const ::std::os::raw::c_void,
    >,
    pub column_table_name: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_stmt,
            arg2: ::std::os::raw::c_int,
        ) -> *const ::std::os::raw::c_char,
    >,
    pub column_table_name16: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_stmt,
            arg2: ::std::os::raw::c_int,
        ) -> *const ::std::os::raw::c_void,
    >,
    pub column_text: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_stmt,
            iCol: ::std::os::raw::c_int,
        ) -> *const ::std::os::raw::c_uchar,
    >,
    pub column_text16: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_stmt,
            iCol: ::std::os::raw::c_int,
        ) -> *const ::std::os::raw::c_void,
    >,
    pub column_type: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_stmt,
            iCol: ::std::os::raw::c_int,
        ) -> ::std::os::raw::c_int,
    >,
    pub column_value: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_stmt,
            iCol: ::std::os::raw::c_int,
        ) -> *mut sqlite3_value,
    >,
    pub commit_hook: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3,
            arg2: ::std::option::Option<
                unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int,
            >,
            arg3: *mut ::std::os::raw::c_void,
        ) -> *mut ::std::os::raw::c_void,
    >,
    pub complete: ::std::option::Option<
        unsafe extern "C" fn(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int,
    >,
    pub complete16: ::std::option::Option<
        unsafe extern "C" fn(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int,
    >,
    pub create_collation: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3,
            arg2: *const ::std::os::raw::c_char,
            arg3: ::std::os::raw::c_int,
            arg4: *mut ::std::os::raw::c_void,
            arg5: ::std::option::Option<
                unsafe extern "C" fn(
                    arg1: *mut ::std::os::raw::c_void,
                    arg2: ::std::os::raw::c_int,
                    arg3: *const ::std::os::raw::c_void,
                    arg4: ::std::os::raw::c_int,
                    arg5: *const ::std::os::raw::c_void,
                ) -> ::std::os::raw::c_int,
            >,
        ) -> ::std::os::raw::c_int,
    >,
    pub create_collation16: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3,
            arg2: *const ::std::os::raw::c_void,
            arg3: ::std::os::raw::c_int,
            arg4: *mut ::std::os::raw::c_void,
            arg5: ::std::option::Option<
                unsafe extern "C" fn(
                    arg1: *mut ::std::os::raw::c_void,
                    arg2: ::std::os::raw::c_int,
                    arg3: *const ::std::os::raw::c_void,
                    arg4: ::std::os::raw::c_int,
                    arg5: *const ::std::os::raw::c_void,
                ) -> ::std::os::raw::c_int,
            >,
        ) -> ::std::os::raw::c_int,
    >,
    pub create_function: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3,
            arg2: *const ::std::os::raw::c_char,
            arg3: ::std::os::raw::c_int,
            arg4: ::std::os::raw::c_int,
            arg5: *mut ::std::os::raw::c_void,
            xFunc: ::std::option::Option<
                unsafe extern "C" fn(
                    arg1: *mut sqlite3_context,
                    arg2: ::std::os::raw::c_int,
                    arg3: *mut *mut sqlite3_value,
                ),
            >,
            xStep: ::std::option::Option<
                unsafe extern "C" fn(
                    arg1: *mut sqlite3_context,
                    arg2: ::std::os::raw::c_int,
                    arg3: *mut *mut sqlite3_value,
                ),
            >,
            xFinal: ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_context)>,
        ) -> ::std::os::raw::c_int,
    >,
    pub create_function16: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3,
            arg2: *const ::std::os::raw::c_void,
            arg3: ::std::os::raw::c_int,
            arg4: ::std::os::raw::c_int,
            arg5: *mut ::std::os::raw::c_void,
            xFunc: ::std::option::Option<
                unsafe extern "C" fn(
                    arg1: *mut sqlite3_context,
                    arg2: ::std::os::raw::c_int,
                    arg3: *mut *mut sqlite3_value,
                ),
            >,
            xStep: ::std::option::Option<
                unsafe extern "C" fn(
                    arg1: *mut sqlite3_context,
                    arg2: ::std::os::raw::c_int,
                    arg3: *mut *mut sqlite3_value,
                ),
            >,
            xFinal: ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_context)>,
        ) -> ::std::os::raw::c_int,
    >,
    pub create_module: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3,
            arg2: *const ::std::os::raw::c_char,
            arg3: *const sqlite3_module,
            arg4: *mut ::std::os::raw::c_void,
        ) -> ::std::os::raw::c_int,
    >,
    pub data_count: ::std::option::Option<
        unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int,
    >,
    pub db_handle:
        ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *mut sqlite3>,
    pub declare_vtab: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3,
            arg2: *const ::std::os::raw::c_char,
        ) -> ::std::os::raw::c_int,
    >,
    pub enable_shared_cache: ::std::option::Option<
        unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int,
    >,
    pub errcode:
        ::std::option::Option<unsafe extern "C" fn(db: *mut sqlite3) -> ::std::os::raw::c_int>,
    pub errmsg: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char,
    >,
    pub errmsg16: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void,
    >,
    pub exec: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3,
            arg2: *const ::std::os::raw::c_char,
            arg3: sqlite3_callback,
            arg4: *mut ::std::os::raw::c_void,
            arg5: *mut *mut ::std::os::raw::c_char,
        ) -> ::std::os::raw::c_int,
    >,
    pub expired: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int,
    >,
    pub finalize: ::std::option::Option<
        unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int,
    >,
    pub free: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
    pub free_table:
        ::std::option::Option<unsafe extern "C" fn(result: *mut *mut ::std::os::raw::c_char)>,
    pub get_autocommit:
        ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3) -> ::std::os::raw::c_int>,
    pub get_auxdata: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_context,
            arg2: ::std::os::raw::c_int,
        ) -> *mut ::std::os::raw::c_void,
    >,
    pub get_table: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3,
            arg2: *const ::std::os::raw::c_char,
            arg3: *mut *mut *mut ::std::os::raw::c_char,
            arg4: *mut ::std::os::raw::c_int,
            arg5: *mut ::std::os::raw::c_int,
            arg6: *mut *mut ::std::os::raw::c_char,
        ) -> ::std::os::raw::c_int,
    >,
    pub global_recover: ::std::option::Option<unsafe extern "C" fn() -> ::std::os::raw::c_int>,
    pub interruptx: ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3)>,
    pub last_insert_rowid:
        ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3) -> sqlite_int64>,
    pub libversion: ::std::option::Option<unsafe extern "C" fn() -> *const ::std::os::raw::c_char>,
    pub libversion_number: ::std::option::Option<unsafe extern "C" fn() -> ::std::os::raw::c_int>,
    pub malloc: ::std::option::Option<
        unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void,
    >,
    pub mprintf: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *const ::std::os::raw::c_char,
            ...
        ) -> *mut ::std::os::raw::c_char,
    >,
    pub open: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *const ::std::os::raw::c_char,
            arg2: *mut *mut sqlite3,
        ) -> ::std::os::raw::c_int,
    >,
    pub open16: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *const ::std::os::raw::c_void,
            arg2: *mut *mut sqlite3,
        ) -> ::std::os::raw::c_int,
    >,
    pub prepare: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3,
            arg2: *const ::std::os::raw::c_char,
            arg3: ::std::os::raw::c_int,
            arg4: *mut *mut sqlite3_stmt,
            arg5: *mut *const ::std::os::raw::c_char,
        ) -> ::std::os::raw::c_int,
    >,
    pub prepare16: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3,
            arg2: *const ::std::os::raw::c_void,
            arg3: ::std::os::raw::c_int,
            arg4: *mut *mut sqlite3_stmt,
            arg5: *mut *const ::std::os::raw::c_void,
        ) -> ::std::os::raw::c_int,
    >,
    pub profile: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3,
            arg2: ::std::option::Option<
                unsafe extern "C" fn(
                    arg1: *mut ::std::os::raw::c_void,
                    arg2: *const ::std::os::raw::c_char,
                    arg3: sqlite_uint64,
                ),
            >,
            arg3: *mut ::std::os::raw::c_void,
        ) -> *mut ::std::os::raw::c_void,
    >,
    pub progress_handler: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3,
            arg2: ::std::os::raw::c_int,
            arg3: ::std::option::Option<
                unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int,
            >,
            arg4: *mut ::std::os::raw::c_void,
        ),
    >,
    pub realloc: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut ::std::os::raw::c_void,
            arg2: ::std::os::raw::c_int,
        ) -> *mut ::std::os::raw::c_void,
    >,
    pub reset: ::std::option::Option<
        unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int,
    >,
    pub result_blob: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_context,
            arg2: *const ::std::os::raw::c_void,
            arg3: ::std::os::raw::c_int,
            arg4: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
        ),
    >,
    pub result_double:
        ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: f64)>,
    pub result_error: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_context,
            arg2: *const ::std::os::raw::c_char,
            arg3: ::std::os::raw::c_int,
        ),
    >,
    pub result_error16: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_context,
            arg2: *const ::std::os::raw::c_void,
            arg3: ::std::os::raw::c_int,
        ),
    >,
    pub result_int: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int),
    >,
    pub result_int64:
        ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: sqlite_int64)>,
    pub result_null: ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_context)>,
    pub result_text: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_context,
            arg2: *const ::std::os::raw::c_char,
            arg3: ::std::os::raw::c_int,
            arg4: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
        ),
    >,
    pub result_text16: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_context,
            arg2: *const ::std::os::raw::c_void,
            arg3: ::std::os::raw::c_int,
            arg4: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
        ),
    >,
    pub result_text16be: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_context,
            arg2: *const ::std::os::raw::c_void,
            arg3: ::std::os::raw::c_int,
            arg4: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
        ),
    >,
    pub result_text16le: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_context,
            arg2: *const ::std::os::raw::c_void,
            arg3: ::std::os::raw::c_int,
            arg4: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
        ),
    >,
    pub result_value: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value),
    >,
    pub rollback_hook: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3,
            arg2: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
            arg3: *mut ::std::os::raw::c_void,
        ) -> *mut ::std::os::raw::c_void,
    >,
    pub set_authorizer: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3,
            arg2: ::std::option::Option<
                unsafe extern "C" fn(
                    arg1: *mut ::std::os::raw::c_void,
                    arg2: ::std::os::raw::c_int,
                    arg3: *const ::std::os::raw::c_char,
                    arg4: *const ::std::os::raw::c_char,
                    arg5: *const ::std::os::raw::c_char,
                    arg6: *const ::std::os::raw::c_char,
                ) -> ::std::os::raw::c_int,
            >,
            arg3: *mut ::std::os::raw::c_void,
        ) -> ::std::os::raw::c_int,
    >,
    pub set_auxdata: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_context,
            arg2: ::std::os::raw::c_int,
            arg3: *mut ::std::os::raw::c_void,
            arg4: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
        ),
    >,
    pub snprintf: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: ::std::os::raw::c_int,
            arg2: *mut ::std::os::raw::c_char,
            arg3: *const ::std::os::raw::c_char,
            ...
        ) -> *mut ::std::os::raw::c_char,
    >,
    pub step: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int,
    >,
    pub table_column_metadata: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3,
            arg2: *const ::std::os::raw::c_char,
            arg3: *const ::std::os::raw::c_char,
            arg4: *const ::std::os::raw::c_char,
            arg5: *mut *const ::std::os::raw::c_char,
            arg6: *mut *const ::std::os::raw::c_char,
            arg7: *mut ::std::os::raw::c_int,
            arg8: *mut ::std::os::raw::c_int,
            arg9: *mut ::std::os::raw::c_int,
        ) -> ::std::os::raw::c_int,
    >,
    pub thread_cleanup: ::std::option::Option<unsafe extern "C" fn()>,
    pub total_changes:
        ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3) -> ::std::os::raw::c_int>,
    pub trace: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3,
            xTrace: ::std::option::Option<
                unsafe extern "C" fn(
                    arg1: *mut ::std::os::raw::c_void,
                    arg2: *const ::std::os::raw::c_char,
                ),
            >,
            arg2: *mut ::std::os::raw::c_void,
        ) -> *mut ::std::os::raw::c_void,
    >,
    pub transfer_bindings: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_stmt,
            arg2: *mut sqlite3_stmt,
        ) -> ::std::os::raw::c_int,
    >,
    pub update_hook: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3,
            arg2: ::std::option::Option<
                unsafe extern "C" fn(
                    arg1: *mut ::std::os::raw::c_void,
                    arg2: ::std::os::raw::c_int,
                    arg3: *const ::std::os::raw::c_char,
                    arg4: *const ::std::os::raw::c_char,
                    arg5: sqlite_int64,
                ),
            >,
            arg3: *mut ::std::os::raw::c_void,
        ) -> *mut ::std::os::raw::c_void,
    >,
    pub user_data: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void,
    >,
    pub value_blob: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void,
    >,
    pub value_bytes: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int,
    >,
    pub value_bytes16: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int,
    >,
    pub value_double: ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_value) -> f64>,
    pub value_int: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int,
    >,
    pub value_int64:
        ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_value) -> sqlite_int64>,
    pub value_numeric_type: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int,
    >,
    pub value_text: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar,
    >,
    pub value_text16: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void,
    >,
    pub value_text16be: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void,
    >,
    pub value_text16le: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void,
    >,
    pub value_type: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int,
    >,
    pub overload_function: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3,
            zFuncName: *const ::std::os::raw::c_char,
            nArg: ::std::os::raw::c_int,
        ) -> ::std::os::raw::c_int,
    >,
    pub prepare_v2: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3,
            arg2: *const ::std::os::raw::c_char,
            arg3: ::std::os::raw::c_int,
            arg4: *mut *mut sqlite3_stmt,
            arg5: *mut *const ::std::os::raw::c_char,
        ) -> ::std::os::raw::c_int,
    >,
    pub prepare16_v2: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3,
            arg2: *const ::std::os::raw::c_void,
            arg3: ::std::os::raw::c_int,
            arg4: *mut *mut sqlite3_stmt,
            arg5: *mut *const ::std::os::raw::c_void,
        ) -> ::std::os::raw::c_int,
    >,
    pub clear_bindings: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int,
    >,
    pub create_module_v2: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3,
            arg2: *const ::std::os::raw::c_char,
            arg3: *const sqlite3_module,
            arg4: *mut ::std::os::raw::c_void,
            xDestroy: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
        ) -> ::std::os::raw::c_int,
    >,
    pub bind_zeroblob: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_stmt,
            arg2: ::std::os::raw::c_int,
            arg3: ::std::os::raw::c_int,
        ) -> ::std::os::raw::c_int,
    >,
    pub blob_bytes: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int,
    >,
    pub blob_close: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int,
    >,
    pub blob_open: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3,
            arg2: *const ::std::os::raw::c_char,
            arg3: *const ::std::os::raw::c_char,
            arg4: *const ::std::os::raw::c_char,
            arg5: sqlite3_int64,
            arg6: ::std::os::raw::c_int,
            arg7: *mut *mut sqlite3_blob,
        ) -> ::std::os::raw::c_int,
    >,
    pub blob_read: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_blob,
            arg2: *mut ::std::os::raw::c_void,
            arg3: ::std::os::raw::c_int,
            arg4: ::std::os::raw::c_int,
        ) -> ::std::os::raw::c_int,
    >,
    pub blob_write: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_blob,
            arg2: *const ::std::os::raw::c_void,
            arg3: ::std::os::raw::c_int,
            arg4: ::std::os::raw::c_int,
        ) -> ::std::os::raw::c_int,
    >,
    pub create_collation_v2: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3,
            arg2: *const ::std::os::raw::c_char,
            arg3: ::std::os::raw::c_int,
            arg4: *mut ::std::os::raw::c_void,
            arg5: ::std::option::Option<
                unsafe extern "C" fn(
                    arg1: *mut ::std::os::raw::c_void,
                    arg2: ::std::os::raw::c_int,
                    arg3: *const ::std::os::raw::c_void,
                    arg4: ::std::os::raw::c_int,
                    arg5: *const ::std::os::raw::c_void,
                ) -> ::std::os::raw::c_int,
            >,
            arg6: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
        ) -> ::std::os::raw::c_int,
    >,
    pub file_control: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3,
            arg2: *const ::std::os::raw::c_char,
            arg3: ::std::os::raw::c_int,
            arg4: *mut ::std::os::raw::c_void,
        ) -> ::std::os::raw::c_int,
    >,
    pub memory_highwater:
        ::std::option::Option<unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> sqlite3_int64>,
    pub memory_used: ::std::option::Option<unsafe extern "C" fn() -> sqlite3_int64>,
    pub mutex_alloc: ::std::option::Option<
        unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex,
    >,
    pub mutex_enter: ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_mutex)>,
    pub mutex_free: ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_mutex)>,
    pub mutex_leave: ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_mutex)>,
    pub mutex_try: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int,
    >,
    pub open_v2: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *const ::std::os::raw::c_char,
            arg2: *mut *mut sqlite3,
            arg3: ::std::os::raw::c_int,
            arg4: *const ::std::os::raw::c_char,
        ) -> ::std::os::raw::c_int,
    >,
    pub release_memory: ::std::option::Option<
        unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int,
    >,
    pub result_error_nomem: ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_context)>,
    pub result_error_toobig:
        ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_context)>,
    pub sleep: ::std::option::Option<
        unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int,
    >,
    pub soft_heap_limit: ::std::option::Option<unsafe extern "C" fn(arg1: ::std::os::raw::c_int)>,
    pub vfs_find: ::std::option::Option<
        unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs,
    >,
    pub vfs_register: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_vfs,
            arg2: ::std::os::raw::c_int,
        ) -> ::std::os::raw::c_int,
    >,
    pub vfs_unregister: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int,
    >,
    pub xthreadsafe: ::std::option::Option<unsafe extern "C" fn() -> ::std::os::raw::c_int>,
    pub result_zeroblob: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int),
    >,
    pub result_error_code: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int),
    >,
    pub test_control: ::std::option::Option<
        unsafe extern "C" fn(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int,
    >,
    pub randomness: ::std::option::Option<
        unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void),
    >,
    pub context_db_handle:
        ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_context) -> *mut sqlite3>,
    pub extended_result_codes: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3,
            arg2: ::std::os::raw::c_int,
        ) -> ::std::os::raw::c_int,
    >,
    pub limit: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3,
            arg2: ::std::os::raw::c_int,
            arg3: ::std::os::raw::c_int,
        ) -> ::std::os::raw::c_int,
    >,
    pub next_stmt: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt,
    >,
    pub sql: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char,
    >,
    pub status: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: ::std::os::raw::c_int,
            arg2: *mut ::std::os::raw::c_int,
            arg3: *mut ::std::os::raw::c_int,
            arg4: ::std::os::raw::c_int,
        ) -> ::std::os::raw::c_int,
    >,
}
#[test]
fn bindgen_test_layout_sqlite3_api_routines() {
    assert_eq!(
        ::std::mem::size_of::<sqlite3_api_routines>(),
        1232usize,
        concat!("Size of: ", stringify!(sqlite3_api_routines))
    );
    assert_eq!(
        ::std::mem::align_of::<sqlite3_api_routines>(),
        8usize,
        concat!("Alignment of ", stringify!(sqlite3_api_routines))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).aggregate_context as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(aggregate_context)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).aggregate_count as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(aggregate_count)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).bind_blob as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(bind_blob)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).bind_double as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(bind_double)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).bind_int as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(bind_int)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).bind_int64 as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(bind_int64)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).bind_null as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(bind_null)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).bind_parameter_count as *const _
                as usize
        },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(bind_parameter_count)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).bind_parameter_index as *const _
                as usize
        },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(bind_parameter_index)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).bind_parameter_name as *const _
                as usize
        },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(bind_parameter_name)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).bind_text as *const _ as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(bind_text)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).bind_text16 as *const _ as usize
        },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(bind_text16)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).bind_value as *const _ as usize },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(bind_value)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).busy_handler as *const _ as usize
        },
        104usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(busy_handler)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).busy_timeout as *const _ as usize
        },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(busy_timeout)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).changes as *const _ as usize },
        120usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(changes)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).close as *const _ as usize },
        128usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(close)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).collation_needed as *const _ as usize
        },
        136usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(collation_needed)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).collation_needed16 as *const _ as usize
        },
        144usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(collation_needed16)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).column_blob as *const _ as usize
        },
        152usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(column_blob)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).column_bytes as *const _ as usize
        },
        160usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(column_bytes)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).column_bytes16 as *const _ as usize
        },
        168usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(column_bytes16)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).column_count as *const _ as usize
        },
        176usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(column_count)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).column_database_name as *const _
                as usize
        },
        184usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(column_database_name)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).column_database_name16 as *const _
                as usize
        },
        192usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(column_database_name16)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).column_decltype as *const _ as usize
        },
        200usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(column_decltype)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).column_decltype16 as *const _ as usize
        },
        208usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(column_decltype16)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).column_double as *const _ as usize
        },
        216usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(column_double)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).column_int as *const _ as usize },
        224usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(column_int)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).column_int64 as *const _ as usize
        },
        232usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(column_int64)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).column_name as *const _ as usize
        },
        240usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(column_name)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).column_name16 as *const _ as usize
        },
        248usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(column_name16)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).column_origin_name as *const _ as usize
        },
        256usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(column_origin_name)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).column_origin_name16 as *const _
                as usize
        },
        264usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(column_origin_name16)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).column_table_name as *const _ as usize
        },
        272usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(column_table_name)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).column_table_name16 as *const _
                as usize
        },
        280usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(column_table_name16)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).column_text as *const _ as usize
        },
        288usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(column_text)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).column_text16 as *const _ as usize
        },
        296usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(column_text16)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).column_type as *const _ as usize
        },
        304usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(column_type)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).column_value as *const _ as usize
        },
        312usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(column_value)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).commit_hook as *const _ as usize
        },
        320usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(commit_hook)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).complete as *const _ as usize },
        328usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(complete)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).complete16 as *const _ as usize },
        336usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(complete16)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).create_collation as *const _ as usize
        },
        344usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(create_collation)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).create_collation16 as *const _ as usize
        },
        352usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(create_collation16)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).create_function as *const _ as usize
        },
        360usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(create_function)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).create_function16 as *const _ as usize
        },
        368usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(create_function16)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).create_module as *const _ as usize
        },
        376usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(create_module)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).data_count as *const _ as usize },
        384usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(data_count)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).db_handle as *const _ as usize },
        392usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(db_handle)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).declare_vtab as *const _ as usize
        },
        400usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(declare_vtab)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).enable_shared_cache as *const _
                as usize
        },
        408usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(enable_shared_cache)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).errcode as *const _ as usize },
        416usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(errcode)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).errmsg as *const _ as usize },
        424usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(errmsg)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).errmsg16 as *const _ as usize },
        432usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(errmsg16)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).exec as *const _ as usize },
        440usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(exec)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).expired as *const _ as usize },
        448usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(expired)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).finalize as *const _ as usize },
        456usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(finalize)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).free as *const _ as usize },
        464usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(free)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).free_table as *const _ as usize },
        472usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(free_table)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).get_autocommit as *const _ as usize
        },
        480usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(get_autocommit)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).get_auxdata as *const _ as usize
        },
        488usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(get_auxdata)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).get_table as *const _ as usize },
        496usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(get_table)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).global_recover as *const _ as usize
        },
        504usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(global_recover)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).interruptx as *const _ as usize },
        512usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(interruptx)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).last_insert_rowid as *const _ as usize
        },
        520usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(last_insert_rowid)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).libversion as *const _ as usize },
        528usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(libversion)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).libversion_number as *const _ as usize
        },
        536usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(libversion_number)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).malloc as *const _ as usize },
        544usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(malloc)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).mprintf as *const _ as usize },
        552usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(mprintf)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).open as *const _ as usize },
        560usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(open)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).open16 as *const _ as usize },
        568usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(open16)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).prepare as *const _ as usize },
        576usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(prepare)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).prepare16 as *const _ as usize },
        584usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(prepare16)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).profile as *const _ as usize },
        592usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(profile)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).progress_handler as *const _ as usize
        },
        600usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(progress_handler)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).realloc as *const _ as usize },
        608usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(realloc)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).reset as *const _ as usize },
        616usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(reset)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).result_blob as *const _ as usize
        },
        624usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(result_blob)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).result_double as *const _ as usize
        },
        632usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(result_double)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).result_error as *const _ as usize
        },
        640usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(result_error)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).result_error16 as *const _ as usize
        },
        648usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(result_error16)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).result_int as *const _ as usize },
        656usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(result_int)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).result_int64 as *const _ as usize
        },
        664usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(result_int64)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).result_null as *const _ as usize
        },
        672usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(result_null)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).result_text as *const _ as usize
        },
        680usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(result_text)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).result_text16 as *const _ as usize
        },
        688usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(result_text16)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).result_text16be as *const _ as usize
        },
        696usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(result_text16be)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).result_text16le as *const _ as usize
        },
        704usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(result_text16le)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).result_value as *const _ as usize
        },
        712usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(result_value)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).rollback_hook as *const _ as usize
        },
        720usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(rollback_hook)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).set_authorizer as *const _ as usize
        },
        728usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(set_authorizer)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).set_auxdata as *const _ as usize
        },
        736usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(set_auxdata)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).snprintf as *const _ as usize },
        744usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(snprintf)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).step as *const _ as usize },
        752usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(step)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).table_column_metadata as *const _
                as usize
        },
        760usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(table_column_metadata)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).thread_cleanup as *const _ as usize
        },
        768usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(thread_cleanup)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).total_changes as *const _ as usize
        },
        776usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(total_changes)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).trace as *const _ as usize },
        784usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(trace)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).transfer_bindings as *const _ as usize
        },
        792usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(transfer_bindings)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).update_hook as *const _ as usize
        },
        800usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(update_hook)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).user_data as *const _ as usize },
        808usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(user_data)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).value_blob as *const _ as usize },
        816usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(value_blob)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).value_bytes as *const _ as usize
        },
        824usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(value_bytes)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).value_bytes16 as *const _ as usize
        },
        832usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(value_bytes16)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).value_double as *const _ as usize
        },
        840usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(value_double)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).value_int as *const _ as usize },
        848usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(value_int)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).value_int64 as *const _ as usize
        },
        856usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(value_int64)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).value_numeric_type as *const _ as usize
        },
        864usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(value_numeric_type)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).value_text as *const _ as usize },
        872usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(value_text)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).value_text16 as *const _ as usize
        },
        880usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(value_text16)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).value_text16be as *const _ as usize
        },
        888usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(value_text16be)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).value_text16le as *const _ as usize
        },
        896usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(value_text16le)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).value_type as *const _ as usize },
        904usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(value_type)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).overload_function as *const _ as usize
        },
        920usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(overload_function)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).prepare_v2 as *const _ as usize },
        928usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(prepare_v2)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).prepare16_v2 as *const _ as usize
        },
        936usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(prepare16_v2)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).clear_bindings as *const _ as usize
        },
        944usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(clear_bindings)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).create_module_v2 as *const _ as usize
        },
        952usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(create_module_v2)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).bind_zeroblob as *const _ as usize
        },
        960usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(bind_zeroblob)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).blob_bytes as *const _ as usize },
        968usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(blob_bytes)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).blob_close as *const _ as usize },
        976usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(blob_close)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).blob_open as *const _ as usize },
        984usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(blob_open)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).blob_read as *const _ as usize },
        992usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(blob_read)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).blob_write as *const _ as usize },
        1000usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(blob_write)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).create_collation_v2 as *const _
                as usize
        },
        1008usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(create_collation_v2)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).file_control as *const _ as usize
        },
        1016usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(file_control)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).memory_highwater as *const _ as usize
        },
        1024usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(memory_highwater)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).memory_used as *const _ as usize
        },
        1032usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(memory_used)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).mutex_alloc as *const _ as usize
        },
        1040usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(mutex_alloc)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).mutex_enter as *const _ as usize
        },
        1048usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(mutex_enter)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).mutex_free as *const _ as usize },
        1056usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(mutex_free)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).mutex_leave as *const _ as usize
        },
        1064usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(mutex_leave)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).mutex_try as *const _ as usize },
        1072usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(mutex_try)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).open_v2 as *const _ as usize },
        1080usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(open_v2)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).release_memory as *const _ as usize
        },
        1088usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(release_memory)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).result_error_nomem as *const _ as usize
        },
        1096usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(result_error_nomem)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).result_error_toobig as *const _
                as usize
        },
        1104usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(result_error_toobig)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).sleep as *const _ as usize },
        1112usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(sleep)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).soft_heap_limit as *const _ as usize
        },
        1120usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(soft_heap_limit)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).vfs_find as *const _ as usize },
        1128usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(vfs_find)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).vfs_register as *const _ as usize
        },
        1136usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(vfs_register)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).vfs_unregister as *const _ as usize
        },
        1144usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(vfs_unregister)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).xthreadsafe as *const _ as usize
        },
        1152usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(xthreadsafe)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).result_zeroblob as *const _ as usize
        },
        1160usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(result_zeroblob)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).result_error_code as *const _ as usize
        },
        1168usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(result_error_code)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).test_control as *const _ as usize
        },
        1176usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(test_control)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).randomness as *const _ as usize },
        1184usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(randomness)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).context_db_handle as *const _ as usize
        },
        1192usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(context_db_handle)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sqlite3_api_routines>())).extended_result_codes as *const _
                as usize
        },
        1200usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(extended_result_codes)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).limit as *const _ as usize },
        1208usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(limit)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).next_stmt as *const _ as usize },
        1216usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(next_stmt)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).sql as *const _ as usize },
        1224usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(sql)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sqlite3_api_routines>())).status as *const _ as usize },
        1232usize,
        concat!(
            "Offset of field: ",
            stringify!(sqlite3_api_routines),
            "::",
            stringify!(status)
        )
    );
}

// sqlite3_api is defined in lib.rs as either a static or an extern when compiled as a loadable_extension
#[cfg(feature = "loadable_extension")]
use crate::sqlite3_api;

// sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen)

pub unsafe fn sqlite3_aggregate_context(
    arg1: *mut sqlite3_context,
    nBytes: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_void {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).aggregate_context.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "aggregate_context",
        " function"
    )))(arg1, nBytes)
}

pub unsafe fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).aggregate_count.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "aggregate_count",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_bind_blob(
    arg1: *mut sqlite3_stmt,
    arg2: ::std::os::raw::c_int,
    arg3: *const ::std::os::raw::c_void,
    n: ::std::os::raw::c_int,
    arg4: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).bind_blob.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "bind_blob",
        " function"
    )))(arg1, arg2, arg3, n, arg4)
}

pub unsafe fn sqlite3_bind_double(
    arg1: *mut sqlite3_stmt,
    arg2: ::std::os::raw::c_int,
    arg3: f64,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).bind_double.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "bind_double",
        " function"
    )))(arg1, arg2, arg3)
}

pub unsafe fn sqlite3_bind_int(
    arg1: *mut sqlite3_stmt,
    arg2: ::std::os::raw::c_int,
    arg3: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).bind_int.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "bind_int",
        " function"
    )))(arg1, arg2, arg3)
}

pub unsafe fn sqlite3_bind_int64(
    arg1: *mut sqlite3_stmt,
    arg2: ::std::os::raw::c_int,
    arg3: sqlite_int64,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).bind_int64.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "bind_int64",
        " function"
    )))(arg1, arg2, arg3)
}

pub unsafe fn sqlite3_bind_null(
    arg1: *mut sqlite3_stmt,
    arg2: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).bind_null.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "bind_null",
        " function"
    )))(arg1, arg2)
}

pub unsafe fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).bind_parameter_count.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "bind_parameter_count",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_bind_parameter_index(
    arg1: *mut sqlite3_stmt,
    zName: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).bind_parameter_index.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "bind_parameter_index",
        " function"
    )))(arg1, zName)
}

pub unsafe fn sqlite3_bind_parameter_name(
    arg1: *mut sqlite3_stmt,
    arg2: ::std::os::raw::c_int,
) -> *const ::std::os::raw::c_char {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).bind_parameter_name.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "bind_parameter_name",
        " function"
    )))(arg1, arg2)
}

pub unsafe fn sqlite3_bind_text(
    arg1: *mut sqlite3_stmt,
    arg2: ::std::os::raw::c_int,
    arg3: *const ::std::os::raw::c_char,
    n: ::std::os::raw::c_int,
    arg4: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).bind_text.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "bind_text",
        " function"
    )))(arg1, arg2, arg3, n, arg4)
}

pub unsafe fn sqlite3_bind_text16(
    arg1: *mut sqlite3_stmt,
    arg2: ::std::os::raw::c_int,
    arg3: *const ::std::os::raw::c_void,
    arg4: ::std::os::raw::c_int,
    arg5: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).bind_text16.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "bind_text16",
        " function"
    )))(arg1, arg2, arg3, arg4, arg5)
}

pub unsafe fn sqlite3_bind_value(
    arg1: *mut sqlite3_stmt,
    arg2: ::std::os::raw::c_int,
    arg3: *const sqlite3_value,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).bind_value.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "bind_value",
        " function"
    )))(arg1, arg2, arg3)
}

pub unsafe fn sqlite3_busy_handler(
    arg1: *mut sqlite3,
    arg2: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut ::std::os::raw::c_void,
            arg2: ::std::os::raw::c_int,
        ) -> ::std::os::raw::c_int,
    >,
    arg3: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).busy_handler.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "busy_handler",
        " function"
    )))(arg1, arg2, arg3)
}

pub unsafe fn sqlite3_busy_timeout(
    arg1: *mut sqlite3,
    ms: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).busy_timeout.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "busy_timeout",
        " function"
    )))(arg1, ms)
}

pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).changes.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "changes",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).close.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "close",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_collation_needed(
    arg1: *mut sqlite3,
    arg2: *mut ::std::os::raw::c_void,
    arg3: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut ::std::os::raw::c_void,
            arg2: *mut sqlite3,
            eTextRep: ::std::os::raw::c_int,
            arg3: *const ::std::os::raw::c_char,
        ),
    >,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).collation_needed.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "collation_needed",
        " function"
    )))(arg1, arg2, arg3)
}

pub unsafe fn sqlite3_collation_needed16(
    arg1: *mut sqlite3,
    arg2: *mut ::std::os::raw::c_void,
    arg3: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut ::std::os::raw::c_void,
            arg2: *mut sqlite3,
            eTextRep: ::std::os::raw::c_int,
            arg3: *const ::std::os::raw::c_void,
        ),
    >,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).collation_needed16.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "collation_needed16",
        " function"
    )))(arg1, arg2, arg3)
}

pub unsafe fn sqlite3_column_blob(
    arg1: *mut sqlite3_stmt,
    iCol: ::std::os::raw::c_int,
) -> *const ::std::os::raw::c_void {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).column_blob.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "column_blob",
        " function"
    )))(arg1, iCol)
}

pub unsafe fn sqlite3_column_bytes(
    arg1: *mut sqlite3_stmt,
    iCol: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).column_bytes.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "column_bytes",
        " function"
    )))(arg1, iCol)
}

pub unsafe fn sqlite3_column_bytes16(
    arg1: *mut sqlite3_stmt,
    iCol: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).column_bytes16.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "column_bytes16",
        " function"
    )))(arg1, iCol)
}

pub unsafe fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).column_count.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "column_count",
        " function"
    )))(pStmt)
}

pub unsafe fn sqlite3_column_database_name(
    arg1: *mut sqlite3_stmt,
    arg2: ::std::os::raw::c_int,
) -> *const ::std::os::raw::c_char {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).column_database_name.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "column_database_name",
        " function"
    )))(arg1, arg2)
}

pub unsafe fn sqlite3_column_database_name16(
    arg1: *mut sqlite3_stmt,
    arg2: ::std::os::raw::c_int,
) -> *const ::std::os::raw::c_void {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).column_database_name16.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "column_database_name16",
        " function"
    )))(arg1, arg2)
}

pub unsafe fn sqlite3_column_decltype(
    arg1: *mut sqlite3_stmt,
    i: ::std::os::raw::c_int,
) -> *const ::std::os::raw::c_char {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).column_decltype.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "column_decltype",
        " function"
    )))(arg1, i)
}

pub unsafe fn sqlite3_column_decltype16(
    arg1: *mut sqlite3_stmt,
    arg2: ::std::os::raw::c_int,
) -> *const ::std::os::raw::c_void {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).column_decltype16.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "column_decltype16",
        " function"
    )))(arg1, arg2)
}

pub unsafe fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64 {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).column_double.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "column_double",
        " function"
    )))(arg1, iCol)
}

pub unsafe fn sqlite3_column_int(
    arg1: *mut sqlite3_stmt,
    iCol: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).column_int.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "column_int",
        " function"
    )))(arg1, iCol)
}

pub unsafe fn sqlite3_column_int64(
    arg1: *mut sqlite3_stmt,
    iCol: ::std::os::raw::c_int,
) -> sqlite_int64 {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).column_int64.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "column_int64",
        " function"
    )))(arg1, iCol)
}

pub unsafe fn sqlite3_column_name(
    arg1: *mut sqlite3_stmt,
    arg2: ::std::os::raw::c_int,
) -> *const ::std::os::raw::c_char {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).column_name.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "column_name",
        " function"
    )))(arg1, arg2)
}

pub unsafe fn sqlite3_column_name16(
    arg1: *mut sqlite3_stmt,
    arg2: ::std::os::raw::c_int,
) -> *const ::std::os::raw::c_void {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).column_name16.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "column_name16",
        " function"
    )))(arg1, arg2)
}

pub unsafe fn sqlite3_column_origin_name(
    arg1: *mut sqlite3_stmt,
    arg2: ::std::os::raw::c_int,
) -> *const ::std::os::raw::c_char {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).column_origin_name.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "column_origin_name",
        " function"
    )))(arg1, arg2)
}

pub unsafe fn sqlite3_column_origin_name16(
    arg1: *mut sqlite3_stmt,
    arg2: ::std::os::raw::c_int,
) -> *const ::std::os::raw::c_void {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).column_origin_name16.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "column_origin_name16",
        " function"
    )))(arg1, arg2)
}

pub unsafe fn sqlite3_column_table_name(
    arg1: *mut sqlite3_stmt,
    arg2: ::std::os::raw::c_int,
) -> *const ::std::os::raw::c_char {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).column_table_name.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "column_table_name",
        " function"
    )))(arg1, arg2)
}

pub unsafe fn sqlite3_column_table_name16(
    arg1: *mut sqlite3_stmt,
    arg2: ::std::os::raw::c_int,
) -> *const ::std::os::raw::c_void {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).column_table_name16.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "column_table_name16",
        " function"
    )))(arg1, arg2)
}

pub unsafe fn sqlite3_column_text(
    arg1: *mut sqlite3_stmt,
    iCol: ::std::os::raw::c_int,
) -> *const ::std::os::raw::c_uchar {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).column_text.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "column_text",
        " function"
    )))(arg1, iCol)
}

pub unsafe fn sqlite3_column_text16(
    arg1: *mut sqlite3_stmt,
    iCol: ::std::os::raw::c_int,
) -> *const ::std::os::raw::c_void {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).column_text16.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "column_text16",
        " function"
    )))(arg1, iCol)
}

pub unsafe fn sqlite3_column_type(
    arg1: *mut sqlite3_stmt,
    iCol: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).column_type.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "column_type",
        " function"
    )))(arg1, iCol)
}

pub unsafe fn sqlite3_column_value(
    arg1: *mut sqlite3_stmt,
    iCol: ::std::os::raw::c_int,
) -> *mut sqlite3_value {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).column_value.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "column_value",
        " function"
    )))(arg1, iCol)
}

pub unsafe fn sqlite3_commit_hook(
    arg1: *mut sqlite3,
    arg2: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int,
    >,
    arg3: *mut ::std::os::raw::c_void,
) -> *mut ::std::os::raw::c_void {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).commit_hook.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "commit_hook",
        " function"
    )))(arg1, arg2, arg3)
}

pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).complete.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "complete",
        " function"
    )))(sql)
}

pub unsafe fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).complete16.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "complete16",
        " function"
    )))(sql)
}

pub unsafe fn sqlite3_create_collation(
    arg1: *mut sqlite3,
    arg2: *const ::std::os::raw::c_char,
    arg3: ::std::os::raw::c_int,
    arg4: *mut ::std::os::raw::c_void,
    arg5: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut ::std::os::raw::c_void,
            arg2: ::std::os::raw::c_int,
            arg3: *const ::std::os::raw::c_void,
            arg4: ::std::os::raw::c_int,
            arg5: *const ::std::os::raw::c_void,
        ) -> ::std::os::raw::c_int,
    >,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).create_collation.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "create_collation",
        " function"
    )))(arg1, arg2, arg3, arg4, arg5)
}

pub unsafe fn sqlite3_create_collation16(
    arg1: *mut sqlite3,
    arg2: *const ::std::os::raw::c_void,
    arg3: ::std::os::raw::c_int,
    arg4: *mut ::std::os::raw::c_void,
    arg5: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut ::std::os::raw::c_void,
            arg2: ::std::os::raw::c_int,
            arg3: *const ::std::os::raw::c_void,
            arg4: ::std::os::raw::c_int,
            arg5: *const ::std::os::raw::c_void,
        ) -> ::std::os::raw::c_int,
    >,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).create_collation16.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "create_collation16",
        " function"
    )))(arg1, arg2, arg3, arg4, arg5)
}

pub unsafe fn sqlite3_create_function(
    arg1: *mut sqlite3,
    arg2: *const ::std::os::raw::c_char,
    arg3: ::std::os::raw::c_int,
    arg4: ::std::os::raw::c_int,
    arg5: *mut ::std::os::raw::c_void,
    xFunc: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_context,
            arg2: ::std::os::raw::c_int,
            arg3: *mut *mut sqlite3_value,
        ),
    >,
    xStep: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_context,
            arg2: ::std::os::raw::c_int,
            arg3: *mut *mut sqlite3_value,
        ),
    >,
    xFinal: ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_context)>,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).create_function.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "create_function",
        " function"
    )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal)
}

pub unsafe fn sqlite3_create_function16(
    arg1: *mut sqlite3,
    arg2: *const ::std::os::raw::c_void,
    arg3: ::std::os::raw::c_int,
    arg4: ::std::os::raw::c_int,
    arg5: *mut ::std::os::raw::c_void,
    xFunc: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_context,
            arg2: ::std::os::raw::c_int,
            arg3: *mut *mut sqlite3_value,
        ),
    >,
    xStep: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut sqlite3_context,
            arg2: ::std::os::raw::c_int,
            arg3: *mut *mut sqlite3_value,
        ),
    >,
    xFinal: ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_context)>,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).create_function16.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "create_function16",
        " function"
    )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal)
}

pub unsafe fn sqlite3_create_module(
    arg1: *mut sqlite3,
    arg2: *const ::std::os::raw::c_char,
    arg3: *const sqlite3_module,
    arg4: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).create_module.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "create_module",
        " function"
    )))(arg1, arg2, arg3, arg4)
}

pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).data_count.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "data_count",
        " function"
    )))(pStmt)
}

pub unsafe fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3 {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).db_handle.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "db_handle",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_declare_vtab(
    arg1: *mut sqlite3,
    arg2: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).declare_vtab.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "declare_vtab",
        " function"
    )))(arg1, arg2)
}

pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).enable_shared_cache.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "enable_shared_cache",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).errcode.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "errcode",
        " function"
    )))(db)
}

pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).errmsg.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "errmsg",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).errmsg16.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "errmsg16",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_exec(
    arg1: *mut sqlite3,
    arg2: *const ::std::os::raw::c_char,
    arg3: sqlite3_callback,
    arg4: *mut ::std::os::raw::c_void,
    arg5: *mut *mut ::std::os::raw::c_char,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).exec.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "exec",
        " function"
    )))(arg1, arg2, arg3, arg4, arg5)
}

pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).expired.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "expired",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).finalize.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "finalize",
        " function"
    )))(pStmt)
}

pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).free.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "free",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).free_table.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "free_table",
        " function"
    )))(result)
}

pub unsafe fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).get_autocommit.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "get_autocommit",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_get_auxdata(
    arg1: *mut sqlite3_context,
    arg2: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_void {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).get_auxdata.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "get_auxdata",
        " function"
    )))(arg1, arg2)
}

pub unsafe fn sqlite3_get_table(
    arg1: *mut sqlite3,
    arg2: *const ::std::os::raw::c_char,
    arg3: *mut *mut *mut ::std::os::raw::c_char,
    arg4: *mut ::std::os::raw::c_int,
    arg5: *mut ::std::os::raw::c_int,
    arg6: *mut *mut ::std::os::raw::c_char,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).get_table.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "get_table",
        " function"
    )))(arg1, arg2, arg3, arg4, arg5, arg6)
}

pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).global_recover.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "global_recover",
        " function"
    )))()
}

pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).interruptx.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "interruptx",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).last_insert_rowid.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "last_insert_rowid",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).libversion.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "libversion",
        " function"
    )))()
}

pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).libversion_number.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "libversion_number",
        " function"
    )))()
}

pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).malloc.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "malloc",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_mprintf(
    arg1: *const ::std::os::raw::c_char,
    vararg1: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).mprintf.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "mprintf",
        " function"
    )))(arg1, vararg1)
}

pub unsafe fn sqlite3_open(
    arg1: *const ::std::os::raw::c_char,
    arg2: *mut *mut sqlite3,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).open.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "open",
        " function"
    )))(arg1, arg2)
}

pub unsafe fn sqlite3_open16(
    arg1: *const ::std::os::raw::c_void,
    arg2: *mut *mut sqlite3,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).open16.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "open16",
        " function"
    )))(arg1, arg2)
}

pub unsafe fn sqlite3_prepare(
    arg1: *mut sqlite3,
    arg2: *const ::std::os::raw::c_char,
    arg3: ::std::os::raw::c_int,
    arg4: *mut *mut sqlite3_stmt,
    arg5: *mut *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).prepare.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "prepare",
        " function"
    )))(arg1, arg2, arg3, arg4, arg5)
}

pub unsafe fn sqlite3_prepare16(
    arg1: *mut sqlite3,
    arg2: *const ::std::os::raw::c_void,
    arg3: ::std::os::raw::c_int,
    arg4: *mut *mut sqlite3_stmt,
    arg5: *mut *const ::std::os::raw::c_void,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).prepare16.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "prepare16",
        " function"
    )))(arg1, arg2, arg3, arg4, arg5)
}

pub unsafe fn sqlite3_profile(
    arg1: *mut sqlite3,
    arg2: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut ::std::os::raw::c_void,
            arg2: *const ::std::os::raw::c_char,
            arg3: sqlite_uint64,
        ),
    >,
    arg3: *mut ::std::os::raw::c_void,
) -> *mut ::std::os::raw::c_void {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).profile.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "profile",
        " function"
    )))(arg1, arg2, arg3)
}

pub unsafe fn sqlite3_progress_handler(
    arg1: *mut sqlite3,
    arg2: ::std::os::raw::c_int,
    arg3: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int,
    >,
    arg4: *mut ::std::os::raw::c_void,
) {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).progress_handler.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "progress_handler",
        " function"
    )))(arg1, arg2, arg3, arg4)
}

pub unsafe fn sqlite3_realloc(
    arg1: *mut ::std::os::raw::c_void,
    arg2: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_void {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).realloc.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "realloc",
        " function"
    )))(arg1, arg2)
}

pub unsafe fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).reset.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "reset",
        " function"
    )))(pStmt)
}

pub unsafe fn sqlite3_result_blob(
    arg1: *mut sqlite3_context,
    arg2: *const ::std::os::raw::c_void,
    arg3: ::std::os::raw::c_int,
    arg4: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
) {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).result_blob.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "result_blob",
        " function"
    )))(arg1, arg2, arg3, arg4)
}

pub unsafe fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64) {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).result_double.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "result_double",
        " function"
    )))(arg1, arg2)
}

pub unsafe fn sqlite3_result_error(
    arg1: *mut sqlite3_context,
    arg2: *const ::std::os::raw::c_char,
    arg3: ::std::os::raw::c_int,
) {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).result_error.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "result_error",
        " function"
    )))(arg1, arg2, arg3)
}

pub unsafe fn sqlite3_result_error16(
    arg1: *mut sqlite3_context,
    arg2: *const ::std::os::raw::c_void,
    arg3: ::std::os::raw::c_int,
) {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).result_error16.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "result_error16",
        " function"
    )))(arg1, arg2, arg3)
}

pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).result_int.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "result_int",
        " function"
    )))(arg1, arg2)
}

pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int64) {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).result_int64.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "result_int64",
        " function"
    )))(arg1, arg2)
}

pub unsafe fn sqlite3_result_null(arg1: *mut sqlite3_context) {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).result_null.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "result_null",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_result_text(
    arg1: *mut sqlite3_context,
    arg2: *const ::std::os::raw::c_char,
    arg3: ::std::os::raw::c_int,
    arg4: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
) {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).result_text.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "result_text",
        " function"
    )))(arg1, arg2, arg3, arg4)
}

pub unsafe fn sqlite3_result_text16(
    arg1: *mut sqlite3_context,
    arg2: *const ::std::os::raw::c_void,
    arg3: ::std::os::raw::c_int,
    arg4: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
) {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).result_text16.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "result_text16",
        " function"
    )))(arg1, arg2, arg3, arg4)
}

pub unsafe fn sqlite3_result_text16be(
    arg1: *mut sqlite3_context,
    arg2: *const ::std::os::raw::c_void,
    arg3: ::std::os::raw::c_int,
    arg4: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
) {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).result_text16be.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "result_text16be",
        " function"
    )))(arg1, arg2, arg3, arg4)
}

pub unsafe fn sqlite3_result_text16le(
    arg1: *mut sqlite3_context,
    arg2: *const ::std::os::raw::c_void,
    arg3: ::std::os::raw::c_int,
    arg4: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
) {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).result_text16le.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "result_text16le",
        " function"
    )))(arg1, arg2, arg3, arg4)
}

pub unsafe fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value) {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).result_value.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "result_value",
        " function"
    )))(arg1, arg2)
}

pub unsafe fn sqlite3_rollback_hook(
    arg1: *mut sqlite3,
    arg2: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
    arg3: *mut ::std::os::raw::c_void,
) -> *mut ::std::os::raw::c_void {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).rollback_hook.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "rollback_hook",
        " function"
    )))(arg1, arg2, arg3)
}

pub unsafe fn sqlite3_set_authorizer(
    arg1: *mut sqlite3,
    arg2: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut ::std::os::raw::c_void,
            arg2: ::std::os::raw::c_int,
            arg3: *const ::std::os::raw::c_char,
            arg4: *const ::std::os::raw::c_char,
            arg5: *const ::std::os::raw::c_char,
            arg6: *const ::std::os::raw::c_char,
        ) -> ::std::os::raw::c_int,
    >,
    arg3: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).set_authorizer.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "set_authorizer",
        " function"
    )))(arg1, arg2, arg3)
}

pub unsafe fn sqlite3_set_auxdata(
    arg1: *mut sqlite3_context,
    arg2: ::std::os::raw::c_int,
    arg3: *mut ::std::os::raw::c_void,
    arg4: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
) {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).set_auxdata.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "set_auxdata",
        " function"
    )))(arg1, arg2, arg3, arg4)
}

pub unsafe fn sqlite3_snprintf(
    arg1: ::std::os::raw::c_int,
    arg2: *mut ::std::os::raw::c_char,
    arg3: *const ::std::os::raw::c_char,
    vararg1: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).snprintf.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "snprintf",
        " function"
    )))(arg1, arg2, arg3, vararg1)
}

pub unsafe fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).step.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "step",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_table_column_metadata(
    arg1: *mut sqlite3,
    arg2: *const ::std::os::raw::c_char,
    arg3: *const ::std::os::raw::c_char,
    arg4: *const ::std::os::raw::c_char,
    arg5: *mut *const ::std::os::raw::c_char,
    arg6: *mut *const ::std::os::raw::c_char,
    arg7: *mut ::std::os::raw::c_int,
    arg8: *mut ::std::os::raw::c_int,
    arg9: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).table_column_metadata.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "table_column_metadata",
        " function"
    )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
}

pub unsafe fn sqlite3_thread_cleanup() {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).thread_cleanup.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "thread_cleanup",
        " function"
    )))()
}

pub unsafe fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).total_changes.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "total_changes",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_trace(
    arg1: *mut sqlite3,
    xTrace: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut ::std::os::raw::c_void,
            arg2: *const ::std::os::raw::c_char,
        ),
    >,
    arg2: *mut ::std::os::raw::c_void,
) -> *mut ::std::os::raw::c_void {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).trace.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "trace",
        " function"
    )))(arg1, xTrace, arg2)
}

pub unsafe fn sqlite3_transfer_bindings(
    arg1: *mut sqlite3_stmt,
    arg2: *mut sqlite3_stmt,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).transfer_bindings.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "transfer_bindings",
        " function"
    )))(arg1, arg2)
}

pub unsafe fn sqlite3_update_hook(
    arg1: *mut sqlite3,
    arg2: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut ::std::os::raw::c_void,
            arg2: ::std::os::raw::c_int,
            arg3: *const ::std::os::raw::c_char,
            arg4: *const ::std::os::raw::c_char,
            arg5: sqlite_int64,
        ),
    >,
    arg3: *mut ::std::os::raw::c_void,
) -> *mut ::std::os::raw::c_void {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).update_hook.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "update_hook",
        " function"
    )))(arg1, arg2, arg3)
}

pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).user_data.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "user_data",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).value_blob.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "value_blob",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).value_bytes.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "value_bytes",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).value_bytes16.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "value_bytes16",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).value_double.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "value_double",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).value_int.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "value_int",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).value_int64.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "value_int64",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).value_numeric_type.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "value_numeric_type",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).value_text.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "value_text",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).value_text16.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "value_text16",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).value_text16be.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "value_text16be",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).value_text16le.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "value_text16le",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).value_type.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "value_type",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_overload_function(
    arg1: *mut sqlite3,
    zFuncName: *const ::std::os::raw::c_char,
    nArg: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).overload_function.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "overload_function",
        " function"
    )))(arg1, zFuncName, nArg)
}

pub unsafe fn sqlite3_prepare_v2(
    arg1: *mut sqlite3,
    arg2: *const ::std::os::raw::c_char,
    arg3: ::std::os::raw::c_int,
    arg4: *mut *mut sqlite3_stmt,
    arg5: *mut *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).prepare_v2.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "prepare_v2",
        " function"
    )))(arg1, arg2, arg3, arg4, arg5)
}

pub unsafe fn sqlite3_prepare16_v2(
    arg1: *mut sqlite3,
    arg2: *const ::std::os::raw::c_void,
    arg3: ::std::os::raw::c_int,
    arg4: *mut *mut sqlite3_stmt,
    arg5: *mut *const ::std::os::raw::c_void,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).prepare16_v2.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "prepare16_v2",
        " function"
    )))(arg1, arg2, arg3, arg4, arg5)
}

pub unsafe fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).clear_bindings.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "clear_bindings",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_create_module_v2(
    arg1: *mut sqlite3,
    arg2: *const ::std::os::raw::c_char,
    arg3: *const sqlite3_module,
    arg4: *mut ::std::os::raw::c_void,
    xDestroy: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).create_module_v2.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "create_module_v2",
        " function"
    )))(arg1, arg2, arg3, arg4, xDestroy)
}

pub unsafe fn sqlite3_bind_zeroblob(
    arg1: *mut sqlite3_stmt,
    arg2: ::std::os::raw::c_int,
    arg3: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).bind_zeroblob.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "bind_zeroblob",
        " function"
    )))(arg1, arg2, arg3)
}

pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).blob_bytes.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "blob_bytes",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).blob_close.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "blob_close",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_blob_open(
    arg1: *mut sqlite3,
    arg2: *const ::std::os::raw::c_char,
    arg3: *const ::std::os::raw::c_char,
    arg4: *const ::std::os::raw::c_char,
    arg5: sqlite3_int64,
    arg6: ::std::os::raw::c_int,
    arg7: *mut *mut sqlite3_blob,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).blob_open.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "blob_open",
        " function"
    )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
}

pub unsafe fn sqlite3_blob_read(
    arg1: *mut sqlite3_blob,
    arg2: *mut ::std::os::raw::c_void,
    arg3: ::std::os::raw::c_int,
    arg4: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).blob_read.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "blob_read",
        " function"
    )))(arg1, arg2, arg3, arg4)
}

pub unsafe fn sqlite3_blob_write(
    arg1: *mut sqlite3_blob,
    arg2: *const ::std::os::raw::c_void,
    arg3: ::std::os::raw::c_int,
    arg4: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).blob_write.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "blob_write",
        " function"
    )))(arg1, arg2, arg3, arg4)
}

pub unsafe fn sqlite3_create_collation_v2(
    arg1: *mut sqlite3,
    arg2: *const ::std::os::raw::c_char,
    arg3: ::std::os::raw::c_int,
    arg4: *mut ::std::os::raw::c_void,
    arg5: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut ::std::os::raw::c_void,
            arg2: ::std::os::raw::c_int,
            arg3: *const ::std::os::raw::c_void,
            arg4: ::std::os::raw::c_int,
            arg5: *const ::std::os::raw::c_void,
        ) -> ::std::os::raw::c_int,
    >,
    arg6: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).create_collation_v2.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "create_collation_v2",
        " function"
    )))(arg1, arg2, arg3, arg4, arg5, arg6)
}

pub unsafe fn sqlite3_file_control(
    arg1: *mut sqlite3,
    arg2: *const ::std::os::raw::c_char,
    arg3: ::std::os::raw::c_int,
    arg4: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).file_control.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "file_control",
        " function"
    )))(arg1, arg2, arg3, arg4)
}

pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_int64 {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).memory_highwater.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "memory_highwater",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).memory_used.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "memory_used",
        " function"
    )))()
}

pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).mutex_alloc.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "mutex_alloc",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).mutex_enter.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "mutex_enter",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).mutex_free.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "mutex_free",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).mutex_leave.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "mutex_leave",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).mutex_try.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "mutex_try",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_open_v2(
    arg1: *const ::std::os::raw::c_char,
    arg2: *mut *mut sqlite3,
    arg3: ::std::os::raw::c_int,
    arg4: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).open_v2.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "open_v2",
        " function"
    )))(arg1, arg2, arg3, arg4)
}

pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).release_memory.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "release_memory",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).result_error_nomem.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "result_error_nomem",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).result_error_toobig.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "result_error_toobig",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).sleep.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "sleep",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).soft_heap_limit.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "soft_heap_limit",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_vfs_find(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).vfs_find.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "vfs_find",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_vfs_register(
    arg1: *mut sqlite3_vfs,
    arg2: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).vfs_register.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "vfs_register",
        " function"
    )))(arg1, arg2)
}

pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).vfs_unregister.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "vfs_unregister",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).xthreadsafe.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "xthreadsafe",
        " function"
    )))()
}

pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).result_zeroblob.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "result_zeroblob",
        " function"
    )))(arg1, arg2)
}

pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).result_error_code.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "result_error_code",
        " function"
    )))(arg1, arg2)
}

pub unsafe fn sqlite3_test_control(
    arg1: ::std::os::raw::c_int,
    vararg1: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).test_control.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "test_control",
        " function"
    )))(arg1, vararg1)
}

pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void) {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).randomness.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "randomness",
        " function"
    )))(arg1, arg2)
}

pub unsafe fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3 {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).context_db_handle.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "context_db_handle",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_extended_result_codes(
    arg1: *mut sqlite3,
    arg2: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).extended_result_codes.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "extended_result_codes",
        " function"
    )))(arg1, arg2)
}

pub unsafe fn sqlite3_limit(
    arg1: *mut sqlite3,
    arg2: ::std::os::raw::c_int,
    arg3: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).limit.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "limit",
        " function"
    )))(arg1, arg2, arg3)
}

pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).next_stmt.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "next_stmt",
        " function"
    )))(arg1, arg2)
}

pub unsafe fn sqlite3_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).sql.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "sql",
        " function"
    )))(arg1)
}

pub unsafe fn sqlite3_status(
    arg1: ::std::os::raw::c_int,
    arg2: *mut ::std::os::raw::c_int,
    arg3: *mut ::std::os::raw::c_int,
    arg4: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int {
    if sqlite3_api.is_null() {
        panic!("sqlite3_api is null");
    }
    ((*sqlite3_api).status.expect(stringify!(
        "sqlite3_api contains null pointer for ",
        "status",
        " function"
    )))(arg1, arg2, arg3, arg4)
}

pub const SQLITE_DETERMINISTIC: i32 = 2048;