1pub type conditional_type<_If> = _If;
4#[repr(C)]
5#[derive(Debug, Copy, Clone)]
6pub struct pair<_T1, _T2> {
7 pub first: _T1,
8 pub second: _T2,
9 pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_T1>>,
10 pub _phantom_1: ::std::marker::PhantomData<::std::cell::UnsafeCell<_T2>>,
11}
12pub type pair_first_type<_T1> = _T1;
13pub type pair_second_type<_T2> = _T2;
14pub type pair__EnableB = u8;
15#[repr(C)]
16#[derive(Debug, Copy, Clone)]
17pub struct pair__CheckArgs {
18 pub _address: u8,
19}
20pub type pair__CheckArgsDep = u8;
21#[repr(C)]
22#[derive(Debug, Copy, Clone)]
23pub struct pair__CheckTupleLikeConstructor {
24 pub _address: u8,
25}
26pub type pair__CheckTLC = u8;
27pub type HHKey = [u64; 4usize];
28pub type HHResult128 = [u64; 2usize];
29pub type HHResult256 = [u64; 4usize];
30extern "C" {
31 pub fn HighwayHash64(key: *mut u64, bytes: *const ::std::os::raw::c_char, size: u64) -> u64;
32}
33extern "C" {
34 pub fn HighwayHash64_TargetPortable(
35 key: *mut u64,
36 bytes: *const ::std::os::raw::c_char,
37 size: u64,
38 ) -> u64;
39}
40extern "C" {
41 pub fn HighwayHash64_TargetSSE41(
42 key: *mut u64,
43 bytes: *const ::std::os::raw::c_char,
44 size: u64,
45 ) -> u64;
46}
47extern "C" {
48 pub fn HighwayHash64_TargetAVX2(
49 key: *mut u64,
50 bytes: *const ::std::os::raw::c_char,
51 size: u64,
52 ) -> u64;
53}
54extern "C" {
55 pub fn HighwayHash64_TargetVSX(
56 key: *mut u64,
57 bytes: *const ::std::os::raw::c_char,
58 size: u64,
59 ) -> u64;
60}
61pub type uint32 = u32;
62pub type uint64 = u64;
63pub type uint128 = pair<uint64, uint64>;
64extern "C" {
65 #[link_name = "\u{1}__Z18CityHash32WithSeedPKcmj"]
66 pub fn CityHash32WithSeed(
67 buf: *const ::std::os::raw::c_char,
68 len: usize,
69 seed: uint32,
70 ) -> uint32;
71}
72extern "C" {
73 #[link_name = "\u{1}__Z10CityHash64PKcm"]
74 pub fn CityHash64(buf: *const ::std::os::raw::c_char, len: usize) -> uint64;
75}
76extern "C" {
77 #[link_name = "\u{1}__Z18CityHash64WithSeedPKcmy"]
78 pub fn CityHash64WithSeed(
79 buf: *const ::std::os::raw::c_char,
80 len: usize,
81 seed: uint64,
82 ) -> uint64;
83}
84extern "C" {
85 #[link_name = "\u{1}__Z19CityHash64WithSeedsPKcmyy"]
86 pub fn CityHash64WithSeeds(
87 buf: *const ::std::os::raw::c_char,
88 len: usize,
89 seed0: uint64,
90 seed1: uint64,
91 ) -> uint64;
92}
93extern "C" {
94 #[link_name = "\u{1}__Z11CityHash128PKcm"]
95 pub fn CityHash128(s: *const ::std::os::raw::c_char, len: usize) -> uint128;
96}
97extern "C" {
98 #[link_name = "\u{1}__Z19CityHash128WithSeedPKcmNSt3__14pairIyyEE"]
99 pub fn CityHash128WithSeed(
100 s: *const ::std::os::raw::c_char,
101 len: usize,
102 seed: uint128,
103 ) -> uint128;
104}
105extern "C" {
106 #[link_name = "\u{1}__Z14CityHashCrc128PKcm"]
107 pub fn CityHashCrc128(s: *const ::std::os::raw::c_char, len: usize) -> uint128;
108}
109extern "C" {
110 #[link_name = "\u{1}__Z22CityHashCrc128WithSeedPKcmNSt3__14pairIyyEE"]
111 pub fn CityHashCrc128WithSeed(
112 s: *const ::std::os::raw::c_char,
113 len: usize,
114 seed: uint128,
115 ) -> uint128;
116}
117extern "C" {
118 #[link_name = "\u{1}__Z14CityHashCrc256PKcmPy"]
119 pub fn CityHashCrc256(s: *const ::std::os::raw::c_char, len: usize, result: *mut uint64);
120}
121#[repr(C)]
122#[derive(Debug, Copy, Clone)]
123pub struct uint128_c_t {
124 pub a: u64,
125 pub b: u64,
126}
127#[test]
128fn bindgen_test_layout_uint128_c_t() {
129 assert_eq!(
130 ::std::mem::size_of::<uint128_c_t>(),
131 16usize,
132 concat!("Size of: ", stringify!(uint128_c_t))
133 );
134 assert_eq!(
135 ::std::mem::align_of::<uint128_c_t>(),
136 8usize,
137 concat!("Alignment of ", stringify!(uint128_c_t))
138 );
139 assert_eq!(
140 unsafe { &(*(::std::ptr::null::<uint128_c_t>())).a as *const _ as usize },
141 0usize,
142 concat!(
143 "Offset of field: ",
144 stringify!(uint128_c_t),
145 "::",
146 stringify!(a)
147 )
148 );
149 assert_eq!(
150 unsafe { &(*(::std::ptr::null::<uint128_c_t>())).b as *const _ as usize },
151 8usize,
152 concat!(
153 "Offset of field: ",
154 stringify!(uint128_c_t),
155 "::",
156 stringify!(b)
157 )
158 );
159}
160extern "C" {
161 pub fn farmhash(s: *const ::std::os::raw::c_char, len: usize) -> usize;
162}
163extern "C" {
164 pub fn farmhash32(s: *const ::std::os::raw::c_char, len: usize) -> u32;
165}
166extern "C" {
167 pub fn farmhash32_with_seed(s: *const ::std::os::raw::c_char, len: usize, seed: u32) -> u32;
168}
169extern "C" {
170 pub fn farmhash64(s: *const ::std::os::raw::c_char, len: usize) -> u64;
171}
172extern "C" {
173 pub fn farmhash64_with_seed(s: *const ::std::os::raw::c_char, len: usize, seed: u64) -> u64;
174}
175extern "C" {
176 pub fn farmhash64_with_seeds(
177 s: *const ::std::os::raw::c_char,
178 len: usize,
179 seed0: u64,
180 seed1: u64,
181 ) -> u64;
182}
183extern "C" {
184 pub fn farmhash128(s: *const ::std::os::raw::c_char, len: usize) -> uint128_c_t;
185}
186extern "C" {
187 pub fn farmhash128_with_seed(
188 s: *const ::std::os::raw::c_char,
189 len: usize,
190 seed: uint128_c_t,
191 ) -> uint128_c_t;
192}
193extern "C" {
194 pub fn farmhash_fingerprint32(s: *const ::std::os::raw::c_char, len: usize) -> u32;
195}
196extern "C" {
197 pub fn farmhash_fingerprint64(s: *const ::std::os::raw::c_char, len: usize) -> u64;
198}
199extern "C" {
200 pub fn farmhash_fingerprint128(s: *const ::std::os::raw::c_char, len: usize) -> uint128_c_t;
201}
202pub type __m128i = [::std::os::raw::c_longlong; 2usize];
203extern "C" {
204 #[link_name = "\u{1}__ZL15MeowShiftAdjust"]
205 pub static mut MeowShiftAdjust: [::std::os::raw::c_uchar; 32usize];
206}
207extern "C" {
208 #[link_name = "\u{1}__ZL11MeowMaskLen"]
209 pub static mut MeowMaskLen: [::std::os::raw::c_uchar; 32usize];
210}
211extern "C" {
212 #[link_name = "\u{1}__ZL15MeowDefaultSeed"]
213 pub static mut MeowDefaultSeed: [::std::os::raw::c_uchar; 128usize];
214}
215#[repr(C)]
216#[repr(align(16))]
217#[derive(Debug, Copy, Clone)]
218pub struct meow_state {
219 pub xmm0: __m128i,
220 pub xmm1: __m128i,
221 pub xmm2: __m128i,
222 pub xmm3: __m128i,
223 pub xmm4: __m128i,
224 pub xmm5: __m128i,
225 pub xmm6: __m128i,
226 pub xmm7: __m128i,
227 pub TotalLengthInBytes: ::std::os::raw::c_ulonglong,
228 pub BufferLen: ::std::os::raw::c_uint,
229 pub Buffer: [::std::os::raw::c_uchar; 256usize],
230 pub Pad: [__m128i; 2usize],
231}
232#[test]
233fn bindgen_test_layout_meow_state() {
234 assert_eq!(
235 ::std::mem::size_of::<meow_state>(),
236 432usize,
237 concat!("Size of: ", stringify!(meow_state))
238 );
239 assert_eq!(
240 ::std::mem::align_of::<meow_state>(),
241 16usize,
242 concat!("Alignment of ", stringify!(meow_state))
243 );
244 assert_eq!(
245 unsafe { &(*(::std::ptr::null::<meow_state>())).xmm0 as *const _ as usize },
246 0usize,
247 concat!(
248 "Offset of field: ",
249 stringify!(meow_state),
250 "::",
251 stringify!(xmm0)
252 )
253 );
254 assert_eq!(
255 unsafe { &(*(::std::ptr::null::<meow_state>())).xmm1 as *const _ as usize },
256 16usize,
257 concat!(
258 "Offset of field: ",
259 stringify!(meow_state),
260 "::",
261 stringify!(xmm1)
262 )
263 );
264 assert_eq!(
265 unsafe { &(*(::std::ptr::null::<meow_state>())).xmm2 as *const _ as usize },
266 32usize,
267 concat!(
268 "Offset of field: ",
269 stringify!(meow_state),
270 "::",
271 stringify!(xmm2)
272 )
273 );
274 assert_eq!(
275 unsafe { &(*(::std::ptr::null::<meow_state>())).xmm3 as *const _ as usize },
276 48usize,
277 concat!(
278 "Offset of field: ",
279 stringify!(meow_state),
280 "::",
281 stringify!(xmm3)
282 )
283 );
284 assert_eq!(
285 unsafe { &(*(::std::ptr::null::<meow_state>())).xmm4 as *const _ as usize },
286 64usize,
287 concat!(
288 "Offset of field: ",
289 stringify!(meow_state),
290 "::",
291 stringify!(xmm4)
292 )
293 );
294 assert_eq!(
295 unsafe { &(*(::std::ptr::null::<meow_state>())).xmm5 as *const _ as usize },
296 80usize,
297 concat!(
298 "Offset of field: ",
299 stringify!(meow_state),
300 "::",
301 stringify!(xmm5)
302 )
303 );
304 assert_eq!(
305 unsafe { &(*(::std::ptr::null::<meow_state>())).xmm6 as *const _ as usize },
306 96usize,
307 concat!(
308 "Offset of field: ",
309 stringify!(meow_state),
310 "::",
311 stringify!(xmm6)
312 )
313 );
314 assert_eq!(
315 unsafe { &(*(::std::ptr::null::<meow_state>())).xmm7 as *const _ as usize },
316 112usize,
317 concat!(
318 "Offset of field: ",
319 stringify!(meow_state),
320 "::",
321 stringify!(xmm7)
322 )
323 );
324 assert_eq!(
325 unsafe { &(*(::std::ptr::null::<meow_state>())).TotalLengthInBytes as *const _ as usize },
326 128usize,
327 concat!(
328 "Offset of field: ",
329 stringify!(meow_state),
330 "::",
331 stringify!(TotalLengthInBytes)
332 )
333 );
334 assert_eq!(
335 unsafe { &(*(::std::ptr::null::<meow_state>())).BufferLen as *const _ as usize },
336 136usize,
337 concat!(
338 "Offset of field: ",
339 stringify!(meow_state),
340 "::",
341 stringify!(BufferLen)
342 )
343 );
344 assert_eq!(
345 unsafe { &(*(::std::ptr::null::<meow_state>())).Buffer as *const _ as usize },
346 140usize,
347 concat!(
348 "Offset of field: ",
349 stringify!(meow_state),
350 "::",
351 stringify!(Buffer)
352 )
353 );
354 assert_eq!(
355 unsafe { &(*(::std::ptr::null::<meow_state>())).Pad as *const _ as usize },
356 400usize,
357 concat!(
358 "Offset of field: ",
359 stringify!(meow_state),
360 "::",
361 stringify!(Pad)
362 )
363 );
364}
365extern "C" {
366 #[link_name = "\u{1}__Z13metrohash64_1PKhyjPh"]
367 pub fn metrohash64_1(key: *const u8, len: u64, seed: u32, out: *mut u8);
368}
369extern "C" {
370 #[link_name = "\u{1}__Z13metrohash64_2PKhyjPh"]
371 pub fn metrohash64_2(key: *const u8, len: u64, seed: u32, out: *mut u8);
372}
373extern "C" {
374 #[link_name = "\u{1}__Z16metrohash64crc_1PKhyjPh"]
375 pub fn metrohash64crc_1(key: *const u8, len: u64, seed: u32, out: *mut u8);
376}
377extern "C" {
378 #[link_name = "\u{1}__Z16metrohash64crc_2PKhyjPh"]
379 pub fn metrohash64crc_2(key: *const u8, len: u64, seed: u32, out: *mut u8);
380}
381extern "C" {
382 #[link_name = "\u{1}__Z14metrohash128_1PKhyjPh"]
383 pub fn metrohash128_1(key: *const u8, len: u64, seed: u32, out: *mut u8);
384}
385extern "C" {
386 #[link_name = "\u{1}__Z14metrohash128_2PKhyjPh"]
387 pub fn metrohash128_2(key: *const u8, len: u64, seed: u32, out: *mut u8);
388}
389extern "C" {
390 #[link_name = "\u{1}__Z17metrohash128crc_1PKhyjPh"]
391 pub fn metrohash128crc_1(key: *const u8, len: u64, seed: u32, out: *mut u8);
392}
393extern "C" {
394 #[link_name = "\u{1}__Z17metrohash128crc_2PKhyjPh"]
395 pub fn metrohash128crc_2(key: *const u8, len: u64, seed: u32, out: *mut u8);
396}
397extern "C" {
398 #[link_name = "\u{1}__Z11MurmurHash1PKvij"]
399 pub fn MurmurHash1(
400 key: *const ::std::os::raw::c_void,
401 len: ::std::os::raw::c_int,
402 seed: u32,
403 ) -> u32;
404}
405extern "C" {
406 #[link_name = "\u{1}__Z18MurmurHash1AlignedPKvij"]
407 pub fn MurmurHash1Aligned(
408 key: *const ::std::os::raw::c_void,
409 len: ::std::os::raw::c_int,
410 seed: u32,
411 ) -> u32;
412}
413extern "C" {
414 #[link_name = "\u{1}__Z11MurmurHash2PKvij"]
415 pub fn MurmurHash2(
416 key: *const ::std::os::raw::c_void,
417 len: ::std::os::raw::c_int,
418 seed: u32,
419 ) -> u32;
420}
421extern "C" {
422 #[link_name = "\u{1}__Z13MurmurHash64APKviy"]
423 pub fn MurmurHash64A(
424 key: *const ::std::os::raw::c_void,
425 len: ::std::os::raw::c_int,
426 seed: u64,
427 ) -> u64;
428}
429extern "C" {
430 #[link_name = "\u{1}__Z13MurmurHash64BPKviy"]
431 pub fn MurmurHash64B(
432 key: *const ::std::os::raw::c_void,
433 len: ::std::os::raw::c_int,
434 seed: u64,
435 ) -> u64;
436}
437extern "C" {
438 #[link_name = "\u{1}__Z12MurmurHash2APKvij"]
439 pub fn MurmurHash2A(
440 key: *const ::std::os::raw::c_void,
441 len: ::std::os::raw::c_int,
442 seed: u32,
443 ) -> u32;
444}
445extern "C" {
446 #[link_name = "\u{1}__Z18MurmurHashNeutral2PKvij"]
447 pub fn MurmurHashNeutral2(
448 key: *const ::std::os::raw::c_void,
449 len: ::std::os::raw::c_int,
450 seed: u32,
451 ) -> u32;
452}
453extern "C" {
454 #[link_name = "\u{1}__Z18MurmurHashAligned2PKvij"]
455 pub fn MurmurHashAligned2(
456 key: *const ::std::os::raw::c_void,
457 len: ::std::os::raw::c_int,
458 seed: u32,
459 ) -> u32;
460}
461extern "C" {
462 #[link_name = "\u{1}__Z18MurmurHash3_x86_32PKvijPv"]
463 pub fn MurmurHash3_x86_32(
464 key: *const ::std::os::raw::c_void,
465 len: ::std::os::raw::c_int,
466 seed: u32,
467 out: *mut ::std::os::raw::c_void,
468 );
469}
470extern "C" {
471 #[link_name = "\u{1}__Z19MurmurHash3_x86_128PKvijPv"]
472 pub fn MurmurHash3_x86_128(
473 key: *const ::std::os::raw::c_void,
474 len: ::std::os::raw::c_int,
475 seed: u32,
476 out: *mut ::std::os::raw::c_void,
477 );
478}
479extern "C" {
480 #[link_name = "\u{1}__Z19MurmurHash3_x64_128PKvijPv"]
481 pub fn MurmurHash3_x64_128(
482 key: *const ::std::os::raw::c_void,
483 len: ::std::os::raw::c_int,
484 seed: u32,
485 out: *mut ::std::os::raw::c_void,
486 );
487}
488#[repr(C)]
489#[derive(Copy, Clone)]
490pub union t1ha_state256 {
491 pub bytes: [u8; 32usize],
492 pub u32_: [u32; 8usize],
493 pub u64_: [u64; 4usize],
494 pub n: t1ha_state256__bindgen_ty_1,
495}
496#[repr(C)]
497#[derive(Debug, Copy, Clone)]
498pub struct t1ha_state256__bindgen_ty_1 {
499 pub a: u64,
500 pub b: u64,
501 pub c: u64,
502 pub d: u64,
503}
504#[test]
505fn bindgen_test_layout_t1ha_state256__bindgen_ty_1() {
506 assert_eq!(
507 ::std::mem::size_of::<t1ha_state256__bindgen_ty_1>(),
508 32usize,
509 concat!("Size of: ", stringify!(t1ha_state256__bindgen_ty_1))
510 );
511 assert_eq!(
512 ::std::mem::align_of::<t1ha_state256__bindgen_ty_1>(),
513 8usize,
514 concat!("Alignment of ", stringify!(t1ha_state256__bindgen_ty_1))
515 );
516 assert_eq!(
517 unsafe { &(*(::std::ptr::null::<t1ha_state256__bindgen_ty_1>())).a as *const _ as usize },
518 0usize,
519 concat!(
520 "Offset of field: ",
521 stringify!(t1ha_state256__bindgen_ty_1),
522 "::",
523 stringify!(a)
524 )
525 );
526 assert_eq!(
527 unsafe { &(*(::std::ptr::null::<t1ha_state256__bindgen_ty_1>())).b as *const _ as usize },
528 8usize,
529 concat!(
530 "Offset of field: ",
531 stringify!(t1ha_state256__bindgen_ty_1),
532 "::",
533 stringify!(b)
534 )
535 );
536 assert_eq!(
537 unsafe { &(*(::std::ptr::null::<t1ha_state256__bindgen_ty_1>())).c as *const _ as usize },
538 16usize,
539 concat!(
540 "Offset of field: ",
541 stringify!(t1ha_state256__bindgen_ty_1),
542 "::",
543 stringify!(c)
544 )
545 );
546 assert_eq!(
547 unsafe { &(*(::std::ptr::null::<t1ha_state256__bindgen_ty_1>())).d as *const _ as usize },
548 24usize,
549 concat!(
550 "Offset of field: ",
551 stringify!(t1ha_state256__bindgen_ty_1),
552 "::",
553 stringify!(d)
554 )
555 );
556}
557#[test]
558fn bindgen_test_layout_t1ha_state256() {
559 assert_eq!(
560 ::std::mem::size_of::<t1ha_state256>(),
561 32usize,
562 concat!("Size of: ", stringify!(t1ha_state256))
563 );
564 assert_eq!(
565 ::std::mem::align_of::<t1ha_state256>(),
566 8usize,
567 concat!("Alignment of ", stringify!(t1ha_state256))
568 );
569 assert_eq!(
570 unsafe { &(*(::std::ptr::null::<t1ha_state256>())).bytes as *const _ as usize },
571 0usize,
572 concat!(
573 "Offset of field: ",
574 stringify!(t1ha_state256),
575 "::",
576 stringify!(bytes)
577 )
578 );
579 assert_eq!(
580 unsafe { &(*(::std::ptr::null::<t1ha_state256>())).u32_ as *const _ as usize },
581 0usize,
582 concat!(
583 "Offset of field: ",
584 stringify!(t1ha_state256),
585 "::",
586 stringify!(u32_)
587 )
588 );
589 assert_eq!(
590 unsafe { &(*(::std::ptr::null::<t1ha_state256>())).u64_ as *const _ as usize },
591 0usize,
592 concat!(
593 "Offset of field: ",
594 stringify!(t1ha_state256),
595 "::",
596 stringify!(u64_)
597 )
598 );
599 assert_eq!(
600 unsafe { &(*(::std::ptr::null::<t1ha_state256>())).n as *const _ as usize },
601 0usize,
602 concat!(
603 "Offset of field: ",
604 stringify!(t1ha_state256),
605 "::",
606 stringify!(n)
607 )
608 );
609}
610pub type t1ha_state256_t = t1ha_state256;
611#[repr(C)]
612#[repr(align(32))]
613#[derive(Copy, Clone)]
614pub struct t1ha_context {
615 pub state: t1ha_state256_t,
616 pub buffer: t1ha_state256_t,
617 pub partial: usize,
618 pub total: u64,
619}
620#[test]
621fn bindgen_test_layout_t1ha_context() {
622 assert_eq!(
623 ::std::mem::size_of::<t1ha_context>(),
624 96usize,
625 concat!("Size of: ", stringify!(t1ha_context))
626 );
627 assert_eq!(
628 ::std::mem::align_of::<t1ha_context>(),
629 32usize,
630 concat!("Alignment of ", stringify!(t1ha_context))
631 );
632 assert_eq!(
633 unsafe { &(*(::std::ptr::null::<t1ha_context>())).state as *const _ as usize },
634 0usize,
635 concat!(
636 "Offset of field: ",
637 stringify!(t1ha_context),
638 "::",
639 stringify!(state)
640 )
641 );
642 assert_eq!(
643 unsafe { &(*(::std::ptr::null::<t1ha_context>())).buffer as *const _ as usize },
644 32usize,
645 concat!(
646 "Offset of field: ",
647 stringify!(t1ha_context),
648 "::",
649 stringify!(buffer)
650 )
651 );
652 assert_eq!(
653 unsafe { &(*(::std::ptr::null::<t1ha_context>())).partial as *const _ as usize },
654 64usize,
655 concat!(
656 "Offset of field: ",
657 stringify!(t1ha_context),
658 "::",
659 stringify!(partial)
660 )
661 );
662 assert_eq!(
663 unsafe { &(*(::std::ptr::null::<t1ha_context>())).total as *const _ as usize },
664 72usize,
665 concat!(
666 "Offset of field: ",
667 stringify!(t1ha_context),
668 "::",
669 stringify!(total)
670 )
671 );
672}
673pub type t1ha_context_t = t1ha_context;
674extern "C" {
675 pub fn t1ha2_atonce(data: *const ::std::os::raw::c_void, length: usize, seed: u64) -> u64;
676}
677extern "C" {
678 pub fn t1ha2_atonce128(
679 extra_result: *mut u64,
680 data: *const ::std::os::raw::c_void,
681 length: usize,
682 seed: u64,
683 ) -> u64;
684}
685extern "C" {
686 pub fn t1ha2_init(ctx: *mut t1ha_context_t, seed_x: u64, seed_y: u64);
687}
688extern "C" {
689 pub fn t1ha2_update(
690 ctx: *mut t1ha_context_t,
691 data: *const ::std::os::raw::c_void,
692 length: usize,
693 );
694}
695extern "C" {
696 pub fn t1ha2_final(ctx: *mut t1ha_context_t, extra_result: *mut u64) -> u64;
697}
698extern "C" {
699 pub fn t1ha1_le(data: *const ::std::os::raw::c_void, length: usize, seed: u64) -> u64;
700}
701extern "C" {
702 pub fn t1ha1_be(data: *const ::std::os::raw::c_void, length: usize, seed: u64) -> u64;
703}
704pub type t1ha0_function_t = ::std::option::Option<
705 unsafe extern "C" fn(arg1: *const ::std::os::raw::c_void, arg2: usize, arg3: u64) -> u64,
706>;
707extern "C" {
708 pub fn t1ha0_resolve() -> t1ha0_function_t;
709}
710pub type wyhashmap_t = u64;
711extern "C" {
712 #[doc = " @brief Obtains the xxHash version."]
713 #[doc = ""]
714 #[doc = " This is only useful when xxHash is compiled as a shared library, as it is"]
715 #[doc = " independent of the version defined in the header."]
716 #[doc = ""]
717 #[doc = " @return `XXH_VERSION_NUMBER` as of when the libray was compiled."]
718 pub fn XXH_versionNumber() -> ::std::os::raw::c_uint;
719}
720pub const XXH_errorcode_XXH_OK: XXH_errorcode = 0;
721pub const XXH_errorcode_XXH_ERROR: XXH_errorcode = 1;
722pub type XXH_errorcode = ::std::os::raw::c_uint;
723pub type XXH32_hash_t = u32;
724extern "C" {
725 #[doc = " @brief Calculates the 32-bit hash of @p input using xxHash32."]
726 #[doc = ""]
727 #[doc = " Speed on Core 2 Duo @ 3 GHz (single thread, SMHasher benchmark): 5.4 GB/s"]
728 #[doc = ""]
729 #[doc = " @param input The block of data to be hashed, at least @p length bytes in size."]
730 #[doc = " @param length The length of @p input, in bytes."]
731 #[doc = " @param seed The 32-bit seed to alter the hash's output predictably."]
732 #[doc = ""]
733 #[doc = " @pre"]
734 #[doc = " The memory between @p input and @p input + @p length must be valid,"]
735 #[doc = " readable, contiguous memory. However, if @p length is `0`, @p input may be"]
736 #[doc = " `NULL`. In C++, this also must be *TriviallyCopyable*."]
737 #[doc = ""]
738 #[doc = " @return The calculated 32-bit hash value."]
739 #[doc = ""]
740 #[doc = " @see"]
741 #[doc = " XXH64(), XXH3_64bits_withSeed(), XXH3_128bits_withSeed(), XXH128():"]
742 #[doc = " Direct equivalents for the other variants of xxHash."]
743 #[doc = " @see"]
744 #[doc = " XXH32_createState(), XXH32_update(), XXH32_digest(): Streaming version."]
745 pub fn XXH32(
746 input: *const ::std::os::raw::c_void,
747 length: usize,
748 seed: XXH32_hash_t,
749 ) -> XXH32_hash_t;
750}
751#[doc = " @typedef struct XXH32_state_s XXH32_state_t"]
752#[doc = " @brief The opaque state struct for the XXH32 streaming API."]
753#[doc = ""]
754#[doc = " @see XXH32_state_s for details."]
755pub type XXH32_state_t = XXH32_state_s;
756extern "C" {
757 #[doc = " @brief Allocates an @ref XXH32_state_t."]
758 #[doc = ""]
759 #[doc = " Must be freed with XXH32_freeState()."]
760 #[doc = " @return An allocated XXH32_state_t on success, `NULL` on failure."]
761 pub fn XXH32_createState() -> *mut XXH32_state_t;
762}
763extern "C" {
764 #[doc = " @brief Frees an @ref XXH32_state_t."]
765 #[doc = ""]
766 #[doc = " Must be allocated with XXH32_createState()."]
767 #[doc = " @param statePtr A pointer to an @ref XXH32_state_t allocated with @ref XXH32_createState()."]
768 #[doc = " @return XXH_OK."]
769 pub fn XXH32_freeState(statePtr: *mut XXH32_state_t) -> XXH_errorcode;
770}
771extern "C" {
772 #[doc = " @brief Copies one @ref XXH32_state_t to another."]
773 #[doc = ""]
774 #[doc = " @param dst_state The state to copy to."]
775 #[doc = " @param src_state The state to copy from."]
776 #[doc = " @pre"]
777 #[doc = " @p dst_state and @p src_state must not be `NULL` and must not overlap."]
778 pub fn XXH32_copyState(dst_state: *mut XXH32_state_t, src_state: *const XXH32_state_t);
779}
780extern "C" {
781 #[doc = " @brief Resets an @ref XXH32_state_t to begin a new hash."]
782 #[doc = ""]
783 #[doc = " This function resets and seeds a state. Call it before @ref XXH32_update()."]
784 #[doc = ""]
785 #[doc = " @param statePtr The state struct to reset."]
786 #[doc = " @param seed The 32-bit seed to alter the hash result predictably."]
787 #[doc = ""]
788 #[doc = " @pre"]
789 #[doc = " @p statePtr must not be `NULL`."]
790 #[doc = ""]
791 #[doc = " @return @ref XXH_OK on success, @ref XXH_ERROR on failure."]
792 pub fn XXH32_reset(statePtr: *mut XXH32_state_t, seed: XXH32_hash_t) -> XXH_errorcode;
793}
794extern "C" {
795 #[doc = " @brief Consumes a block of @p input to an @ref XXH32_state_t."]
796 #[doc = ""]
797 #[doc = " Call this to incrementally consume blocks of data."]
798 #[doc = ""]
799 #[doc = " @param statePtr The state struct to update."]
800 #[doc = " @param input The block of data to be hashed, at least @p length bytes in size."]
801 #[doc = " @param length The length of @p input, in bytes."]
802 #[doc = ""]
803 #[doc = " @pre"]
804 #[doc = " @p statePtr must not be `NULL`."]
805 #[doc = " @pre"]
806 #[doc = " The memory between @p input and @p input + @p length must be valid,"]
807 #[doc = " readable, contiguous memory. However, if @p length is `0`, @p input may be"]
808 #[doc = " `NULL`. In C++, this also must be *TriviallyCopyable*."]
809 #[doc = ""]
810 #[doc = " @return @ref XXH_OK on success, @ref XXH_ERROR on failure."]
811 pub fn XXH32_update(
812 statePtr: *mut XXH32_state_t,
813 input: *const ::std::os::raw::c_void,
814 length: usize,
815 ) -> XXH_errorcode;
816}
817extern "C" {
818 #[doc = " @brief Returns the calculated hash value from an @ref XXH32_state_t."]
819 #[doc = ""]
820 #[doc = " @note"]
821 #[doc = " Calling XXH32_digest() will not affect @p statePtr, so you can update,"]
822 #[doc = " digest, and update again."]
823 #[doc = ""]
824 #[doc = " @param statePtr The state struct to calculate the hash from."]
825 #[doc = ""]
826 #[doc = " @pre"]
827 #[doc = " @p statePtr must not be `NULL`."]
828 #[doc = ""]
829 #[doc = " @return The calculated xxHash32 value from that state."]
830 pub fn XXH32_digest(statePtr: *const XXH32_state_t) -> XXH32_hash_t;
831}
832#[doc = " @brief Canonical (big endian) representation of @ref XXH32_hash_t."]
833#[repr(C)]
834#[derive(Debug, Copy, Clone)]
835pub struct XXH32_canonical_t {
836 #[doc = "< Hash bytes, big endian"]
837 pub digest: [::std::os::raw::c_uchar; 4usize],
838}
839#[test]
840fn bindgen_test_layout_XXH32_canonical_t() {
841 assert_eq!(
842 ::std::mem::size_of::<XXH32_canonical_t>(),
843 4usize,
844 concat!("Size of: ", stringify!(XXH32_canonical_t))
845 );
846 assert_eq!(
847 ::std::mem::align_of::<XXH32_canonical_t>(),
848 1usize,
849 concat!("Alignment of ", stringify!(XXH32_canonical_t))
850 );
851 assert_eq!(
852 unsafe { &(*(::std::ptr::null::<XXH32_canonical_t>())).digest as *const _ as usize },
853 0usize,
854 concat!(
855 "Offset of field: ",
856 stringify!(XXH32_canonical_t),
857 "::",
858 stringify!(digest)
859 )
860 );
861}
862extern "C" {
863 #[doc = " @brief Converts an @ref XXH32_hash_t to a big endian @ref XXH32_canonical_t."]
864 #[doc = ""]
865 #[doc = " @param dst The @ref XXH32_canonical_t pointer to be stored to."]
866 #[doc = " @param hash The @ref XXH32_hash_t to be converted."]
867 #[doc = ""]
868 #[doc = " @pre"]
869 #[doc = " @p dst must not be `NULL`."]
870 pub fn XXH32_canonicalFromHash(dst: *mut XXH32_canonical_t, hash: XXH32_hash_t);
871}
872extern "C" {
873 #[doc = " @brief Converts an @ref XXH32_canonical_t to a native @ref XXH32_hash_t."]
874 #[doc = ""]
875 #[doc = " @param src The @ref XXH32_canonical_t to convert."]
876 #[doc = ""]
877 #[doc = " @pre"]
878 #[doc = " @p src must not be `NULL`."]
879 #[doc = ""]
880 #[doc = " @return The converted hash."]
881 pub fn XXH32_hashFromCanonical(src: *const XXH32_canonical_t) -> XXH32_hash_t;
882}
883pub type XXH64_hash_t = u64;
884extern "C" {
885 #[doc = " @brief Calculates the 64-bit hash of @p input using xxHash64."]
886 #[doc = ""]
887 #[doc = " This function usually runs faster on 64-bit systems, but slower on 32-bit"]
888 #[doc = " systems (see benchmark)."]
889 #[doc = ""]
890 #[doc = " @param input The block of data to be hashed, at least @p length bytes in size."]
891 #[doc = " @param length The length of @p input, in bytes."]
892 #[doc = " @param seed The 64-bit seed to alter the hash's output predictably."]
893 #[doc = ""]
894 #[doc = " @pre"]
895 #[doc = " The memory between @p input and @p input + @p length must be valid,"]
896 #[doc = " readable, contiguous memory. However, if @p length is `0`, @p input may be"]
897 #[doc = " `NULL`. In C++, this also must be *TriviallyCopyable*."]
898 #[doc = ""]
899 #[doc = " @return The calculated 64-bit hash."]
900 #[doc = ""]
901 #[doc = " @see"]
902 #[doc = " XXH32(), XXH3_64bits_withSeed(), XXH3_128bits_withSeed(), XXH128():"]
903 #[doc = " Direct equivalents for the other variants of xxHash."]
904 #[doc = " @see"]
905 #[doc = " XXH64_createState(), XXH64_update(), XXH64_digest(): Streaming version."]
906 pub fn XXH64(
907 input: *const ::std::os::raw::c_void,
908 length: usize,
909 seed: XXH64_hash_t,
910 ) -> XXH64_hash_t;
911}
912#[doc = " Streaming *******/"]
913#[doc = " @brief The opaque state struct for the XXH64 streaming API."]
914#[doc = ""]
915#[doc = " @see XXH64_state_s for details."]
916pub type XXH64_state_t = XXH64_state_s;
917extern "C" {
918 pub fn XXH64_createState() -> *mut XXH64_state_t;
919}
920extern "C" {
921 pub fn XXH64_freeState(statePtr: *mut XXH64_state_t) -> XXH_errorcode;
922}
923extern "C" {
924 pub fn XXH64_copyState(dst_state: *mut XXH64_state_t, src_state: *const XXH64_state_t);
925}
926extern "C" {
927 pub fn XXH64_reset(statePtr: *mut XXH64_state_t, seed: XXH64_hash_t) -> XXH_errorcode;
928}
929extern "C" {
930 pub fn XXH64_update(
931 statePtr: *mut XXH64_state_t,
932 input: *const ::std::os::raw::c_void,
933 length: usize,
934 ) -> XXH_errorcode;
935}
936extern "C" {
937 pub fn XXH64_digest(statePtr: *const XXH64_state_t) -> XXH64_hash_t;
938}
939#[doc = " Canonical representation"]
940#[repr(C)]
941#[derive(Debug, Copy, Clone)]
942pub struct XXH64_canonical_t {
943 pub digest: [::std::os::raw::c_uchar; 8usize],
944}
945#[test]
946fn bindgen_test_layout_XXH64_canonical_t() {
947 assert_eq!(
948 ::std::mem::size_of::<XXH64_canonical_t>(),
949 8usize,
950 concat!("Size of: ", stringify!(XXH64_canonical_t))
951 );
952 assert_eq!(
953 ::std::mem::align_of::<XXH64_canonical_t>(),
954 1usize,
955 concat!("Alignment of ", stringify!(XXH64_canonical_t))
956 );
957 assert_eq!(
958 unsafe { &(*(::std::ptr::null::<XXH64_canonical_t>())).digest as *const _ as usize },
959 0usize,
960 concat!(
961 "Offset of field: ",
962 stringify!(XXH64_canonical_t),
963 "::",
964 stringify!(digest)
965 )
966 );
967}
968extern "C" {
969 pub fn XXH64_canonicalFromHash(dst: *mut XXH64_canonical_t, hash: XXH64_hash_t);
970}
971extern "C" {
972 pub fn XXH64_hashFromCanonical(src: *const XXH64_canonical_t) -> XXH64_hash_t;
973}
974extern "C" {
975 #[doc = " @}"]
976 #[doc = " ************************************************************************"]
977 #[doc = " @defgroup xxh3_family XXH3 family"]
978 #[doc = " @ingroup public"]
979 #[doc = " @{"]
980 #[doc = ""]
981 #[doc = " XXH3 is a more recent hash algorithm featuring:"]
982 #[doc = " - Improved speed for both small and large inputs"]
983 #[doc = " - True 64-bit and 128-bit outputs"]
984 #[doc = " - SIMD acceleration"]
985 #[doc = " - Improved 32-bit viability"]
986 #[doc = ""]
987 #[doc = " Speed analysis methodology is explained here:"]
988 #[doc = ""]
989 #[doc = " https://fastcompression.blogspot.com/2019/03/presenting-xxh3.html"]
990 #[doc = ""]
991 #[doc = " Compared to XXH64, expect XXH3 to run approximately"]
992 #[doc = " ~2x faster on large inputs and >3x faster on small ones,"]
993 #[doc = " exact differences vary depending on platform."]
994 #[doc = ""]
995 #[doc = " XXH3's speed benefits greatly from SIMD and 64-bit arithmetic,"]
996 #[doc = " but does not require it."]
997 #[doc = " Any 32-bit and 64-bit targets that can run XXH32 smoothly"]
998 #[doc = " can run XXH3 at competitive speeds, even without vector support."]
999 #[doc = " Further details are explained in the implementation."]
1000 #[doc = ""]
1001 #[doc = " Optimized implementations are provided for AVX512, AVX2, SSE2, NEON, POWER8,"]
1002 #[doc = " ZVector and scalar targets. This can be controlled via the XXH_VECTOR macro."]
1003 #[doc = ""]
1004 #[doc = " XXH3 implementation is portable:"]
1005 #[doc = " it has a generic C90 formulation that can be compiled on any platform,"]
1006 #[doc = " all implementations generage exactly the same hash value on all platforms."]
1007 #[doc = " Starting from v0.8.0, it's also labelled \"stable\", meaning that"]
1008 #[doc = " any future version will also generate the same hash value."]
1009 #[doc = ""]
1010 #[doc = " XXH3 offers 2 variants, _64bits and _128bits."]
1011 #[doc = ""]
1012 #[doc = " When only 64 bits are needed, prefer invoking the _64bits variant, as it"]
1013 #[doc = " reduces the amount of mixing, resulting in faster speed on small inputs."]
1014 #[doc = " It's also generally simpler to manipulate a scalar return type than a struct."]
1015 #[doc = ""]
1016 #[doc = " The API supports one-shot hashing, streaming mode, and custom secrets."]
1017 pub fn XXH3_64bits(data: *const ::std::os::raw::c_void, len: usize) -> XXH64_hash_t;
1018}
1019extern "C" {
1020 pub fn XXH3_64bits_withSeed(
1021 data: *const ::std::os::raw::c_void,
1022 len: usize,
1023 seed: XXH64_hash_t,
1024 ) -> XXH64_hash_t;
1025}
1026extern "C" {
1027 pub fn XXH3_64bits_withSecret(
1028 data: *const ::std::os::raw::c_void,
1029 len: usize,
1030 secret: *const ::std::os::raw::c_void,
1031 secretSize: usize,
1032 ) -> XXH64_hash_t;
1033}
1034#[doc = " @brief The state struct for the XXH3 streaming API."]
1035#[doc = ""]
1036#[doc = " @see XXH3_state_s for details."]
1037pub type XXH3_state_t = XXH3_state_s;
1038extern "C" {
1039 pub fn XXH3_createState() -> *mut XXH3_state_t;
1040}
1041extern "C" {
1042 pub fn XXH3_freeState(statePtr: *mut XXH3_state_t) -> XXH_errorcode;
1043}
1044extern "C" {
1045 pub fn XXH3_copyState(dst_state: *mut XXH3_state_t, src_state: *const XXH3_state_t);
1046}
1047extern "C" {
1048 pub fn XXH3_64bits_reset(statePtr: *mut XXH3_state_t) -> XXH_errorcode;
1049}
1050extern "C" {
1051 pub fn XXH3_64bits_reset_withSeed(
1052 statePtr: *mut XXH3_state_t,
1053 seed: XXH64_hash_t,
1054 ) -> XXH_errorcode;
1055}
1056extern "C" {
1057 pub fn XXH3_64bits_reset_withSecret(
1058 statePtr: *mut XXH3_state_t,
1059 secret: *const ::std::os::raw::c_void,
1060 secretSize: usize,
1061 ) -> XXH_errorcode;
1062}
1063extern "C" {
1064 pub fn XXH3_64bits_update(
1065 statePtr: *mut XXH3_state_t,
1066 input: *const ::std::os::raw::c_void,
1067 length: usize,
1068 ) -> XXH_errorcode;
1069}
1070extern "C" {
1071 pub fn XXH3_64bits_digest(statePtr: *const XXH3_state_t) -> XXH64_hash_t;
1072}
1073#[doc = " @brief The return value from 128-bit hashes."]
1074#[doc = ""]
1075#[doc = " Stored in little endian order, although the fields themselves are in native"]
1076#[doc = " endianness."]
1077#[repr(C)]
1078#[derive(Debug, Copy, Clone)]
1079pub struct XXH128_hash_t {
1080 #[doc = "< `value & 0xFFFFFFFFFFFFFFFF`"]
1081 pub low64: XXH64_hash_t,
1082 #[doc = "< `value >> 64`"]
1083 pub high64: XXH64_hash_t,
1084}
1085#[test]
1086fn bindgen_test_layout_XXH128_hash_t() {
1087 assert_eq!(
1088 ::std::mem::size_of::<XXH128_hash_t>(),
1089 16usize,
1090 concat!("Size of: ", stringify!(XXH128_hash_t))
1091 );
1092 assert_eq!(
1093 ::std::mem::align_of::<XXH128_hash_t>(),
1094 8usize,
1095 concat!("Alignment of ", stringify!(XXH128_hash_t))
1096 );
1097 assert_eq!(
1098 unsafe { &(*(::std::ptr::null::<XXH128_hash_t>())).low64 as *const _ as usize },
1099 0usize,
1100 concat!(
1101 "Offset of field: ",
1102 stringify!(XXH128_hash_t),
1103 "::",
1104 stringify!(low64)
1105 )
1106 );
1107 assert_eq!(
1108 unsafe { &(*(::std::ptr::null::<XXH128_hash_t>())).high64 as *const _ as usize },
1109 8usize,
1110 concat!(
1111 "Offset of field: ",
1112 stringify!(XXH128_hash_t),
1113 "::",
1114 stringify!(high64)
1115 )
1116 );
1117}
1118extern "C" {
1119 pub fn XXH3_128bits(data: *const ::std::os::raw::c_void, len: usize) -> XXH128_hash_t;
1120}
1121extern "C" {
1122 pub fn XXH3_128bits_withSeed(
1123 data: *const ::std::os::raw::c_void,
1124 len: usize,
1125 seed: XXH64_hash_t,
1126 ) -> XXH128_hash_t;
1127}
1128extern "C" {
1129 pub fn XXH3_128bits_withSecret(
1130 data: *const ::std::os::raw::c_void,
1131 len: usize,
1132 secret: *const ::std::os::raw::c_void,
1133 secretSize: usize,
1134 ) -> XXH128_hash_t;
1135}
1136extern "C" {
1137 #[doc = " Streaming"]
1138 pub fn XXH3_128bits_reset(statePtr: *mut XXH3_state_t) -> XXH_errorcode;
1139}
1140extern "C" {
1141 pub fn XXH3_128bits_reset_withSeed(
1142 statePtr: *mut XXH3_state_t,
1143 seed: XXH64_hash_t,
1144 ) -> XXH_errorcode;
1145}
1146extern "C" {
1147 pub fn XXH3_128bits_reset_withSecret(
1148 statePtr: *mut XXH3_state_t,
1149 secret: *const ::std::os::raw::c_void,
1150 secretSize: usize,
1151 ) -> XXH_errorcode;
1152}
1153extern "C" {
1154 pub fn XXH3_128bits_update(
1155 statePtr: *mut XXH3_state_t,
1156 input: *const ::std::os::raw::c_void,
1157 length: usize,
1158 ) -> XXH_errorcode;
1159}
1160extern "C" {
1161 pub fn XXH3_128bits_digest(statePtr: *const XXH3_state_t) -> XXH128_hash_t;
1162}
1163extern "C" {
1164 #[doc = " XXH128_isEqual():"]
1165 #[doc = " Return: 1 if `h1` and `h2` are equal, 0 if they are not."]
1166 pub fn XXH128_isEqual(h1: XXH128_hash_t, h2: XXH128_hash_t) -> ::std::os::raw::c_int;
1167}
1168extern "C" {
1169 #[doc = " XXH128_cmp():"]
1170 #[doc = ""]
1171 #[doc = " This comparator is compatible with stdlib's `qsort()`/`bsearch()`."]
1172 #[doc = ""]
1173 #[doc = " return: >0 if *h128_1 > *h128_2"]
1174 #[doc = " =0 if *h128_1 == *h128_2"]
1175 #[doc = " <0 if *h128_1 < *h128_2"]
1176 pub fn XXH128_cmp(
1177 h128_1: *const ::std::os::raw::c_void,
1178 h128_2: *const ::std::os::raw::c_void,
1179 ) -> ::std::os::raw::c_int;
1180}
1181#[doc = " Canonical representation"]
1182#[repr(C)]
1183#[derive(Debug, Copy, Clone)]
1184pub struct XXH128_canonical_t {
1185 pub digest: [::std::os::raw::c_uchar; 16usize],
1186}
1187#[test]
1188fn bindgen_test_layout_XXH128_canonical_t() {
1189 assert_eq!(
1190 ::std::mem::size_of::<XXH128_canonical_t>(),
1191 16usize,
1192 concat!("Size of: ", stringify!(XXH128_canonical_t))
1193 );
1194 assert_eq!(
1195 ::std::mem::align_of::<XXH128_canonical_t>(),
1196 1usize,
1197 concat!("Alignment of ", stringify!(XXH128_canonical_t))
1198 );
1199 assert_eq!(
1200 unsafe { &(*(::std::ptr::null::<XXH128_canonical_t>())).digest as *const _ as usize },
1201 0usize,
1202 concat!(
1203 "Offset of field: ",
1204 stringify!(XXH128_canonical_t),
1205 "::",
1206 stringify!(digest)
1207 )
1208 );
1209}
1210extern "C" {
1211 pub fn XXH128_canonicalFromHash(dst: *mut XXH128_canonical_t, hash: XXH128_hash_t);
1212}
1213extern "C" {
1214 pub fn XXH128_hashFromCanonical(src: *const XXH128_canonical_t) -> XXH128_hash_t;
1215}
1216#[doc = " @internal"]
1217#[doc = " @brief Structure for XXH32 streaming API."]
1218#[doc = ""]
1219#[doc = " @note This is only defined when @ref XXH_STATIC_LINKING_ONLY,"]
1220#[doc = " @ref XXH_INLINE_ALL, or @ref XXH_IMPLEMENTATION is defined. Otherwise it is"]
1221#[doc = " an opaque type. This allows fields to safely be changed."]
1222#[doc = ""]
1223#[doc = " Typedef'd to @ref XXH32_state_t."]
1224#[doc = " Do not access the members of this struct directly."]
1225#[doc = " @see XXH64_state_s, XXH3_state_s"]
1226#[repr(C)]
1227#[derive(Debug, Copy, Clone)]
1228pub struct XXH32_state_s {
1229 #[doc = "< Total length hashed, modulo 2^32"]
1230 pub total_len_32: XXH32_hash_t,
1231 #[doc = "< Whether the hash is >= 16 (handles @ref total_len_32 overflow)"]
1232 pub large_len: XXH32_hash_t,
1233 #[doc = "< First accumulator lane"]
1234 pub v1: XXH32_hash_t,
1235 #[doc = "< Second accumulator lane"]
1236 pub v2: XXH32_hash_t,
1237 #[doc = "< Third accumulator lane"]
1238 pub v3: XXH32_hash_t,
1239 #[doc = "< Fourth accumulator lane"]
1240 pub v4: XXH32_hash_t,
1241 #[doc = "< Internal buffer for partial reads. Treated as unsigned char[16]."]
1242 pub mem32: [XXH32_hash_t; 4usize],
1243 #[doc = "< Amount of data in @ref mem32"]
1244 pub memsize: XXH32_hash_t,
1245 #[doc = "< Reserved field. Do not read or write to it, it may be removed."]
1246 pub reserved: XXH32_hash_t,
1247}
1248#[test]
1249fn bindgen_test_layout_XXH32_state_s() {
1250 assert_eq!(
1251 ::std::mem::size_of::<XXH32_state_s>(),
1252 48usize,
1253 concat!("Size of: ", stringify!(XXH32_state_s))
1254 );
1255 assert_eq!(
1256 ::std::mem::align_of::<XXH32_state_s>(),
1257 4usize,
1258 concat!("Alignment of ", stringify!(XXH32_state_s))
1259 );
1260 assert_eq!(
1261 unsafe { &(*(::std::ptr::null::<XXH32_state_s>())).total_len_32 as *const _ as usize },
1262 0usize,
1263 concat!(
1264 "Offset of field: ",
1265 stringify!(XXH32_state_s),
1266 "::",
1267 stringify!(total_len_32)
1268 )
1269 );
1270 assert_eq!(
1271 unsafe { &(*(::std::ptr::null::<XXH32_state_s>())).large_len as *const _ as usize },
1272 4usize,
1273 concat!(
1274 "Offset of field: ",
1275 stringify!(XXH32_state_s),
1276 "::",
1277 stringify!(large_len)
1278 )
1279 );
1280 assert_eq!(
1281 unsafe { &(*(::std::ptr::null::<XXH32_state_s>())).v1 as *const _ as usize },
1282 8usize,
1283 concat!(
1284 "Offset of field: ",
1285 stringify!(XXH32_state_s),
1286 "::",
1287 stringify!(v1)
1288 )
1289 );
1290 assert_eq!(
1291 unsafe { &(*(::std::ptr::null::<XXH32_state_s>())).v2 as *const _ as usize },
1292 12usize,
1293 concat!(
1294 "Offset of field: ",
1295 stringify!(XXH32_state_s),
1296 "::",
1297 stringify!(v2)
1298 )
1299 );
1300 assert_eq!(
1301 unsafe { &(*(::std::ptr::null::<XXH32_state_s>())).v3 as *const _ as usize },
1302 16usize,
1303 concat!(
1304 "Offset of field: ",
1305 stringify!(XXH32_state_s),
1306 "::",
1307 stringify!(v3)
1308 )
1309 );
1310 assert_eq!(
1311 unsafe { &(*(::std::ptr::null::<XXH32_state_s>())).v4 as *const _ as usize },
1312 20usize,
1313 concat!(
1314 "Offset of field: ",
1315 stringify!(XXH32_state_s),
1316 "::",
1317 stringify!(v4)
1318 )
1319 );
1320 assert_eq!(
1321 unsafe { &(*(::std::ptr::null::<XXH32_state_s>())).mem32 as *const _ as usize },
1322 24usize,
1323 concat!(
1324 "Offset of field: ",
1325 stringify!(XXH32_state_s),
1326 "::",
1327 stringify!(mem32)
1328 )
1329 );
1330 assert_eq!(
1331 unsafe { &(*(::std::ptr::null::<XXH32_state_s>())).memsize as *const _ as usize },
1332 40usize,
1333 concat!(
1334 "Offset of field: ",
1335 stringify!(XXH32_state_s),
1336 "::",
1337 stringify!(memsize)
1338 )
1339 );
1340 assert_eq!(
1341 unsafe { &(*(::std::ptr::null::<XXH32_state_s>())).reserved as *const _ as usize },
1342 44usize,
1343 concat!(
1344 "Offset of field: ",
1345 stringify!(XXH32_state_s),
1346 "::",
1347 stringify!(reserved)
1348 )
1349 );
1350}
1351#[doc = " @internal"]
1352#[doc = " @brief Structure for XXH64 streaming API."]
1353#[doc = ""]
1354#[doc = " @note This is only defined when @ref XXH_STATIC_LINKING_ONLY,"]
1355#[doc = " @ref XXH_INLINE_ALL, or @ref XXH_IMPLEMENTATION is defined. Otherwise it is"]
1356#[doc = " an opaque type. This allows fields to safely be changed."]
1357#[doc = ""]
1358#[doc = " Typedef'd to @ref XXH64_state_t."]
1359#[doc = " Do not access the members of this struct directly."]
1360#[doc = " @see XXH32_state_s, XXH3_state_s"]
1361#[repr(C)]
1362#[derive(Debug, Copy, Clone)]
1363pub struct XXH64_state_s {
1364 #[doc = "< Total length hashed. This is always 64-bit."]
1365 pub total_len: XXH64_hash_t,
1366 #[doc = "< First accumulator lane"]
1367 pub v1: XXH64_hash_t,
1368 #[doc = "< Second accumulator lane"]
1369 pub v2: XXH64_hash_t,
1370 #[doc = "< Third accumulator lane"]
1371 pub v3: XXH64_hash_t,
1372 #[doc = "< Fourth accumulator lane"]
1373 pub v4: XXH64_hash_t,
1374 #[doc = "< Internal buffer for partial reads. Treated as unsigned char[32]."]
1375 pub mem64: [XXH64_hash_t; 4usize],
1376 #[doc = "< Amount of data in @ref mem64"]
1377 pub memsize: XXH32_hash_t,
1378 #[doc = "< Reserved field, needed for padding anyways"]
1379 pub reserved32: XXH32_hash_t,
1380 #[doc = "< Reserved field. Do not read or write to it, it may be removed."]
1381 pub reserved64: XXH64_hash_t,
1382}
1383#[test]
1384fn bindgen_test_layout_XXH64_state_s() {
1385 assert_eq!(
1386 ::std::mem::size_of::<XXH64_state_s>(),
1387 88usize,
1388 concat!("Size of: ", stringify!(XXH64_state_s))
1389 );
1390 assert_eq!(
1391 ::std::mem::align_of::<XXH64_state_s>(),
1392 8usize,
1393 concat!("Alignment of ", stringify!(XXH64_state_s))
1394 );
1395 assert_eq!(
1396 unsafe { &(*(::std::ptr::null::<XXH64_state_s>())).total_len as *const _ as usize },
1397 0usize,
1398 concat!(
1399 "Offset of field: ",
1400 stringify!(XXH64_state_s),
1401 "::",
1402 stringify!(total_len)
1403 )
1404 );
1405 assert_eq!(
1406 unsafe { &(*(::std::ptr::null::<XXH64_state_s>())).v1 as *const _ as usize },
1407 8usize,
1408 concat!(
1409 "Offset of field: ",
1410 stringify!(XXH64_state_s),
1411 "::",
1412 stringify!(v1)
1413 )
1414 );
1415 assert_eq!(
1416 unsafe { &(*(::std::ptr::null::<XXH64_state_s>())).v2 as *const _ as usize },
1417 16usize,
1418 concat!(
1419 "Offset of field: ",
1420 stringify!(XXH64_state_s),
1421 "::",
1422 stringify!(v2)
1423 )
1424 );
1425 assert_eq!(
1426 unsafe { &(*(::std::ptr::null::<XXH64_state_s>())).v3 as *const _ as usize },
1427 24usize,
1428 concat!(
1429 "Offset of field: ",
1430 stringify!(XXH64_state_s),
1431 "::",
1432 stringify!(v3)
1433 )
1434 );
1435 assert_eq!(
1436 unsafe { &(*(::std::ptr::null::<XXH64_state_s>())).v4 as *const _ as usize },
1437 32usize,
1438 concat!(
1439 "Offset of field: ",
1440 stringify!(XXH64_state_s),
1441 "::",
1442 stringify!(v4)
1443 )
1444 );
1445 assert_eq!(
1446 unsafe { &(*(::std::ptr::null::<XXH64_state_s>())).mem64 as *const _ as usize },
1447 40usize,
1448 concat!(
1449 "Offset of field: ",
1450 stringify!(XXH64_state_s),
1451 "::",
1452 stringify!(mem64)
1453 )
1454 );
1455 assert_eq!(
1456 unsafe { &(*(::std::ptr::null::<XXH64_state_s>())).memsize as *const _ as usize },
1457 72usize,
1458 concat!(
1459 "Offset of field: ",
1460 stringify!(XXH64_state_s),
1461 "::",
1462 stringify!(memsize)
1463 )
1464 );
1465 assert_eq!(
1466 unsafe { &(*(::std::ptr::null::<XXH64_state_s>())).reserved32 as *const _ as usize },
1467 76usize,
1468 concat!(
1469 "Offset of field: ",
1470 stringify!(XXH64_state_s),
1471 "::",
1472 stringify!(reserved32)
1473 )
1474 );
1475 assert_eq!(
1476 unsafe { &(*(::std::ptr::null::<XXH64_state_s>())).reserved64 as *const _ as usize },
1477 80usize,
1478 concat!(
1479 "Offset of field: ",
1480 stringify!(XXH64_state_s),
1481 "::",
1482 stringify!(reserved64)
1483 )
1484 );
1485}
1486#[doc = " @internal"]
1487#[doc = " @brief Structure for XXH3 streaming API."]
1488#[doc = ""]
1489#[doc = " @note This is only defined when @ref XXH_STATIC_LINKING_ONLY,"]
1490#[doc = " @ref XXH_INLINE_ALL, or @ref XXH_IMPLEMENTATION is defined."]
1491#[doc = " Otherwise it is an opaque type."]
1492#[doc = " Never use this definition in combination with dynamic library."]
1493#[doc = " This allows fields to safely be changed in the future."]
1494#[doc = ""]
1495#[doc = " @note ** This structure has a strict alignment requirement of 64 bytes!! **"]
1496#[doc = " Do not allocate this with `malloc()` or `new`,"]
1497#[doc = " it will not be sufficiently aligned."]
1498#[doc = " Use @ref XXH3_createState() and @ref XXH3_freeState(), or stack allocation."]
1499#[doc = ""]
1500#[doc = " Typedef'd to @ref XXH3_state_t."]
1501#[doc = " Do never access the members of this struct directly."]
1502#[doc = ""]
1503#[doc = " @see XXH3_INITSTATE() for stack initialization."]
1504#[doc = " @see XXH3_createState(), XXH3_freeState()."]
1505#[doc = " @see XXH32_state_s, XXH64_state_s"]
1506#[repr(C)]
1507#[repr(align(64))]
1508#[derive(Debug, Copy, Clone)]
1509pub struct XXH3_state_s {
1510 pub acc: [XXH64_hash_t; 8usize],
1511 pub customSecret: [::std::os::raw::c_uchar; 192usize],
1512 pub buffer: [::std::os::raw::c_uchar; 256usize],
1513 pub bufferedSize: XXH32_hash_t,
1514 pub reserved32: XXH32_hash_t,
1515 pub nbStripesSoFar: usize,
1516 pub totalLen: XXH64_hash_t,
1517 pub nbStripesPerBlock: usize,
1518 pub secretLimit: usize,
1519 pub seed: XXH64_hash_t,
1520 pub reserved64: XXH64_hash_t,
1521 pub extSecret: *const ::std::os::raw::c_uchar,
1522}
1523#[test]
1524fn bindgen_test_layout_XXH3_state_s() {
1525 assert_eq!(
1526 ::std::mem::size_of::<XXH3_state_s>(),
1527 576usize,
1528 concat!("Size of: ", stringify!(XXH3_state_s))
1529 );
1530 assert_eq!(
1531 ::std::mem::align_of::<XXH3_state_s>(),
1532 64usize,
1533 concat!("Alignment of ", stringify!(XXH3_state_s))
1534 );
1535 assert_eq!(
1536 unsafe { &(*(::std::ptr::null::<XXH3_state_s>())).acc as *const _ as usize },
1537 0usize,
1538 concat!(
1539 "Offset of field: ",
1540 stringify!(XXH3_state_s),
1541 "::",
1542 stringify!(acc)
1543 )
1544 );
1545 assert_eq!(
1546 unsafe { &(*(::std::ptr::null::<XXH3_state_s>())).customSecret as *const _ as usize },
1547 64usize,
1548 concat!(
1549 "Offset of field: ",
1550 stringify!(XXH3_state_s),
1551 "::",
1552 stringify!(customSecret)
1553 )
1554 );
1555 assert_eq!(
1556 unsafe { &(*(::std::ptr::null::<XXH3_state_s>())).buffer as *const _ as usize },
1557 256usize,
1558 concat!(
1559 "Offset of field: ",
1560 stringify!(XXH3_state_s),
1561 "::",
1562 stringify!(buffer)
1563 )
1564 );
1565 assert_eq!(
1566 unsafe { &(*(::std::ptr::null::<XXH3_state_s>())).bufferedSize as *const _ as usize },
1567 512usize,
1568 concat!(
1569 "Offset of field: ",
1570 stringify!(XXH3_state_s),
1571 "::",
1572 stringify!(bufferedSize)
1573 )
1574 );
1575 assert_eq!(
1576 unsafe { &(*(::std::ptr::null::<XXH3_state_s>())).reserved32 as *const _ as usize },
1577 516usize,
1578 concat!(
1579 "Offset of field: ",
1580 stringify!(XXH3_state_s),
1581 "::",
1582 stringify!(reserved32)
1583 )
1584 );
1585 assert_eq!(
1586 unsafe { &(*(::std::ptr::null::<XXH3_state_s>())).nbStripesSoFar as *const _ as usize },
1587 520usize,
1588 concat!(
1589 "Offset of field: ",
1590 stringify!(XXH3_state_s),
1591 "::",
1592 stringify!(nbStripesSoFar)
1593 )
1594 );
1595 assert_eq!(
1596 unsafe { &(*(::std::ptr::null::<XXH3_state_s>())).totalLen as *const _ as usize },
1597 528usize,
1598 concat!(
1599 "Offset of field: ",
1600 stringify!(XXH3_state_s),
1601 "::",
1602 stringify!(totalLen)
1603 )
1604 );
1605 assert_eq!(
1606 unsafe { &(*(::std::ptr::null::<XXH3_state_s>())).nbStripesPerBlock as *const _ as usize },
1607 536usize,
1608 concat!(
1609 "Offset of field: ",
1610 stringify!(XXH3_state_s),
1611 "::",
1612 stringify!(nbStripesPerBlock)
1613 )
1614 );
1615 assert_eq!(
1616 unsafe { &(*(::std::ptr::null::<XXH3_state_s>())).secretLimit as *const _ as usize },
1617 544usize,
1618 concat!(
1619 "Offset of field: ",
1620 stringify!(XXH3_state_s),
1621 "::",
1622 stringify!(secretLimit)
1623 )
1624 );
1625 assert_eq!(
1626 unsafe { &(*(::std::ptr::null::<XXH3_state_s>())).seed as *const _ as usize },
1627 552usize,
1628 concat!(
1629 "Offset of field: ",
1630 stringify!(XXH3_state_s),
1631 "::",
1632 stringify!(seed)
1633 )
1634 );
1635 assert_eq!(
1636 unsafe { &(*(::std::ptr::null::<XXH3_state_s>())).reserved64 as *const _ as usize },
1637 560usize,
1638 concat!(
1639 "Offset of field: ",
1640 stringify!(XXH3_state_s),
1641 "::",
1642 stringify!(reserved64)
1643 )
1644 );
1645 assert_eq!(
1646 unsafe { &(*(::std::ptr::null::<XXH3_state_s>())).extSecret as *const _ as usize },
1647 568usize,
1648 concat!(
1649 "Offset of field: ",
1650 stringify!(XXH3_state_s),
1651 "::",
1652 stringify!(extSecret)
1653 )
1654 );
1655}
1656extern "C" {
1657 pub fn XXH3_generateSecret(
1658 secretBuffer: *mut ::std::os::raw::c_void,
1659 customSeed: *const ::std::os::raw::c_void,
1660 customSeedSize: usize,
1661 );
1662}
1663extern "C" {
1664 pub fn XXH128(
1665 data: *const ::std::os::raw::c_void,
1666 len: usize,
1667 seed: XXH64_hash_t,
1668 ) -> XXH128_hash_t;
1669}
1670extern "C" {
1671 #[link_name = "\u{1}__Z7lookup3PKcij"]
1672 pub fn lookup3(
1673 key: *const ::std::os::raw::c_char,
1674 length: ::std::os::raw::c_int,
1675 initval: u32,
1676 ) -> u32;
1677}
1678extern "C" {
1679 #[link_name = "\u{1}__Z28farmhash_fingerprint_uint12811uint128_c_t"]
1680 pub fn farmhash_fingerprint_uint128(x: uint128_c_t) -> u64;
1681}
1682extern "C" {
1683 #[link_name = "\u{1}__Z27farmhash_fingerprint_uint64y"]
1684 pub fn farmhash_fingerprint_uint64(x: u64) -> u64;
1685}
1686extern "C" {
1687 #[link_name = "\u{1}__Z9mum_hash_PKvmy"]
1688 pub fn mum_hash_(key: *const ::std::os::raw::c_void, len: usize, seed: u64) -> u64;
1689}
1690extern "C" {
1691 #[link_name = "\u{1}__Z16SpookyHasherHashPKvmPyS1_"]
1692 pub fn SpookyHasherHash(
1693 message: *const ::std::os::raw::c_void,
1694 length: usize,
1695 hash1: *mut uint64,
1696 hash2: *mut uint64,
1697 );
1698}
1699extern "C" {
1700 #[link_name = "\u{1}__Z15SpookyHasherNewv"]
1701 pub fn SpookyHasherNew() -> *mut ::std::os::raw::c_void;
1702}
1703extern "C" {
1704 #[link_name = "\u{1}__Z16SpookyHasherFreePv"]
1705 pub fn SpookyHasherFree(h: *mut ::std::os::raw::c_void);
1706}
1707extern "C" {
1708 #[link_name = "\u{1}__Z16SpookyHasherInitPvyy"]
1709 pub fn SpookyHasherInit(h: *mut ::std::os::raw::c_void, seed1: uint64, seed2: uint64);
1710}
1711extern "C" {
1712 #[link_name = "\u{1}__Z18SpookyHasherUpdatePvPKvm"]
1713 pub fn SpookyHasherUpdate(
1714 h: *mut ::std::os::raw::c_void,
1715 message: *const ::std::os::raw::c_void,
1716 length: usize,
1717 );
1718}
1719extern "C" {
1720 #[link_name = "\u{1}__Z17SpookyHasherFinalPvPyS0_"]
1721 pub fn SpookyHasherFinal(
1722 h: *mut ::std::os::raw::c_void,
1723 hash1: *mut uint64,
1724 hash2: *mut uint64,
1725 );
1726}
1727extern "C" {
1728 #[link_name = "\u{1}__Z8t1ha0_64PKvmy"]
1729 pub fn t1ha0_64(data: *const ::std::os::raw::c_void, length: usize, seed: u64) -> u64;
1730}
1731extern "C" {
1732 #[link_name = "\u{1}__Z14HighwayHash128PKyPKcyRA2_y"]
1733 pub fn HighwayHash128(
1734 key: *mut u64,
1735 bytes: *const ::std::os::raw::c_char,
1736 size: u64,
1737 hash: *mut HHResult128,
1738 );
1739}
1740extern "C" {
1741 #[link_name = "\u{1}__Z14HighwayHash256PKyPKcyRA4_y"]
1742 pub fn HighwayHash256(
1743 key: *mut u64,
1744 bytes: *const ::std::os::raw::c_char,
1745 size: u64,
1746 hash: *mut HHResult256,
1747 );
1748}
1749extern "C" {
1750 #[link_name = "\u{1}__Z8wyhash64PKvyy"]
1751 pub fn wyhash64(key: *const ::std::os::raw::c_void, len: u64, seed: u64) -> u64;
1752}
1753extern "C" {
1754 #[link_name = "\u{1}__Z11MeowHash128PKviPvS1_"]
1755 pub fn MeowHash128(
1756 key: *const ::std::os::raw::c_void,
1757 len: ::std::os::raw::c_int,
1758 seed: *mut ::std::os::raw::c_void,
1759 out: *mut ::std::os::raw::c_void,
1760 );
1761}
1762extern "C" {
1763 #[link_name = "\u{1}__Z13MeowHashBeginP10meow_statePv"]
1764 pub fn MeowHashBegin(State: *mut meow_state, Seed128: *mut ::std::os::raw::c_void);
1765}
1766extern "C" {
1767 #[link_name = "\u{1}__Z14MeowHashUpdateP10meow_statemPv"]
1768 pub fn MeowHashUpdate(
1769 State: *mut meow_state,
1770 Len: usize,
1771 SourceInit: *mut ::std::os::raw::c_void,
1772 );
1773}
1774extern "C" {
1775 #[link_name = "\u{1}__Z11MeowHashEndP10meow_statePv"]
1776 pub fn MeowHashEnd(State: *mut meow_state, out: *mut ::std::os::raw::c_void);
1777}
1778extern "C" {
1779 #[link_name = "\u{1}__Z18MeowHashExpandSeedyPvPh"]
1780 pub fn MeowHashExpandSeed(
1781 InputLen: ::std::os::raw::c_ulonglong,
1782 Input: *mut ::std::os::raw::c_void,
1783 SeedResult: *mut ::std::os::raw::c_uchar,
1784 );
1785}
1786#[test]
1787fn __bindgen_test_layout_pair_open0_uint64_uint64_close0_instantiation() {
1788 assert_eq!(
1789 ::std::mem::size_of::<pair<uint64, uint64>>(),
1790 16usize,
1791 concat!(
1792 "Size of template specialization: ",
1793 stringify ! (pair < uint64 , uint64 >)
1794 )
1795 );
1796 assert_eq!(
1797 ::std::mem::align_of::<pair<uint64, uint64>>(),
1798 8usize,
1799 concat!(
1800 "Alignment of template specialization: ",
1801 stringify ! (pair < uint64 , uint64 >)
1802 )
1803 );
1804}