nostrdb-rs

nostrdb in rust!
git clone git://jb55.com/nostrdb-rs
Log | Files | Refs | Submodules | README | LICENSE

bindings.rs (157203B)


      1 /* automatically generated by rust-bindgen 0.69.1 */
      2 
      3 #[repr(C)]
      4 #[derive(Default)]
      5 pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
      6 impl<T> __IncompleteArrayField<T> {
      7     #[inline]
      8     pub const fn new() -> Self {
      9         __IncompleteArrayField(::std::marker::PhantomData, [])
     10     }
     11     #[inline]
     12     pub fn as_ptr(&self) -> *const T {
     13         self as *const _ as *const T
     14     }
     15     #[inline]
     16     pub fn as_mut_ptr(&mut self) -> *mut T {
     17         self as *mut _ as *mut T
     18     }
     19     #[inline]
     20     pub unsafe fn as_slice(&self, len: usize) -> &[T] {
     21         ::std::slice::from_raw_parts(self.as_ptr(), len)
     22     }
     23     #[inline]
     24     pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
     25         ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
     26     }
     27 }
     28 impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
     29     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
     30         fmt.write_str("__IncompleteArrayField")
     31     }
     32 }
     33 pub const _INTTYPES_H: u32 = 1;
     34 pub const _FEATURES_H: u32 = 1;
     35 pub const _DEFAULT_SOURCE: u32 = 1;
     36 pub const __GLIBC_USE_ISOC2X: u32 = 0;
     37 pub const __USE_ISOC11: u32 = 1;
     38 pub const __USE_ISOC99: u32 = 1;
     39 pub const __USE_ISOC95: u32 = 1;
     40 pub const __USE_POSIX_IMPLICITLY: u32 = 1;
     41 pub const _POSIX_SOURCE: u32 = 1;
     42 pub const _POSIX_C_SOURCE: u32 = 200809;
     43 pub const __USE_POSIX: u32 = 1;
     44 pub const __USE_POSIX2: u32 = 1;
     45 pub const __USE_POSIX199309: u32 = 1;
     46 pub const __USE_POSIX199506: u32 = 1;
     47 pub const __USE_XOPEN2K: u32 = 1;
     48 pub const __USE_XOPEN2K8: u32 = 1;
     49 pub const _ATFILE_SOURCE: u32 = 1;
     50 pub const __WORDSIZE: u32 = 64;
     51 pub const __WORDSIZE_TIME64_COMPAT32: u32 = 1;
     52 pub const __SYSCALL_WORDSIZE: u32 = 64;
     53 pub const __TIMESIZE: u32 = 64;
     54 pub const __USE_MISC: u32 = 1;
     55 pub const __USE_ATFILE: u32 = 1;
     56 pub const __USE_FORTIFY_LEVEL: u32 = 0;
     57 pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 0;
     58 pub const __GLIBC_USE_DEPRECATED_SCANF: u32 = 0;
     59 pub const __GLIBC_USE_C2X_STRTOL: u32 = 0;
     60 pub const _STDC_PREDEF_H: u32 = 1;
     61 pub const __STDC_IEC_559__: u32 = 1;
     62 pub const __STDC_IEC_60559_BFP__: u32 = 201404;
     63 pub const __STDC_IEC_559_COMPLEX__: u32 = 1;
     64 pub const __STDC_IEC_60559_COMPLEX__: u32 = 201404;
     65 pub const __STDC_ISO_10646__: u32 = 201706;
     66 pub const __GNU_LIBRARY__: u32 = 6;
     67 pub const __GLIBC__: u32 = 2;
     68 pub const __GLIBC_MINOR__: u32 = 38;
     69 pub const _SYS_CDEFS_H: u32 = 1;
     70 pub const __glibc_c99_flexarr_available: u32 = 1;
     71 pub const __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI: u32 = 0;
     72 pub const __HAVE_GENERIC_SELECTION: u32 = 1;
     73 pub const _STDINT_H: u32 = 1;
     74 pub const __GLIBC_USE_LIB_EXT2: u32 = 0;
     75 pub const __GLIBC_USE_IEC_60559_BFP_EXT: u32 = 0;
     76 pub const __GLIBC_USE_IEC_60559_BFP_EXT_C2X: u32 = 0;
     77 pub const __GLIBC_USE_IEC_60559_EXT: u32 = 0;
     78 pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: u32 = 0;
     79 pub const __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X: u32 = 0;
     80 pub const __GLIBC_USE_IEC_60559_TYPES_EXT: u32 = 0;
     81 pub const _BITS_TYPES_H: u32 = 1;
     82 pub const _BITS_TYPESIZES_H: u32 = 1;
     83 pub const __OFF_T_MATCHES_OFF64_T: u32 = 1;
     84 pub const __INO_T_MATCHES_INO64_T: u32 = 1;
     85 pub const __RLIM_T_MATCHES_RLIM64_T: u32 = 1;
     86 pub const __STATFS_MATCHES_STATFS64: u32 = 1;
     87 pub const __KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64: u32 = 1;
     88 pub const __FD_SETSIZE: u32 = 1024;
     89 pub const _BITS_TIME64_H: u32 = 1;
     90 pub const _BITS_WCHAR_H: u32 = 1;
     91 pub const _BITS_STDINT_INTN_H: u32 = 1;
     92 pub const _BITS_STDINT_UINTN_H: u32 = 1;
     93 pub const INT8_MIN: i32 = -128;
     94 pub const INT16_MIN: i32 = -32768;
     95 pub const INT32_MIN: i32 = -2147483648;
     96 pub const INT8_MAX: u32 = 127;
     97 pub const INT16_MAX: u32 = 32767;
     98 pub const INT32_MAX: u32 = 2147483647;
     99 pub const UINT8_MAX: u32 = 255;
    100 pub const UINT16_MAX: u32 = 65535;
    101 pub const UINT32_MAX: u32 = 4294967295;
    102 pub const INT_LEAST8_MIN: i32 = -128;
    103 pub const INT_LEAST16_MIN: i32 = -32768;
    104 pub const INT_LEAST32_MIN: i32 = -2147483648;
    105 pub const INT_LEAST8_MAX: u32 = 127;
    106 pub const INT_LEAST16_MAX: u32 = 32767;
    107 pub const INT_LEAST32_MAX: u32 = 2147483647;
    108 pub const UINT_LEAST8_MAX: u32 = 255;
    109 pub const UINT_LEAST16_MAX: u32 = 65535;
    110 pub const UINT_LEAST32_MAX: u32 = 4294967295;
    111 pub const INT_FAST8_MIN: i32 = -128;
    112 pub const INT_FAST16_MIN: i64 = -9223372036854775808;
    113 pub const INT_FAST32_MIN: i64 = -9223372036854775808;
    114 pub const INT_FAST8_MAX: u32 = 127;
    115 pub const INT_FAST16_MAX: u64 = 9223372036854775807;
    116 pub const INT_FAST32_MAX: u64 = 9223372036854775807;
    117 pub const UINT_FAST8_MAX: u32 = 255;
    118 pub const UINT_FAST16_MAX: i32 = -1;
    119 pub const UINT_FAST32_MAX: i32 = -1;
    120 pub const INTPTR_MIN: i64 = -9223372036854775808;
    121 pub const INTPTR_MAX: u64 = 9223372036854775807;
    122 pub const UINTPTR_MAX: i32 = -1;
    123 pub const PTRDIFF_MIN: i64 = -9223372036854775808;
    124 pub const PTRDIFF_MAX: u64 = 9223372036854775807;
    125 pub const SIG_ATOMIC_MIN: i32 = -2147483648;
    126 pub const SIG_ATOMIC_MAX: u32 = 2147483647;
    127 pub const SIZE_MAX: i32 = -1;
    128 pub const WINT_MIN: u32 = 0;
    129 pub const WINT_MAX: u32 = 4294967295;
    130 pub const ____gwchar_t_defined: u32 = 1;
    131 pub const __PRI64_PREFIX: &[u8; 2] = b"l\0";
    132 pub const __PRIPTR_PREFIX: &[u8; 2] = b"l\0";
    133 pub const PRId8: &[u8; 2] = b"d\0";
    134 pub const PRId16: &[u8; 2] = b"d\0";
    135 pub const PRId32: &[u8; 2] = b"d\0";
    136 pub const PRId64: &[u8; 3] = b"ld\0";
    137 pub const PRIdLEAST8: &[u8; 2] = b"d\0";
    138 pub const PRIdLEAST16: &[u8; 2] = b"d\0";
    139 pub const PRIdLEAST32: &[u8; 2] = b"d\0";
    140 pub const PRIdLEAST64: &[u8; 3] = b"ld\0";
    141 pub const PRIdFAST8: &[u8; 2] = b"d\0";
    142 pub const PRIdFAST16: &[u8; 3] = b"ld\0";
    143 pub const PRIdFAST32: &[u8; 3] = b"ld\0";
    144 pub const PRIdFAST64: &[u8; 3] = b"ld\0";
    145 pub const PRIi8: &[u8; 2] = b"i\0";
    146 pub const PRIi16: &[u8; 2] = b"i\0";
    147 pub const PRIi32: &[u8; 2] = b"i\0";
    148 pub const PRIi64: &[u8; 3] = b"li\0";
    149 pub const PRIiLEAST8: &[u8; 2] = b"i\0";
    150 pub const PRIiLEAST16: &[u8; 2] = b"i\0";
    151 pub const PRIiLEAST32: &[u8; 2] = b"i\0";
    152 pub const PRIiLEAST64: &[u8; 3] = b"li\0";
    153 pub const PRIiFAST8: &[u8; 2] = b"i\0";
    154 pub const PRIiFAST16: &[u8; 3] = b"li\0";
    155 pub const PRIiFAST32: &[u8; 3] = b"li\0";
    156 pub const PRIiFAST64: &[u8; 3] = b"li\0";
    157 pub const PRIo8: &[u8; 2] = b"o\0";
    158 pub const PRIo16: &[u8; 2] = b"o\0";
    159 pub const PRIo32: &[u8; 2] = b"o\0";
    160 pub const PRIo64: &[u8; 3] = b"lo\0";
    161 pub const PRIoLEAST8: &[u8; 2] = b"o\0";
    162 pub const PRIoLEAST16: &[u8; 2] = b"o\0";
    163 pub const PRIoLEAST32: &[u8; 2] = b"o\0";
    164 pub const PRIoLEAST64: &[u8; 3] = b"lo\0";
    165 pub const PRIoFAST8: &[u8; 2] = b"o\0";
    166 pub const PRIoFAST16: &[u8; 3] = b"lo\0";
    167 pub const PRIoFAST32: &[u8; 3] = b"lo\0";
    168 pub const PRIoFAST64: &[u8; 3] = b"lo\0";
    169 pub const PRIu8: &[u8; 2] = b"u\0";
    170 pub const PRIu16: &[u8; 2] = b"u\0";
    171 pub const PRIu32: &[u8; 2] = b"u\0";
    172 pub const PRIu64: &[u8; 3] = b"lu\0";
    173 pub const PRIuLEAST8: &[u8; 2] = b"u\0";
    174 pub const PRIuLEAST16: &[u8; 2] = b"u\0";
    175 pub const PRIuLEAST32: &[u8; 2] = b"u\0";
    176 pub const PRIuLEAST64: &[u8; 3] = b"lu\0";
    177 pub const PRIuFAST8: &[u8; 2] = b"u\0";
    178 pub const PRIuFAST16: &[u8; 3] = b"lu\0";
    179 pub const PRIuFAST32: &[u8; 3] = b"lu\0";
    180 pub const PRIuFAST64: &[u8; 3] = b"lu\0";
    181 pub const PRIx8: &[u8; 2] = b"x\0";
    182 pub const PRIx16: &[u8; 2] = b"x\0";
    183 pub const PRIx32: &[u8; 2] = b"x\0";
    184 pub const PRIx64: &[u8; 3] = b"lx\0";
    185 pub const PRIxLEAST8: &[u8; 2] = b"x\0";
    186 pub const PRIxLEAST16: &[u8; 2] = b"x\0";
    187 pub const PRIxLEAST32: &[u8; 2] = b"x\0";
    188 pub const PRIxLEAST64: &[u8; 3] = b"lx\0";
    189 pub const PRIxFAST8: &[u8; 2] = b"x\0";
    190 pub const PRIxFAST16: &[u8; 3] = b"lx\0";
    191 pub const PRIxFAST32: &[u8; 3] = b"lx\0";
    192 pub const PRIxFAST64: &[u8; 3] = b"lx\0";
    193 pub const PRIX8: &[u8; 2] = b"X\0";
    194 pub const PRIX16: &[u8; 2] = b"X\0";
    195 pub const PRIX32: &[u8; 2] = b"X\0";
    196 pub const PRIX64: &[u8; 3] = b"lX\0";
    197 pub const PRIXLEAST8: &[u8; 2] = b"X\0";
    198 pub const PRIXLEAST16: &[u8; 2] = b"X\0";
    199 pub const PRIXLEAST32: &[u8; 2] = b"X\0";
    200 pub const PRIXLEAST64: &[u8; 3] = b"lX\0";
    201 pub const PRIXFAST8: &[u8; 2] = b"X\0";
    202 pub const PRIXFAST16: &[u8; 3] = b"lX\0";
    203 pub const PRIXFAST32: &[u8; 3] = b"lX\0";
    204 pub const PRIXFAST64: &[u8; 3] = b"lX\0";
    205 pub const PRIdMAX: &[u8; 3] = b"ld\0";
    206 pub const PRIiMAX: &[u8; 3] = b"li\0";
    207 pub const PRIoMAX: &[u8; 3] = b"lo\0";
    208 pub const PRIuMAX: &[u8; 3] = b"lu\0";
    209 pub const PRIxMAX: &[u8; 3] = b"lx\0";
    210 pub const PRIXMAX: &[u8; 3] = b"lX\0";
    211 pub const PRIdPTR: &[u8; 3] = b"ld\0";
    212 pub const PRIiPTR: &[u8; 3] = b"li\0";
    213 pub const PRIoPTR: &[u8; 3] = b"lo\0";
    214 pub const PRIuPTR: &[u8; 3] = b"lu\0";
    215 pub const PRIxPTR: &[u8; 3] = b"lx\0";
    216 pub const PRIXPTR: &[u8; 3] = b"lX\0";
    217 pub const SCNd8: &[u8; 4] = b"hhd\0";
    218 pub const SCNd16: &[u8; 3] = b"hd\0";
    219 pub const SCNd32: &[u8; 2] = b"d\0";
    220 pub const SCNd64: &[u8; 3] = b"ld\0";
    221 pub const SCNdLEAST8: &[u8; 4] = b"hhd\0";
    222 pub const SCNdLEAST16: &[u8; 3] = b"hd\0";
    223 pub const SCNdLEAST32: &[u8; 2] = b"d\0";
    224 pub const SCNdLEAST64: &[u8; 3] = b"ld\0";
    225 pub const SCNdFAST8: &[u8; 4] = b"hhd\0";
    226 pub const SCNdFAST16: &[u8; 3] = b"ld\0";
    227 pub const SCNdFAST32: &[u8; 3] = b"ld\0";
    228 pub const SCNdFAST64: &[u8; 3] = b"ld\0";
    229 pub const SCNi8: &[u8; 4] = b"hhi\0";
    230 pub const SCNi16: &[u8; 3] = b"hi\0";
    231 pub const SCNi32: &[u8; 2] = b"i\0";
    232 pub const SCNi64: &[u8; 3] = b"li\0";
    233 pub const SCNiLEAST8: &[u8; 4] = b"hhi\0";
    234 pub const SCNiLEAST16: &[u8; 3] = b"hi\0";
    235 pub const SCNiLEAST32: &[u8; 2] = b"i\0";
    236 pub const SCNiLEAST64: &[u8; 3] = b"li\0";
    237 pub const SCNiFAST8: &[u8; 4] = b"hhi\0";
    238 pub const SCNiFAST16: &[u8; 3] = b"li\0";
    239 pub const SCNiFAST32: &[u8; 3] = b"li\0";
    240 pub const SCNiFAST64: &[u8; 3] = b"li\0";
    241 pub const SCNu8: &[u8; 4] = b"hhu\0";
    242 pub const SCNu16: &[u8; 3] = b"hu\0";
    243 pub const SCNu32: &[u8; 2] = b"u\0";
    244 pub const SCNu64: &[u8; 3] = b"lu\0";
    245 pub const SCNuLEAST8: &[u8; 4] = b"hhu\0";
    246 pub const SCNuLEAST16: &[u8; 3] = b"hu\0";
    247 pub const SCNuLEAST32: &[u8; 2] = b"u\0";
    248 pub const SCNuLEAST64: &[u8; 3] = b"lu\0";
    249 pub const SCNuFAST8: &[u8; 4] = b"hhu\0";
    250 pub const SCNuFAST16: &[u8; 3] = b"lu\0";
    251 pub const SCNuFAST32: &[u8; 3] = b"lu\0";
    252 pub const SCNuFAST64: &[u8; 3] = b"lu\0";
    253 pub const SCNo8: &[u8; 4] = b"hho\0";
    254 pub const SCNo16: &[u8; 3] = b"ho\0";
    255 pub const SCNo32: &[u8; 2] = b"o\0";
    256 pub const SCNo64: &[u8; 3] = b"lo\0";
    257 pub const SCNoLEAST8: &[u8; 4] = b"hho\0";
    258 pub const SCNoLEAST16: &[u8; 3] = b"ho\0";
    259 pub const SCNoLEAST32: &[u8; 2] = b"o\0";
    260 pub const SCNoLEAST64: &[u8; 3] = b"lo\0";
    261 pub const SCNoFAST8: &[u8; 4] = b"hho\0";
    262 pub const SCNoFAST16: &[u8; 3] = b"lo\0";
    263 pub const SCNoFAST32: &[u8; 3] = b"lo\0";
    264 pub const SCNoFAST64: &[u8; 3] = b"lo\0";
    265 pub const SCNx8: &[u8; 4] = b"hhx\0";
    266 pub const SCNx16: &[u8; 3] = b"hx\0";
    267 pub const SCNx32: &[u8; 2] = b"x\0";
    268 pub const SCNx64: &[u8; 3] = b"lx\0";
    269 pub const SCNxLEAST8: &[u8; 4] = b"hhx\0";
    270 pub const SCNxLEAST16: &[u8; 3] = b"hx\0";
    271 pub const SCNxLEAST32: &[u8; 2] = b"x\0";
    272 pub const SCNxLEAST64: &[u8; 3] = b"lx\0";
    273 pub const SCNxFAST8: &[u8; 4] = b"hhx\0";
    274 pub const SCNxFAST16: &[u8; 3] = b"lx\0";
    275 pub const SCNxFAST32: &[u8; 3] = b"lx\0";
    276 pub const SCNxFAST64: &[u8; 3] = b"lx\0";
    277 pub const SCNdMAX: &[u8; 3] = b"ld\0";
    278 pub const SCNiMAX: &[u8; 3] = b"li\0";
    279 pub const SCNoMAX: &[u8; 3] = b"lo\0";
    280 pub const SCNuMAX: &[u8; 3] = b"lu\0";
    281 pub const SCNxMAX: &[u8; 3] = b"lx\0";
    282 pub const SCNdPTR: &[u8; 3] = b"ld\0";
    283 pub const SCNiPTR: &[u8; 3] = b"li\0";
    284 pub const SCNoPTR: &[u8; 3] = b"lo\0";
    285 pub const SCNuPTR: &[u8; 3] = b"lu\0";
    286 pub const SCNxPTR: &[u8; 3] = b"lx\0";
    287 pub const CCAN_COMPILER: &[u8; 3] = b"cc\0";
    288 pub const CCAN_CFLAGS : & [u8 ; 111] = b"-g3 -ggdb -Wall -Wundef -Wmissing-prototypes -Wmissing-declarations -Wstrict-prototypes -Wold-style-definition\0" ;
    289 pub const CCAN_OUTPUT_EXE_CFLAG: &[u8; 3] = b"-o\0";
    290 pub const HAVE_CCAN: u32 = 1;
    291 pub const HAVE_UNALIGNED_ACCESS: u32 = 1;
    292 pub const HAVE_TYPEOF: u32 = 1;
    293 pub const HAVE_BIG_ENDIAN: u32 = 0;
    294 pub const HAVE_BYTESWAP_H: u32 = 0;
    295 pub const HAVE_BSWAP_64: u32 = 0;
    296 pub const HAVE_LITTLE_ENDIAN: u32 = 1;
    297 pub const __bool_true_false_are_defined: u32 = 1;
    298 pub const true_: u32 = 1;
    299 pub const false_: u32 = 0;
    300 pub const _STDIO_H: u32 = 1;
    301 pub const _____fpos_t_defined: u32 = 1;
    302 pub const ____mbstate_t_defined: u32 = 1;
    303 pub const _____fpos64_t_defined: u32 = 1;
    304 pub const ____FILE_defined: u32 = 1;
    305 pub const __FILE_defined: u32 = 1;
    306 pub const __struct_FILE_defined: u32 = 1;
    307 pub const _IO_EOF_SEEN: u32 = 16;
    308 pub const _IO_ERR_SEEN: u32 = 32;
    309 pub const _IO_USER_LOCK: u32 = 32768;
    310 pub const __cookie_io_functions_t_defined: u32 = 1;
    311 pub const _IOFBF: u32 = 0;
    312 pub const _IOLBF: u32 = 1;
    313 pub const _IONBF: u32 = 2;
    314 pub const BUFSIZ: u32 = 8192;
    315 pub const EOF: i32 = -1;
    316 pub const SEEK_SET: u32 = 0;
    317 pub const SEEK_CUR: u32 = 1;
    318 pub const SEEK_END: u32 = 2;
    319 pub const P_tmpdir: &[u8; 5] = b"/tmp\0";
    320 pub const L_tmpnam: u32 = 20;
    321 pub const TMP_MAX: u32 = 238328;
    322 pub const _BITS_STDIO_LIM_H: u32 = 1;
    323 pub const FILENAME_MAX: u32 = 4096;
    324 pub const L_ctermid: u32 = 9;
    325 pub const FOPEN_MAX: u32 = 16;
    326 pub const __HAVE_FLOAT128: u32 = 0;
    327 pub const __HAVE_DISTINCT_FLOAT128: u32 = 0;
    328 pub const __HAVE_FLOAT64X: u32 = 1;
    329 pub const __HAVE_FLOAT64X_LONG_DOUBLE: u32 = 1;
    330 pub const __HAVE_FLOAT16: u32 = 0;
    331 pub const __HAVE_FLOAT32: u32 = 1;
    332 pub const __HAVE_FLOAT64: u32 = 1;
    333 pub const __HAVE_FLOAT32X: u32 = 1;
    334 pub const __HAVE_FLOAT128X: u32 = 0;
    335 pub const __HAVE_DISTINCT_FLOAT16: u32 = 0;
    336 pub const __HAVE_DISTINCT_FLOAT32: u32 = 0;
    337 pub const __HAVE_DISTINCT_FLOAT64: u32 = 0;
    338 pub const __HAVE_DISTINCT_FLOAT32X: u32 = 0;
    339 pub const __HAVE_DISTINCT_FLOAT64X: u32 = 0;
    340 pub const __HAVE_DISTINCT_FLOAT128X: u32 = 0;
    341 pub const __HAVE_FLOATN_NOT_TYPEDEF: u32 = 0;
    342 pub const _CTYPE_H: u32 = 1;
    343 pub const _BITS_ENDIAN_H: u32 = 1;
    344 pub const __LITTLE_ENDIAN: u32 = 1234;
    345 pub const __BIG_ENDIAN: u32 = 4321;
    346 pub const __PDP_ENDIAN: u32 = 3412;
    347 pub const _BITS_ENDIANNESS_H: u32 = 1;
    348 pub const __BYTE_ORDER: u32 = 1234;
    349 pub const __FLOAT_WORD_ORDER: u32 = 1234;
    350 pub const _BITS_TYPES_LOCALE_T_H: u32 = 1;
    351 pub const _BITS_TYPES___LOCALE_T_H: u32 = 1;
    352 pub const _ASSERT_H: u32 = 1;
    353 pub const _STRING_H: u32 = 1;
    354 pub const _STRINGS_H: u32 = 1;
    355 pub const NDB_PACKED_STR: u32 = 1;
    356 pub const NDB_PACKED_ID: u32 = 2;
    357 pub const NDB_FLAG_NOMIGRATE: u32 = 1;
    358 pub const NDB_FLAG_SKIP_NOTE_VERIFY: u32 = 2;
    359 pub const NDB_NUM_FILTERS: u32 = 7;
    360 pub const MAX_TEXT_SEARCH_RESULTS: u32 = 128;
    361 pub const MAX_TEXT_SEARCH_WORDS: u32 = 8;
    362 pub const NDB_NUM_BLOCK_TYPES: u32 = 6;
    363 pub const NDB_MAX_RELAYS: u32 = 24;
    364 pub const NOSTR_BECH32_KNOWN_TYPES: u32 = 7;
    365 pub type __u_char = ::std::os::raw::c_uchar;
    366 pub type __u_short = ::std::os::raw::c_ushort;
    367 pub type __u_int = ::std::os::raw::c_uint;
    368 pub type __u_long = ::std::os::raw::c_ulong;
    369 pub type __int8_t = ::std::os::raw::c_schar;
    370 pub type __uint8_t = ::std::os::raw::c_uchar;
    371 pub type __int16_t = ::std::os::raw::c_short;
    372 pub type __uint16_t = ::std::os::raw::c_ushort;
    373 pub type __int32_t = ::std::os::raw::c_int;
    374 pub type __uint32_t = ::std::os::raw::c_uint;
    375 pub type __int64_t = ::std::os::raw::c_long;
    376 pub type __uint64_t = ::std::os::raw::c_ulong;
    377 pub type __int_least8_t = __int8_t;
    378 pub type __uint_least8_t = __uint8_t;
    379 pub type __int_least16_t = __int16_t;
    380 pub type __uint_least16_t = __uint16_t;
    381 pub type __int_least32_t = __int32_t;
    382 pub type __uint_least32_t = __uint32_t;
    383 pub type __int_least64_t = __int64_t;
    384 pub type __uint_least64_t = __uint64_t;
    385 pub type __quad_t = ::std::os::raw::c_long;
    386 pub type __u_quad_t = ::std::os::raw::c_ulong;
    387 pub type __intmax_t = ::std::os::raw::c_long;
    388 pub type __uintmax_t = ::std::os::raw::c_ulong;
    389 pub type __dev_t = ::std::os::raw::c_ulong;
    390 pub type __uid_t = ::std::os::raw::c_uint;
    391 pub type __gid_t = ::std::os::raw::c_uint;
    392 pub type __ino_t = ::std::os::raw::c_ulong;
    393 pub type __ino64_t = ::std::os::raw::c_ulong;
    394 pub type __mode_t = ::std::os::raw::c_uint;
    395 pub type __nlink_t = ::std::os::raw::c_ulong;
    396 pub type __off_t = ::std::os::raw::c_long;
    397 pub type __off64_t = ::std::os::raw::c_long;
    398 pub type __pid_t = ::std::os::raw::c_int;
    399 #[repr(C)]
    400 #[derive(Debug, Copy, Clone)]
    401 pub struct __fsid_t {
    402     pub __val: [::std::os::raw::c_int; 2usize],
    403 }
    404 #[test]
    405 fn bindgen_test_layout___fsid_t() {
    406     const UNINIT: ::std::mem::MaybeUninit<__fsid_t> = ::std::mem::MaybeUninit::uninit();
    407     let ptr = UNINIT.as_ptr();
    408     assert_eq!(
    409         ::std::mem::size_of::<__fsid_t>(),
    410         8usize,
    411         concat!("Size of: ", stringify!(__fsid_t))
    412     );
    413     assert_eq!(
    414         ::std::mem::align_of::<__fsid_t>(),
    415         4usize,
    416         concat!("Alignment of ", stringify!(__fsid_t))
    417     );
    418     assert_eq!(
    419         unsafe { ::std::ptr::addr_of!((*ptr).__val) as usize - ptr as usize },
    420         0usize,
    421         concat!(
    422             "Offset of field: ",
    423             stringify!(__fsid_t),
    424             "::",
    425             stringify!(__val)
    426         )
    427     );
    428 }
    429 pub type __clock_t = ::std::os::raw::c_long;
    430 pub type __rlim_t = ::std::os::raw::c_ulong;
    431 pub type __rlim64_t = ::std::os::raw::c_ulong;
    432 pub type __id_t = ::std::os::raw::c_uint;
    433 pub type __time_t = ::std::os::raw::c_long;
    434 pub type __useconds_t = ::std::os::raw::c_uint;
    435 pub type __suseconds_t = ::std::os::raw::c_long;
    436 pub type __suseconds64_t = ::std::os::raw::c_long;
    437 pub type __daddr_t = ::std::os::raw::c_int;
    438 pub type __key_t = ::std::os::raw::c_int;
    439 pub type __clockid_t = ::std::os::raw::c_int;
    440 pub type __timer_t = *mut ::std::os::raw::c_void;
    441 pub type __blksize_t = ::std::os::raw::c_long;
    442 pub type __blkcnt_t = ::std::os::raw::c_long;
    443 pub type __blkcnt64_t = ::std::os::raw::c_long;
    444 pub type __fsblkcnt_t = ::std::os::raw::c_ulong;
    445 pub type __fsblkcnt64_t = ::std::os::raw::c_ulong;
    446 pub type __fsfilcnt_t = ::std::os::raw::c_ulong;
    447 pub type __fsfilcnt64_t = ::std::os::raw::c_ulong;
    448 pub type __fsword_t = ::std::os::raw::c_long;
    449 pub type __ssize_t = ::std::os::raw::c_long;
    450 pub type __syscall_slong_t = ::std::os::raw::c_long;
    451 pub type __syscall_ulong_t = ::std::os::raw::c_ulong;
    452 pub type __loff_t = __off64_t;
    453 pub type __caddr_t = *mut ::std::os::raw::c_char;
    454 pub type __intptr_t = ::std::os::raw::c_long;
    455 pub type __socklen_t = ::std::os::raw::c_uint;
    456 pub type __sig_atomic_t = ::std::os::raw::c_int;
    457 pub type int_least8_t = __int_least8_t;
    458 pub type int_least16_t = __int_least16_t;
    459 pub type int_least32_t = __int_least32_t;
    460 pub type int_least64_t = __int_least64_t;
    461 pub type uint_least8_t = __uint_least8_t;
    462 pub type uint_least16_t = __uint_least16_t;
    463 pub type uint_least32_t = __uint_least32_t;
    464 pub type uint_least64_t = __uint_least64_t;
    465 pub type int_fast8_t = ::std::os::raw::c_schar;
    466 pub type int_fast16_t = ::std::os::raw::c_long;
    467 pub type int_fast32_t = ::std::os::raw::c_long;
    468 pub type int_fast64_t = ::std::os::raw::c_long;
    469 pub type uint_fast8_t = ::std::os::raw::c_uchar;
    470 pub type uint_fast16_t = ::std::os::raw::c_ulong;
    471 pub type uint_fast32_t = ::std::os::raw::c_ulong;
    472 pub type uint_fast64_t = ::std::os::raw::c_ulong;
    473 pub type intmax_t = __intmax_t;
    474 pub type uintmax_t = __uintmax_t;
    475 pub type __gwchar_t = ::std::os::raw::c_int;
    476 #[repr(C)]
    477 #[derive(Debug, Copy, Clone)]
    478 pub struct imaxdiv_t {
    479     pub quot: ::std::os::raw::c_long,
    480     pub rem: ::std::os::raw::c_long,
    481 }
    482 #[test]
    483 fn bindgen_test_layout_imaxdiv_t() {
    484     const UNINIT: ::std::mem::MaybeUninit<imaxdiv_t> = ::std::mem::MaybeUninit::uninit();
    485     let ptr = UNINIT.as_ptr();
    486     assert_eq!(
    487         ::std::mem::size_of::<imaxdiv_t>(),
    488         16usize,
    489         concat!("Size of: ", stringify!(imaxdiv_t))
    490     );
    491     assert_eq!(
    492         ::std::mem::align_of::<imaxdiv_t>(),
    493         8usize,
    494         concat!("Alignment of ", stringify!(imaxdiv_t))
    495     );
    496     assert_eq!(
    497         unsafe { ::std::ptr::addr_of!((*ptr).quot) as usize - ptr as usize },
    498         0usize,
    499         concat!(
    500             "Offset of field: ",
    501             stringify!(imaxdiv_t),
    502             "::",
    503             stringify!(quot)
    504         )
    505     );
    506     assert_eq!(
    507         unsafe { ::std::ptr::addr_of!((*ptr).rem) as usize - ptr as usize },
    508         8usize,
    509         concat!(
    510             "Offset of field: ",
    511             stringify!(imaxdiv_t),
    512             "::",
    513             stringify!(rem)
    514         )
    515     );
    516 }
    517 extern "C" {
    518     pub fn imaxabs(__n: intmax_t) -> intmax_t;
    519 }
    520 extern "C" {
    521     pub fn imaxdiv(__numer: intmax_t, __denom: intmax_t) -> imaxdiv_t;
    522 }
    523 extern "C" {
    524     pub fn strtoimax(
    525         __nptr: *const ::std::os::raw::c_char,
    526         __endptr: *mut *mut ::std::os::raw::c_char,
    527         __base: ::std::os::raw::c_int,
    528     ) -> intmax_t;
    529 }
    530 extern "C" {
    531     pub fn strtoumax(
    532         __nptr: *const ::std::os::raw::c_char,
    533         __endptr: *mut *mut ::std::os::raw::c_char,
    534         __base: ::std::os::raw::c_int,
    535     ) -> uintmax_t;
    536 }
    537 extern "C" {
    538     pub fn wcstoimax(
    539         __nptr: *const __gwchar_t,
    540         __endptr: *mut *mut __gwchar_t,
    541         __base: ::std::os::raw::c_int,
    542     ) -> intmax_t;
    543 }
    544 extern "C" {
    545     pub fn wcstoumax(
    546         __nptr: *const __gwchar_t,
    547         __endptr: *mut *mut __gwchar_t,
    548         __base: ::std::os::raw::c_int,
    549     ) -> uintmax_t;
    550 }
    551 pub type __gnuc_va_list = __builtin_va_list;
    552 #[repr(C)]
    553 #[derive(Copy, Clone)]
    554 pub struct __mbstate_t {
    555     pub __count: ::std::os::raw::c_int,
    556     pub __value: __mbstate_t__bindgen_ty_1,
    557 }
    558 #[repr(C)]
    559 #[derive(Copy, Clone)]
    560 pub union __mbstate_t__bindgen_ty_1 {
    561     pub __wch: ::std::os::raw::c_uint,
    562     pub __wchb: [::std::os::raw::c_char; 4usize],
    563 }
    564 #[test]
    565 fn bindgen_test_layout___mbstate_t__bindgen_ty_1() {
    566     const UNINIT: ::std::mem::MaybeUninit<__mbstate_t__bindgen_ty_1> =
    567         ::std::mem::MaybeUninit::uninit();
    568     let ptr = UNINIT.as_ptr();
    569     assert_eq!(
    570         ::std::mem::size_of::<__mbstate_t__bindgen_ty_1>(),
    571         4usize,
    572         concat!("Size of: ", stringify!(__mbstate_t__bindgen_ty_1))
    573     );
    574     assert_eq!(
    575         ::std::mem::align_of::<__mbstate_t__bindgen_ty_1>(),
    576         4usize,
    577         concat!("Alignment of ", stringify!(__mbstate_t__bindgen_ty_1))
    578     );
    579     assert_eq!(
    580         unsafe { ::std::ptr::addr_of!((*ptr).__wch) as usize - ptr as usize },
    581         0usize,
    582         concat!(
    583             "Offset of field: ",
    584             stringify!(__mbstate_t__bindgen_ty_1),
    585             "::",
    586             stringify!(__wch)
    587         )
    588     );
    589     assert_eq!(
    590         unsafe { ::std::ptr::addr_of!((*ptr).__wchb) as usize - ptr as usize },
    591         0usize,
    592         concat!(
    593             "Offset of field: ",
    594             stringify!(__mbstate_t__bindgen_ty_1),
    595             "::",
    596             stringify!(__wchb)
    597         )
    598     );
    599 }
    600 #[test]
    601 fn bindgen_test_layout___mbstate_t() {
    602     const UNINIT: ::std::mem::MaybeUninit<__mbstate_t> = ::std::mem::MaybeUninit::uninit();
    603     let ptr = UNINIT.as_ptr();
    604     assert_eq!(
    605         ::std::mem::size_of::<__mbstate_t>(),
    606         8usize,
    607         concat!("Size of: ", stringify!(__mbstate_t))
    608     );
    609     assert_eq!(
    610         ::std::mem::align_of::<__mbstate_t>(),
    611         4usize,
    612         concat!("Alignment of ", stringify!(__mbstate_t))
    613     );
    614     assert_eq!(
    615         unsafe { ::std::ptr::addr_of!((*ptr).__count) as usize - ptr as usize },
    616         0usize,
    617         concat!(
    618             "Offset of field: ",
    619             stringify!(__mbstate_t),
    620             "::",
    621             stringify!(__count)
    622         )
    623     );
    624     assert_eq!(
    625         unsafe { ::std::ptr::addr_of!((*ptr).__value) as usize - ptr as usize },
    626         4usize,
    627         concat!(
    628             "Offset of field: ",
    629             stringify!(__mbstate_t),
    630             "::",
    631             stringify!(__value)
    632         )
    633     );
    634 }
    635 #[repr(C)]
    636 #[derive(Copy, Clone)]
    637 pub struct _G_fpos_t {
    638     pub __pos: __off_t,
    639     pub __state: __mbstate_t,
    640 }
    641 #[test]
    642 fn bindgen_test_layout__G_fpos_t() {
    643     const UNINIT: ::std::mem::MaybeUninit<_G_fpos_t> = ::std::mem::MaybeUninit::uninit();
    644     let ptr = UNINIT.as_ptr();
    645     assert_eq!(
    646         ::std::mem::size_of::<_G_fpos_t>(),
    647         16usize,
    648         concat!("Size of: ", stringify!(_G_fpos_t))
    649     );
    650     assert_eq!(
    651         ::std::mem::align_of::<_G_fpos_t>(),
    652         8usize,
    653         concat!("Alignment of ", stringify!(_G_fpos_t))
    654     );
    655     assert_eq!(
    656         unsafe { ::std::ptr::addr_of!((*ptr).__pos) as usize - ptr as usize },
    657         0usize,
    658         concat!(
    659             "Offset of field: ",
    660             stringify!(_G_fpos_t),
    661             "::",
    662             stringify!(__pos)
    663         )
    664     );
    665     assert_eq!(
    666         unsafe { ::std::ptr::addr_of!((*ptr).__state) as usize - ptr as usize },
    667         8usize,
    668         concat!(
    669             "Offset of field: ",
    670             stringify!(_G_fpos_t),
    671             "::",
    672             stringify!(__state)
    673         )
    674     );
    675 }
    676 pub type __fpos_t = _G_fpos_t;
    677 #[repr(C)]
    678 #[derive(Copy, Clone)]
    679 pub struct _G_fpos64_t {
    680     pub __pos: __off64_t,
    681     pub __state: __mbstate_t,
    682 }
    683 #[test]
    684 fn bindgen_test_layout__G_fpos64_t() {
    685     const UNINIT: ::std::mem::MaybeUninit<_G_fpos64_t> = ::std::mem::MaybeUninit::uninit();
    686     let ptr = UNINIT.as_ptr();
    687     assert_eq!(
    688         ::std::mem::size_of::<_G_fpos64_t>(),
    689         16usize,
    690         concat!("Size of: ", stringify!(_G_fpos64_t))
    691     );
    692     assert_eq!(
    693         ::std::mem::align_of::<_G_fpos64_t>(),
    694         8usize,
    695         concat!("Alignment of ", stringify!(_G_fpos64_t))
    696     );
    697     assert_eq!(
    698         unsafe { ::std::ptr::addr_of!((*ptr).__pos) as usize - ptr as usize },
    699         0usize,
    700         concat!(
    701             "Offset of field: ",
    702             stringify!(_G_fpos64_t),
    703             "::",
    704             stringify!(__pos)
    705         )
    706     );
    707     assert_eq!(
    708         unsafe { ::std::ptr::addr_of!((*ptr).__state) as usize - ptr as usize },
    709         8usize,
    710         concat!(
    711             "Offset of field: ",
    712             stringify!(_G_fpos64_t),
    713             "::",
    714             stringify!(__state)
    715         )
    716     );
    717 }
    718 pub type __fpos64_t = _G_fpos64_t;
    719 pub type __FILE = _IO_FILE;
    720 pub type FILE = _IO_FILE;
    721 #[repr(C)]
    722 #[derive(Debug, Copy, Clone)]
    723 pub struct _IO_marker {
    724     _unused: [u8; 0],
    725 }
    726 #[repr(C)]
    727 #[derive(Debug, Copy, Clone)]
    728 pub struct _IO_codecvt {
    729     _unused: [u8; 0],
    730 }
    731 #[repr(C)]
    732 #[derive(Debug, Copy, Clone)]
    733 pub struct _IO_wide_data {
    734     _unused: [u8; 0],
    735 }
    736 pub type _IO_lock_t = ::std::os::raw::c_void;
    737 #[repr(C)]
    738 #[derive(Debug, Copy, Clone)]
    739 pub struct _IO_FILE {
    740     pub _flags: ::std::os::raw::c_int,
    741     pub _IO_read_ptr: *mut ::std::os::raw::c_char,
    742     pub _IO_read_end: *mut ::std::os::raw::c_char,
    743     pub _IO_read_base: *mut ::std::os::raw::c_char,
    744     pub _IO_write_base: *mut ::std::os::raw::c_char,
    745     pub _IO_write_ptr: *mut ::std::os::raw::c_char,
    746     pub _IO_write_end: *mut ::std::os::raw::c_char,
    747     pub _IO_buf_base: *mut ::std::os::raw::c_char,
    748     pub _IO_buf_end: *mut ::std::os::raw::c_char,
    749     pub _IO_save_base: *mut ::std::os::raw::c_char,
    750     pub _IO_backup_base: *mut ::std::os::raw::c_char,
    751     pub _IO_save_end: *mut ::std::os::raw::c_char,
    752     pub _markers: *mut _IO_marker,
    753     pub _chain: *mut _IO_FILE,
    754     pub _fileno: ::std::os::raw::c_int,
    755     pub _flags2: ::std::os::raw::c_int,
    756     pub _old_offset: __off_t,
    757     pub _cur_column: ::std::os::raw::c_ushort,
    758     pub _vtable_offset: ::std::os::raw::c_schar,
    759     pub _shortbuf: [::std::os::raw::c_char; 1usize],
    760     pub _lock: *mut _IO_lock_t,
    761     pub _offset: __off64_t,
    762     pub _codecvt: *mut _IO_codecvt,
    763     pub _wide_data: *mut _IO_wide_data,
    764     pub _freeres_list: *mut _IO_FILE,
    765     pub _freeres_buf: *mut ::std::os::raw::c_void,
    766     pub __pad5: usize,
    767     pub _mode: ::std::os::raw::c_int,
    768     pub _unused2: [::std::os::raw::c_char; 20usize],
    769 }
    770 #[test]
    771 fn bindgen_test_layout__IO_FILE() {
    772     const UNINIT: ::std::mem::MaybeUninit<_IO_FILE> = ::std::mem::MaybeUninit::uninit();
    773     let ptr = UNINIT.as_ptr();
    774     assert_eq!(
    775         ::std::mem::size_of::<_IO_FILE>(),
    776         216usize,
    777         concat!("Size of: ", stringify!(_IO_FILE))
    778     );
    779     assert_eq!(
    780         ::std::mem::align_of::<_IO_FILE>(),
    781         8usize,
    782         concat!("Alignment of ", stringify!(_IO_FILE))
    783     );
    784     assert_eq!(
    785         unsafe { ::std::ptr::addr_of!((*ptr)._flags) as usize - ptr as usize },
    786         0usize,
    787         concat!(
    788             "Offset of field: ",
    789             stringify!(_IO_FILE),
    790             "::",
    791             stringify!(_flags)
    792         )
    793     );
    794     assert_eq!(
    795         unsafe { ::std::ptr::addr_of!((*ptr)._IO_read_ptr) as usize - ptr as usize },
    796         8usize,
    797         concat!(
    798             "Offset of field: ",
    799             stringify!(_IO_FILE),
    800             "::",
    801             stringify!(_IO_read_ptr)
    802         )
    803     );
    804     assert_eq!(
    805         unsafe { ::std::ptr::addr_of!((*ptr)._IO_read_end) as usize - ptr as usize },
    806         16usize,
    807         concat!(
    808             "Offset of field: ",
    809             stringify!(_IO_FILE),
    810             "::",
    811             stringify!(_IO_read_end)
    812         )
    813     );
    814     assert_eq!(
    815         unsafe { ::std::ptr::addr_of!((*ptr)._IO_read_base) as usize - ptr as usize },
    816         24usize,
    817         concat!(
    818             "Offset of field: ",
    819             stringify!(_IO_FILE),
    820             "::",
    821             stringify!(_IO_read_base)
    822         )
    823     );
    824     assert_eq!(
    825         unsafe { ::std::ptr::addr_of!((*ptr)._IO_write_base) as usize - ptr as usize },
    826         32usize,
    827         concat!(
    828             "Offset of field: ",
    829             stringify!(_IO_FILE),
    830             "::",
    831             stringify!(_IO_write_base)
    832         )
    833     );
    834     assert_eq!(
    835         unsafe { ::std::ptr::addr_of!((*ptr)._IO_write_ptr) as usize - ptr as usize },
    836         40usize,
    837         concat!(
    838             "Offset of field: ",
    839             stringify!(_IO_FILE),
    840             "::",
    841             stringify!(_IO_write_ptr)
    842         )
    843     );
    844     assert_eq!(
    845         unsafe { ::std::ptr::addr_of!((*ptr)._IO_write_end) as usize - ptr as usize },
    846         48usize,
    847         concat!(
    848             "Offset of field: ",
    849             stringify!(_IO_FILE),
    850             "::",
    851             stringify!(_IO_write_end)
    852         )
    853     );
    854     assert_eq!(
    855         unsafe { ::std::ptr::addr_of!((*ptr)._IO_buf_base) as usize - ptr as usize },
    856         56usize,
    857         concat!(
    858             "Offset of field: ",
    859             stringify!(_IO_FILE),
    860             "::",
    861             stringify!(_IO_buf_base)
    862         )
    863     );
    864     assert_eq!(
    865         unsafe { ::std::ptr::addr_of!((*ptr)._IO_buf_end) as usize - ptr as usize },
    866         64usize,
    867         concat!(
    868             "Offset of field: ",
    869             stringify!(_IO_FILE),
    870             "::",
    871             stringify!(_IO_buf_end)
    872         )
    873     );
    874     assert_eq!(
    875         unsafe { ::std::ptr::addr_of!((*ptr)._IO_save_base) as usize - ptr as usize },
    876         72usize,
    877         concat!(
    878             "Offset of field: ",
    879             stringify!(_IO_FILE),
    880             "::",
    881             stringify!(_IO_save_base)
    882         )
    883     );
    884     assert_eq!(
    885         unsafe { ::std::ptr::addr_of!((*ptr)._IO_backup_base) as usize - ptr as usize },
    886         80usize,
    887         concat!(
    888             "Offset of field: ",
    889             stringify!(_IO_FILE),
    890             "::",
    891             stringify!(_IO_backup_base)
    892         )
    893     );
    894     assert_eq!(
    895         unsafe { ::std::ptr::addr_of!((*ptr)._IO_save_end) as usize - ptr as usize },
    896         88usize,
    897         concat!(
    898             "Offset of field: ",
    899             stringify!(_IO_FILE),
    900             "::",
    901             stringify!(_IO_save_end)
    902         )
    903     );
    904     assert_eq!(
    905         unsafe { ::std::ptr::addr_of!((*ptr)._markers) as usize - ptr as usize },
    906         96usize,
    907         concat!(
    908             "Offset of field: ",
    909             stringify!(_IO_FILE),
    910             "::",
    911             stringify!(_markers)
    912         )
    913     );
    914     assert_eq!(
    915         unsafe { ::std::ptr::addr_of!((*ptr)._chain) as usize - ptr as usize },
    916         104usize,
    917         concat!(
    918             "Offset of field: ",
    919             stringify!(_IO_FILE),
    920             "::",
    921             stringify!(_chain)
    922         )
    923     );
    924     assert_eq!(
    925         unsafe { ::std::ptr::addr_of!((*ptr)._fileno) as usize - ptr as usize },
    926         112usize,
    927         concat!(
    928             "Offset of field: ",
    929             stringify!(_IO_FILE),
    930             "::",
    931             stringify!(_fileno)
    932         )
    933     );
    934     assert_eq!(
    935         unsafe { ::std::ptr::addr_of!((*ptr)._flags2) as usize - ptr as usize },
    936         116usize,
    937         concat!(
    938             "Offset of field: ",
    939             stringify!(_IO_FILE),
    940             "::",
    941             stringify!(_flags2)
    942         )
    943     );
    944     assert_eq!(
    945         unsafe { ::std::ptr::addr_of!((*ptr)._old_offset) as usize - ptr as usize },
    946         120usize,
    947         concat!(
    948             "Offset of field: ",
    949             stringify!(_IO_FILE),
    950             "::",
    951             stringify!(_old_offset)
    952         )
    953     );
    954     assert_eq!(
    955         unsafe { ::std::ptr::addr_of!((*ptr)._cur_column) as usize - ptr as usize },
    956         128usize,
    957         concat!(
    958             "Offset of field: ",
    959             stringify!(_IO_FILE),
    960             "::",
    961             stringify!(_cur_column)
    962         )
    963     );
    964     assert_eq!(
    965         unsafe { ::std::ptr::addr_of!((*ptr)._vtable_offset) as usize - ptr as usize },
    966         130usize,
    967         concat!(
    968             "Offset of field: ",
    969             stringify!(_IO_FILE),
    970             "::",
    971             stringify!(_vtable_offset)
    972         )
    973     );
    974     assert_eq!(
    975         unsafe { ::std::ptr::addr_of!((*ptr)._shortbuf) as usize - ptr as usize },
    976         131usize,
    977         concat!(
    978             "Offset of field: ",
    979             stringify!(_IO_FILE),
    980             "::",
    981             stringify!(_shortbuf)
    982         )
    983     );
    984     assert_eq!(
    985         unsafe { ::std::ptr::addr_of!((*ptr)._lock) as usize - ptr as usize },
    986         136usize,
    987         concat!(
    988             "Offset of field: ",
    989             stringify!(_IO_FILE),
    990             "::",
    991             stringify!(_lock)
    992         )
    993     );
    994     assert_eq!(
    995         unsafe { ::std::ptr::addr_of!((*ptr)._offset) as usize - ptr as usize },
    996         144usize,
    997         concat!(
    998             "Offset of field: ",
    999             stringify!(_IO_FILE),
   1000             "::",
   1001             stringify!(_offset)
   1002         )
   1003     );
   1004     assert_eq!(
   1005         unsafe { ::std::ptr::addr_of!((*ptr)._codecvt) as usize - ptr as usize },
   1006         152usize,
   1007         concat!(
   1008             "Offset of field: ",
   1009             stringify!(_IO_FILE),
   1010             "::",
   1011             stringify!(_codecvt)
   1012         )
   1013     );
   1014     assert_eq!(
   1015         unsafe { ::std::ptr::addr_of!((*ptr)._wide_data) as usize - ptr as usize },
   1016         160usize,
   1017         concat!(
   1018             "Offset of field: ",
   1019             stringify!(_IO_FILE),
   1020             "::",
   1021             stringify!(_wide_data)
   1022         )
   1023     );
   1024     assert_eq!(
   1025         unsafe { ::std::ptr::addr_of!((*ptr)._freeres_list) as usize - ptr as usize },
   1026         168usize,
   1027         concat!(
   1028             "Offset of field: ",
   1029             stringify!(_IO_FILE),
   1030             "::",
   1031             stringify!(_freeres_list)
   1032         )
   1033     );
   1034     assert_eq!(
   1035         unsafe { ::std::ptr::addr_of!((*ptr)._freeres_buf) as usize - ptr as usize },
   1036         176usize,
   1037         concat!(
   1038             "Offset of field: ",
   1039             stringify!(_IO_FILE),
   1040             "::",
   1041             stringify!(_freeres_buf)
   1042         )
   1043     );
   1044     assert_eq!(
   1045         unsafe { ::std::ptr::addr_of!((*ptr).__pad5) as usize - ptr as usize },
   1046         184usize,
   1047         concat!(
   1048             "Offset of field: ",
   1049             stringify!(_IO_FILE),
   1050             "::",
   1051             stringify!(__pad5)
   1052         )
   1053     );
   1054     assert_eq!(
   1055         unsafe { ::std::ptr::addr_of!((*ptr)._mode) as usize - ptr as usize },
   1056         192usize,
   1057         concat!(
   1058             "Offset of field: ",
   1059             stringify!(_IO_FILE),
   1060             "::",
   1061             stringify!(_mode)
   1062         )
   1063     );
   1064     assert_eq!(
   1065         unsafe { ::std::ptr::addr_of!((*ptr)._unused2) as usize - ptr as usize },
   1066         196usize,
   1067         concat!(
   1068             "Offset of field: ",
   1069             stringify!(_IO_FILE),
   1070             "::",
   1071             stringify!(_unused2)
   1072         )
   1073     );
   1074 }
   1075 pub type cookie_read_function_t = ::std::option::Option<
   1076     unsafe extern "C" fn(
   1077         __cookie: *mut ::std::os::raw::c_void,
   1078         __buf: *mut ::std::os::raw::c_char,
   1079         __nbytes: usize,
   1080     ) -> __ssize_t,
   1081 >;
   1082 pub type cookie_write_function_t = ::std::option::Option<
   1083     unsafe extern "C" fn(
   1084         __cookie: *mut ::std::os::raw::c_void,
   1085         __buf: *const ::std::os::raw::c_char,
   1086         __nbytes: usize,
   1087     ) -> __ssize_t,
   1088 >;
   1089 pub type cookie_seek_function_t = ::std::option::Option<
   1090     unsafe extern "C" fn(
   1091         __cookie: *mut ::std::os::raw::c_void,
   1092         __pos: *mut __off64_t,
   1093         __w: ::std::os::raw::c_int,
   1094     ) -> ::std::os::raw::c_int,
   1095 >;
   1096 pub type cookie_close_function_t = ::std::option::Option<
   1097     unsafe extern "C" fn(__cookie: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int,
   1098 >;
   1099 #[repr(C)]
   1100 #[derive(Debug, Copy, Clone)]
   1101 pub struct _IO_cookie_io_functions_t {
   1102     pub read: cookie_read_function_t,
   1103     pub write: cookie_write_function_t,
   1104     pub seek: cookie_seek_function_t,
   1105     pub close: cookie_close_function_t,
   1106 }
   1107 #[test]
   1108 fn bindgen_test_layout__IO_cookie_io_functions_t() {
   1109     const UNINIT: ::std::mem::MaybeUninit<_IO_cookie_io_functions_t> =
   1110         ::std::mem::MaybeUninit::uninit();
   1111     let ptr = UNINIT.as_ptr();
   1112     assert_eq!(
   1113         ::std::mem::size_of::<_IO_cookie_io_functions_t>(),
   1114         32usize,
   1115         concat!("Size of: ", stringify!(_IO_cookie_io_functions_t))
   1116     );
   1117     assert_eq!(
   1118         ::std::mem::align_of::<_IO_cookie_io_functions_t>(),
   1119         8usize,
   1120         concat!("Alignment of ", stringify!(_IO_cookie_io_functions_t))
   1121     );
   1122     assert_eq!(
   1123         unsafe { ::std::ptr::addr_of!((*ptr).read) as usize - ptr as usize },
   1124         0usize,
   1125         concat!(
   1126             "Offset of field: ",
   1127             stringify!(_IO_cookie_io_functions_t),
   1128             "::",
   1129             stringify!(read)
   1130         )
   1131     );
   1132     assert_eq!(
   1133         unsafe { ::std::ptr::addr_of!((*ptr).write) as usize - ptr as usize },
   1134         8usize,
   1135         concat!(
   1136             "Offset of field: ",
   1137             stringify!(_IO_cookie_io_functions_t),
   1138             "::",
   1139             stringify!(write)
   1140         )
   1141     );
   1142     assert_eq!(
   1143         unsafe { ::std::ptr::addr_of!((*ptr).seek) as usize - ptr as usize },
   1144         16usize,
   1145         concat!(
   1146             "Offset of field: ",
   1147             stringify!(_IO_cookie_io_functions_t),
   1148             "::",
   1149             stringify!(seek)
   1150         )
   1151     );
   1152     assert_eq!(
   1153         unsafe { ::std::ptr::addr_of!((*ptr).close) as usize - ptr as usize },
   1154         24usize,
   1155         concat!(
   1156             "Offset of field: ",
   1157             stringify!(_IO_cookie_io_functions_t),
   1158             "::",
   1159             stringify!(close)
   1160         )
   1161     );
   1162 }
   1163 pub type cookie_io_functions_t = _IO_cookie_io_functions_t;
   1164 pub type va_list = __gnuc_va_list;
   1165 pub type off_t = __off_t;
   1166 pub type fpos_t = __fpos_t;
   1167 extern "C" {
   1168     pub static mut stdin: *mut FILE;
   1169 }
   1170 extern "C" {
   1171     pub static mut stdout: *mut FILE;
   1172 }
   1173 extern "C" {
   1174     pub static mut stderr: *mut FILE;
   1175 }
   1176 extern "C" {
   1177     pub fn remove(__filename: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
   1178 }
   1179 extern "C" {
   1180     pub fn rename(
   1181         __old: *const ::std::os::raw::c_char,
   1182         __new: *const ::std::os::raw::c_char,
   1183     ) -> ::std::os::raw::c_int;
   1184 }
   1185 extern "C" {
   1186     pub fn renameat(
   1187         __oldfd: ::std::os::raw::c_int,
   1188         __old: *const ::std::os::raw::c_char,
   1189         __newfd: ::std::os::raw::c_int,
   1190         __new: *const ::std::os::raw::c_char,
   1191     ) -> ::std::os::raw::c_int;
   1192 }
   1193 extern "C" {
   1194     pub fn fclose(__stream: *mut FILE) -> ::std::os::raw::c_int;
   1195 }
   1196 extern "C" {
   1197     pub fn tmpfile() -> *mut FILE;
   1198 }
   1199 extern "C" {
   1200     pub fn tmpnam(arg1: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
   1201 }
   1202 extern "C" {
   1203     pub fn tmpnam_r(__s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
   1204 }
   1205 extern "C" {
   1206     pub fn tempnam(
   1207         __dir: *const ::std::os::raw::c_char,
   1208         __pfx: *const ::std::os::raw::c_char,
   1209     ) -> *mut ::std::os::raw::c_char;
   1210 }
   1211 extern "C" {
   1212     pub fn fflush(__stream: *mut FILE) -> ::std::os::raw::c_int;
   1213 }
   1214 extern "C" {
   1215     pub fn fflush_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
   1216 }
   1217 extern "C" {
   1218     pub fn fopen(
   1219         __filename: *const ::std::os::raw::c_char,
   1220         __modes: *const ::std::os::raw::c_char,
   1221     ) -> *mut FILE;
   1222 }
   1223 extern "C" {
   1224     pub fn freopen(
   1225         __filename: *const ::std::os::raw::c_char,
   1226         __modes: *const ::std::os::raw::c_char,
   1227         __stream: *mut FILE,
   1228     ) -> *mut FILE;
   1229 }
   1230 extern "C" {
   1231     pub fn fdopen(__fd: ::std::os::raw::c_int, __modes: *const ::std::os::raw::c_char)
   1232         -> *mut FILE;
   1233 }
   1234 extern "C" {
   1235     pub fn fopencookie(
   1236         __magic_cookie: *mut ::std::os::raw::c_void,
   1237         __modes: *const ::std::os::raw::c_char,
   1238         __io_funcs: cookie_io_functions_t,
   1239     ) -> *mut FILE;
   1240 }
   1241 extern "C" {
   1242     pub fn fmemopen(
   1243         __s: *mut ::std::os::raw::c_void,
   1244         __len: usize,
   1245         __modes: *const ::std::os::raw::c_char,
   1246     ) -> *mut FILE;
   1247 }
   1248 extern "C" {
   1249     pub fn open_memstream(
   1250         __bufloc: *mut *mut ::std::os::raw::c_char,
   1251         __sizeloc: *mut usize,
   1252     ) -> *mut FILE;
   1253 }
   1254 extern "C" {
   1255     pub fn setbuf(__stream: *mut FILE, __buf: *mut ::std::os::raw::c_char);
   1256 }
   1257 extern "C" {
   1258     pub fn setvbuf(
   1259         __stream: *mut FILE,
   1260         __buf: *mut ::std::os::raw::c_char,
   1261         __modes: ::std::os::raw::c_int,
   1262         __n: usize,
   1263     ) -> ::std::os::raw::c_int;
   1264 }
   1265 extern "C" {
   1266     pub fn setbuffer(__stream: *mut FILE, __buf: *mut ::std::os::raw::c_char, __size: usize);
   1267 }
   1268 extern "C" {
   1269     pub fn setlinebuf(__stream: *mut FILE);
   1270 }
   1271 extern "C" {
   1272     pub fn fprintf(
   1273         __stream: *mut FILE,
   1274         __format: *const ::std::os::raw::c_char,
   1275         ...
   1276     ) -> ::std::os::raw::c_int;
   1277 }
   1278 extern "C" {
   1279     pub fn printf(__format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
   1280 }
   1281 extern "C" {
   1282     pub fn sprintf(
   1283         __s: *mut ::std::os::raw::c_char,
   1284         __format: *const ::std::os::raw::c_char,
   1285         ...
   1286     ) -> ::std::os::raw::c_int;
   1287 }
   1288 extern "C" {
   1289     pub fn vfprintf(
   1290         __s: *mut FILE,
   1291         __format: *const ::std::os::raw::c_char,
   1292         __arg: *mut __va_list_tag,
   1293     ) -> ::std::os::raw::c_int;
   1294 }
   1295 extern "C" {
   1296     pub fn vprintf(
   1297         __format: *const ::std::os::raw::c_char,
   1298         __arg: *mut __va_list_tag,
   1299     ) -> ::std::os::raw::c_int;
   1300 }
   1301 extern "C" {
   1302     pub fn vsprintf(
   1303         __s: *mut ::std::os::raw::c_char,
   1304         __format: *const ::std::os::raw::c_char,
   1305         __arg: *mut __va_list_tag,
   1306     ) -> ::std::os::raw::c_int;
   1307 }
   1308 extern "C" {
   1309     pub fn snprintf(
   1310         __s: *mut ::std::os::raw::c_char,
   1311         __maxlen: ::std::os::raw::c_ulong,
   1312         __format: *const ::std::os::raw::c_char,
   1313         ...
   1314     ) -> ::std::os::raw::c_int;
   1315 }
   1316 extern "C" {
   1317     pub fn vsnprintf(
   1318         __s: *mut ::std::os::raw::c_char,
   1319         __maxlen: ::std::os::raw::c_ulong,
   1320         __format: *const ::std::os::raw::c_char,
   1321         __arg: *mut __va_list_tag,
   1322     ) -> ::std::os::raw::c_int;
   1323 }
   1324 extern "C" {
   1325     pub fn vasprintf(
   1326         __ptr: *mut *mut ::std::os::raw::c_char,
   1327         __f: *const ::std::os::raw::c_char,
   1328         __arg: *mut __va_list_tag,
   1329     ) -> ::std::os::raw::c_int;
   1330 }
   1331 extern "C" {
   1332     pub fn __asprintf(
   1333         __ptr: *mut *mut ::std::os::raw::c_char,
   1334         __fmt: *const ::std::os::raw::c_char,
   1335         ...
   1336     ) -> ::std::os::raw::c_int;
   1337 }
   1338 extern "C" {
   1339     pub fn asprintf(
   1340         __ptr: *mut *mut ::std::os::raw::c_char,
   1341         __fmt: *const ::std::os::raw::c_char,
   1342         ...
   1343     ) -> ::std::os::raw::c_int;
   1344 }
   1345 extern "C" {
   1346     pub fn vdprintf(
   1347         __fd: ::std::os::raw::c_int,
   1348         __fmt: *const ::std::os::raw::c_char,
   1349         __arg: *mut __va_list_tag,
   1350     ) -> ::std::os::raw::c_int;
   1351 }
   1352 extern "C" {
   1353     pub fn dprintf(
   1354         __fd: ::std::os::raw::c_int,
   1355         __fmt: *const ::std::os::raw::c_char,
   1356         ...
   1357     ) -> ::std::os::raw::c_int;
   1358 }
   1359 extern "C" {
   1360     pub fn fscanf(
   1361         __stream: *mut FILE,
   1362         __format: *const ::std::os::raw::c_char,
   1363         ...
   1364     ) -> ::std::os::raw::c_int;
   1365 }
   1366 extern "C" {
   1367     pub fn scanf(__format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
   1368 }
   1369 extern "C" {
   1370     pub fn sscanf(
   1371         __s: *const ::std::os::raw::c_char,
   1372         __format: *const ::std::os::raw::c_char,
   1373         ...
   1374     ) -> ::std::os::raw::c_int;
   1375 }
   1376 pub type _Float32 = f32;
   1377 pub type _Float64 = f64;
   1378 pub type _Float32x = f64;
   1379 pub type _Float64x = u128;
   1380 extern "C" {
   1381     #[link_name = "\u{1}__isoc99_fscanf"]
   1382     pub fn fscanf1(
   1383         __stream: *mut FILE,
   1384         __format: *const ::std::os::raw::c_char,
   1385         ...
   1386     ) -> ::std::os::raw::c_int;
   1387 }
   1388 extern "C" {
   1389     #[link_name = "\u{1}__isoc99_scanf"]
   1390     pub fn scanf1(__format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
   1391 }
   1392 extern "C" {
   1393     #[link_name = "\u{1}__isoc99_sscanf"]
   1394     pub fn sscanf1(
   1395         __s: *const ::std::os::raw::c_char,
   1396         __format: *const ::std::os::raw::c_char,
   1397         ...
   1398     ) -> ::std::os::raw::c_int;
   1399 }
   1400 extern "C" {
   1401     pub fn vfscanf(
   1402         __s: *mut FILE,
   1403         __format: *const ::std::os::raw::c_char,
   1404         __arg: *mut __va_list_tag,
   1405     ) -> ::std::os::raw::c_int;
   1406 }
   1407 extern "C" {
   1408     pub fn vscanf(
   1409         __format: *const ::std::os::raw::c_char,
   1410         __arg: *mut __va_list_tag,
   1411     ) -> ::std::os::raw::c_int;
   1412 }
   1413 extern "C" {
   1414     pub fn vsscanf(
   1415         __s: *const ::std::os::raw::c_char,
   1416         __format: *const ::std::os::raw::c_char,
   1417         __arg: *mut __va_list_tag,
   1418     ) -> ::std::os::raw::c_int;
   1419 }
   1420 extern "C" {
   1421     #[link_name = "\u{1}__isoc99_vfscanf"]
   1422     pub fn vfscanf1(
   1423         __s: *mut FILE,
   1424         __format: *const ::std::os::raw::c_char,
   1425         __arg: *mut __va_list_tag,
   1426     ) -> ::std::os::raw::c_int;
   1427 }
   1428 extern "C" {
   1429     #[link_name = "\u{1}__isoc99_vscanf"]
   1430     pub fn vscanf1(
   1431         __format: *const ::std::os::raw::c_char,
   1432         __arg: *mut __va_list_tag,
   1433     ) -> ::std::os::raw::c_int;
   1434 }
   1435 extern "C" {
   1436     #[link_name = "\u{1}__isoc99_vsscanf"]
   1437     pub fn vsscanf1(
   1438         __s: *const ::std::os::raw::c_char,
   1439         __format: *const ::std::os::raw::c_char,
   1440         __arg: *mut __va_list_tag,
   1441     ) -> ::std::os::raw::c_int;
   1442 }
   1443 extern "C" {
   1444     pub fn fgetc(__stream: *mut FILE) -> ::std::os::raw::c_int;
   1445 }
   1446 extern "C" {
   1447     pub fn getc(__stream: *mut FILE) -> ::std::os::raw::c_int;
   1448 }
   1449 extern "C" {
   1450     pub fn getchar() -> ::std::os::raw::c_int;
   1451 }
   1452 extern "C" {
   1453     pub fn getc_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
   1454 }
   1455 extern "C" {
   1456     pub fn getchar_unlocked() -> ::std::os::raw::c_int;
   1457 }
   1458 extern "C" {
   1459     pub fn fgetc_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
   1460 }
   1461 extern "C" {
   1462     pub fn fputc(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
   1463 }
   1464 extern "C" {
   1465     pub fn putc(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
   1466 }
   1467 extern "C" {
   1468     pub fn putchar(__c: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
   1469 }
   1470 extern "C" {
   1471     pub fn fputc_unlocked(__c: ::std::os::raw::c_int, __stream: *mut FILE)
   1472         -> ::std::os::raw::c_int;
   1473 }
   1474 extern "C" {
   1475     pub fn putc_unlocked(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
   1476 }
   1477 extern "C" {
   1478     pub fn putchar_unlocked(__c: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
   1479 }
   1480 extern "C" {
   1481     pub fn getw(__stream: *mut FILE) -> ::std::os::raw::c_int;
   1482 }
   1483 extern "C" {
   1484     pub fn putw(__w: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
   1485 }
   1486 extern "C" {
   1487     pub fn fgets(
   1488         __s: *mut ::std::os::raw::c_char,
   1489         __n: ::std::os::raw::c_int,
   1490         __stream: *mut FILE,
   1491     ) -> *mut ::std::os::raw::c_char;
   1492 }
   1493 extern "C" {
   1494     pub fn __getdelim(
   1495         __lineptr: *mut *mut ::std::os::raw::c_char,
   1496         __n: *mut usize,
   1497         __delimiter: ::std::os::raw::c_int,
   1498         __stream: *mut FILE,
   1499     ) -> __ssize_t;
   1500 }
   1501 extern "C" {
   1502     pub fn getdelim(
   1503         __lineptr: *mut *mut ::std::os::raw::c_char,
   1504         __n: *mut usize,
   1505         __delimiter: ::std::os::raw::c_int,
   1506         __stream: *mut FILE,
   1507     ) -> __ssize_t;
   1508 }
   1509 extern "C" {
   1510     pub fn getline(
   1511         __lineptr: *mut *mut ::std::os::raw::c_char,
   1512         __n: *mut usize,
   1513         __stream: *mut FILE,
   1514     ) -> __ssize_t;
   1515 }
   1516 extern "C" {
   1517     pub fn fputs(__s: *const ::std::os::raw::c_char, __stream: *mut FILE) -> ::std::os::raw::c_int;
   1518 }
   1519 extern "C" {
   1520     pub fn puts(__s: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
   1521 }
   1522 extern "C" {
   1523     pub fn ungetc(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
   1524 }
   1525 extern "C" {
   1526     pub fn fread(
   1527         __ptr: *mut ::std::os::raw::c_void,
   1528         __size: ::std::os::raw::c_ulong,
   1529         __n: ::std::os::raw::c_ulong,
   1530         __stream: *mut FILE,
   1531     ) -> ::std::os::raw::c_ulong;
   1532 }
   1533 extern "C" {
   1534     pub fn fwrite(
   1535         __ptr: *const ::std::os::raw::c_void,
   1536         __size: ::std::os::raw::c_ulong,
   1537         __n: ::std::os::raw::c_ulong,
   1538         __s: *mut FILE,
   1539     ) -> ::std::os::raw::c_ulong;
   1540 }
   1541 extern "C" {
   1542     pub fn fread_unlocked(
   1543         __ptr: *mut ::std::os::raw::c_void,
   1544         __size: usize,
   1545         __n: usize,
   1546         __stream: *mut FILE,
   1547     ) -> usize;
   1548 }
   1549 extern "C" {
   1550     pub fn fwrite_unlocked(
   1551         __ptr: *const ::std::os::raw::c_void,
   1552         __size: usize,
   1553         __n: usize,
   1554         __stream: *mut FILE,
   1555     ) -> usize;
   1556 }
   1557 extern "C" {
   1558     pub fn fseek(
   1559         __stream: *mut FILE,
   1560         __off: ::std::os::raw::c_long,
   1561         __whence: ::std::os::raw::c_int,
   1562     ) -> ::std::os::raw::c_int;
   1563 }
   1564 extern "C" {
   1565     pub fn ftell(__stream: *mut FILE) -> ::std::os::raw::c_long;
   1566 }
   1567 extern "C" {
   1568     pub fn rewind(__stream: *mut FILE);
   1569 }
   1570 extern "C" {
   1571     pub fn fseeko(
   1572         __stream: *mut FILE,
   1573         __off: __off_t,
   1574         __whence: ::std::os::raw::c_int,
   1575     ) -> ::std::os::raw::c_int;
   1576 }
   1577 extern "C" {
   1578     pub fn ftello(__stream: *mut FILE) -> __off_t;
   1579 }
   1580 extern "C" {
   1581     pub fn fgetpos(__stream: *mut FILE, __pos: *mut fpos_t) -> ::std::os::raw::c_int;
   1582 }
   1583 extern "C" {
   1584     pub fn fsetpos(__stream: *mut FILE, __pos: *const fpos_t) -> ::std::os::raw::c_int;
   1585 }
   1586 extern "C" {
   1587     pub fn clearerr(__stream: *mut FILE);
   1588 }
   1589 extern "C" {
   1590     pub fn feof(__stream: *mut FILE) -> ::std::os::raw::c_int;
   1591 }
   1592 extern "C" {
   1593     pub fn ferror(__stream: *mut FILE) -> ::std::os::raw::c_int;
   1594 }
   1595 extern "C" {
   1596     pub fn clearerr_unlocked(__stream: *mut FILE);
   1597 }
   1598 extern "C" {
   1599     pub fn feof_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
   1600 }
   1601 extern "C" {
   1602     pub fn ferror_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
   1603 }
   1604 extern "C" {
   1605     pub fn perror(__s: *const ::std::os::raw::c_char);
   1606 }
   1607 extern "C" {
   1608     pub fn fileno(__stream: *mut FILE) -> ::std::os::raw::c_int;
   1609 }
   1610 extern "C" {
   1611     pub fn fileno_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
   1612 }
   1613 extern "C" {
   1614     pub fn pclose(__stream: *mut FILE) -> ::std::os::raw::c_int;
   1615 }
   1616 extern "C" {
   1617     pub fn popen(
   1618         __command: *const ::std::os::raw::c_char,
   1619         __modes: *const ::std::os::raw::c_char,
   1620     ) -> *mut FILE;
   1621 }
   1622 extern "C" {
   1623     pub fn ctermid(__s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
   1624 }
   1625 extern "C" {
   1626     pub fn flockfile(__stream: *mut FILE);
   1627 }
   1628 extern "C" {
   1629     pub fn ftrylockfile(__stream: *mut FILE) -> ::std::os::raw::c_int;
   1630 }
   1631 extern "C" {
   1632     pub fn funlockfile(__stream: *mut FILE);
   1633 }
   1634 extern "C" {
   1635     pub fn __uflow(arg1: *mut FILE) -> ::std::os::raw::c_int;
   1636 }
   1637 extern "C" {
   1638     pub fn __overflow(arg1: *mut FILE, arg2: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
   1639 }
   1640 pub const _ISupper: _bindgen_ty_1 = 256;
   1641 pub const _ISlower: _bindgen_ty_1 = 512;
   1642 pub const _ISalpha: _bindgen_ty_1 = 1024;
   1643 pub const _ISdigit: _bindgen_ty_1 = 2048;
   1644 pub const _ISxdigit: _bindgen_ty_1 = 4096;
   1645 pub const _ISspace: _bindgen_ty_1 = 8192;
   1646 pub const _ISprint: _bindgen_ty_1 = 16384;
   1647 pub const _ISgraph: _bindgen_ty_1 = 32768;
   1648 pub const _ISblank: _bindgen_ty_1 = 1;
   1649 pub const _IScntrl: _bindgen_ty_1 = 2;
   1650 pub const _ISpunct: _bindgen_ty_1 = 4;
   1651 pub const _ISalnum: _bindgen_ty_1 = 8;
   1652 pub type _bindgen_ty_1 = ::std::os::raw::c_uint;
   1653 extern "C" {
   1654     pub fn __ctype_b_loc() -> *mut *const ::std::os::raw::c_ushort;
   1655 }
   1656 extern "C" {
   1657     pub fn __ctype_tolower_loc() -> *mut *const __int32_t;
   1658 }
   1659 extern "C" {
   1660     pub fn __ctype_toupper_loc() -> *mut *const __int32_t;
   1661 }
   1662 extern "C" {
   1663     pub fn isalnum(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
   1664 }
   1665 extern "C" {
   1666     pub fn isalpha(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
   1667 }
   1668 extern "C" {
   1669     pub fn iscntrl(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
   1670 }
   1671 extern "C" {
   1672     pub fn isdigit(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
   1673 }
   1674 extern "C" {
   1675     pub fn islower(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
   1676 }
   1677 extern "C" {
   1678     pub fn isgraph(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
   1679 }
   1680 extern "C" {
   1681     pub fn isprint(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
   1682 }
   1683 extern "C" {
   1684     pub fn ispunct(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
   1685 }
   1686 extern "C" {
   1687     pub fn isspace(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
   1688 }
   1689 extern "C" {
   1690     pub fn isupper(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
   1691 }
   1692 extern "C" {
   1693     pub fn isxdigit(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
   1694 }
   1695 extern "C" {
   1696     pub fn tolower(__c: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
   1697 }
   1698 extern "C" {
   1699     pub fn toupper(__c: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
   1700 }
   1701 extern "C" {
   1702     pub fn isblank(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
   1703 }
   1704 extern "C" {
   1705     pub fn isascii(__c: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
   1706 }
   1707 extern "C" {
   1708     pub fn toascii(__c: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
   1709 }
   1710 extern "C" {
   1711     pub fn _toupper(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
   1712 }
   1713 extern "C" {
   1714     pub fn _tolower(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
   1715 }
   1716 #[repr(C)]
   1717 #[derive(Debug, Copy, Clone)]
   1718 pub struct __locale_struct {
   1719     pub __locales: [*mut __locale_data; 13usize],
   1720     pub __ctype_b: *const ::std::os::raw::c_ushort,
   1721     pub __ctype_tolower: *const ::std::os::raw::c_int,
   1722     pub __ctype_toupper: *const ::std::os::raw::c_int,
   1723     pub __names: [*const ::std::os::raw::c_char; 13usize],
   1724 }
   1725 #[test]
   1726 fn bindgen_test_layout___locale_struct() {
   1727     const UNINIT: ::std::mem::MaybeUninit<__locale_struct> = ::std::mem::MaybeUninit::uninit();
   1728     let ptr = UNINIT.as_ptr();
   1729     assert_eq!(
   1730         ::std::mem::size_of::<__locale_struct>(),
   1731         232usize,
   1732         concat!("Size of: ", stringify!(__locale_struct))
   1733     );
   1734     assert_eq!(
   1735         ::std::mem::align_of::<__locale_struct>(),
   1736         8usize,
   1737         concat!("Alignment of ", stringify!(__locale_struct))
   1738     );
   1739     assert_eq!(
   1740         unsafe { ::std::ptr::addr_of!((*ptr).__locales) as usize - ptr as usize },
   1741         0usize,
   1742         concat!(
   1743             "Offset of field: ",
   1744             stringify!(__locale_struct),
   1745             "::",
   1746             stringify!(__locales)
   1747         )
   1748     );
   1749     assert_eq!(
   1750         unsafe { ::std::ptr::addr_of!((*ptr).__ctype_b) as usize - ptr as usize },
   1751         104usize,
   1752         concat!(
   1753             "Offset of field: ",
   1754             stringify!(__locale_struct),
   1755             "::",
   1756             stringify!(__ctype_b)
   1757         )
   1758     );
   1759     assert_eq!(
   1760         unsafe { ::std::ptr::addr_of!((*ptr).__ctype_tolower) as usize - ptr as usize },
   1761         112usize,
   1762         concat!(
   1763             "Offset of field: ",
   1764             stringify!(__locale_struct),
   1765             "::",
   1766             stringify!(__ctype_tolower)
   1767         )
   1768     );
   1769     assert_eq!(
   1770         unsafe { ::std::ptr::addr_of!((*ptr).__ctype_toupper) as usize - ptr as usize },
   1771         120usize,
   1772         concat!(
   1773             "Offset of field: ",
   1774             stringify!(__locale_struct),
   1775             "::",
   1776             stringify!(__ctype_toupper)
   1777         )
   1778     );
   1779     assert_eq!(
   1780         unsafe { ::std::ptr::addr_of!((*ptr).__names) as usize - ptr as usize },
   1781         128usize,
   1782         concat!(
   1783             "Offset of field: ",
   1784             stringify!(__locale_struct),
   1785             "::",
   1786             stringify!(__names)
   1787         )
   1788     );
   1789 }
   1790 pub type __locale_t = *mut __locale_struct;
   1791 pub type locale_t = __locale_t;
   1792 extern "C" {
   1793     pub fn isalnum_l(arg1: ::std::os::raw::c_int, arg2: locale_t) -> ::std::os::raw::c_int;
   1794 }
   1795 extern "C" {
   1796     pub fn isalpha_l(arg1: ::std::os::raw::c_int, arg2: locale_t) -> ::std::os::raw::c_int;
   1797 }
   1798 extern "C" {
   1799     pub fn iscntrl_l(arg1: ::std::os::raw::c_int, arg2: locale_t) -> ::std::os::raw::c_int;
   1800 }
   1801 extern "C" {
   1802     pub fn isdigit_l(arg1: ::std::os::raw::c_int, arg2: locale_t) -> ::std::os::raw::c_int;
   1803 }
   1804 extern "C" {
   1805     pub fn islower_l(arg1: ::std::os::raw::c_int, arg2: locale_t) -> ::std::os::raw::c_int;
   1806 }
   1807 extern "C" {
   1808     pub fn isgraph_l(arg1: ::std::os::raw::c_int, arg2: locale_t) -> ::std::os::raw::c_int;
   1809 }
   1810 extern "C" {
   1811     pub fn isprint_l(arg1: ::std::os::raw::c_int, arg2: locale_t) -> ::std::os::raw::c_int;
   1812 }
   1813 extern "C" {
   1814     pub fn ispunct_l(arg1: ::std::os::raw::c_int, arg2: locale_t) -> ::std::os::raw::c_int;
   1815 }
   1816 extern "C" {
   1817     pub fn isspace_l(arg1: ::std::os::raw::c_int, arg2: locale_t) -> ::std::os::raw::c_int;
   1818 }
   1819 extern "C" {
   1820     pub fn isupper_l(arg1: ::std::os::raw::c_int, arg2: locale_t) -> ::std::os::raw::c_int;
   1821 }
   1822 extern "C" {
   1823     pub fn isxdigit_l(arg1: ::std::os::raw::c_int, arg2: locale_t) -> ::std::os::raw::c_int;
   1824 }
   1825 extern "C" {
   1826     pub fn isblank_l(arg1: ::std::os::raw::c_int, arg2: locale_t) -> ::std::os::raw::c_int;
   1827 }
   1828 extern "C" {
   1829     pub fn __tolower_l(__c: ::std::os::raw::c_int, __l: locale_t) -> ::std::os::raw::c_int;
   1830 }
   1831 extern "C" {
   1832     pub fn tolower_l(__c: ::std::os::raw::c_int, __l: locale_t) -> ::std::os::raw::c_int;
   1833 }
   1834 extern "C" {
   1835     pub fn __toupper_l(__c: ::std::os::raw::c_int, __l: locale_t) -> ::std::os::raw::c_int;
   1836 }
   1837 extern "C" {
   1838     pub fn toupper_l(__c: ::std::os::raw::c_int, __l: locale_t) -> ::std::os::raw::c_int;
   1839 }
   1840 extern "C" {
   1841     pub fn __assert_fail(
   1842         __assertion: *const ::std::os::raw::c_char,
   1843         __file: *const ::std::os::raw::c_char,
   1844         __line: ::std::os::raw::c_uint,
   1845         __function: *const ::std::os::raw::c_char,
   1846     ) -> !;
   1847 }
   1848 extern "C" {
   1849     pub fn __assert_perror_fail(
   1850         __errnum: ::std::os::raw::c_int,
   1851         __file: *const ::std::os::raw::c_char,
   1852         __line: ::std::os::raw::c_uint,
   1853         __function: *const ::std::os::raw::c_char,
   1854     ) -> !;
   1855 }
   1856 extern "C" {
   1857     pub fn __assert(
   1858         __assertion: *const ::std::os::raw::c_char,
   1859         __file: *const ::std::os::raw::c_char,
   1860         __line: ::std::os::raw::c_int,
   1861     ) -> !;
   1862 }
   1863 extern "C" {
   1864     pub fn memcpy(
   1865         __dest: *mut ::std::os::raw::c_void,
   1866         __src: *const ::std::os::raw::c_void,
   1867         __n: ::std::os::raw::c_ulong,
   1868     ) -> *mut ::std::os::raw::c_void;
   1869 }
   1870 extern "C" {
   1871     pub fn memmove(
   1872         __dest: *mut ::std::os::raw::c_void,
   1873         __src: *const ::std::os::raw::c_void,
   1874         __n: ::std::os::raw::c_ulong,
   1875     ) -> *mut ::std::os::raw::c_void;
   1876 }
   1877 extern "C" {
   1878     pub fn memccpy(
   1879         __dest: *mut ::std::os::raw::c_void,
   1880         __src: *const ::std::os::raw::c_void,
   1881         __c: ::std::os::raw::c_int,
   1882         __n: ::std::os::raw::c_ulong,
   1883     ) -> *mut ::std::os::raw::c_void;
   1884 }
   1885 extern "C" {
   1886     pub fn memset(
   1887         __s: *mut ::std::os::raw::c_void,
   1888         __c: ::std::os::raw::c_int,
   1889         __n: ::std::os::raw::c_ulong,
   1890     ) -> *mut ::std::os::raw::c_void;
   1891 }
   1892 extern "C" {
   1893     pub fn memcmp(
   1894         __s1: *const ::std::os::raw::c_void,
   1895         __s2: *const ::std::os::raw::c_void,
   1896         __n: ::std::os::raw::c_ulong,
   1897     ) -> ::std::os::raw::c_int;
   1898 }
   1899 extern "C" {
   1900     pub fn __memcmpeq(
   1901         __s1: *const ::std::os::raw::c_void,
   1902         __s2: *const ::std::os::raw::c_void,
   1903         __n: usize,
   1904     ) -> ::std::os::raw::c_int;
   1905 }
   1906 extern "C" {
   1907     pub fn memchr(
   1908         __s: *const ::std::os::raw::c_void,
   1909         __c: ::std::os::raw::c_int,
   1910         __n: ::std::os::raw::c_ulong,
   1911     ) -> *mut ::std::os::raw::c_void;
   1912 }
   1913 extern "C" {
   1914     pub fn strcpy(
   1915         __dest: *mut ::std::os::raw::c_char,
   1916         __src: *const ::std::os::raw::c_char,
   1917     ) -> *mut ::std::os::raw::c_char;
   1918 }
   1919 extern "C" {
   1920     pub fn strncpy(
   1921         __dest: *mut ::std::os::raw::c_char,
   1922         __src: *const ::std::os::raw::c_char,
   1923         __n: ::std::os::raw::c_ulong,
   1924     ) -> *mut ::std::os::raw::c_char;
   1925 }
   1926 extern "C" {
   1927     pub fn strcat(
   1928         __dest: *mut ::std::os::raw::c_char,
   1929         __src: *const ::std::os::raw::c_char,
   1930     ) -> *mut ::std::os::raw::c_char;
   1931 }
   1932 extern "C" {
   1933     pub fn strncat(
   1934         __dest: *mut ::std::os::raw::c_char,
   1935         __src: *const ::std::os::raw::c_char,
   1936         __n: ::std::os::raw::c_ulong,
   1937     ) -> *mut ::std::os::raw::c_char;
   1938 }
   1939 extern "C" {
   1940     pub fn strcmp(
   1941         __s1: *const ::std::os::raw::c_char,
   1942         __s2: *const ::std::os::raw::c_char,
   1943     ) -> ::std::os::raw::c_int;
   1944 }
   1945 extern "C" {
   1946     pub fn strncmp(
   1947         __s1: *const ::std::os::raw::c_char,
   1948         __s2: *const ::std::os::raw::c_char,
   1949         __n: ::std::os::raw::c_ulong,
   1950     ) -> ::std::os::raw::c_int;
   1951 }
   1952 extern "C" {
   1953     pub fn strcoll(
   1954         __s1: *const ::std::os::raw::c_char,
   1955         __s2: *const ::std::os::raw::c_char,
   1956     ) -> ::std::os::raw::c_int;
   1957 }
   1958 extern "C" {
   1959     pub fn strxfrm(
   1960         __dest: *mut ::std::os::raw::c_char,
   1961         __src: *const ::std::os::raw::c_char,
   1962         __n: ::std::os::raw::c_ulong,
   1963     ) -> ::std::os::raw::c_ulong;
   1964 }
   1965 extern "C" {
   1966     pub fn strcoll_l(
   1967         __s1: *const ::std::os::raw::c_char,
   1968         __s2: *const ::std::os::raw::c_char,
   1969         __l: locale_t,
   1970     ) -> ::std::os::raw::c_int;
   1971 }
   1972 extern "C" {
   1973     pub fn strxfrm_l(
   1974         __dest: *mut ::std::os::raw::c_char,
   1975         __src: *const ::std::os::raw::c_char,
   1976         __n: usize,
   1977         __l: locale_t,
   1978     ) -> usize;
   1979 }
   1980 extern "C" {
   1981     pub fn strdup(__s: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
   1982 }
   1983 extern "C" {
   1984     pub fn strndup(
   1985         __string: *const ::std::os::raw::c_char,
   1986         __n: ::std::os::raw::c_ulong,
   1987     ) -> *mut ::std::os::raw::c_char;
   1988 }
   1989 extern "C" {
   1990     pub fn strchr(
   1991         __s: *const ::std::os::raw::c_char,
   1992         __c: ::std::os::raw::c_int,
   1993     ) -> *mut ::std::os::raw::c_char;
   1994 }
   1995 extern "C" {
   1996     pub fn strrchr(
   1997         __s: *const ::std::os::raw::c_char,
   1998         __c: ::std::os::raw::c_int,
   1999     ) -> *mut ::std::os::raw::c_char;
   2000 }
   2001 extern "C" {
   2002     pub fn strchrnul(
   2003         __s: *const ::std::os::raw::c_char,
   2004         __c: ::std::os::raw::c_int,
   2005     ) -> *mut ::std::os::raw::c_char;
   2006 }
   2007 extern "C" {
   2008     pub fn strcspn(
   2009         __s: *const ::std::os::raw::c_char,
   2010         __reject: *const ::std::os::raw::c_char,
   2011     ) -> ::std::os::raw::c_ulong;
   2012 }
   2013 extern "C" {
   2014     pub fn strspn(
   2015         __s: *const ::std::os::raw::c_char,
   2016         __accept: *const ::std::os::raw::c_char,
   2017     ) -> ::std::os::raw::c_ulong;
   2018 }
   2019 extern "C" {
   2020     pub fn strpbrk(
   2021         __s: *const ::std::os::raw::c_char,
   2022         __accept: *const ::std::os::raw::c_char,
   2023     ) -> *mut ::std::os::raw::c_char;
   2024 }
   2025 extern "C" {
   2026     pub fn strstr(
   2027         __haystack: *const ::std::os::raw::c_char,
   2028         __needle: *const ::std::os::raw::c_char,
   2029     ) -> *mut ::std::os::raw::c_char;
   2030 }
   2031 extern "C" {
   2032     pub fn strtok(
   2033         __s: *mut ::std::os::raw::c_char,
   2034         __delim: *const ::std::os::raw::c_char,
   2035     ) -> *mut ::std::os::raw::c_char;
   2036 }
   2037 extern "C" {
   2038     pub fn __strtok_r(
   2039         __s: *mut ::std::os::raw::c_char,
   2040         __delim: *const ::std::os::raw::c_char,
   2041         __save_ptr: *mut *mut ::std::os::raw::c_char,
   2042     ) -> *mut ::std::os::raw::c_char;
   2043 }
   2044 extern "C" {
   2045     pub fn strtok_r(
   2046         __s: *mut ::std::os::raw::c_char,
   2047         __delim: *const ::std::os::raw::c_char,
   2048         __save_ptr: *mut *mut ::std::os::raw::c_char,
   2049     ) -> *mut ::std::os::raw::c_char;
   2050 }
   2051 extern "C" {
   2052     pub fn strcasestr(
   2053         __haystack: *const ::std::os::raw::c_char,
   2054         __needle: *const ::std::os::raw::c_char,
   2055     ) -> *mut ::std::os::raw::c_char;
   2056 }
   2057 extern "C" {
   2058     pub fn memmem(
   2059         __haystack: *const ::std::os::raw::c_void,
   2060         __haystacklen: usize,
   2061         __needle: *const ::std::os::raw::c_void,
   2062         __needlelen: usize,
   2063     ) -> *mut ::std::os::raw::c_void;
   2064 }
   2065 extern "C" {
   2066     pub fn __mempcpy(
   2067         __dest: *mut ::std::os::raw::c_void,
   2068         __src: *const ::std::os::raw::c_void,
   2069         __n: usize,
   2070     ) -> *mut ::std::os::raw::c_void;
   2071 }
   2072 extern "C" {
   2073     pub fn mempcpy(
   2074         __dest: *mut ::std::os::raw::c_void,
   2075         __src: *const ::std::os::raw::c_void,
   2076         __n: ::std::os::raw::c_ulong,
   2077     ) -> *mut ::std::os::raw::c_void;
   2078 }
   2079 extern "C" {
   2080     pub fn strlen(__s: *const ::std::os::raw::c_char) -> ::std::os::raw::c_ulong;
   2081 }
   2082 extern "C" {
   2083     pub fn strnlen(__string: *const ::std::os::raw::c_char, __maxlen: usize) -> usize;
   2084 }
   2085 extern "C" {
   2086     pub fn strerror(__errnum: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_char;
   2087 }
   2088 extern "C" {
   2089     #[link_name = "\u{1}__xpg_strerror_r"]
   2090     pub fn strerror_r(
   2091         __errnum: ::std::os::raw::c_int,
   2092         __buf: *mut ::std::os::raw::c_char,
   2093         __buflen: usize,
   2094     ) -> ::std::os::raw::c_int;
   2095 }
   2096 extern "C" {
   2097     pub fn strerror_l(
   2098         __errnum: ::std::os::raw::c_int,
   2099         __l: locale_t,
   2100     ) -> *mut ::std::os::raw::c_char;
   2101 }
   2102 extern "C" {
   2103     pub fn bcmp(
   2104         __s1: *const ::std::os::raw::c_void,
   2105         __s2: *const ::std::os::raw::c_void,
   2106         __n: ::std::os::raw::c_ulong,
   2107     ) -> ::std::os::raw::c_int;
   2108 }
   2109 extern "C" {
   2110     pub fn bcopy(
   2111         __src: *const ::std::os::raw::c_void,
   2112         __dest: *mut ::std::os::raw::c_void,
   2113         __n: usize,
   2114     );
   2115 }
   2116 extern "C" {
   2117     pub fn bzero(__s: *mut ::std::os::raw::c_void, __n: ::std::os::raw::c_ulong);
   2118 }
   2119 extern "C" {
   2120     pub fn index(
   2121         __s: *const ::std::os::raw::c_char,
   2122         __c: ::std::os::raw::c_int,
   2123     ) -> *mut ::std::os::raw::c_char;
   2124 }
   2125 extern "C" {
   2126     pub fn rindex(
   2127         __s: *const ::std::os::raw::c_char,
   2128         __c: ::std::os::raw::c_int,
   2129     ) -> *mut ::std::os::raw::c_char;
   2130 }
   2131 extern "C" {
   2132     pub fn ffs(__i: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
   2133 }
   2134 extern "C" {
   2135     pub fn ffsl(__l: ::std::os::raw::c_long) -> ::std::os::raw::c_int;
   2136 }
   2137 extern "C" {
   2138     pub fn ffsll(__ll: ::std::os::raw::c_longlong) -> ::std::os::raw::c_int;
   2139 }
   2140 extern "C" {
   2141     pub fn strcasecmp(
   2142         __s1: *const ::std::os::raw::c_char,
   2143         __s2: *const ::std::os::raw::c_char,
   2144     ) -> ::std::os::raw::c_int;
   2145 }
   2146 extern "C" {
   2147     pub fn strncasecmp(
   2148         __s1: *const ::std::os::raw::c_char,
   2149         __s2: *const ::std::os::raw::c_char,
   2150         __n: ::std::os::raw::c_ulong,
   2151     ) -> ::std::os::raw::c_int;
   2152 }
   2153 extern "C" {
   2154     pub fn strcasecmp_l(
   2155         __s1: *const ::std::os::raw::c_char,
   2156         __s2: *const ::std::os::raw::c_char,
   2157         __loc: locale_t,
   2158     ) -> ::std::os::raw::c_int;
   2159 }
   2160 extern "C" {
   2161     pub fn strncasecmp_l(
   2162         __s1: *const ::std::os::raw::c_char,
   2163         __s2: *const ::std::os::raw::c_char,
   2164         __n: usize,
   2165         __loc: locale_t,
   2166     ) -> ::std::os::raw::c_int;
   2167 }
   2168 extern "C" {
   2169     pub fn explicit_bzero(__s: *mut ::std::os::raw::c_void, __n: usize);
   2170 }
   2171 extern "C" {
   2172     pub fn strsep(
   2173         __stringp: *mut *mut ::std::os::raw::c_char,
   2174         __delim: *const ::std::os::raw::c_char,
   2175     ) -> *mut ::std::os::raw::c_char;
   2176 }
   2177 extern "C" {
   2178     pub fn strsignal(__sig: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_char;
   2179 }
   2180 extern "C" {
   2181     pub fn __stpcpy(
   2182         __dest: *mut ::std::os::raw::c_char,
   2183         __src: *const ::std::os::raw::c_char,
   2184     ) -> *mut ::std::os::raw::c_char;
   2185 }
   2186 extern "C" {
   2187     pub fn stpcpy(
   2188         __dest: *mut ::std::os::raw::c_char,
   2189         __src: *const ::std::os::raw::c_char,
   2190     ) -> *mut ::std::os::raw::c_char;
   2191 }
   2192 extern "C" {
   2193     pub fn __stpncpy(
   2194         __dest: *mut ::std::os::raw::c_char,
   2195         __src: *const ::std::os::raw::c_char,
   2196         __n: usize,
   2197     ) -> *mut ::std::os::raw::c_char;
   2198 }
   2199 extern "C" {
   2200     pub fn stpncpy(
   2201         __dest: *mut ::std::os::raw::c_char,
   2202         __src: *const ::std::os::raw::c_char,
   2203         __n: ::std::os::raw::c_ulong,
   2204     ) -> *mut ::std::os::raw::c_char;
   2205 }
   2206 extern "C" {
   2207     pub fn strlcpy(
   2208         __dest: *mut ::std::os::raw::c_char,
   2209         __src: *const ::std::os::raw::c_char,
   2210         __n: ::std::os::raw::c_ulong,
   2211     ) -> ::std::os::raw::c_ulong;
   2212 }
   2213 extern "C" {
   2214     pub fn strlcat(
   2215         __dest: *mut ::std::os::raw::c_char,
   2216         __src: *const ::std::os::raw::c_char,
   2217         __n: ::std::os::raw::c_ulong,
   2218     ) -> ::std::os::raw::c_ulong;
   2219 }
   2220 #[repr(C)]
   2221 #[derive(Debug, Copy, Clone)]
   2222 pub struct cursor {
   2223     pub start: *mut ::std::os::raw::c_uchar,
   2224     pub p: *mut ::std::os::raw::c_uchar,
   2225     pub end: *mut ::std::os::raw::c_uchar,
   2226 }
   2227 #[test]
   2228 fn bindgen_test_layout_cursor() {
   2229     const UNINIT: ::std::mem::MaybeUninit<cursor> = ::std::mem::MaybeUninit::uninit();
   2230     let ptr = UNINIT.as_ptr();
   2231     assert_eq!(
   2232         ::std::mem::size_of::<cursor>(),
   2233         24usize,
   2234         concat!("Size of: ", stringify!(cursor))
   2235     );
   2236     assert_eq!(
   2237         ::std::mem::align_of::<cursor>(),
   2238         8usize,
   2239         concat!("Alignment of ", stringify!(cursor))
   2240     );
   2241     assert_eq!(
   2242         unsafe { ::std::ptr::addr_of!((*ptr).start) as usize - ptr as usize },
   2243         0usize,
   2244         concat!(
   2245             "Offset of field: ",
   2246             stringify!(cursor),
   2247             "::",
   2248             stringify!(start)
   2249         )
   2250     );
   2251     assert_eq!(
   2252         unsafe { ::std::ptr::addr_of!((*ptr).p) as usize - ptr as usize },
   2253         8usize,
   2254         concat!("Offset of field: ", stringify!(cursor), "::", stringify!(p))
   2255     );
   2256     assert_eq!(
   2257         unsafe { ::std::ptr::addr_of!((*ptr).end) as usize - ptr as usize },
   2258         16usize,
   2259         concat!(
   2260             "Offset of field: ",
   2261             stringify!(cursor),
   2262             "::",
   2263             stringify!(end)
   2264         )
   2265     );
   2266 }
   2267 #[repr(C)]
   2268 #[derive(Debug, Copy, Clone)]
   2269 pub struct ndb_str_block {
   2270     pub str_: *const ::std::os::raw::c_char,
   2271     pub len: u32,
   2272 }
   2273 #[test]
   2274 fn bindgen_test_layout_ndb_str_block() {
   2275     const UNINIT: ::std::mem::MaybeUninit<ndb_str_block> = ::std::mem::MaybeUninit::uninit();
   2276     let ptr = UNINIT.as_ptr();
   2277     assert_eq!(
   2278         ::std::mem::size_of::<ndb_str_block>(),
   2279         16usize,
   2280         concat!("Size of: ", stringify!(ndb_str_block))
   2281     );
   2282     assert_eq!(
   2283         ::std::mem::align_of::<ndb_str_block>(),
   2284         8usize,
   2285         concat!("Alignment of ", stringify!(ndb_str_block))
   2286     );
   2287     assert_eq!(
   2288         unsafe { ::std::ptr::addr_of!((*ptr).str_) as usize - ptr as usize },
   2289         0usize,
   2290         concat!(
   2291             "Offset of field: ",
   2292             stringify!(ndb_str_block),
   2293             "::",
   2294             stringify!(str_)
   2295         )
   2296     );
   2297     assert_eq!(
   2298         unsafe { ::std::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
   2299         8usize,
   2300         concat!(
   2301             "Offset of field: ",
   2302             stringify!(ndb_str_block),
   2303             "::",
   2304             stringify!(len)
   2305         )
   2306     );
   2307 }
   2308 pub type str_block_t = ndb_str_block;
   2309 #[repr(C)]
   2310 #[derive(Debug, Copy, Clone)]
   2311 pub struct ndb_json_parser {
   2312     _unused: [u8; 0],
   2313 }
   2314 #[repr(C)]
   2315 #[derive(Debug, Copy, Clone)]
   2316 pub struct ndb {
   2317     _unused: [u8; 0],
   2318 }
   2319 #[repr(C)]
   2320 #[derive(Debug, Copy, Clone)]
   2321 pub struct ndb_blocks {
   2322     _unused: [u8; 0],
   2323 }
   2324 #[repr(C)]
   2325 #[derive(Debug, Copy, Clone)]
   2326 pub struct ndb_note {
   2327     _unused: [u8; 0],
   2328 }
   2329 #[repr(C)]
   2330 #[derive(Debug, Copy, Clone)]
   2331 pub struct ndb_tag {
   2332     _unused: [u8; 0],
   2333 }
   2334 #[repr(C)]
   2335 #[derive(Debug, Copy, Clone)]
   2336 pub struct ndb_tags {
   2337     _unused: [u8; 0],
   2338 }
   2339 #[repr(C)]
   2340 #[derive(Debug, Copy, Clone)]
   2341 pub struct ndb_lmdb {
   2342     _unused: [u8; 0],
   2343 }
   2344 #[repr(C)]
   2345 #[derive(Copy, Clone)]
   2346 pub struct ndb_packed_str {
   2347     _unused: [u8; 0],
   2348 }
   2349 #[repr(C)]
   2350 #[derive(Debug, Copy, Clone)]
   2351 pub struct bolt11 {
   2352     _unused: [u8; 0],
   2353 }
   2354 #[repr(C)]
   2355 #[derive(Debug, Copy, Clone)]
   2356 pub struct ndb_tag_ptr {
   2357     pub ptr: *mut ndb_tag,
   2358 }
   2359 #[test]
   2360 fn bindgen_test_layout_ndb_tag_ptr() {
   2361     const UNINIT: ::std::mem::MaybeUninit<ndb_tag_ptr> = ::std::mem::MaybeUninit::uninit();
   2362     let ptr = UNINIT.as_ptr();
   2363     assert_eq!(
   2364         ::std::mem::size_of::<ndb_tag_ptr>(),
   2365         8usize,
   2366         concat!("Size of: ", stringify!(ndb_tag_ptr))
   2367     );
   2368     assert_eq!(
   2369         ::std::mem::align_of::<ndb_tag_ptr>(),
   2370         8usize,
   2371         concat!("Alignment of ", stringify!(ndb_tag_ptr))
   2372     );
   2373     assert_eq!(
   2374         unsafe { ::std::ptr::addr_of!((*ptr).ptr) as usize - ptr as usize },
   2375         0usize,
   2376         concat!(
   2377             "Offset of field: ",
   2378             stringify!(ndb_tag_ptr),
   2379             "::",
   2380             stringify!(ptr)
   2381         )
   2382     );
   2383 }
   2384 #[repr(C)]
   2385 #[derive(Debug, Copy, Clone)]
   2386 pub struct ndb_tags_ptr {
   2387     pub ptr: *mut ndb_tags,
   2388 }
   2389 #[test]
   2390 fn bindgen_test_layout_ndb_tags_ptr() {
   2391     const UNINIT: ::std::mem::MaybeUninit<ndb_tags_ptr> = ::std::mem::MaybeUninit::uninit();
   2392     let ptr = UNINIT.as_ptr();
   2393     assert_eq!(
   2394         ::std::mem::size_of::<ndb_tags_ptr>(),
   2395         8usize,
   2396         concat!("Size of: ", stringify!(ndb_tags_ptr))
   2397     );
   2398     assert_eq!(
   2399         ::std::mem::align_of::<ndb_tags_ptr>(),
   2400         8usize,
   2401         concat!("Alignment of ", stringify!(ndb_tags_ptr))
   2402     );
   2403     assert_eq!(
   2404         unsafe { ::std::ptr::addr_of!((*ptr).ptr) as usize - ptr as usize },
   2405         0usize,
   2406         concat!(
   2407             "Offset of field: ",
   2408             stringify!(ndb_tags_ptr),
   2409             "::",
   2410             stringify!(ptr)
   2411         )
   2412     );
   2413 }
   2414 #[repr(C)]
   2415 #[derive(Debug, Copy, Clone)]
   2416 pub struct ndb_block_ptr {
   2417     pub ptr: *mut ndb_block,
   2418 }
   2419 #[test]
   2420 fn bindgen_test_layout_ndb_block_ptr() {
   2421     const UNINIT: ::std::mem::MaybeUninit<ndb_block_ptr> = ::std::mem::MaybeUninit::uninit();
   2422     let ptr = UNINIT.as_ptr();
   2423     assert_eq!(
   2424         ::std::mem::size_of::<ndb_block_ptr>(),
   2425         8usize,
   2426         concat!("Size of: ", stringify!(ndb_block_ptr))
   2427     );
   2428     assert_eq!(
   2429         ::std::mem::align_of::<ndb_block_ptr>(),
   2430         8usize,
   2431         concat!("Alignment of ", stringify!(ndb_block_ptr))
   2432     );
   2433     assert_eq!(
   2434         unsafe { ::std::ptr::addr_of!((*ptr).ptr) as usize - ptr as usize },
   2435         0usize,
   2436         concat!(
   2437             "Offset of field: ",
   2438             stringify!(ndb_block_ptr),
   2439             "::",
   2440             stringify!(ptr)
   2441         )
   2442     );
   2443 }
   2444 #[repr(C)]
   2445 #[derive(Debug, Copy, Clone)]
   2446 pub struct ndb_blocks_ptr {
   2447     pub ptr: *mut ndb_blocks,
   2448 }
   2449 #[test]
   2450 fn bindgen_test_layout_ndb_blocks_ptr() {
   2451     const UNINIT: ::std::mem::MaybeUninit<ndb_blocks_ptr> = ::std::mem::MaybeUninit::uninit();
   2452     let ptr = UNINIT.as_ptr();
   2453     assert_eq!(
   2454         ::std::mem::size_of::<ndb_blocks_ptr>(),
   2455         8usize,
   2456         concat!("Size of: ", stringify!(ndb_blocks_ptr))
   2457     );
   2458     assert_eq!(
   2459         ::std::mem::align_of::<ndb_blocks_ptr>(),
   2460         8usize,
   2461         concat!("Alignment of ", stringify!(ndb_blocks_ptr))
   2462     );
   2463     assert_eq!(
   2464         unsafe { ::std::ptr::addr_of!((*ptr).ptr) as usize - ptr as usize },
   2465         0usize,
   2466         concat!(
   2467             "Offset of field: ",
   2468             stringify!(ndb_blocks_ptr),
   2469             "::",
   2470             stringify!(ptr)
   2471         )
   2472     );
   2473 }
   2474 #[repr(C)]
   2475 #[derive(Debug, Copy, Clone)]
   2476 pub struct ndb_note_ptr {
   2477     pub ptr: *mut ndb_note,
   2478 }
   2479 #[test]
   2480 fn bindgen_test_layout_ndb_note_ptr() {
   2481     const UNINIT: ::std::mem::MaybeUninit<ndb_note_ptr> = ::std::mem::MaybeUninit::uninit();
   2482     let ptr = UNINIT.as_ptr();
   2483     assert_eq!(
   2484         ::std::mem::size_of::<ndb_note_ptr>(),
   2485         8usize,
   2486         concat!("Size of: ", stringify!(ndb_note_ptr))
   2487     );
   2488     assert_eq!(
   2489         ::std::mem::align_of::<ndb_note_ptr>(),
   2490         8usize,
   2491         concat!("Alignment of ", stringify!(ndb_note_ptr))
   2492     );
   2493     assert_eq!(
   2494         unsafe { ::std::ptr::addr_of!((*ptr).ptr) as usize - ptr as usize },
   2495         0usize,
   2496         concat!(
   2497             "Offset of field: ",
   2498             stringify!(ndb_note_ptr),
   2499             "::",
   2500             stringify!(ptr)
   2501         )
   2502     );
   2503 }
   2504 #[repr(C)]
   2505 #[derive(Debug, Copy, Clone)]
   2506 pub struct ndb_t {
   2507     pub ndb: *mut ndb,
   2508 }
   2509 #[test]
   2510 fn bindgen_test_layout_ndb_t() {
   2511     const UNINIT: ::std::mem::MaybeUninit<ndb_t> = ::std::mem::MaybeUninit::uninit();
   2512     let ptr = UNINIT.as_ptr();
   2513     assert_eq!(
   2514         ::std::mem::size_of::<ndb_t>(),
   2515         8usize,
   2516         concat!("Size of: ", stringify!(ndb_t))
   2517     );
   2518     assert_eq!(
   2519         ::std::mem::align_of::<ndb_t>(),
   2520         8usize,
   2521         concat!("Alignment of ", stringify!(ndb_t))
   2522     );
   2523     assert_eq!(
   2524         unsafe { ::std::ptr::addr_of!((*ptr).ndb) as usize - ptr as usize },
   2525         0usize,
   2526         concat!(
   2527             "Offset of field: ",
   2528             stringify!(ndb_t),
   2529             "::",
   2530             stringify!(ndb)
   2531         )
   2532     );
   2533 }
   2534 #[repr(C)]
   2535 #[derive(Copy, Clone)]
   2536 pub struct ndb_str {
   2537     pub flag: ::std::os::raw::c_uchar,
   2538     pub __bindgen_anon_1: ndb_str__bindgen_ty_1,
   2539 }
   2540 #[repr(C)]
   2541 #[derive(Copy, Clone)]
   2542 pub union ndb_str__bindgen_ty_1 {
   2543     pub str_: *const ::std::os::raw::c_char,
   2544     pub id: *mut ::std::os::raw::c_uchar,
   2545 }
   2546 #[test]
   2547 fn bindgen_test_layout_ndb_str__bindgen_ty_1() {
   2548     const UNINIT: ::std::mem::MaybeUninit<ndb_str__bindgen_ty_1> =
   2549         ::std::mem::MaybeUninit::uninit();
   2550     let ptr = UNINIT.as_ptr();
   2551     assert_eq!(
   2552         ::std::mem::size_of::<ndb_str__bindgen_ty_1>(),
   2553         8usize,
   2554         concat!("Size of: ", stringify!(ndb_str__bindgen_ty_1))
   2555     );
   2556     assert_eq!(
   2557         ::std::mem::align_of::<ndb_str__bindgen_ty_1>(),
   2558         8usize,
   2559         concat!("Alignment of ", stringify!(ndb_str__bindgen_ty_1))
   2560     );
   2561     assert_eq!(
   2562         unsafe { ::std::ptr::addr_of!((*ptr).str_) as usize - ptr as usize },
   2563         0usize,
   2564         concat!(
   2565             "Offset of field: ",
   2566             stringify!(ndb_str__bindgen_ty_1),
   2567             "::",
   2568             stringify!(str_)
   2569         )
   2570     );
   2571     assert_eq!(
   2572         unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
   2573         0usize,
   2574         concat!(
   2575             "Offset of field: ",
   2576             stringify!(ndb_str__bindgen_ty_1),
   2577             "::",
   2578             stringify!(id)
   2579         )
   2580     );
   2581 }
   2582 #[test]
   2583 fn bindgen_test_layout_ndb_str() {
   2584     const UNINIT: ::std::mem::MaybeUninit<ndb_str> = ::std::mem::MaybeUninit::uninit();
   2585     let ptr = UNINIT.as_ptr();
   2586     assert_eq!(
   2587         ::std::mem::size_of::<ndb_str>(),
   2588         16usize,
   2589         concat!("Size of: ", stringify!(ndb_str))
   2590     );
   2591     assert_eq!(
   2592         ::std::mem::align_of::<ndb_str>(),
   2593         8usize,
   2594         concat!("Alignment of ", stringify!(ndb_str))
   2595     );
   2596     assert_eq!(
   2597         unsafe { ::std::ptr::addr_of!((*ptr).flag) as usize - ptr as usize },
   2598         0usize,
   2599         concat!(
   2600             "Offset of field: ",
   2601             stringify!(ndb_str),
   2602             "::",
   2603             stringify!(flag)
   2604         )
   2605     );
   2606 }
   2607 #[repr(C)]
   2608 #[derive(Debug, Copy, Clone)]
   2609 pub struct ndb_keypair {
   2610     pub pubkey: [::std::os::raw::c_uchar; 32usize],
   2611     pub secret: [::std::os::raw::c_uchar; 32usize],
   2612     pub pair: [::std::os::raw::c_uchar; 96usize],
   2613 }
   2614 #[test]
   2615 fn bindgen_test_layout_ndb_keypair() {
   2616     const UNINIT: ::std::mem::MaybeUninit<ndb_keypair> = ::std::mem::MaybeUninit::uninit();
   2617     let ptr = UNINIT.as_ptr();
   2618     assert_eq!(
   2619         ::std::mem::size_of::<ndb_keypair>(),
   2620         160usize,
   2621         concat!("Size of: ", stringify!(ndb_keypair))
   2622     );
   2623     assert_eq!(
   2624         ::std::mem::align_of::<ndb_keypair>(),
   2625         1usize,
   2626         concat!("Alignment of ", stringify!(ndb_keypair))
   2627     );
   2628     assert_eq!(
   2629         unsafe { ::std::ptr::addr_of!((*ptr).pubkey) as usize - ptr as usize },
   2630         0usize,
   2631         concat!(
   2632             "Offset of field: ",
   2633             stringify!(ndb_keypair),
   2634             "::",
   2635             stringify!(pubkey)
   2636         )
   2637     );
   2638     assert_eq!(
   2639         unsafe { ::std::ptr::addr_of!((*ptr).secret) as usize - ptr as usize },
   2640         32usize,
   2641         concat!(
   2642             "Offset of field: ",
   2643             stringify!(ndb_keypair),
   2644             "::",
   2645             stringify!(secret)
   2646         )
   2647     );
   2648     assert_eq!(
   2649         unsafe { ::std::ptr::addr_of!((*ptr).pair) as usize - ptr as usize },
   2650         64usize,
   2651         concat!(
   2652             "Offset of field: ",
   2653             stringify!(ndb_keypair),
   2654             "::",
   2655             stringify!(pair)
   2656         )
   2657     );
   2658 }
   2659 pub type ndb_idres = i32;
   2660 pub type ndb_id_fn = ::std::option::Option<
   2661     unsafe extern "C" fn(
   2662         arg1: *mut ::std::os::raw::c_void,
   2663         arg2: *const ::std::os::raw::c_char,
   2664     ) -> ndb_idres,
   2665 >;
   2666 #[repr(C)]
   2667 #[derive(Debug, Copy, Clone)]
   2668 pub struct ndb_id_cb {
   2669     pub fn_: ndb_id_fn,
   2670     pub data: *mut ::std::os::raw::c_void,
   2671 }
   2672 #[test]
   2673 fn bindgen_test_layout_ndb_id_cb() {
   2674     const UNINIT: ::std::mem::MaybeUninit<ndb_id_cb> = ::std::mem::MaybeUninit::uninit();
   2675     let ptr = UNINIT.as_ptr();
   2676     assert_eq!(
   2677         ::std::mem::size_of::<ndb_id_cb>(),
   2678         16usize,
   2679         concat!("Size of: ", stringify!(ndb_id_cb))
   2680     );
   2681     assert_eq!(
   2682         ::std::mem::align_of::<ndb_id_cb>(),
   2683         8usize,
   2684         concat!("Alignment of ", stringify!(ndb_id_cb))
   2685     );
   2686     assert_eq!(
   2687         unsafe { ::std::ptr::addr_of!((*ptr).fn_) as usize - ptr as usize },
   2688         0usize,
   2689         concat!(
   2690             "Offset of field: ",
   2691             stringify!(ndb_id_cb),
   2692             "::",
   2693             stringify!(fn_)
   2694         )
   2695     );
   2696     assert_eq!(
   2697         unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
   2698         8usize,
   2699         concat!(
   2700             "Offset of field: ",
   2701             stringify!(ndb_id_cb),
   2702             "::",
   2703             stringify!(data)
   2704         )
   2705     );
   2706 }
   2707 #[repr(C)]
   2708 #[derive(Debug, Copy, Clone)]
   2709 pub struct ndb_txn {
   2710     pub lmdb: *mut ndb_lmdb,
   2711     pub mdb_txn: *mut ::std::os::raw::c_void,
   2712 }
   2713 #[test]
   2714 fn bindgen_test_layout_ndb_txn() {
   2715     const UNINIT: ::std::mem::MaybeUninit<ndb_txn> = ::std::mem::MaybeUninit::uninit();
   2716     let ptr = UNINIT.as_ptr();
   2717     assert_eq!(
   2718         ::std::mem::size_of::<ndb_txn>(),
   2719         16usize,
   2720         concat!("Size of: ", stringify!(ndb_txn))
   2721     );
   2722     assert_eq!(
   2723         ::std::mem::align_of::<ndb_txn>(),
   2724         8usize,
   2725         concat!("Alignment of ", stringify!(ndb_txn))
   2726     );
   2727     assert_eq!(
   2728         unsafe { ::std::ptr::addr_of!((*ptr).lmdb) as usize - ptr as usize },
   2729         0usize,
   2730         concat!(
   2731             "Offset of field: ",
   2732             stringify!(ndb_txn),
   2733             "::",
   2734             stringify!(lmdb)
   2735         )
   2736     );
   2737     assert_eq!(
   2738         unsafe { ::std::ptr::addr_of!((*ptr).mdb_txn) as usize - ptr as usize },
   2739         8usize,
   2740         concat!(
   2741             "Offset of field: ",
   2742             stringify!(ndb_txn),
   2743             "::",
   2744             stringify!(mdb_txn)
   2745         )
   2746     );
   2747 }
   2748 #[repr(C)]
   2749 #[derive(Debug, Copy, Clone)]
   2750 pub struct ndb_event {
   2751     pub note: *mut ndb_note,
   2752 }
   2753 #[test]
   2754 fn bindgen_test_layout_ndb_event() {
   2755     const UNINIT: ::std::mem::MaybeUninit<ndb_event> = ::std::mem::MaybeUninit::uninit();
   2756     let ptr = UNINIT.as_ptr();
   2757     assert_eq!(
   2758         ::std::mem::size_of::<ndb_event>(),
   2759         8usize,
   2760         concat!("Size of: ", stringify!(ndb_event))
   2761     );
   2762     assert_eq!(
   2763         ::std::mem::align_of::<ndb_event>(),
   2764         8usize,
   2765         concat!("Alignment of ", stringify!(ndb_event))
   2766     );
   2767     assert_eq!(
   2768         unsafe { ::std::ptr::addr_of!((*ptr).note) as usize - ptr as usize },
   2769         0usize,
   2770         concat!(
   2771             "Offset of field: ",
   2772             stringify!(ndb_event),
   2773             "::",
   2774             stringify!(note)
   2775         )
   2776     );
   2777 }
   2778 #[repr(C)]
   2779 #[derive(Debug, Copy, Clone)]
   2780 pub struct ndb_command_result {
   2781     pub ok: ::std::os::raw::c_int,
   2782     pub msg: *const ::std::os::raw::c_char,
   2783     pub msglen: ::std::os::raw::c_int,
   2784 }
   2785 #[test]
   2786 fn bindgen_test_layout_ndb_command_result() {
   2787     const UNINIT: ::std::mem::MaybeUninit<ndb_command_result> = ::std::mem::MaybeUninit::uninit();
   2788     let ptr = UNINIT.as_ptr();
   2789     assert_eq!(
   2790         ::std::mem::size_of::<ndb_command_result>(),
   2791         24usize,
   2792         concat!("Size of: ", stringify!(ndb_command_result))
   2793     );
   2794     assert_eq!(
   2795         ::std::mem::align_of::<ndb_command_result>(),
   2796         8usize,
   2797         concat!("Alignment of ", stringify!(ndb_command_result))
   2798     );
   2799     assert_eq!(
   2800         unsafe { ::std::ptr::addr_of!((*ptr).ok) as usize - ptr as usize },
   2801         0usize,
   2802         concat!(
   2803             "Offset of field: ",
   2804             stringify!(ndb_command_result),
   2805             "::",
   2806             stringify!(ok)
   2807         )
   2808     );
   2809     assert_eq!(
   2810         unsafe { ::std::ptr::addr_of!((*ptr).msg) as usize - ptr as usize },
   2811         8usize,
   2812         concat!(
   2813             "Offset of field: ",
   2814             stringify!(ndb_command_result),
   2815             "::",
   2816             stringify!(msg)
   2817         )
   2818     );
   2819     assert_eq!(
   2820         unsafe { ::std::ptr::addr_of!((*ptr).msglen) as usize - ptr as usize },
   2821         16usize,
   2822         concat!(
   2823             "Offset of field: ",
   2824             stringify!(ndb_command_result),
   2825             "::",
   2826             stringify!(msglen)
   2827         )
   2828     );
   2829 }
   2830 pub const fce_type_NDB_FCE_EVENT: fce_type = 1;
   2831 pub type fce_type = ::std::os::raw::c_uint;
   2832 pub const tce_type_NDB_TCE_EVENT: tce_type = 1;
   2833 pub const tce_type_NDB_TCE_OK: tce_type = 2;
   2834 pub const tce_type_NDB_TCE_NOTICE: tce_type = 3;
   2835 pub const tce_type_NDB_TCE_EOSE: tce_type = 4;
   2836 pub const tce_type_NDB_TCE_AUTH: tce_type = 5;
   2837 pub type tce_type = ::std::os::raw::c_uint;
   2838 pub const ndb_ingest_filter_action_NDB_INGEST_REJECT: ndb_ingest_filter_action = 0;
   2839 pub const ndb_ingest_filter_action_NDB_INGEST_ACCEPT: ndb_ingest_filter_action = 1;
   2840 pub const ndb_ingest_filter_action_NDB_INGEST_SKIP_VALIDATION: ndb_ingest_filter_action = 2;
   2841 pub type ndb_ingest_filter_action = ::std::os::raw::c_uint;
   2842 #[repr(C)]
   2843 #[derive(Debug, Copy, Clone)]
   2844 pub struct ndb_search_key {
   2845     pub search: [::std::os::raw::c_char; 24usize],
   2846     pub id: [::std::os::raw::c_uchar; 32usize],
   2847     pub timestamp: u64,
   2848 }
   2849 #[test]
   2850 fn bindgen_test_layout_ndb_search_key() {
   2851     const UNINIT: ::std::mem::MaybeUninit<ndb_search_key> = ::std::mem::MaybeUninit::uninit();
   2852     let ptr = UNINIT.as_ptr();
   2853     assert_eq!(
   2854         ::std::mem::size_of::<ndb_search_key>(),
   2855         64usize,
   2856         concat!("Size of: ", stringify!(ndb_search_key))
   2857     );
   2858     assert_eq!(
   2859         ::std::mem::align_of::<ndb_search_key>(),
   2860         8usize,
   2861         concat!("Alignment of ", stringify!(ndb_search_key))
   2862     );
   2863     assert_eq!(
   2864         unsafe { ::std::ptr::addr_of!((*ptr).search) as usize - ptr as usize },
   2865         0usize,
   2866         concat!(
   2867             "Offset of field: ",
   2868             stringify!(ndb_search_key),
   2869             "::",
   2870             stringify!(search)
   2871         )
   2872     );
   2873     assert_eq!(
   2874         unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
   2875         24usize,
   2876         concat!(
   2877             "Offset of field: ",
   2878             stringify!(ndb_search_key),
   2879             "::",
   2880             stringify!(id)
   2881         )
   2882     );
   2883     assert_eq!(
   2884         unsafe { ::std::ptr::addr_of!((*ptr).timestamp) as usize - ptr as usize },
   2885         56usize,
   2886         concat!(
   2887             "Offset of field: ",
   2888             stringify!(ndb_search_key),
   2889             "::",
   2890             stringify!(timestamp)
   2891         )
   2892     );
   2893 }
   2894 #[repr(C)]
   2895 #[derive(Debug, Copy, Clone)]
   2896 pub struct ndb_search {
   2897     pub key: *mut ndb_search_key,
   2898     pub profile_key: u64,
   2899     pub cursor: *mut ::std::os::raw::c_void,
   2900 }
   2901 #[test]
   2902 fn bindgen_test_layout_ndb_search() {
   2903     const UNINIT: ::std::mem::MaybeUninit<ndb_search> = ::std::mem::MaybeUninit::uninit();
   2904     let ptr = UNINIT.as_ptr();
   2905     assert_eq!(
   2906         ::std::mem::size_of::<ndb_search>(),
   2907         24usize,
   2908         concat!("Size of: ", stringify!(ndb_search))
   2909     );
   2910     assert_eq!(
   2911         ::std::mem::align_of::<ndb_search>(),
   2912         8usize,
   2913         concat!("Alignment of ", stringify!(ndb_search))
   2914     );
   2915     assert_eq!(
   2916         unsafe { ::std::ptr::addr_of!((*ptr).key) as usize - ptr as usize },
   2917         0usize,
   2918         concat!(
   2919             "Offset of field: ",
   2920             stringify!(ndb_search),
   2921             "::",
   2922             stringify!(key)
   2923         )
   2924     );
   2925     assert_eq!(
   2926         unsafe { ::std::ptr::addr_of!((*ptr).profile_key) as usize - ptr as usize },
   2927         8usize,
   2928         concat!(
   2929             "Offset of field: ",
   2930             stringify!(ndb_search),
   2931             "::",
   2932             stringify!(profile_key)
   2933         )
   2934     );
   2935     assert_eq!(
   2936         unsafe { ::std::ptr::addr_of!((*ptr).cursor) as usize - ptr as usize },
   2937         16usize,
   2938         concat!(
   2939             "Offset of field: ",
   2940             stringify!(ndb_search),
   2941             "::",
   2942             stringify!(cursor)
   2943         )
   2944     );
   2945 }
   2946 #[repr(C)]
   2947 #[derive(Copy, Clone)]
   2948 pub struct ndb_fce {
   2949     pub evtype: fce_type,
   2950     pub __bindgen_anon_1: ndb_fce__bindgen_ty_1,
   2951 }
   2952 #[repr(C)]
   2953 #[derive(Copy, Clone)]
   2954 pub union ndb_fce__bindgen_ty_1 {
   2955     pub event: ndb_event,
   2956 }
   2957 #[test]
   2958 fn bindgen_test_layout_ndb_fce__bindgen_ty_1() {
   2959     const UNINIT: ::std::mem::MaybeUninit<ndb_fce__bindgen_ty_1> =
   2960         ::std::mem::MaybeUninit::uninit();
   2961     let ptr = UNINIT.as_ptr();
   2962     assert_eq!(
   2963         ::std::mem::size_of::<ndb_fce__bindgen_ty_1>(),
   2964         8usize,
   2965         concat!("Size of: ", stringify!(ndb_fce__bindgen_ty_1))
   2966     );
   2967     assert_eq!(
   2968         ::std::mem::align_of::<ndb_fce__bindgen_ty_1>(),
   2969         8usize,
   2970         concat!("Alignment of ", stringify!(ndb_fce__bindgen_ty_1))
   2971     );
   2972     assert_eq!(
   2973         unsafe { ::std::ptr::addr_of!((*ptr).event) as usize - ptr as usize },
   2974         0usize,
   2975         concat!(
   2976             "Offset of field: ",
   2977             stringify!(ndb_fce__bindgen_ty_1),
   2978             "::",
   2979             stringify!(event)
   2980         )
   2981     );
   2982 }
   2983 #[test]
   2984 fn bindgen_test_layout_ndb_fce() {
   2985     const UNINIT: ::std::mem::MaybeUninit<ndb_fce> = ::std::mem::MaybeUninit::uninit();
   2986     let ptr = UNINIT.as_ptr();
   2987     assert_eq!(
   2988         ::std::mem::size_of::<ndb_fce>(),
   2989         16usize,
   2990         concat!("Size of: ", stringify!(ndb_fce))
   2991     );
   2992     assert_eq!(
   2993         ::std::mem::align_of::<ndb_fce>(),
   2994         8usize,
   2995         concat!("Alignment of ", stringify!(ndb_fce))
   2996     );
   2997     assert_eq!(
   2998         unsafe { ::std::ptr::addr_of!((*ptr).evtype) as usize - ptr as usize },
   2999         0usize,
   3000         concat!(
   3001             "Offset of field: ",
   3002             stringify!(ndb_fce),
   3003             "::",
   3004             stringify!(evtype)
   3005         )
   3006     );
   3007 }
   3008 #[repr(C)]
   3009 #[derive(Copy, Clone)]
   3010 pub struct ndb_tce {
   3011     pub evtype: tce_type,
   3012     pub subid: *const ::std::os::raw::c_char,
   3013     pub subid_len: ::std::os::raw::c_int,
   3014     pub __bindgen_anon_1: ndb_tce__bindgen_ty_1,
   3015 }
   3016 #[repr(C)]
   3017 #[derive(Copy, Clone)]
   3018 pub union ndb_tce__bindgen_ty_1 {
   3019     pub event: ndb_event,
   3020     pub command_result: ndb_command_result,
   3021 }
   3022 #[test]
   3023 fn bindgen_test_layout_ndb_tce__bindgen_ty_1() {
   3024     const UNINIT: ::std::mem::MaybeUninit<ndb_tce__bindgen_ty_1> =
   3025         ::std::mem::MaybeUninit::uninit();
   3026     let ptr = UNINIT.as_ptr();
   3027     assert_eq!(
   3028         ::std::mem::size_of::<ndb_tce__bindgen_ty_1>(),
   3029         24usize,
   3030         concat!("Size of: ", stringify!(ndb_tce__bindgen_ty_1))
   3031     );
   3032     assert_eq!(
   3033         ::std::mem::align_of::<ndb_tce__bindgen_ty_1>(),
   3034         8usize,
   3035         concat!("Alignment of ", stringify!(ndb_tce__bindgen_ty_1))
   3036     );
   3037     assert_eq!(
   3038         unsafe { ::std::ptr::addr_of!((*ptr).event) as usize - ptr as usize },
   3039         0usize,
   3040         concat!(
   3041             "Offset of field: ",
   3042             stringify!(ndb_tce__bindgen_ty_1),
   3043             "::",
   3044             stringify!(event)
   3045         )
   3046     );
   3047     assert_eq!(
   3048         unsafe { ::std::ptr::addr_of!((*ptr).command_result) as usize - ptr as usize },
   3049         0usize,
   3050         concat!(
   3051             "Offset of field: ",
   3052             stringify!(ndb_tce__bindgen_ty_1),
   3053             "::",
   3054             stringify!(command_result)
   3055         )
   3056     );
   3057 }
   3058 #[test]
   3059 fn bindgen_test_layout_ndb_tce() {
   3060     const UNINIT: ::std::mem::MaybeUninit<ndb_tce> = ::std::mem::MaybeUninit::uninit();
   3061     let ptr = UNINIT.as_ptr();
   3062     assert_eq!(
   3063         ::std::mem::size_of::<ndb_tce>(),
   3064         48usize,
   3065         concat!("Size of: ", stringify!(ndb_tce))
   3066     );
   3067     assert_eq!(
   3068         ::std::mem::align_of::<ndb_tce>(),
   3069         8usize,
   3070         concat!("Alignment of ", stringify!(ndb_tce))
   3071     );
   3072     assert_eq!(
   3073         unsafe { ::std::ptr::addr_of!((*ptr).evtype) as usize - ptr as usize },
   3074         0usize,
   3075         concat!(
   3076             "Offset of field: ",
   3077             stringify!(ndb_tce),
   3078             "::",
   3079             stringify!(evtype)
   3080         )
   3081     );
   3082     assert_eq!(
   3083         unsafe { ::std::ptr::addr_of!((*ptr).subid) as usize - ptr as usize },
   3084         8usize,
   3085         concat!(
   3086             "Offset of field: ",
   3087             stringify!(ndb_tce),
   3088             "::",
   3089             stringify!(subid)
   3090         )
   3091     );
   3092     assert_eq!(
   3093         unsafe { ::std::ptr::addr_of!((*ptr).subid_len) as usize - ptr as usize },
   3094         16usize,
   3095         concat!(
   3096             "Offset of field: ",
   3097             stringify!(ndb_tce),
   3098             "::",
   3099             stringify!(subid_len)
   3100         )
   3101     );
   3102 }
   3103 pub type ndb_ingest_filter_fn = ::std::option::Option<
   3104     unsafe extern "C" fn(
   3105         arg1: *mut ::std::os::raw::c_void,
   3106         arg2: *mut ndb_note,
   3107     ) -> ndb_ingest_filter_action,
   3108 >;
   3109 pub const ndb_filter_fieldtype_NDB_FILTER_IDS: ndb_filter_fieldtype = 1;
   3110 pub const ndb_filter_fieldtype_NDB_FILTER_AUTHORS: ndb_filter_fieldtype = 2;
   3111 pub const ndb_filter_fieldtype_NDB_FILTER_KINDS: ndb_filter_fieldtype = 3;
   3112 pub const ndb_filter_fieldtype_NDB_FILTER_TAGS: ndb_filter_fieldtype = 4;
   3113 pub const ndb_filter_fieldtype_NDB_FILTER_SINCE: ndb_filter_fieldtype = 5;
   3114 pub const ndb_filter_fieldtype_NDB_FILTER_UNTIL: ndb_filter_fieldtype = 6;
   3115 pub const ndb_filter_fieldtype_NDB_FILTER_LIMIT: ndb_filter_fieldtype = 7;
   3116 pub type ndb_filter_fieldtype = ::std::os::raw::c_uint;
   3117 pub const ndb_generic_element_type_NDB_ELEMENT_UNKNOWN: ndb_generic_element_type = 0;
   3118 pub const ndb_generic_element_type_NDB_ELEMENT_STRING: ndb_generic_element_type = 1;
   3119 pub const ndb_generic_element_type_NDB_ELEMENT_ID: ndb_generic_element_type = 2;
   3120 pub type ndb_generic_element_type = ::std::os::raw::c_uint;
   3121 pub const ndb_search_order_NDB_ORDER_DESCENDING: ndb_search_order = 0;
   3122 pub const ndb_search_order_NDB_ORDER_ASCENDING: ndb_search_order = 1;
   3123 pub type ndb_search_order = ::std::os::raw::c_uint;
   3124 pub const ndb_dbs_NDB_DB_NOTE: ndb_dbs = 0;
   3125 pub const ndb_dbs_NDB_DB_META: ndb_dbs = 1;
   3126 pub const ndb_dbs_NDB_DB_PROFILE: ndb_dbs = 2;
   3127 pub const ndb_dbs_NDB_DB_NOTE_ID: ndb_dbs = 3;
   3128 pub const ndb_dbs_NDB_DB_PROFILE_PK: ndb_dbs = 4;
   3129 pub const ndb_dbs_NDB_DB_NDB_META: ndb_dbs = 5;
   3130 pub const ndb_dbs_NDB_DB_PROFILE_SEARCH: ndb_dbs = 6;
   3131 pub const ndb_dbs_NDB_DB_PROFILE_LAST_FETCH: ndb_dbs = 7;
   3132 pub const ndb_dbs_NDB_DB_NOTE_KIND: ndb_dbs = 8;
   3133 pub const ndb_dbs_NDB_DB_NOTE_TEXT: ndb_dbs = 9;
   3134 pub const ndb_dbs_NDB_DB_NOTE_BLOCKS: ndb_dbs = 10;
   3135 pub const ndb_dbs_NDB_DB_NOTE_TAGS: ndb_dbs = 11;
   3136 pub const ndb_dbs_NDB_DBS: ndb_dbs = 12;
   3137 pub type ndb_dbs = ::std::os::raw::c_uint;
   3138 pub const ndb_common_kind_NDB_CKIND_PROFILE: ndb_common_kind = 0;
   3139 pub const ndb_common_kind_NDB_CKIND_TEXT: ndb_common_kind = 1;
   3140 pub const ndb_common_kind_NDB_CKIND_CONTACTS: ndb_common_kind = 2;
   3141 pub const ndb_common_kind_NDB_CKIND_DM: ndb_common_kind = 3;
   3142 pub const ndb_common_kind_NDB_CKIND_DELETE: ndb_common_kind = 4;
   3143 pub const ndb_common_kind_NDB_CKIND_REPOST: ndb_common_kind = 5;
   3144 pub const ndb_common_kind_NDB_CKIND_REACTION: ndb_common_kind = 6;
   3145 pub const ndb_common_kind_NDB_CKIND_ZAP: ndb_common_kind = 7;
   3146 pub const ndb_common_kind_NDB_CKIND_ZAP_REQUEST: ndb_common_kind = 8;
   3147 pub const ndb_common_kind_NDB_CKIND_NWC_REQUEST: ndb_common_kind = 9;
   3148 pub const ndb_common_kind_NDB_CKIND_NWC_RESPONSE: ndb_common_kind = 10;
   3149 pub const ndb_common_kind_NDB_CKIND_HTTP_AUTH: ndb_common_kind = 11;
   3150 pub const ndb_common_kind_NDB_CKIND_LIST: ndb_common_kind = 12;
   3151 pub const ndb_common_kind_NDB_CKIND_LONGFORM: ndb_common_kind = 13;
   3152 pub const ndb_common_kind_NDB_CKIND_STATUS: ndb_common_kind = 14;
   3153 pub const ndb_common_kind_NDB_CKIND_COUNT: ndb_common_kind = 15;
   3154 pub type ndb_common_kind = ::std::os::raw::c_uint;
   3155 #[repr(C)]
   3156 #[derive(Debug, Copy, Clone)]
   3157 pub struct ndb_builder {
   3158     pub mem: cursor,
   3159     pub note_cur: cursor,
   3160     pub strings: cursor,
   3161     pub str_indices: cursor,
   3162     pub note: *mut ndb_note,
   3163     pub current_tag: *mut ndb_tag,
   3164 }
   3165 #[test]
   3166 fn bindgen_test_layout_ndb_builder() {
   3167     const UNINIT: ::std::mem::MaybeUninit<ndb_builder> = ::std::mem::MaybeUninit::uninit();
   3168     let ptr = UNINIT.as_ptr();
   3169     assert_eq!(
   3170         ::std::mem::size_of::<ndb_builder>(),
   3171         112usize,
   3172         concat!("Size of: ", stringify!(ndb_builder))
   3173     );
   3174     assert_eq!(
   3175         ::std::mem::align_of::<ndb_builder>(),
   3176         8usize,
   3177         concat!("Alignment of ", stringify!(ndb_builder))
   3178     );
   3179     assert_eq!(
   3180         unsafe { ::std::ptr::addr_of!((*ptr).mem) as usize - ptr as usize },
   3181         0usize,
   3182         concat!(
   3183             "Offset of field: ",
   3184             stringify!(ndb_builder),
   3185             "::",
   3186             stringify!(mem)
   3187         )
   3188     );
   3189     assert_eq!(
   3190         unsafe { ::std::ptr::addr_of!((*ptr).note_cur) as usize - ptr as usize },
   3191         24usize,
   3192         concat!(
   3193             "Offset of field: ",
   3194             stringify!(ndb_builder),
   3195             "::",
   3196             stringify!(note_cur)
   3197         )
   3198     );
   3199     assert_eq!(
   3200         unsafe { ::std::ptr::addr_of!((*ptr).strings) as usize - ptr as usize },
   3201         48usize,
   3202         concat!(
   3203             "Offset of field: ",
   3204             stringify!(ndb_builder),
   3205             "::",
   3206             stringify!(strings)
   3207         )
   3208     );
   3209     assert_eq!(
   3210         unsafe { ::std::ptr::addr_of!((*ptr).str_indices) as usize - ptr as usize },
   3211         72usize,
   3212         concat!(
   3213             "Offset of field: ",
   3214             stringify!(ndb_builder),
   3215             "::",
   3216             stringify!(str_indices)
   3217         )
   3218     );
   3219     assert_eq!(
   3220         unsafe { ::std::ptr::addr_of!((*ptr).note) as usize - ptr as usize },
   3221         96usize,
   3222         concat!(
   3223             "Offset of field: ",
   3224             stringify!(ndb_builder),
   3225             "::",
   3226             stringify!(note)
   3227         )
   3228     );
   3229     assert_eq!(
   3230         unsafe { ::std::ptr::addr_of!((*ptr).current_tag) as usize - ptr as usize },
   3231         104usize,
   3232         concat!(
   3233             "Offset of field: ",
   3234             stringify!(ndb_builder),
   3235             "::",
   3236             stringify!(current_tag)
   3237         )
   3238     );
   3239 }
   3240 #[repr(C)]
   3241 #[derive(Debug, Copy, Clone)]
   3242 pub struct ndb_iterator {
   3243     pub note: *mut ndb_note,
   3244     pub tag: *mut ndb_tag,
   3245     pub index: ::std::os::raw::c_int,
   3246 }
   3247 #[test]
   3248 fn bindgen_test_layout_ndb_iterator() {
   3249     const UNINIT: ::std::mem::MaybeUninit<ndb_iterator> = ::std::mem::MaybeUninit::uninit();
   3250     let ptr = UNINIT.as_ptr();
   3251     assert_eq!(
   3252         ::std::mem::size_of::<ndb_iterator>(),
   3253         24usize,
   3254         concat!("Size of: ", stringify!(ndb_iterator))
   3255     );
   3256     assert_eq!(
   3257         ::std::mem::align_of::<ndb_iterator>(),
   3258         8usize,
   3259         concat!("Alignment of ", stringify!(ndb_iterator))
   3260     );
   3261     assert_eq!(
   3262         unsafe { ::std::ptr::addr_of!((*ptr).note) as usize - ptr as usize },
   3263         0usize,
   3264         concat!(
   3265             "Offset of field: ",
   3266             stringify!(ndb_iterator),
   3267             "::",
   3268             stringify!(note)
   3269         )
   3270     );
   3271     assert_eq!(
   3272         unsafe { ::std::ptr::addr_of!((*ptr).tag) as usize - ptr as usize },
   3273         8usize,
   3274         concat!(
   3275             "Offset of field: ",
   3276             stringify!(ndb_iterator),
   3277             "::",
   3278             stringify!(tag)
   3279         )
   3280     );
   3281     assert_eq!(
   3282         unsafe { ::std::ptr::addr_of!((*ptr).index) as usize - ptr as usize },
   3283         16usize,
   3284         concat!(
   3285             "Offset of field: ",
   3286             stringify!(ndb_iterator),
   3287             "::",
   3288             stringify!(index)
   3289         )
   3290     );
   3291 }
   3292 #[repr(C)]
   3293 #[derive(Copy, Clone)]
   3294 pub union ndb_filter_element {
   3295     pub string: *const ::std::os::raw::c_char,
   3296     pub id: *const ::std::os::raw::c_uchar,
   3297     pub integer: u64,
   3298 }
   3299 #[test]
   3300 fn bindgen_test_layout_ndb_filter_element() {
   3301     const UNINIT: ::std::mem::MaybeUninit<ndb_filter_element> = ::std::mem::MaybeUninit::uninit();
   3302     let ptr = UNINIT.as_ptr();
   3303     assert_eq!(
   3304         ::std::mem::size_of::<ndb_filter_element>(),
   3305         8usize,
   3306         concat!("Size of: ", stringify!(ndb_filter_element))
   3307     );
   3308     assert_eq!(
   3309         ::std::mem::align_of::<ndb_filter_element>(),
   3310         8usize,
   3311         concat!("Alignment of ", stringify!(ndb_filter_element))
   3312     );
   3313     assert_eq!(
   3314         unsafe { ::std::ptr::addr_of!((*ptr).string) as usize - ptr as usize },
   3315         0usize,
   3316         concat!(
   3317             "Offset of field: ",
   3318             stringify!(ndb_filter_element),
   3319             "::",
   3320             stringify!(string)
   3321         )
   3322     );
   3323     assert_eq!(
   3324         unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
   3325         0usize,
   3326         concat!(
   3327             "Offset of field: ",
   3328             stringify!(ndb_filter_element),
   3329             "::",
   3330             stringify!(id)
   3331         )
   3332     );
   3333     assert_eq!(
   3334         unsafe { ::std::ptr::addr_of!((*ptr).integer) as usize - ptr as usize },
   3335         0usize,
   3336         concat!(
   3337             "Offset of field: ",
   3338             stringify!(ndb_filter_element),
   3339             "::",
   3340             stringify!(integer)
   3341         )
   3342     );
   3343 }
   3344 #[repr(C)]
   3345 #[derive(Debug, Copy, Clone)]
   3346 pub struct ndb_filter_field {
   3347     pub type_: ndb_filter_fieldtype,
   3348     pub elem_type: ndb_generic_element_type,
   3349     pub tag: ::std::os::raw::c_char,
   3350 }
   3351 #[test]
   3352 fn bindgen_test_layout_ndb_filter_field() {
   3353     const UNINIT: ::std::mem::MaybeUninit<ndb_filter_field> = ::std::mem::MaybeUninit::uninit();
   3354     let ptr = UNINIT.as_ptr();
   3355     assert_eq!(
   3356         ::std::mem::size_of::<ndb_filter_field>(),
   3357         12usize,
   3358         concat!("Size of: ", stringify!(ndb_filter_field))
   3359     );
   3360     assert_eq!(
   3361         ::std::mem::align_of::<ndb_filter_field>(),
   3362         4usize,
   3363         concat!("Alignment of ", stringify!(ndb_filter_field))
   3364     );
   3365     assert_eq!(
   3366         unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
   3367         0usize,
   3368         concat!(
   3369             "Offset of field: ",
   3370             stringify!(ndb_filter_field),
   3371             "::",
   3372             stringify!(type_)
   3373         )
   3374     );
   3375     assert_eq!(
   3376         unsafe { ::std::ptr::addr_of!((*ptr).elem_type) as usize - ptr as usize },
   3377         4usize,
   3378         concat!(
   3379             "Offset of field: ",
   3380             stringify!(ndb_filter_field),
   3381             "::",
   3382             stringify!(elem_type)
   3383         )
   3384     );
   3385     assert_eq!(
   3386         unsafe { ::std::ptr::addr_of!((*ptr).tag) as usize - ptr as usize },
   3387         8usize,
   3388         concat!(
   3389             "Offset of field: ",
   3390             stringify!(ndb_filter_field),
   3391             "::",
   3392             stringify!(tag)
   3393         )
   3394     );
   3395 }
   3396 #[repr(C)]
   3397 #[derive(Debug)]
   3398 pub struct ndb_filter_elements {
   3399     pub field: ndb_filter_field,
   3400     pub count: ::std::os::raw::c_int,
   3401     pub elements: __IncompleteArrayField<u64>,
   3402 }
   3403 #[test]
   3404 fn bindgen_test_layout_ndb_filter_elements() {
   3405     const UNINIT: ::std::mem::MaybeUninit<ndb_filter_elements> = ::std::mem::MaybeUninit::uninit();
   3406     let ptr = UNINIT.as_ptr();
   3407     assert_eq!(
   3408         ::std::mem::size_of::<ndb_filter_elements>(),
   3409         16usize,
   3410         concat!("Size of: ", stringify!(ndb_filter_elements))
   3411     );
   3412     assert_eq!(
   3413         ::std::mem::align_of::<ndb_filter_elements>(),
   3414         8usize,
   3415         concat!("Alignment of ", stringify!(ndb_filter_elements))
   3416     );
   3417     assert_eq!(
   3418         unsafe { ::std::ptr::addr_of!((*ptr).field) as usize - ptr as usize },
   3419         0usize,
   3420         concat!(
   3421             "Offset of field: ",
   3422             stringify!(ndb_filter_elements),
   3423             "::",
   3424             stringify!(field)
   3425         )
   3426     );
   3427     assert_eq!(
   3428         unsafe { ::std::ptr::addr_of!((*ptr).count) as usize - ptr as usize },
   3429         12usize,
   3430         concat!(
   3431             "Offset of field: ",
   3432             stringify!(ndb_filter_elements),
   3433             "::",
   3434             stringify!(count)
   3435         )
   3436     );
   3437     assert_eq!(
   3438         unsafe { ::std::ptr::addr_of!((*ptr).elements) as usize - ptr as usize },
   3439         16usize,
   3440         concat!(
   3441             "Offset of field: ",
   3442             stringify!(ndb_filter_elements),
   3443             "::",
   3444             stringify!(elements)
   3445         )
   3446     );
   3447 }
   3448 #[repr(C)]
   3449 #[derive(Debug, Copy, Clone)]
   3450 pub struct ndb_filter {
   3451     pub elem_buf: cursor,
   3452     pub data_buf: cursor,
   3453     pub num_elements: ::std::os::raw::c_int,
   3454     pub finalized: ::std::os::raw::c_int,
   3455     pub current: ::std::os::raw::c_int,
   3456     pub elements: [::std::os::raw::c_int; 7usize],
   3457 }
   3458 #[test]
   3459 fn bindgen_test_layout_ndb_filter() {
   3460     const UNINIT: ::std::mem::MaybeUninit<ndb_filter> = ::std::mem::MaybeUninit::uninit();
   3461     let ptr = UNINIT.as_ptr();
   3462     assert_eq!(
   3463         ::std::mem::size_of::<ndb_filter>(),
   3464         88usize,
   3465         concat!("Size of: ", stringify!(ndb_filter))
   3466     );
   3467     assert_eq!(
   3468         ::std::mem::align_of::<ndb_filter>(),
   3469         8usize,
   3470         concat!("Alignment of ", stringify!(ndb_filter))
   3471     );
   3472     assert_eq!(
   3473         unsafe { ::std::ptr::addr_of!((*ptr).elem_buf) as usize - ptr as usize },
   3474         0usize,
   3475         concat!(
   3476             "Offset of field: ",
   3477             stringify!(ndb_filter),
   3478             "::",
   3479             stringify!(elem_buf)
   3480         )
   3481     );
   3482     assert_eq!(
   3483         unsafe { ::std::ptr::addr_of!((*ptr).data_buf) as usize - ptr as usize },
   3484         24usize,
   3485         concat!(
   3486             "Offset of field: ",
   3487             stringify!(ndb_filter),
   3488             "::",
   3489             stringify!(data_buf)
   3490         )
   3491     );
   3492     assert_eq!(
   3493         unsafe { ::std::ptr::addr_of!((*ptr).num_elements) as usize - ptr as usize },
   3494         48usize,
   3495         concat!(
   3496             "Offset of field: ",
   3497             stringify!(ndb_filter),
   3498             "::",
   3499             stringify!(num_elements)
   3500         )
   3501     );
   3502     assert_eq!(
   3503         unsafe { ::std::ptr::addr_of!((*ptr).finalized) as usize - ptr as usize },
   3504         52usize,
   3505         concat!(
   3506             "Offset of field: ",
   3507             stringify!(ndb_filter),
   3508             "::",
   3509             stringify!(finalized)
   3510         )
   3511     );
   3512     assert_eq!(
   3513         unsafe { ::std::ptr::addr_of!((*ptr).current) as usize - ptr as usize },
   3514         56usize,
   3515         concat!(
   3516             "Offset of field: ",
   3517             stringify!(ndb_filter),
   3518             "::",
   3519             stringify!(current)
   3520         )
   3521     );
   3522     assert_eq!(
   3523         unsafe { ::std::ptr::addr_of!((*ptr).elements) as usize - ptr as usize },
   3524         60usize,
   3525         concat!(
   3526             "Offset of field: ",
   3527             stringify!(ndb_filter),
   3528             "::",
   3529             stringify!(elements)
   3530         )
   3531     );
   3532 }
   3533 #[repr(C)]
   3534 #[derive(Debug, Copy, Clone)]
   3535 pub struct ndb_config {
   3536     pub flags: ::std::os::raw::c_int,
   3537     pub ingester_threads: ::std::os::raw::c_int,
   3538     pub mapsize: usize,
   3539     pub filter_context: *mut ::std::os::raw::c_void,
   3540     pub ingest_filter: ndb_ingest_filter_fn,
   3541 }
   3542 #[test]
   3543 fn bindgen_test_layout_ndb_config() {
   3544     const UNINIT: ::std::mem::MaybeUninit<ndb_config> = ::std::mem::MaybeUninit::uninit();
   3545     let ptr = UNINIT.as_ptr();
   3546     assert_eq!(
   3547         ::std::mem::size_of::<ndb_config>(),
   3548         32usize,
   3549         concat!("Size of: ", stringify!(ndb_config))
   3550     );
   3551     assert_eq!(
   3552         ::std::mem::align_of::<ndb_config>(),
   3553         8usize,
   3554         concat!("Alignment of ", stringify!(ndb_config))
   3555     );
   3556     assert_eq!(
   3557         unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
   3558         0usize,
   3559         concat!(
   3560             "Offset of field: ",
   3561             stringify!(ndb_config),
   3562             "::",
   3563             stringify!(flags)
   3564         )
   3565     );
   3566     assert_eq!(
   3567         unsafe { ::std::ptr::addr_of!((*ptr).ingester_threads) as usize - ptr as usize },
   3568         4usize,
   3569         concat!(
   3570             "Offset of field: ",
   3571             stringify!(ndb_config),
   3572             "::",
   3573             stringify!(ingester_threads)
   3574         )
   3575     );
   3576     assert_eq!(
   3577         unsafe { ::std::ptr::addr_of!((*ptr).mapsize) as usize - ptr as usize },
   3578         8usize,
   3579         concat!(
   3580             "Offset of field: ",
   3581             stringify!(ndb_config),
   3582             "::",
   3583             stringify!(mapsize)
   3584         )
   3585     );
   3586     assert_eq!(
   3587         unsafe { ::std::ptr::addr_of!((*ptr).filter_context) as usize - ptr as usize },
   3588         16usize,
   3589         concat!(
   3590             "Offset of field: ",
   3591             stringify!(ndb_config),
   3592             "::",
   3593             stringify!(filter_context)
   3594         )
   3595     );
   3596     assert_eq!(
   3597         unsafe { ::std::ptr::addr_of!((*ptr).ingest_filter) as usize - ptr as usize },
   3598         24usize,
   3599         concat!(
   3600             "Offset of field: ",
   3601             stringify!(ndb_config),
   3602             "::",
   3603             stringify!(ingest_filter)
   3604         )
   3605     );
   3606 }
   3607 #[repr(C)]
   3608 #[derive(Debug, Copy, Clone)]
   3609 pub struct ndb_text_search_config {
   3610     pub order: ndb_search_order,
   3611     pub limit: ::std::os::raw::c_int,
   3612 }
   3613 #[test]
   3614 fn bindgen_test_layout_ndb_text_search_config() {
   3615     const UNINIT: ::std::mem::MaybeUninit<ndb_text_search_config> =
   3616         ::std::mem::MaybeUninit::uninit();
   3617     let ptr = UNINIT.as_ptr();
   3618     assert_eq!(
   3619         ::std::mem::size_of::<ndb_text_search_config>(),
   3620         8usize,
   3621         concat!("Size of: ", stringify!(ndb_text_search_config))
   3622     );
   3623     assert_eq!(
   3624         ::std::mem::align_of::<ndb_text_search_config>(),
   3625         4usize,
   3626         concat!("Alignment of ", stringify!(ndb_text_search_config))
   3627     );
   3628     assert_eq!(
   3629         unsafe { ::std::ptr::addr_of!((*ptr).order) as usize - ptr as usize },
   3630         0usize,
   3631         concat!(
   3632             "Offset of field: ",
   3633             stringify!(ndb_text_search_config),
   3634             "::",
   3635             stringify!(order)
   3636         )
   3637     );
   3638     assert_eq!(
   3639         unsafe { ::std::ptr::addr_of!((*ptr).limit) as usize - ptr as usize },
   3640         4usize,
   3641         concat!(
   3642             "Offset of field: ",
   3643             stringify!(ndb_text_search_config),
   3644             "::",
   3645             stringify!(limit)
   3646         )
   3647     );
   3648 }
   3649 #[repr(C)]
   3650 #[derive(Debug, Copy, Clone)]
   3651 pub struct ndb_stat_counts {
   3652     pub key_size: usize,
   3653     pub value_size: usize,
   3654     pub count: usize,
   3655 }
   3656 #[test]
   3657 fn bindgen_test_layout_ndb_stat_counts() {
   3658     const UNINIT: ::std::mem::MaybeUninit<ndb_stat_counts> = ::std::mem::MaybeUninit::uninit();
   3659     let ptr = UNINIT.as_ptr();
   3660     assert_eq!(
   3661         ::std::mem::size_of::<ndb_stat_counts>(),
   3662         24usize,
   3663         concat!("Size of: ", stringify!(ndb_stat_counts))
   3664     );
   3665     assert_eq!(
   3666         ::std::mem::align_of::<ndb_stat_counts>(),
   3667         8usize,
   3668         concat!("Alignment of ", stringify!(ndb_stat_counts))
   3669     );
   3670     assert_eq!(
   3671         unsafe { ::std::ptr::addr_of!((*ptr).key_size) as usize - ptr as usize },
   3672         0usize,
   3673         concat!(
   3674             "Offset of field: ",
   3675             stringify!(ndb_stat_counts),
   3676             "::",
   3677             stringify!(key_size)
   3678         )
   3679     );
   3680     assert_eq!(
   3681         unsafe { ::std::ptr::addr_of!((*ptr).value_size) as usize - ptr as usize },
   3682         8usize,
   3683         concat!(
   3684             "Offset of field: ",
   3685             stringify!(ndb_stat_counts),
   3686             "::",
   3687             stringify!(value_size)
   3688         )
   3689     );
   3690     assert_eq!(
   3691         unsafe { ::std::ptr::addr_of!((*ptr).count) as usize - ptr as usize },
   3692         16usize,
   3693         concat!(
   3694             "Offset of field: ",
   3695             stringify!(ndb_stat_counts),
   3696             "::",
   3697             stringify!(count)
   3698         )
   3699     );
   3700 }
   3701 #[repr(C)]
   3702 #[derive(Debug, Copy, Clone)]
   3703 pub struct ndb_stat {
   3704     pub dbs: [ndb_stat_counts; 12usize],
   3705     pub common_kinds: [ndb_stat_counts; 15usize],
   3706     pub other_kinds: ndb_stat_counts,
   3707 }
   3708 #[test]
   3709 fn bindgen_test_layout_ndb_stat() {
   3710     const UNINIT: ::std::mem::MaybeUninit<ndb_stat> = ::std::mem::MaybeUninit::uninit();
   3711     let ptr = UNINIT.as_ptr();
   3712     assert_eq!(
   3713         ::std::mem::size_of::<ndb_stat>(),
   3714         672usize,
   3715         concat!("Size of: ", stringify!(ndb_stat))
   3716     );
   3717     assert_eq!(
   3718         ::std::mem::align_of::<ndb_stat>(),
   3719         8usize,
   3720         concat!("Alignment of ", stringify!(ndb_stat))
   3721     );
   3722     assert_eq!(
   3723         unsafe { ::std::ptr::addr_of!((*ptr).dbs) as usize - ptr as usize },
   3724         0usize,
   3725         concat!(
   3726             "Offset of field: ",
   3727             stringify!(ndb_stat),
   3728             "::",
   3729             stringify!(dbs)
   3730         )
   3731     );
   3732     assert_eq!(
   3733         unsafe { ::std::ptr::addr_of!((*ptr).common_kinds) as usize - ptr as usize },
   3734         288usize,
   3735         concat!(
   3736             "Offset of field: ",
   3737             stringify!(ndb_stat),
   3738             "::",
   3739             stringify!(common_kinds)
   3740         )
   3741     );
   3742     assert_eq!(
   3743         unsafe { ::std::ptr::addr_of!((*ptr).other_kinds) as usize - ptr as usize },
   3744         648usize,
   3745         concat!(
   3746             "Offset of field: ",
   3747             stringify!(ndb_stat),
   3748             "::",
   3749             stringify!(other_kinds)
   3750         )
   3751     );
   3752 }
   3753 #[repr(C)]
   3754 #[derive(Debug, Copy, Clone)]
   3755 pub struct ndb_text_search_key {
   3756     pub str_len: ::std::os::raw::c_int,
   3757     pub str_: *const ::std::os::raw::c_char,
   3758     pub timestamp: u64,
   3759     pub note_id: u64,
   3760     pub word_index: u64,
   3761 }
   3762 #[test]
   3763 fn bindgen_test_layout_ndb_text_search_key() {
   3764     const UNINIT: ::std::mem::MaybeUninit<ndb_text_search_key> = ::std::mem::MaybeUninit::uninit();
   3765     let ptr = UNINIT.as_ptr();
   3766     assert_eq!(
   3767         ::std::mem::size_of::<ndb_text_search_key>(),
   3768         40usize,
   3769         concat!("Size of: ", stringify!(ndb_text_search_key))
   3770     );
   3771     assert_eq!(
   3772         ::std::mem::align_of::<ndb_text_search_key>(),
   3773         8usize,
   3774         concat!("Alignment of ", stringify!(ndb_text_search_key))
   3775     );
   3776     assert_eq!(
   3777         unsafe { ::std::ptr::addr_of!((*ptr).str_len) as usize - ptr as usize },
   3778         0usize,
   3779         concat!(
   3780             "Offset of field: ",
   3781             stringify!(ndb_text_search_key),
   3782             "::",
   3783             stringify!(str_len)
   3784         )
   3785     );
   3786     assert_eq!(
   3787         unsafe { ::std::ptr::addr_of!((*ptr).str_) as usize - ptr as usize },
   3788         8usize,
   3789         concat!(
   3790             "Offset of field: ",
   3791             stringify!(ndb_text_search_key),
   3792             "::",
   3793             stringify!(str_)
   3794         )
   3795     );
   3796     assert_eq!(
   3797         unsafe { ::std::ptr::addr_of!((*ptr).timestamp) as usize - ptr as usize },
   3798         16usize,
   3799         concat!(
   3800             "Offset of field: ",
   3801             stringify!(ndb_text_search_key),
   3802             "::",
   3803             stringify!(timestamp)
   3804         )
   3805     );
   3806     assert_eq!(
   3807         unsafe { ::std::ptr::addr_of!((*ptr).note_id) as usize - ptr as usize },
   3808         24usize,
   3809         concat!(
   3810             "Offset of field: ",
   3811             stringify!(ndb_text_search_key),
   3812             "::",
   3813             stringify!(note_id)
   3814         )
   3815     );
   3816     assert_eq!(
   3817         unsafe { ::std::ptr::addr_of!((*ptr).word_index) as usize - ptr as usize },
   3818         32usize,
   3819         concat!(
   3820             "Offset of field: ",
   3821             stringify!(ndb_text_search_key),
   3822             "::",
   3823             stringify!(word_index)
   3824         )
   3825     );
   3826 }
   3827 #[repr(C)]
   3828 #[derive(Debug, Copy, Clone)]
   3829 pub struct ndb_text_search_result {
   3830     pub key: ndb_text_search_key,
   3831     pub prefix_chars: ::std::os::raw::c_int,
   3832 }
   3833 #[test]
   3834 fn bindgen_test_layout_ndb_text_search_result() {
   3835     const UNINIT: ::std::mem::MaybeUninit<ndb_text_search_result> =
   3836         ::std::mem::MaybeUninit::uninit();
   3837     let ptr = UNINIT.as_ptr();
   3838     assert_eq!(
   3839         ::std::mem::size_of::<ndb_text_search_result>(),
   3840         48usize,
   3841         concat!("Size of: ", stringify!(ndb_text_search_result))
   3842     );
   3843     assert_eq!(
   3844         ::std::mem::align_of::<ndb_text_search_result>(),
   3845         8usize,
   3846         concat!("Alignment of ", stringify!(ndb_text_search_result))
   3847     );
   3848     assert_eq!(
   3849         unsafe { ::std::ptr::addr_of!((*ptr).key) as usize - ptr as usize },
   3850         0usize,
   3851         concat!(
   3852             "Offset of field: ",
   3853             stringify!(ndb_text_search_result),
   3854             "::",
   3855             stringify!(key)
   3856         )
   3857     );
   3858     assert_eq!(
   3859         unsafe { ::std::ptr::addr_of!((*ptr).prefix_chars) as usize - ptr as usize },
   3860         40usize,
   3861         concat!(
   3862             "Offset of field: ",
   3863             stringify!(ndb_text_search_result),
   3864             "::",
   3865             stringify!(prefix_chars)
   3866         )
   3867     );
   3868 }
   3869 #[repr(C)]
   3870 #[derive(Debug, Copy, Clone)]
   3871 pub struct ndb_text_search_results {
   3872     pub results: [ndb_text_search_result; 128usize],
   3873     pub num_results: ::std::os::raw::c_int,
   3874 }
   3875 #[test]
   3876 fn bindgen_test_layout_ndb_text_search_results() {
   3877     const UNINIT: ::std::mem::MaybeUninit<ndb_text_search_results> =
   3878         ::std::mem::MaybeUninit::uninit();
   3879     let ptr = UNINIT.as_ptr();
   3880     assert_eq!(
   3881         ::std::mem::size_of::<ndb_text_search_results>(),
   3882         6152usize,
   3883         concat!("Size of: ", stringify!(ndb_text_search_results))
   3884     );
   3885     assert_eq!(
   3886         ::std::mem::align_of::<ndb_text_search_results>(),
   3887         8usize,
   3888         concat!("Alignment of ", stringify!(ndb_text_search_results))
   3889     );
   3890     assert_eq!(
   3891         unsafe { ::std::ptr::addr_of!((*ptr).results) as usize - ptr as usize },
   3892         0usize,
   3893         concat!(
   3894             "Offset of field: ",
   3895             stringify!(ndb_text_search_results),
   3896             "::",
   3897             stringify!(results)
   3898         )
   3899     );
   3900     assert_eq!(
   3901         unsafe { ::std::ptr::addr_of!((*ptr).num_results) as usize - ptr as usize },
   3902         6144usize,
   3903         concat!(
   3904             "Offset of field: ",
   3905             stringify!(ndb_text_search_results),
   3906             "::",
   3907             stringify!(num_results)
   3908         )
   3909     );
   3910 }
   3911 pub const ndb_block_type_BLOCK_HASHTAG: ndb_block_type = 1;
   3912 pub const ndb_block_type_BLOCK_TEXT: ndb_block_type = 2;
   3913 pub const ndb_block_type_BLOCK_MENTION_INDEX: ndb_block_type = 3;
   3914 pub const ndb_block_type_BLOCK_MENTION_BECH32: ndb_block_type = 4;
   3915 pub const ndb_block_type_BLOCK_URL: ndb_block_type = 5;
   3916 pub const ndb_block_type_BLOCK_INVOICE: ndb_block_type = 6;
   3917 pub type ndb_block_type = ::std::os::raw::c_uint;
   3918 #[repr(C)]
   3919 #[derive(Debug, Copy, Clone)]
   3920 pub struct ndb_relays {
   3921     pub relays: [ndb_str_block; 24usize],
   3922     pub num_relays: ::std::os::raw::c_int,
   3923 }
   3924 #[test]
   3925 fn bindgen_test_layout_ndb_relays() {
   3926     const UNINIT: ::std::mem::MaybeUninit<ndb_relays> = ::std::mem::MaybeUninit::uninit();
   3927     let ptr = UNINIT.as_ptr();
   3928     assert_eq!(
   3929         ::std::mem::size_of::<ndb_relays>(),
   3930         392usize,
   3931         concat!("Size of: ", stringify!(ndb_relays))
   3932     );
   3933     assert_eq!(
   3934         ::std::mem::align_of::<ndb_relays>(),
   3935         8usize,
   3936         concat!("Alignment of ", stringify!(ndb_relays))
   3937     );
   3938     assert_eq!(
   3939         unsafe { ::std::ptr::addr_of!((*ptr).relays) as usize - ptr as usize },
   3940         0usize,
   3941         concat!(
   3942             "Offset of field: ",
   3943             stringify!(ndb_relays),
   3944             "::",
   3945             stringify!(relays)
   3946         )
   3947     );
   3948     assert_eq!(
   3949         unsafe { ::std::ptr::addr_of!((*ptr).num_relays) as usize - ptr as usize },
   3950         384usize,
   3951         concat!(
   3952             "Offset of field: ",
   3953             stringify!(ndb_relays),
   3954             "::",
   3955             stringify!(num_relays)
   3956         )
   3957     );
   3958 }
   3959 pub const nostr_bech32_type_NOSTR_BECH32_NOTE: nostr_bech32_type = 1;
   3960 pub const nostr_bech32_type_NOSTR_BECH32_NPUB: nostr_bech32_type = 2;
   3961 pub const nostr_bech32_type_NOSTR_BECH32_NPROFILE: nostr_bech32_type = 3;
   3962 pub const nostr_bech32_type_NOSTR_BECH32_NEVENT: nostr_bech32_type = 4;
   3963 pub const nostr_bech32_type_NOSTR_BECH32_NRELAY: nostr_bech32_type = 5;
   3964 pub const nostr_bech32_type_NOSTR_BECH32_NADDR: nostr_bech32_type = 6;
   3965 pub const nostr_bech32_type_NOSTR_BECH32_NSEC: nostr_bech32_type = 7;
   3966 pub type nostr_bech32_type = ::std::os::raw::c_uint;
   3967 #[repr(C)]
   3968 #[derive(Debug, Copy, Clone)]
   3969 pub struct bech32_note {
   3970     pub event_id: *const ::std::os::raw::c_uchar,
   3971 }
   3972 #[test]
   3973 fn bindgen_test_layout_bech32_note() {
   3974     const UNINIT: ::std::mem::MaybeUninit<bech32_note> = ::std::mem::MaybeUninit::uninit();
   3975     let ptr = UNINIT.as_ptr();
   3976     assert_eq!(
   3977         ::std::mem::size_of::<bech32_note>(),
   3978         8usize,
   3979         concat!("Size of: ", stringify!(bech32_note))
   3980     );
   3981     assert_eq!(
   3982         ::std::mem::align_of::<bech32_note>(),
   3983         8usize,
   3984         concat!("Alignment of ", stringify!(bech32_note))
   3985     );
   3986     assert_eq!(
   3987         unsafe { ::std::ptr::addr_of!((*ptr).event_id) as usize - ptr as usize },
   3988         0usize,
   3989         concat!(
   3990             "Offset of field: ",
   3991             stringify!(bech32_note),
   3992             "::",
   3993             stringify!(event_id)
   3994         )
   3995     );
   3996 }
   3997 #[repr(C)]
   3998 #[derive(Debug, Copy, Clone)]
   3999 pub struct bech32_npub {
   4000     pub pubkey: *const ::std::os::raw::c_uchar,
   4001 }
   4002 #[test]
   4003 fn bindgen_test_layout_bech32_npub() {
   4004     const UNINIT: ::std::mem::MaybeUninit<bech32_npub> = ::std::mem::MaybeUninit::uninit();
   4005     let ptr = UNINIT.as_ptr();
   4006     assert_eq!(
   4007         ::std::mem::size_of::<bech32_npub>(),
   4008         8usize,
   4009         concat!("Size of: ", stringify!(bech32_npub))
   4010     );
   4011     assert_eq!(
   4012         ::std::mem::align_of::<bech32_npub>(),
   4013         8usize,
   4014         concat!("Alignment of ", stringify!(bech32_npub))
   4015     );
   4016     assert_eq!(
   4017         unsafe { ::std::ptr::addr_of!((*ptr).pubkey) as usize - ptr as usize },
   4018         0usize,
   4019         concat!(
   4020             "Offset of field: ",
   4021             stringify!(bech32_npub),
   4022             "::",
   4023             stringify!(pubkey)
   4024         )
   4025     );
   4026 }
   4027 #[repr(C)]
   4028 #[derive(Debug, Copy, Clone)]
   4029 pub struct bech32_nsec {
   4030     pub nsec: *const ::std::os::raw::c_uchar,
   4031 }
   4032 #[test]
   4033 fn bindgen_test_layout_bech32_nsec() {
   4034     const UNINIT: ::std::mem::MaybeUninit<bech32_nsec> = ::std::mem::MaybeUninit::uninit();
   4035     let ptr = UNINIT.as_ptr();
   4036     assert_eq!(
   4037         ::std::mem::size_of::<bech32_nsec>(),
   4038         8usize,
   4039         concat!("Size of: ", stringify!(bech32_nsec))
   4040     );
   4041     assert_eq!(
   4042         ::std::mem::align_of::<bech32_nsec>(),
   4043         8usize,
   4044         concat!("Alignment of ", stringify!(bech32_nsec))
   4045     );
   4046     assert_eq!(
   4047         unsafe { ::std::ptr::addr_of!((*ptr).nsec) as usize - ptr as usize },
   4048         0usize,
   4049         concat!(
   4050             "Offset of field: ",
   4051             stringify!(bech32_nsec),
   4052             "::",
   4053             stringify!(nsec)
   4054         )
   4055     );
   4056 }
   4057 #[repr(C)]
   4058 #[derive(Debug, Copy, Clone)]
   4059 pub struct bech32_nevent {
   4060     pub relays: ndb_relays,
   4061     pub event_id: *const ::std::os::raw::c_uchar,
   4062     pub pubkey: *const ::std::os::raw::c_uchar,
   4063 }
   4064 #[test]
   4065 fn bindgen_test_layout_bech32_nevent() {
   4066     const UNINIT: ::std::mem::MaybeUninit<bech32_nevent> = ::std::mem::MaybeUninit::uninit();
   4067     let ptr = UNINIT.as_ptr();
   4068     assert_eq!(
   4069         ::std::mem::size_of::<bech32_nevent>(),
   4070         408usize,
   4071         concat!("Size of: ", stringify!(bech32_nevent))
   4072     );
   4073     assert_eq!(
   4074         ::std::mem::align_of::<bech32_nevent>(),
   4075         8usize,
   4076         concat!("Alignment of ", stringify!(bech32_nevent))
   4077     );
   4078     assert_eq!(
   4079         unsafe { ::std::ptr::addr_of!((*ptr).relays) as usize - ptr as usize },
   4080         0usize,
   4081         concat!(
   4082             "Offset of field: ",
   4083             stringify!(bech32_nevent),
   4084             "::",
   4085             stringify!(relays)
   4086         )
   4087     );
   4088     assert_eq!(
   4089         unsafe { ::std::ptr::addr_of!((*ptr).event_id) as usize - ptr as usize },
   4090         392usize,
   4091         concat!(
   4092             "Offset of field: ",
   4093             stringify!(bech32_nevent),
   4094             "::",
   4095             stringify!(event_id)
   4096         )
   4097     );
   4098     assert_eq!(
   4099         unsafe { ::std::ptr::addr_of!((*ptr).pubkey) as usize - ptr as usize },
   4100         400usize,
   4101         concat!(
   4102             "Offset of field: ",
   4103             stringify!(bech32_nevent),
   4104             "::",
   4105             stringify!(pubkey)
   4106         )
   4107     );
   4108 }
   4109 #[repr(C)]
   4110 #[derive(Debug, Copy, Clone)]
   4111 pub struct bech32_nprofile {
   4112     pub relays: ndb_relays,
   4113     pub pubkey: *const ::std::os::raw::c_uchar,
   4114 }
   4115 #[test]
   4116 fn bindgen_test_layout_bech32_nprofile() {
   4117     const UNINIT: ::std::mem::MaybeUninit<bech32_nprofile> = ::std::mem::MaybeUninit::uninit();
   4118     let ptr = UNINIT.as_ptr();
   4119     assert_eq!(
   4120         ::std::mem::size_of::<bech32_nprofile>(),
   4121         400usize,
   4122         concat!("Size of: ", stringify!(bech32_nprofile))
   4123     );
   4124     assert_eq!(
   4125         ::std::mem::align_of::<bech32_nprofile>(),
   4126         8usize,
   4127         concat!("Alignment of ", stringify!(bech32_nprofile))
   4128     );
   4129     assert_eq!(
   4130         unsafe { ::std::ptr::addr_of!((*ptr).relays) as usize - ptr as usize },
   4131         0usize,
   4132         concat!(
   4133             "Offset of field: ",
   4134             stringify!(bech32_nprofile),
   4135             "::",
   4136             stringify!(relays)
   4137         )
   4138     );
   4139     assert_eq!(
   4140         unsafe { ::std::ptr::addr_of!((*ptr).pubkey) as usize - ptr as usize },
   4141         392usize,
   4142         concat!(
   4143             "Offset of field: ",
   4144             stringify!(bech32_nprofile),
   4145             "::",
   4146             stringify!(pubkey)
   4147         )
   4148     );
   4149 }
   4150 #[repr(C)]
   4151 #[derive(Debug, Copy, Clone)]
   4152 pub struct bech32_naddr {
   4153     pub relays: ndb_relays,
   4154     pub identifier: ndb_str_block,
   4155     pub pubkey: *const ::std::os::raw::c_uchar,
   4156 }
   4157 #[test]
   4158 fn bindgen_test_layout_bech32_naddr() {
   4159     const UNINIT: ::std::mem::MaybeUninit<bech32_naddr> = ::std::mem::MaybeUninit::uninit();
   4160     let ptr = UNINIT.as_ptr();
   4161     assert_eq!(
   4162         ::std::mem::size_of::<bech32_naddr>(),
   4163         416usize,
   4164         concat!("Size of: ", stringify!(bech32_naddr))
   4165     );
   4166     assert_eq!(
   4167         ::std::mem::align_of::<bech32_naddr>(),
   4168         8usize,
   4169         concat!("Alignment of ", stringify!(bech32_naddr))
   4170     );
   4171     assert_eq!(
   4172         unsafe { ::std::ptr::addr_of!((*ptr).relays) as usize - ptr as usize },
   4173         0usize,
   4174         concat!(
   4175             "Offset of field: ",
   4176             stringify!(bech32_naddr),
   4177             "::",
   4178             stringify!(relays)
   4179         )
   4180     );
   4181     assert_eq!(
   4182         unsafe { ::std::ptr::addr_of!((*ptr).identifier) as usize - ptr as usize },
   4183         392usize,
   4184         concat!(
   4185             "Offset of field: ",
   4186             stringify!(bech32_naddr),
   4187             "::",
   4188             stringify!(identifier)
   4189         )
   4190     );
   4191     assert_eq!(
   4192         unsafe { ::std::ptr::addr_of!((*ptr).pubkey) as usize - ptr as usize },
   4193         408usize,
   4194         concat!(
   4195             "Offset of field: ",
   4196             stringify!(bech32_naddr),
   4197             "::",
   4198             stringify!(pubkey)
   4199         )
   4200     );
   4201 }
   4202 #[repr(C)]
   4203 #[derive(Debug, Copy, Clone)]
   4204 pub struct bech32_nrelay {
   4205     pub relay: ndb_str_block,
   4206 }
   4207 #[test]
   4208 fn bindgen_test_layout_bech32_nrelay() {
   4209     const UNINIT: ::std::mem::MaybeUninit<bech32_nrelay> = ::std::mem::MaybeUninit::uninit();
   4210     let ptr = UNINIT.as_ptr();
   4211     assert_eq!(
   4212         ::std::mem::size_of::<bech32_nrelay>(),
   4213         16usize,
   4214         concat!("Size of: ", stringify!(bech32_nrelay))
   4215     );
   4216     assert_eq!(
   4217         ::std::mem::align_of::<bech32_nrelay>(),
   4218         8usize,
   4219         concat!("Alignment of ", stringify!(bech32_nrelay))
   4220     );
   4221     assert_eq!(
   4222         unsafe { ::std::ptr::addr_of!((*ptr).relay) as usize - ptr as usize },
   4223         0usize,
   4224         concat!(
   4225             "Offset of field: ",
   4226             stringify!(bech32_nrelay),
   4227             "::",
   4228             stringify!(relay)
   4229         )
   4230     );
   4231 }
   4232 #[repr(C)]
   4233 #[derive(Copy, Clone)]
   4234 pub struct nostr_bech32 {
   4235     pub type_: nostr_bech32_type,
   4236     pub __bindgen_anon_1: nostr_bech32__bindgen_ty_1,
   4237 }
   4238 #[repr(C)]
   4239 #[derive(Copy, Clone)]
   4240 pub union nostr_bech32__bindgen_ty_1 {
   4241     pub note: bech32_note,
   4242     pub npub: bech32_npub,
   4243     pub nsec: bech32_nsec,
   4244     pub nevent: bech32_nevent,
   4245     pub nprofile: bech32_nprofile,
   4246     pub naddr: bech32_naddr,
   4247     pub nrelay: bech32_nrelay,
   4248 }
   4249 #[test]
   4250 fn bindgen_test_layout_nostr_bech32__bindgen_ty_1() {
   4251     const UNINIT: ::std::mem::MaybeUninit<nostr_bech32__bindgen_ty_1> =
   4252         ::std::mem::MaybeUninit::uninit();
   4253     let ptr = UNINIT.as_ptr();
   4254     assert_eq!(
   4255         ::std::mem::size_of::<nostr_bech32__bindgen_ty_1>(),
   4256         416usize,
   4257         concat!("Size of: ", stringify!(nostr_bech32__bindgen_ty_1))
   4258     );
   4259     assert_eq!(
   4260         ::std::mem::align_of::<nostr_bech32__bindgen_ty_1>(),
   4261         8usize,
   4262         concat!("Alignment of ", stringify!(nostr_bech32__bindgen_ty_1))
   4263     );
   4264     assert_eq!(
   4265         unsafe { ::std::ptr::addr_of!((*ptr).note) as usize - ptr as usize },
   4266         0usize,
   4267         concat!(
   4268             "Offset of field: ",
   4269             stringify!(nostr_bech32__bindgen_ty_1),
   4270             "::",
   4271             stringify!(note)
   4272         )
   4273     );
   4274     assert_eq!(
   4275         unsafe { ::std::ptr::addr_of!((*ptr).npub) as usize - ptr as usize },
   4276         0usize,
   4277         concat!(
   4278             "Offset of field: ",
   4279             stringify!(nostr_bech32__bindgen_ty_1),
   4280             "::",
   4281             stringify!(npub)
   4282         )
   4283     );
   4284     assert_eq!(
   4285         unsafe { ::std::ptr::addr_of!((*ptr).nsec) as usize - ptr as usize },
   4286         0usize,
   4287         concat!(
   4288             "Offset of field: ",
   4289             stringify!(nostr_bech32__bindgen_ty_1),
   4290             "::",
   4291             stringify!(nsec)
   4292         )
   4293     );
   4294     assert_eq!(
   4295         unsafe { ::std::ptr::addr_of!((*ptr).nevent) as usize - ptr as usize },
   4296         0usize,
   4297         concat!(
   4298             "Offset of field: ",
   4299             stringify!(nostr_bech32__bindgen_ty_1),
   4300             "::",
   4301             stringify!(nevent)
   4302         )
   4303     );
   4304     assert_eq!(
   4305         unsafe { ::std::ptr::addr_of!((*ptr).nprofile) as usize - ptr as usize },
   4306         0usize,
   4307         concat!(
   4308             "Offset of field: ",
   4309             stringify!(nostr_bech32__bindgen_ty_1),
   4310             "::",
   4311             stringify!(nprofile)
   4312         )
   4313     );
   4314     assert_eq!(
   4315         unsafe { ::std::ptr::addr_of!((*ptr).naddr) as usize - ptr as usize },
   4316         0usize,
   4317         concat!(
   4318             "Offset of field: ",
   4319             stringify!(nostr_bech32__bindgen_ty_1),
   4320             "::",
   4321             stringify!(naddr)
   4322         )
   4323     );
   4324     assert_eq!(
   4325         unsafe { ::std::ptr::addr_of!((*ptr).nrelay) as usize - ptr as usize },
   4326         0usize,
   4327         concat!(
   4328             "Offset of field: ",
   4329             stringify!(nostr_bech32__bindgen_ty_1),
   4330             "::",
   4331             stringify!(nrelay)
   4332         )
   4333     );
   4334 }
   4335 #[test]
   4336 fn bindgen_test_layout_nostr_bech32() {
   4337     const UNINIT: ::std::mem::MaybeUninit<nostr_bech32> = ::std::mem::MaybeUninit::uninit();
   4338     let ptr = UNINIT.as_ptr();
   4339     assert_eq!(
   4340         ::std::mem::size_of::<nostr_bech32>(),
   4341         424usize,
   4342         concat!("Size of: ", stringify!(nostr_bech32))
   4343     );
   4344     assert_eq!(
   4345         ::std::mem::align_of::<nostr_bech32>(),
   4346         8usize,
   4347         concat!("Alignment of ", stringify!(nostr_bech32))
   4348     );
   4349     assert_eq!(
   4350         unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
   4351         0usize,
   4352         concat!(
   4353             "Offset of field: ",
   4354             stringify!(nostr_bech32),
   4355             "::",
   4356             stringify!(type_)
   4357         )
   4358     );
   4359 }
   4360 #[repr(C)]
   4361 #[derive(Copy, Clone)]
   4362 pub struct ndb_mention_bech32_block {
   4363     pub str_: ndb_str_block,
   4364     pub bech32: nostr_bech32,
   4365 }
   4366 #[test]
   4367 fn bindgen_test_layout_ndb_mention_bech32_block() {
   4368     const UNINIT: ::std::mem::MaybeUninit<ndb_mention_bech32_block> =
   4369         ::std::mem::MaybeUninit::uninit();
   4370     let ptr = UNINIT.as_ptr();
   4371     assert_eq!(
   4372         ::std::mem::size_of::<ndb_mention_bech32_block>(),
   4373         440usize,
   4374         concat!("Size of: ", stringify!(ndb_mention_bech32_block))
   4375     );
   4376     assert_eq!(
   4377         ::std::mem::align_of::<ndb_mention_bech32_block>(),
   4378         8usize,
   4379         concat!("Alignment of ", stringify!(ndb_mention_bech32_block))
   4380     );
   4381     assert_eq!(
   4382         unsafe { ::std::ptr::addr_of!((*ptr).str_) as usize - ptr as usize },
   4383         0usize,
   4384         concat!(
   4385             "Offset of field: ",
   4386             stringify!(ndb_mention_bech32_block),
   4387             "::",
   4388             stringify!(str_)
   4389         )
   4390     );
   4391     assert_eq!(
   4392         unsafe { ::std::ptr::addr_of!((*ptr).bech32) as usize - ptr as usize },
   4393         16usize,
   4394         concat!(
   4395             "Offset of field: ",
   4396             stringify!(ndb_mention_bech32_block),
   4397             "::",
   4398             stringify!(bech32)
   4399         )
   4400     );
   4401 }
   4402 #[repr(C)]
   4403 #[derive(Debug, Copy, Clone)]
   4404 pub struct ndb_invoice {
   4405     pub version: ::std::os::raw::c_uchar,
   4406     pub amount: u64,
   4407     pub timestamp: u64,
   4408     pub expiry: u64,
   4409     pub description: *mut ::std::os::raw::c_char,
   4410     pub description_hash: *mut ::std::os::raw::c_uchar,
   4411 }
   4412 #[test]
   4413 fn bindgen_test_layout_ndb_invoice() {
   4414     const UNINIT: ::std::mem::MaybeUninit<ndb_invoice> = ::std::mem::MaybeUninit::uninit();
   4415     let ptr = UNINIT.as_ptr();
   4416     assert_eq!(
   4417         ::std::mem::size_of::<ndb_invoice>(),
   4418         48usize,
   4419         concat!("Size of: ", stringify!(ndb_invoice))
   4420     );
   4421     assert_eq!(
   4422         ::std::mem::align_of::<ndb_invoice>(),
   4423         8usize,
   4424         concat!("Alignment of ", stringify!(ndb_invoice))
   4425     );
   4426     assert_eq!(
   4427         unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize },
   4428         0usize,
   4429         concat!(
   4430             "Offset of field: ",
   4431             stringify!(ndb_invoice),
   4432             "::",
   4433             stringify!(version)
   4434         )
   4435     );
   4436     assert_eq!(
   4437         unsafe { ::std::ptr::addr_of!((*ptr).amount) as usize - ptr as usize },
   4438         8usize,
   4439         concat!(
   4440             "Offset of field: ",
   4441             stringify!(ndb_invoice),
   4442             "::",
   4443             stringify!(amount)
   4444         )
   4445     );
   4446     assert_eq!(
   4447         unsafe { ::std::ptr::addr_of!((*ptr).timestamp) as usize - ptr as usize },
   4448         16usize,
   4449         concat!(
   4450             "Offset of field: ",
   4451             stringify!(ndb_invoice),
   4452             "::",
   4453             stringify!(timestamp)
   4454         )
   4455     );
   4456     assert_eq!(
   4457         unsafe { ::std::ptr::addr_of!((*ptr).expiry) as usize - ptr as usize },
   4458         24usize,
   4459         concat!(
   4460             "Offset of field: ",
   4461             stringify!(ndb_invoice),
   4462             "::",
   4463             stringify!(expiry)
   4464         )
   4465     );
   4466     assert_eq!(
   4467         unsafe { ::std::ptr::addr_of!((*ptr).description) as usize - ptr as usize },
   4468         32usize,
   4469         concat!(
   4470             "Offset of field: ",
   4471             stringify!(ndb_invoice),
   4472             "::",
   4473             stringify!(description)
   4474         )
   4475     );
   4476     assert_eq!(
   4477         unsafe { ::std::ptr::addr_of!((*ptr).description_hash) as usize - ptr as usize },
   4478         40usize,
   4479         concat!(
   4480             "Offset of field: ",
   4481             stringify!(ndb_invoice),
   4482             "::",
   4483             stringify!(description_hash)
   4484         )
   4485     );
   4486 }
   4487 #[repr(C)]
   4488 #[derive(Debug, Copy, Clone)]
   4489 pub struct ndb_invoice_block {
   4490     pub invstr: ndb_str_block,
   4491     pub invoice: ndb_invoice,
   4492 }
   4493 #[test]
   4494 fn bindgen_test_layout_ndb_invoice_block() {
   4495     const UNINIT: ::std::mem::MaybeUninit<ndb_invoice_block> = ::std::mem::MaybeUninit::uninit();
   4496     let ptr = UNINIT.as_ptr();
   4497     assert_eq!(
   4498         ::std::mem::size_of::<ndb_invoice_block>(),
   4499         64usize,
   4500         concat!("Size of: ", stringify!(ndb_invoice_block))
   4501     );
   4502     assert_eq!(
   4503         ::std::mem::align_of::<ndb_invoice_block>(),
   4504         8usize,
   4505         concat!("Alignment of ", stringify!(ndb_invoice_block))
   4506     );
   4507     assert_eq!(
   4508         unsafe { ::std::ptr::addr_of!((*ptr).invstr) as usize - ptr as usize },
   4509         0usize,
   4510         concat!(
   4511             "Offset of field: ",
   4512             stringify!(ndb_invoice_block),
   4513             "::",
   4514             stringify!(invstr)
   4515         )
   4516     );
   4517     assert_eq!(
   4518         unsafe { ::std::ptr::addr_of!((*ptr).invoice) as usize - ptr as usize },
   4519         16usize,
   4520         concat!(
   4521             "Offset of field: ",
   4522             stringify!(ndb_invoice_block),
   4523             "::",
   4524             stringify!(invoice)
   4525         )
   4526     );
   4527 }
   4528 #[repr(C)]
   4529 #[derive(Copy, Clone)]
   4530 pub struct ndb_block {
   4531     pub type_: ndb_block_type,
   4532     pub block: ndb_block__bindgen_ty_1,
   4533 }
   4534 #[repr(C)]
   4535 #[derive(Copy, Clone)]
   4536 pub union ndb_block__bindgen_ty_1 {
   4537     pub str_: ndb_str_block,
   4538     pub invoice: ndb_invoice_block,
   4539     pub mention_bech32: ndb_mention_bech32_block,
   4540     pub mention_index: u32,
   4541 }
   4542 #[test]
   4543 fn bindgen_test_layout_ndb_block__bindgen_ty_1() {
   4544     const UNINIT: ::std::mem::MaybeUninit<ndb_block__bindgen_ty_1> =
   4545         ::std::mem::MaybeUninit::uninit();
   4546     let ptr = UNINIT.as_ptr();
   4547     assert_eq!(
   4548         ::std::mem::size_of::<ndb_block__bindgen_ty_1>(),
   4549         440usize,
   4550         concat!("Size of: ", stringify!(ndb_block__bindgen_ty_1))
   4551     );
   4552     assert_eq!(
   4553         ::std::mem::align_of::<ndb_block__bindgen_ty_1>(),
   4554         8usize,
   4555         concat!("Alignment of ", stringify!(ndb_block__bindgen_ty_1))
   4556     );
   4557     assert_eq!(
   4558         unsafe { ::std::ptr::addr_of!((*ptr).str_) as usize - ptr as usize },
   4559         0usize,
   4560         concat!(
   4561             "Offset of field: ",
   4562             stringify!(ndb_block__bindgen_ty_1),
   4563             "::",
   4564             stringify!(str_)
   4565         )
   4566     );
   4567     assert_eq!(
   4568         unsafe { ::std::ptr::addr_of!((*ptr).invoice) as usize - ptr as usize },
   4569         0usize,
   4570         concat!(
   4571             "Offset of field: ",
   4572             stringify!(ndb_block__bindgen_ty_1),
   4573             "::",
   4574             stringify!(invoice)
   4575         )
   4576     );
   4577     assert_eq!(
   4578         unsafe { ::std::ptr::addr_of!((*ptr).mention_bech32) as usize - ptr as usize },
   4579         0usize,
   4580         concat!(
   4581             "Offset of field: ",
   4582             stringify!(ndb_block__bindgen_ty_1),
   4583             "::",
   4584             stringify!(mention_bech32)
   4585         )
   4586     );
   4587     assert_eq!(
   4588         unsafe { ::std::ptr::addr_of!((*ptr).mention_index) as usize - ptr as usize },
   4589         0usize,
   4590         concat!(
   4591             "Offset of field: ",
   4592             stringify!(ndb_block__bindgen_ty_1),
   4593             "::",
   4594             stringify!(mention_index)
   4595         )
   4596     );
   4597 }
   4598 #[test]
   4599 fn bindgen_test_layout_ndb_block() {
   4600     const UNINIT: ::std::mem::MaybeUninit<ndb_block> = ::std::mem::MaybeUninit::uninit();
   4601     let ptr = UNINIT.as_ptr();
   4602     assert_eq!(
   4603         ::std::mem::size_of::<ndb_block>(),
   4604         448usize,
   4605         concat!("Size of: ", stringify!(ndb_block))
   4606     );
   4607     assert_eq!(
   4608         ::std::mem::align_of::<ndb_block>(),
   4609         8usize,
   4610         concat!("Alignment of ", stringify!(ndb_block))
   4611     );
   4612     assert_eq!(
   4613         unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
   4614         0usize,
   4615         concat!(
   4616             "Offset of field: ",
   4617             stringify!(ndb_block),
   4618             "::",
   4619             stringify!(type_)
   4620         )
   4621     );
   4622     assert_eq!(
   4623         unsafe { ::std::ptr::addr_of!((*ptr).block) as usize - ptr as usize },
   4624         8usize,
   4625         concat!(
   4626             "Offset of field: ",
   4627             stringify!(ndb_block),
   4628             "::",
   4629             stringify!(block)
   4630         )
   4631     );
   4632 }
   4633 #[repr(C)]
   4634 #[derive(Copy, Clone)]
   4635 pub struct ndb_block_iterator {
   4636     pub content: *const ::std::os::raw::c_char,
   4637     pub blocks: *mut ndb_blocks,
   4638     pub block: ndb_block,
   4639     pub p: *mut ::std::os::raw::c_uchar,
   4640 }
   4641 #[test]
   4642 fn bindgen_test_layout_ndb_block_iterator() {
   4643     const UNINIT: ::std::mem::MaybeUninit<ndb_block_iterator> = ::std::mem::MaybeUninit::uninit();
   4644     let ptr = UNINIT.as_ptr();
   4645     assert_eq!(
   4646         ::std::mem::size_of::<ndb_block_iterator>(),
   4647         472usize,
   4648         concat!("Size of: ", stringify!(ndb_block_iterator))
   4649     );
   4650     assert_eq!(
   4651         ::std::mem::align_of::<ndb_block_iterator>(),
   4652         8usize,
   4653         concat!("Alignment of ", stringify!(ndb_block_iterator))
   4654     );
   4655     assert_eq!(
   4656         unsafe { ::std::ptr::addr_of!((*ptr).content) as usize - ptr as usize },
   4657         0usize,
   4658         concat!(
   4659             "Offset of field: ",
   4660             stringify!(ndb_block_iterator),
   4661             "::",
   4662             stringify!(content)
   4663         )
   4664     );
   4665     assert_eq!(
   4666         unsafe { ::std::ptr::addr_of!((*ptr).blocks) as usize - ptr as usize },
   4667         8usize,
   4668         concat!(
   4669             "Offset of field: ",
   4670             stringify!(ndb_block_iterator),
   4671             "::",
   4672             stringify!(blocks)
   4673         )
   4674     );
   4675     assert_eq!(
   4676         unsafe { ::std::ptr::addr_of!((*ptr).block) as usize - ptr as usize },
   4677         16usize,
   4678         concat!(
   4679             "Offset of field: ",
   4680             stringify!(ndb_block_iterator),
   4681             "::",
   4682             stringify!(block)
   4683         )
   4684     );
   4685     assert_eq!(
   4686         unsafe { ::std::ptr::addr_of!((*ptr).p) as usize - ptr as usize },
   4687         464usize,
   4688         concat!(
   4689             "Offset of field: ",
   4690             stringify!(ndb_block_iterator),
   4691             "::",
   4692             stringify!(p)
   4693         )
   4694     );
   4695 }
   4696 #[repr(C)]
   4697 #[derive(Debug, Copy, Clone)]
   4698 pub struct ndb_query_result {
   4699     pub note: *mut ndb_note,
   4700     pub note_size: u64,
   4701     pub note_id: u64,
   4702 }
   4703 #[test]
   4704 fn bindgen_test_layout_ndb_query_result() {
   4705     const UNINIT: ::std::mem::MaybeUninit<ndb_query_result> = ::std::mem::MaybeUninit::uninit();
   4706     let ptr = UNINIT.as_ptr();
   4707     assert_eq!(
   4708         ::std::mem::size_of::<ndb_query_result>(),
   4709         24usize,
   4710         concat!("Size of: ", stringify!(ndb_query_result))
   4711     );
   4712     assert_eq!(
   4713         ::std::mem::align_of::<ndb_query_result>(),
   4714         8usize,
   4715         concat!("Alignment of ", stringify!(ndb_query_result))
   4716     );
   4717     assert_eq!(
   4718         unsafe { ::std::ptr::addr_of!((*ptr).note) as usize - ptr as usize },
   4719         0usize,
   4720         concat!(
   4721             "Offset of field: ",
   4722             stringify!(ndb_query_result),
   4723             "::",
   4724             stringify!(note)
   4725         )
   4726     );
   4727     assert_eq!(
   4728         unsafe { ::std::ptr::addr_of!((*ptr).note_size) as usize - ptr as usize },
   4729         8usize,
   4730         concat!(
   4731             "Offset of field: ",
   4732             stringify!(ndb_query_result),
   4733             "::",
   4734             stringify!(note_size)
   4735         )
   4736     );
   4737     assert_eq!(
   4738         unsafe { ::std::ptr::addr_of!((*ptr).note_id) as usize - ptr as usize },
   4739         16usize,
   4740         concat!(
   4741             "Offset of field: ",
   4742             stringify!(ndb_query_result),
   4743             "::",
   4744             stringify!(note_id)
   4745         )
   4746     );
   4747 }
   4748 #[repr(C)]
   4749 #[derive(Debug, Copy, Clone)]
   4750 pub struct ndb_query_results {
   4751     pub cur: cursor,
   4752 }
   4753 #[test]
   4754 fn bindgen_test_layout_ndb_query_results() {
   4755     const UNINIT: ::std::mem::MaybeUninit<ndb_query_results> = ::std::mem::MaybeUninit::uninit();
   4756     let ptr = UNINIT.as_ptr();
   4757     assert_eq!(
   4758         ::std::mem::size_of::<ndb_query_results>(),
   4759         24usize,
   4760         concat!("Size of: ", stringify!(ndb_query_results))
   4761     );
   4762     assert_eq!(
   4763         ::std::mem::align_of::<ndb_query_results>(),
   4764         8usize,
   4765         concat!("Alignment of ", stringify!(ndb_query_results))
   4766     );
   4767     assert_eq!(
   4768         unsafe { ::std::ptr::addr_of!((*ptr).cur) as usize - ptr as usize },
   4769         0usize,
   4770         concat!(
   4771             "Offset of field: ",
   4772             stringify!(ndb_query_results),
   4773             "::",
   4774             stringify!(cur)
   4775         )
   4776     );
   4777 }
   4778 extern "C" {
   4779     pub fn ndb_default_config(arg1: *mut ndb_config);
   4780 }
   4781 extern "C" {
   4782     pub fn ndb_config_set_ingest_threads(config: *mut ndb_config, threads: ::std::os::raw::c_int);
   4783 }
   4784 extern "C" {
   4785     pub fn ndb_config_set_flags(config: *mut ndb_config, flags: ::std::os::raw::c_int);
   4786 }
   4787 extern "C" {
   4788     pub fn ndb_config_set_mapsize(config: *mut ndb_config, mapsize: usize);
   4789 }
   4790 extern "C" {
   4791     pub fn ndb_config_set_ingest_filter(
   4792         config: *mut ndb_config,
   4793         fn_: ndb_ingest_filter_fn,
   4794         arg1: *mut ::std::os::raw::c_void,
   4795     );
   4796 }
   4797 extern "C" {
   4798     pub fn ndb_calculate_id(
   4799         note: *mut ndb_note,
   4800         buf: *mut ::std::os::raw::c_uchar,
   4801         buflen: ::std::os::raw::c_int,
   4802     ) -> ::std::os::raw::c_int;
   4803 }
   4804 extern "C" {
   4805     pub fn ndb_sign_id(
   4806         keypair: *mut ndb_keypair,
   4807         id: *mut ::std::os::raw::c_uchar,
   4808         sig: *mut ::std::os::raw::c_uchar,
   4809     ) -> ::std::os::raw::c_int;
   4810 }
   4811 extern "C" {
   4812     pub fn ndb_create_keypair(key: *mut ndb_keypair) -> ::std::os::raw::c_int;
   4813 }
   4814 extern "C" {
   4815     pub fn ndb_decode_key(
   4816         secstr: *const ::std::os::raw::c_char,
   4817         keypair: *mut ndb_keypair,
   4818     ) -> ::std::os::raw::c_int;
   4819 }
   4820 extern "C" {
   4821     pub fn ndb_note_verify(
   4822         secp_ctx: *mut ::std::os::raw::c_void,
   4823         pubkey: *mut ::std::os::raw::c_uchar,
   4824         id: *mut ::std::os::raw::c_uchar,
   4825         signature: *mut ::std::os::raw::c_uchar,
   4826     ) -> ::std::os::raw::c_int;
   4827 }
   4828 extern "C" {
   4829     pub fn ndb_init(
   4830         ndb: *mut *mut ndb,
   4831         dbdir: *const ::std::os::raw::c_char,
   4832         arg1: *const ndb_config,
   4833     ) -> ::std::os::raw::c_int;
   4834 }
   4835 extern "C" {
   4836     pub fn ndb_db_version(ndb: *mut ndb) -> ::std::os::raw::c_int;
   4837 }
   4838 extern "C" {
   4839     pub fn ndb_process_event(
   4840         arg1: *mut ndb,
   4841         json: *const ::std::os::raw::c_char,
   4842         len: ::std::os::raw::c_int,
   4843     ) -> ::std::os::raw::c_int;
   4844 }
   4845 extern "C" {
   4846     pub fn ndb_process_events(
   4847         arg1: *mut ndb,
   4848         ldjson: *const ::std::os::raw::c_char,
   4849         len: usize,
   4850     ) -> ::std::os::raw::c_int;
   4851 }
   4852 extern "C" {
   4853     pub fn ndb_process_events_stream(arg1: *mut ndb, fp: *mut FILE) -> ::std::os::raw::c_int;
   4854 }
   4855 extern "C" {
   4856     pub fn ndb_process_client_event(
   4857         arg1: *mut ndb,
   4858         json: *const ::std::os::raw::c_char,
   4859         len: ::std::os::raw::c_int,
   4860     ) -> ::std::os::raw::c_int;
   4861 }
   4862 extern "C" {
   4863     pub fn ndb_process_client_events(
   4864         arg1: *mut ndb,
   4865         json: *const ::std::os::raw::c_char,
   4866         len: usize,
   4867     ) -> ::std::os::raw::c_int;
   4868 }
   4869 extern "C" {
   4870     pub fn ndb_begin_query(arg1: *mut ndb, arg2: *mut ndb_txn) -> ::std::os::raw::c_int;
   4871 }
   4872 extern "C" {
   4873     pub fn ndb_search_profile(
   4874         txn: *mut ndb_txn,
   4875         search: *mut ndb_search,
   4876         query: *const ::std::os::raw::c_char,
   4877     ) -> ::std::os::raw::c_int;
   4878 }
   4879 extern "C" {
   4880     pub fn ndb_search_profile_next(search: *mut ndb_search) -> ::std::os::raw::c_int;
   4881 }
   4882 extern "C" {
   4883     pub fn ndb_search_profile_end(search: *mut ndb_search);
   4884 }
   4885 extern "C" {
   4886     pub fn ndb_end_query(arg1: *mut ndb_txn) -> ::std::os::raw::c_int;
   4887 }
   4888 extern "C" {
   4889     pub fn ndb_write_last_profile_fetch(
   4890         ndb: *mut ndb,
   4891         pubkey: *const ::std::os::raw::c_uchar,
   4892         fetched_at: u64,
   4893     ) -> ::std::os::raw::c_int;
   4894 }
   4895 extern "C" {
   4896     pub fn ndb_read_last_profile_fetch(
   4897         txn: *mut ndb_txn,
   4898         pubkey: *const ::std::os::raw::c_uchar,
   4899     ) -> u64;
   4900 }
   4901 extern "C" {
   4902     pub fn ndb_get_profile_by_pubkey(
   4903         txn: *mut ndb_txn,
   4904         pubkey: *const ::std::os::raw::c_uchar,
   4905         len: *mut usize,
   4906         primkey: *mut u64,
   4907     ) -> *mut ::std::os::raw::c_void;
   4908 }
   4909 extern "C" {
   4910     pub fn ndb_get_profile_by_key(
   4911         txn: *mut ndb_txn,
   4912         key: u64,
   4913         len: *mut usize,
   4914     ) -> *mut ::std::os::raw::c_void;
   4915 }
   4916 extern "C" {
   4917     pub fn ndb_get_notekey_by_id(txn: *mut ndb_txn, id: *const ::std::os::raw::c_uchar) -> u64;
   4918 }
   4919 extern "C" {
   4920     pub fn ndb_get_profilekey_by_pubkey(
   4921         txn: *mut ndb_txn,
   4922         id: *const ::std::os::raw::c_uchar,
   4923     ) -> u64;
   4924 }
   4925 extern "C" {
   4926     pub fn ndb_get_note_by_id(
   4927         txn: *mut ndb_txn,
   4928         id: *const ::std::os::raw::c_uchar,
   4929         len: *mut usize,
   4930         primkey: *mut u64,
   4931     ) -> *mut ndb_note;
   4932 }
   4933 extern "C" {
   4934     pub fn ndb_get_note_by_key(txn: *mut ndb_txn, key: u64, len: *mut usize) -> *mut ndb_note;
   4935 }
   4936 extern "C" {
   4937     pub fn ndb_get_note_meta(
   4938         txn: *mut ndb_txn,
   4939         id: *const ::std::os::raw::c_uchar,
   4940         len: *mut usize,
   4941     ) -> *mut ::std::os::raw::c_void;
   4942 }
   4943 extern "C" {
   4944     pub fn ndb_destroy(arg1: *mut ndb);
   4945 }
   4946 extern "C" {
   4947     pub fn ndb_parse_json_note(
   4948         arg1: *mut ndb_json_parser,
   4949         arg2: *mut *mut ndb_note,
   4950     ) -> ::std::os::raw::c_int;
   4951 }
   4952 extern "C" {
   4953     pub fn ndb_client_event_from_json(
   4954         json: *const ::std::os::raw::c_char,
   4955         len: ::std::os::raw::c_int,
   4956         fce: *mut ndb_fce,
   4957         buf: *mut ::std::os::raw::c_uchar,
   4958         bufsize: ::std::os::raw::c_int,
   4959         cb: *mut ndb_id_cb,
   4960     ) -> ::std::os::raw::c_int;
   4961 }
   4962 extern "C" {
   4963     pub fn ndb_ws_event_from_json(
   4964         json: *const ::std::os::raw::c_char,
   4965         len: ::std::os::raw::c_int,
   4966         tce: *mut ndb_tce,
   4967         buf: *mut ::std::os::raw::c_uchar,
   4968         bufsize: ::std::os::raw::c_int,
   4969         arg1: *mut ndb_id_cb,
   4970     ) -> ::std::os::raw::c_int;
   4971 }
   4972 extern "C" {
   4973     pub fn ndb_note_from_json(
   4974         json: *const ::std::os::raw::c_char,
   4975         len: ::std::os::raw::c_int,
   4976         arg1: *mut *mut ndb_note,
   4977         buf: *mut ::std::os::raw::c_uchar,
   4978         buflen: ::std::os::raw::c_int,
   4979     ) -> ::std::os::raw::c_int;
   4980 }
   4981 extern "C" {
   4982     pub fn ndb_builder_init(
   4983         builder: *mut ndb_builder,
   4984         buf: *mut ::std::os::raw::c_uchar,
   4985         bufsize: usize,
   4986     ) -> ::std::os::raw::c_int;
   4987 }
   4988 extern "C" {
   4989     pub fn ndb_builder_finalize(
   4990         builder: *mut ndb_builder,
   4991         note: *mut *mut ndb_note,
   4992         privkey: *mut ndb_keypair,
   4993     ) -> ::std::os::raw::c_int;
   4994 }
   4995 extern "C" {
   4996     pub fn ndb_builder_set_content(
   4997         builder: *mut ndb_builder,
   4998         content: *const ::std::os::raw::c_char,
   4999         len: ::std::os::raw::c_int,
   5000     ) -> ::std::os::raw::c_int;
   5001 }
   5002 extern "C" {
   5003     pub fn ndb_builder_set_created_at(builder: *mut ndb_builder, created_at: u64);
   5004 }
   5005 extern "C" {
   5006     pub fn ndb_builder_set_sig(builder: *mut ndb_builder, sig: *mut ::std::os::raw::c_uchar);
   5007 }
   5008 extern "C" {
   5009     pub fn ndb_builder_set_pubkey(builder: *mut ndb_builder, pubkey: *mut ::std::os::raw::c_uchar);
   5010 }
   5011 extern "C" {
   5012     pub fn ndb_builder_set_id(builder: *mut ndb_builder, id: *mut ::std::os::raw::c_uchar);
   5013 }
   5014 extern "C" {
   5015     pub fn ndb_builder_set_kind(builder: *mut ndb_builder, kind: u32);
   5016 }
   5017 extern "C" {
   5018     pub fn ndb_builder_new_tag(builder: *mut ndb_builder) -> ::std::os::raw::c_int;
   5019 }
   5020 extern "C" {
   5021     pub fn ndb_builder_push_tag_str(
   5022         builder: *mut ndb_builder,
   5023         str_: *const ::std::os::raw::c_char,
   5024         len: ::std::os::raw::c_int,
   5025     ) -> ::std::os::raw::c_int;
   5026 }
   5027 extern "C" {
   5028     pub fn ndb_filter_init(arg1: *mut ndb_filter) -> ::std::os::raw::c_int;
   5029 }
   5030 extern "C" {
   5031     pub fn ndb_filter_add_id_element(
   5032         arg1: *mut ndb_filter,
   5033         id: *const ::std::os::raw::c_uchar,
   5034     ) -> ::std::os::raw::c_int;
   5035 }
   5036 extern "C" {
   5037     pub fn ndb_filter_add_int_element(arg1: *mut ndb_filter, integer: u64)
   5038         -> ::std::os::raw::c_int;
   5039 }
   5040 extern "C" {
   5041     pub fn ndb_filter_add_str_element(
   5042         arg1: *mut ndb_filter,
   5043         str_: *const ::std::os::raw::c_char,
   5044     ) -> ::std::os::raw::c_int;
   5045 }
   5046 extern "C" {
   5047     pub fn ndb_filter_current_element(arg1: *mut ndb_filter) -> *mut ndb_filter_elements;
   5048 }
   5049 extern "C" {
   5050     pub fn ndb_filter_start_field(
   5051         arg1: *mut ndb_filter,
   5052         arg2: ndb_filter_fieldtype,
   5053     ) -> ::std::os::raw::c_int;
   5054 }
   5055 extern "C" {
   5056     pub fn ndb_filter_start_tag_field(
   5057         arg1: *mut ndb_filter,
   5058         tag: ::std::os::raw::c_char,
   5059     ) -> ::std::os::raw::c_int;
   5060 }
   5061 extern "C" {
   5062     pub fn ndb_filter_matches(arg1: *mut ndb_filter, arg2: *mut ndb_note) -> ::std::os::raw::c_int;
   5063 }
   5064 extern "C" {
   5065     pub fn ndb_filter_clone(dst: *mut ndb_filter, src: *mut ndb_filter) -> ::std::os::raw::c_int;
   5066 }
   5067 extern "C" {
   5068     pub fn ndb_filter_end(arg1: *mut ndb_filter) -> ::std::os::raw::c_int;
   5069 }
   5070 extern "C" {
   5071     pub fn ndb_filter_end_field(arg1: *mut ndb_filter);
   5072 }
   5073 extern "C" {
   5074     pub fn ndb_filter_destroy(arg1: *mut ndb_filter);
   5075 }
   5076 extern "C" {
   5077     pub fn ndb_subscribe(
   5078         arg1: *mut ndb,
   5079         arg2: *mut ndb_filter,
   5080         num_filters: ::std::os::raw::c_int,
   5081     ) -> u64;
   5082 }
   5083 extern "C" {
   5084     pub fn ndb_wait_for_notes(
   5085         arg1: *mut ndb,
   5086         subid: u64,
   5087         note_ids: *mut u64,
   5088         note_id_capacity: ::std::os::raw::c_int,
   5089     ) -> ::std::os::raw::c_int;
   5090 }
   5091 extern "C" {
   5092     pub fn ndb_poll_for_notes(
   5093         arg1: *mut ndb,
   5094         subid: u64,
   5095         note_ids: *mut u64,
   5096         note_id_capacity: ::std::os::raw::c_int,
   5097     ) -> ::std::os::raw::c_int;
   5098 }
   5099 extern "C" {
   5100     pub fn ndb_unsubscribe(subid: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
   5101 }
   5102 extern "C" {
   5103     pub fn ndb_text_search(
   5104         txn: *mut ndb_txn,
   5105         query: *const ::std::os::raw::c_char,
   5106         arg1: *mut ndb_text_search_results,
   5107         arg2: *mut ndb_text_search_config,
   5108     ) -> ::std::os::raw::c_int;
   5109 }
   5110 extern "C" {
   5111     pub fn ndb_default_text_search_config(arg1: *mut ndb_text_search_config);
   5112 }
   5113 extern "C" {
   5114     pub fn ndb_text_search_config_set_order(
   5115         arg1: *mut ndb_text_search_config,
   5116         arg2: ndb_search_order,
   5117     );
   5118 }
   5119 extern "C" {
   5120     pub fn ndb_text_search_config_set_limit(
   5121         arg1: *mut ndb_text_search_config,
   5122         limit: ::std::os::raw::c_int,
   5123     );
   5124 }
   5125 extern "C" {
   5126     pub fn ndb_query(
   5127         txn: *mut ndb_txn,
   5128         filters: *mut ndb_filter,
   5129         num_filters: ::std::os::raw::c_int,
   5130         results: *mut ndb_query_result,
   5131         result_capacity: ::std::os::raw::c_int,
   5132         count: *mut ::std::os::raw::c_int,
   5133     ) -> ::std::os::raw::c_int;
   5134 }
   5135 extern "C" {
   5136     pub fn ndb_stat(ndb: *mut ndb, stat: *mut ndb_stat) -> ::std::os::raw::c_int;
   5137 }
   5138 extern "C" {
   5139     pub fn ndb_stat_counts_init(counts: *mut ndb_stat_counts);
   5140 }
   5141 extern "C" {
   5142     pub fn ndb_note_content(note: *mut ndb_note) -> *const ::std::os::raw::c_char;
   5143 }
   5144 extern "C" {
   5145     pub fn ndb_note_str(note: *mut ndb_note, pstr: *mut ndb_packed_str) -> ndb_str;
   5146 }
   5147 extern "C" {
   5148     pub fn ndb_note_content_length(note: *mut ndb_note) -> u32;
   5149 }
   5150 extern "C" {
   5151     pub fn ndb_note_created_at(note: *mut ndb_note) -> u32;
   5152 }
   5153 extern "C" {
   5154     pub fn ndb_note_kind(note: *mut ndb_note) -> u32;
   5155 }
   5156 extern "C" {
   5157     pub fn ndb_note_id(note: *mut ndb_note) -> *mut ::std::os::raw::c_uchar;
   5158 }
   5159 extern "C" {
   5160     pub fn ndb_note_pubkey(note: *mut ndb_note) -> *mut ::std::os::raw::c_uchar;
   5161 }
   5162 extern "C" {
   5163     pub fn ndb_note_sig(note: *mut ndb_note) -> *mut ::std::os::raw::c_uchar;
   5164 }
   5165 extern "C" {
   5166     pub fn _ndb_note_set_kind(note: *mut ndb_note, kind: u32);
   5167 }
   5168 extern "C" {
   5169     pub fn ndb_note_tags(note: *mut ndb_note) -> *mut ndb_tags;
   5170 }
   5171 extern "C" {
   5172     pub fn ndb_str_len(str_: *mut ndb_str) -> ::std::os::raw::c_int;
   5173 }
   5174 extern "C" {
   5175     pub fn ndb_tags_iterate_start(note: *mut ndb_note, iter: *mut ndb_iterator);
   5176 }
   5177 extern "C" {
   5178     pub fn ndb_tags_count(arg1: *mut ndb_tags) -> u16;
   5179 }
   5180 extern "C" {
   5181     pub fn ndb_tag_count(arg1: *mut ndb_tag) -> u16;
   5182 }
   5183 extern "C" {
   5184     pub fn ndb_tags_iterate_next(iter: *mut ndb_iterator) -> ::std::os::raw::c_int;
   5185 }
   5186 extern "C" {
   5187     pub fn ndb_iter_tag_str(iter: *mut ndb_iterator, ind: ::std::os::raw::c_int) -> ndb_str;
   5188 }
   5189 extern "C" {
   5190     pub fn ndb_tag_str(
   5191         note: *mut ndb_note,
   5192         tag: *mut ndb_tag,
   5193         ind: ::std::os::raw::c_int,
   5194     ) -> ndb_str;
   5195 }
   5196 extern "C" {
   5197     pub fn ndb_db_name(db: ndb_dbs) -> *const ::std::os::raw::c_char;
   5198 }
   5199 extern "C" {
   5200     pub fn ndb_kind_name(ck: ndb_common_kind) -> *const ::std::os::raw::c_char;
   5201 }
   5202 extern "C" {
   5203     pub fn ndb_kind_to_common_kind(kind: ::std::os::raw::c_int) -> ndb_common_kind;
   5204 }
   5205 extern "C" {
   5206     pub fn ndb_parse_content(
   5207         buf: *mut ::std::os::raw::c_uchar,
   5208         buf_size: ::std::os::raw::c_int,
   5209         content: *const ::std::os::raw::c_char,
   5210         content_len: ::std::os::raw::c_int,
   5211         blocks_p: *mut *mut ndb_blocks,
   5212     ) -> ::std::os::raw::c_int;
   5213 }
   5214 extern "C" {
   5215     pub fn ndb_get_block_type(block: *mut ndb_block) -> ndb_block_type;
   5216 }
   5217 extern "C" {
   5218     pub fn ndb_blocks_flags(block: *mut ndb_blocks) -> ::std::os::raw::c_int;
   5219 }
   5220 extern "C" {
   5221     pub fn ndb_blocks_total_size(blocks: *mut ndb_blocks) -> usize;
   5222 }
   5223 extern "C" {
   5224     pub fn ndb_blocks_word_count(blocks: *mut ndb_blocks) -> ::std::os::raw::c_int;
   5225 }
   5226 extern "C" {
   5227     #[doc = " Free blocks if they are owned, safe to call on unowned blocks as well."]
   5228     pub fn ndb_blocks_free(blocks: *mut ndb_blocks);
   5229 }
   5230 extern "C" {
   5231     pub fn ndb_get_blocks_by_key(
   5232         ndb: *mut ndb,
   5233         txn: *mut ndb_txn,
   5234         note_key: u64,
   5235     ) -> *mut ndb_blocks;
   5236 }
   5237 extern "C" {
   5238     pub fn ndb_blocks_iterate_start(
   5239         arg1: *const ::std::os::raw::c_char,
   5240         arg2: *mut ndb_blocks,
   5241         arg3: *mut ndb_block_iterator,
   5242     );
   5243 }
   5244 extern "C" {
   5245     pub fn ndb_blocks_iterate_next(arg1: *mut ndb_block_iterator) -> *mut ndb_block;
   5246 }
   5247 extern "C" {
   5248     pub fn ndb_block_str(arg1: *mut ndb_block) -> *mut ndb_str_block;
   5249 }
   5250 extern "C" {
   5251     pub fn ndb_str_block_ptr(arg1: *mut ndb_str_block) -> *const ::std::os::raw::c_char;
   5252 }
   5253 extern "C" {
   5254     pub fn ndb_str_block_len(arg1: *mut ndb_str_block) -> u32;
   5255 }
   5256 extern "C" {
   5257     pub fn ndb_bech32_block(block: *mut ndb_block) -> *mut nostr_bech32;
   5258 }
   5259 pub type __builtin_va_list = [__va_list_tag; 1usize];
   5260 #[repr(C)]
   5261 #[derive(Debug, Copy, Clone)]
   5262 pub struct __va_list_tag {
   5263     pub gp_offset: ::std::os::raw::c_uint,
   5264     pub fp_offset: ::std::os::raw::c_uint,
   5265     pub overflow_arg_area: *mut ::std::os::raw::c_void,
   5266     pub reg_save_area: *mut ::std::os::raw::c_void,
   5267 }
   5268 #[test]
   5269 fn bindgen_test_layout___va_list_tag() {
   5270     const UNINIT: ::std::mem::MaybeUninit<__va_list_tag> = ::std::mem::MaybeUninit::uninit();
   5271     let ptr = UNINIT.as_ptr();
   5272     assert_eq!(
   5273         ::std::mem::size_of::<__va_list_tag>(),
   5274         24usize,
   5275         concat!("Size of: ", stringify!(__va_list_tag))
   5276     );
   5277     assert_eq!(
   5278         ::std::mem::align_of::<__va_list_tag>(),
   5279         8usize,
   5280         concat!("Alignment of ", stringify!(__va_list_tag))
   5281     );
   5282     assert_eq!(
   5283         unsafe { ::std::ptr::addr_of!((*ptr).gp_offset) as usize - ptr as usize },
   5284         0usize,
   5285         concat!(
   5286             "Offset of field: ",
   5287             stringify!(__va_list_tag),
   5288             "::",
   5289             stringify!(gp_offset)
   5290         )
   5291     );
   5292     assert_eq!(
   5293         unsafe { ::std::ptr::addr_of!((*ptr).fp_offset) as usize - ptr as usize },
   5294         4usize,
   5295         concat!(
   5296             "Offset of field: ",
   5297             stringify!(__va_list_tag),
   5298             "::",
   5299             stringify!(fp_offset)
   5300         )
   5301     );
   5302     assert_eq!(
   5303         unsafe { ::std::ptr::addr_of!((*ptr).overflow_arg_area) as usize - ptr as usize },
   5304         8usize,
   5305         concat!(
   5306             "Offset of field: ",
   5307             stringify!(__va_list_tag),
   5308             "::",
   5309             stringify!(overflow_arg_area)
   5310         )
   5311     );
   5312     assert_eq!(
   5313         unsafe { ::std::ptr::addr_of!((*ptr).reg_save_area) as usize - ptr as usize },
   5314         16usize,
   5315         concat!(
   5316             "Offset of field: ",
   5317             stringify!(__va_list_tag),
   5318             "::",
   5319             stringify!(reg_save_area)
   5320         )
   5321     );
   5322 }
   5323 #[repr(C)]
   5324 #[derive(Debug, Copy, Clone)]
   5325 pub struct __locale_data {
   5326     pub _address: u8,
   5327 }