/* automatically generated by rust-bindgen 0.56.0 */

#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct __BindgenBitfieldUnit<Storage, Align> {
    storage: Storage,
    align: [Align; 0],
}
impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
    #[inline]
    pub const fn new(storage: Storage) -> Self {
        Self { storage, align: [] }
    }
}
impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
where
    Storage: AsRef<[u8]> + AsMut<[u8]>,
{
    #[inline]
    pub fn get_bit(&self, index: usize) -> bool {
        debug_assert!(index / 8 < self.storage.as_ref().len());
        let byte_index = index / 8;
        let byte = self.storage.as_ref()[byte_index];
        let bit_index = if cfg!(target_endian = "big") {
            7 - (index % 8)
        } else {
            index % 8
        };
        let mask = 1 << bit_index;
        byte & mask == mask
    }
    #[inline]
    pub fn set_bit(&mut self, index: usize, val: bool) {
        debug_assert!(index / 8 < self.storage.as_ref().len());
        let byte_index = index / 8;
        let byte = &mut self.storage.as_mut()[byte_index];
        let bit_index = if cfg!(target_endian = "big") {
            7 - (index % 8)
        } else {
            index % 8
        };
        let mask = 1 << bit_index;
        if val {
            *byte |= mask;
        } else {
            *byte &= !mask;
        }
    }
    #[inline]
    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
        debug_assert!(bit_width <= 64);
        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
        debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
        let mut val = 0;
        for i in 0..(bit_width as usize) {
            if self.get_bit(i + bit_offset) {
                let index = if cfg!(target_endian = "big") {
                    bit_width as usize - 1 - i
                } else {
                    i
                };
                val |= 1 << index;
            }
        }
        val
    }
    #[inline]
    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
        debug_assert!(bit_width <= 64);
        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
        debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
        for i in 0..(bit_width as usize) {
            let mask = 1 << i;
            let val_bit_is_set = val & mask == mask;
            let index = if cfg!(target_endian = "big") {
                bit_width as usize - 1 - i
            } else {
                i
            };
            self.set_bit(index + bit_offset, val_bit_is_set);
        }
    }
}
#[repr(C)]
#[derive(Default)]
pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
impl<T> __IncompleteArrayField<T> {
    #[inline]
    pub const fn new() -> Self {
        __IncompleteArrayField(::std::marker::PhantomData, [])
    }
    #[inline]
    pub fn as_ptr(&self) -> *const T {
        self as *const _ as *const T
    }
    #[inline]
    pub fn as_mut_ptr(&mut self) -> *mut T {
        self as *mut _ as *mut T
    }
    #[inline]
    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
        ::std::slice::from_raw_parts(self.as_ptr(), len)
    }
    #[inline]
    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
    }
}
impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        fmt.write_str("__IncompleteArrayField")
    }
}
#[repr(C)]
pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
impl<T> __BindgenUnionField<T> {
    #[inline]
    pub const fn new() -> Self {
        __BindgenUnionField(::std::marker::PhantomData)
    }
    #[inline]
    pub unsafe fn as_ref(&self) -> &T {
        ::std::mem::transmute(self)
    }
    #[inline]
    pub unsafe fn as_mut(&mut self) -> &mut T {
        ::std::mem::transmute(self)
    }
}
impl<T> ::std::default::Default for __BindgenUnionField<T> {
    #[inline]
    fn default() -> Self {
        Self::new()
    }
}
impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
    #[inline]
    fn clone(&self) -> Self {
        Self::new()
    }
}
impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        fmt.write_str("__BindgenUnionField")
    }
}
impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
}
impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
        true
    }
}
impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
pub const _ENDIAN_H: u32 = 1;
pub const _FEATURES_H: u32 = 1;
pub const _DEFAULT_SOURCE: u32 = 1;
pub const __GLIBC_USE_ISOC2X: u32 = 0;
pub const __USE_ISOC11: u32 = 1;
pub const __USE_ISOC99: u32 = 1;
pub const __USE_ISOC95: u32 = 1;
pub const __USE_POSIX_IMPLICITLY: u32 = 1;
pub const _POSIX_SOURCE: u32 = 1;
pub const _POSIX_C_SOURCE: u32 = 200809;
pub const __USE_POSIX: u32 = 1;
pub const __USE_POSIX2: u32 = 1;
pub const __USE_POSIX199309: u32 = 1;
pub const __USE_POSIX199506: u32 = 1;
pub const __USE_XOPEN2K: u32 = 1;
pub const __USE_XOPEN2K8: u32 = 1;
pub const _ATFILE_SOURCE: u32 = 1;
pub const __USE_MISC: u32 = 1;
pub const __USE_ATFILE: u32 = 1;
pub const __USE_FORTIFY_LEVEL: u32 = 0;
pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 0;
pub const __GLIBC_USE_DEPRECATED_SCANF: u32 = 0;
pub const _STDC_PREDEF_H: u32 = 1;
pub const __STDC_IEC_559__: u32 = 1;
pub const __STDC_IEC_559_COMPLEX__: u32 = 1;
pub const __STDC_ISO_10646__: u32 = 201706;
pub const __GNU_LIBRARY__: u32 = 6;
pub const __GLIBC__: u32 = 2;
pub const __GLIBC_MINOR__: u32 = 31;
pub const _SYS_CDEFS_H: u32 = 1;
pub const __glibc_c99_flexarr_available: u32 = 1;
pub const __WORDSIZE: u32 = 64;
pub const __WORDSIZE_TIME64_COMPAT32: u32 = 1;
pub const __SYSCALL_WORDSIZE: u32 = 64;
pub const __LONG_DOUBLE_USES_FLOAT128: u32 = 0;
pub const __HAVE_GENERIC_SELECTION: u32 = 1;
pub const _BITS_ENDIAN_H: u32 = 1;
pub const __LITTLE_ENDIAN: u32 = 1234;
pub const __BIG_ENDIAN: u32 = 4321;
pub const __PDP_ENDIAN: u32 = 3412;
pub const _BITS_ENDIANNESS_H: u32 = 1;
pub const __BYTE_ORDER: u32 = 1234;
pub const __FLOAT_WORD_ORDER: u32 = 1234;
pub const LITTLE_ENDIAN: u32 = 1234;
pub const BIG_ENDIAN: u32 = 4321;
pub const PDP_ENDIAN: u32 = 3412;
pub const BYTE_ORDER: u32 = 1234;
pub const _BITS_BYTESWAP_H: u32 = 1;
pub const _BITS_TYPES_H: u32 = 1;
pub const __TIMESIZE: u32 = 64;
pub const _BITS_TYPESIZES_H: u32 = 1;
pub const __OFF_T_MATCHES_OFF64_T: u32 = 1;
pub const __INO_T_MATCHES_INO64_T: u32 = 1;
pub const __RLIM_T_MATCHES_RLIM64_T: u32 = 1;
pub const __STATFS_MATCHES_STATFS64: u32 = 1;
pub const __FD_SETSIZE: u32 = 1024;
pub const _BITS_TIME64_H: u32 = 1;
pub const _BITS_UINTN_IDENTITY_H: u32 = 1;
pub const _STDINT_H: u32 = 1;
pub const __GLIBC_USE_LIB_EXT2: u32 = 0;
pub const __GLIBC_USE_IEC_60559_BFP_EXT: u32 = 0;
pub const __GLIBC_USE_IEC_60559_BFP_EXT_C2X: u32 = 0;
pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: u32 = 0;
pub const __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X: u32 = 0;
pub const __GLIBC_USE_IEC_60559_TYPES_EXT: u32 = 0;
pub const _BITS_WCHAR_H: u32 = 1;
pub const _BITS_STDINT_INTN_H: u32 = 1;
pub const _BITS_STDINT_UINTN_H: u32 = 1;
pub const INT8_MIN: i32 = -128;
pub const INT16_MIN: i32 = -32768;
pub const INT32_MIN: i32 = -2147483648;
pub const INT8_MAX: u32 = 127;
pub const INT16_MAX: u32 = 32767;
pub const INT32_MAX: u32 = 2147483647;
pub const UINT8_MAX: u32 = 255;
pub const UINT16_MAX: u32 = 65535;
pub const UINT32_MAX: u32 = 4294967295;
pub const INT_LEAST8_MIN: i32 = -128;
pub const INT_LEAST16_MIN: i32 = -32768;
pub const INT_LEAST32_MIN: i32 = -2147483648;
pub const INT_LEAST8_MAX: u32 = 127;
pub const INT_LEAST16_MAX: u32 = 32767;
pub const INT_LEAST32_MAX: u32 = 2147483647;
pub const UINT_LEAST8_MAX: u32 = 255;
pub const UINT_LEAST16_MAX: u32 = 65535;
pub const UINT_LEAST32_MAX: u32 = 4294967295;
pub const INT_FAST8_MIN: i32 = -128;
pub const INT_FAST16_MIN: i64 = -9223372036854775808;
pub const INT_FAST32_MIN: i64 = -9223372036854775808;
pub const INT_FAST8_MAX: u32 = 127;
pub const INT_FAST16_MAX: u64 = 9223372036854775807;
pub const INT_FAST32_MAX: u64 = 9223372036854775807;
pub const UINT_FAST8_MAX: u32 = 255;
pub const UINT_FAST16_MAX: i32 = -1;
pub const UINT_FAST32_MAX: i32 = -1;
pub const INTPTR_MIN: i64 = -9223372036854775808;
pub const INTPTR_MAX: u64 = 9223372036854775807;
pub const UINTPTR_MAX: i32 = -1;
pub const PTRDIFF_MIN: i64 = -9223372036854775808;
pub const PTRDIFF_MAX: u64 = 9223372036854775807;
pub const SIG_ATOMIC_MIN: i32 = -2147483648;
pub const SIG_ATOMIC_MAX: u32 = 2147483647;
pub const SIZE_MAX: i32 = -1;
pub const WINT_MIN: u32 = 0;
pub const WINT_MAX: u32 = 4294967295;
pub const __BITS_PER_LONG: u32 = 64;
pub const SCOUTFS_INTEROP_VERSION: u32 = 0;
pub const SCOUTFS_SUPER_MAGIC: u32 = 1431257939;
pub const SCOUTFS_BLOCK_MAGIC_SUPER: u32 = 272384651;
pub const SCOUTFS_BLOCK_MAGIC_BTREE: u32 = 3851942253;
pub const SCOUTFS_BLOCK_MAGIC_BLOOM: u32 = 832132612;
pub const SCOUTFS_BLOCK_MAGIC_SRCH_BLOCK: u32 = 2306755197;
pub const SCOUTFS_BLOCK_MAGIC_SRCH_PARENT: u32 = 2990156293;
pub const SCOUTFS_BLOCK_MAGIC_ALLOC_LIST: u32 = 2324933763;
pub const SCOUTFS_BLOCK_SM_SHIFT: u32 = 12;
pub const SCOUTFS_BLOCK_SM_SIZE: u32 = 4096;
pub const SCOUTFS_BLOCK_SM_MASK: u32 = 4095;
pub const SCOUTFS_BLOCK_SM_SECTOR_SHIFT: u32 = 3;
pub const SCOUTFS_BLOCK_SM_SECTORS: u32 = 8;
pub const SCOUTFS_BLOCK_LG_SHIFT: u32 = 16;
pub const SCOUTFS_BLOCK_LG_SIZE: u32 = 65536;
pub const SCOUTFS_BLOCK_LG_MASK: u32 = 65535;
pub const SCOUTFS_BLOCK_LG_SECTOR_SHIFT: u32 = 7;
pub const SCOUTFS_BLOCK_LG_SECTORS: u32 = 128;
pub const SCOUTFS_BLOCK_SM_LG_SHIFT: u32 = 4;
pub const SCOUTFS_SUPER_BLKNO: u32 = 16;
pub const SCOUTFS_QUORUM_BLKNO: u32 = 64;
pub const SCOUTFS_QUORUM_BLOCKS: u32 = 64;
pub const SCOUTFS_DATA_DEV_START_BLKNO: u32 = 64;
pub const SCOUTFS_UNIQUE_NAME_MAX_BYTES: u32 = 64;
pub const SCOUTFS_BTREE_MAX_VAL_LEN: u32 = 896;
pub const SCOUTFS_BTREE_MAX_HEIGHT: u32 = 20;
pub const SCOUTFS_BTREE_VALUE_ALIGN: u32 = 8;
pub const SCOUTFS_ALLOC_OWNER_NONE: u32 = 0;
pub const SCOUTFS_ALLOC_OWNER_SERVER: u32 = 1;
pub const SCOUTFS_ALLOC_OWNER_MOUNT: u32 = 2;
pub const SCOUTFS_ALLOC_OWNER_SRCH: u32 = 3;
pub const SCOUTFS_MOUNTED_CLIENT_VOTER: u32 = 1;
pub const SCOUTFS_SRCH_LOG_BLOCK_LIMIT: u32 = 16;
pub const SCOUTFS_SRCH_COMPACT_ORDER: u32 = 2;
pub const SCOUTFS_SRCH_COMPACT_NR: u32 = 4;
pub const SCOUTFS_SRCH_COMPACT_FLAG_LOG: u32 = 1;
pub const SCOUTFS_SRCH_COMPACT_FLAG_SORTED: u32 = 2;
pub const SCOUTFS_SRCH_COMPACT_FLAG_DELETE: u32 = 4;
pub const SCOUTFS_SRCH_COMPACT_FLAG_DONE: u32 = 16;
pub const SCOUTFS_SRCH_COMPACT_FLAG_ERROR: u32 = 32;
pub const SCOUTFS_LOG_ITEM_FLAG_DELETION: u32 = 1;
pub const SCOUTFS_FOREST_BLOOM_NRS: u32 = 3;
pub const SCOUTFS_FOREST_BLOOM_FUNC_BITS: u32 = 19;
pub const SCOUTFS_INODE_INDEX_ZONE: u32 = 1;
pub const SCOUTFS_RID_ZONE: u32 = 2;
pub const SCOUTFS_FS_ZONE: u32 = 3;
pub const SCOUTFS_LOCK_ZONE: u32 = 4;
pub const SCOUTFS_LOG_TREES_ZONE: u32 = 6;
pub const SCOUTFS_LOCK_CLIENTS_ZONE: u32 = 7;
pub const SCOUTFS_TRANS_SEQ_ZONE: u32 = 8;
pub const SCOUTFS_MOUNTED_CLIENT_ZONE: u32 = 9;
pub const SCOUTFS_SRCH_ZONE: u32 = 10;
pub const SCOUTFS_FREE_EXTENT_ZONE: u32 = 11;
pub const SCOUTFS_INODE_INDEX_META_SEQ_TYPE: u32 = 1;
pub const SCOUTFS_INODE_INDEX_DATA_SEQ_TYPE: u32 = 2;
pub const SCOUTFS_INODE_INDEX_NR: u32 = 3;
pub const SCOUTFS_ORPHAN_TYPE: u32 = 1;
pub const SCOUTFS_INODE_TYPE: u32 = 1;
pub const SCOUTFS_XATTR_TYPE: u32 = 2;
pub const SCOUTFS_DIRENT_TYPE: u32 = 3;
pub const SCOUTFS_READDIR_TYPE: u32 = 4;
pub const SCOUTFS_LINK_BACKREF_TYPE: u32 = 5;
pub const SCOUTFS_SYMLINK_TYPE: u32 = 6;
pub const SCOUTFS_DATA_EXTENT_TYPE: u32 = 7;
pub const SCOUTFS_RENAME_TYPE: u32 = 1;
pub const SCOUTFS_SRCH_LOG_TYPE: u32 = 1;
pub const SCOUTFS_SRCH_BLOCKS_TYPE: u32 = 2;
pub const SCOUTFS_SRCH_PENDING_TYPE: u32 = 3;
pub const SCOUTFS_SRCH_BUSY_TYPE: u32 = 4;
pub const SCOUTFS_FREE_EXTENT_BLKNO_TYPE: u32 = 1;
pub const SCOUTFS_FREE_EXTENT_LEN_TYPE: u32 = 2;
pub const SEF_OFFLINE: u32 = 1;
pub const SEF_UNWRITTEN: u32 = 2;
pub const SCOUTFS_UUID_BYTES: u32 = 16;
pub const SCOUTFS_QUORUM_MAX_COUNT: u32 = 9;
pub const SCOUTFS_QUORUM_CYCLE_LO_MS: u32 = 10;
pub const SCOUTFS_QUORUM_CYCLE_HI_MS: u32 = 20;
pub const SCOUTFS_QUORUM_TERM_LO_MS: u32 = 250;
pub const SCOUTFS_QUORUM_TERM_HI_MS: u32 = 500;
pub const SCOUTFS_QUORUM_ELECTED_LOG_CYCLES: u32 = 10;
pub const SCOUTFS_FLAG_IS_META_BDEV: u32 = 1;
pub const SCOUTFS_ROOT_INO: u32 = 1;
pub const SCOUTFS_INO_FLAG_TRUNCATE: u32 = 1;
pub const SCOUTFS_SYMLINK_MAX_SIZE: u32 = 4096;
pub const SCOUTFS_NAME_LEN: u32 = 255;
pub const SCOUTFS_DIRENT_FIRST_POS: u32 = 2;
pub const SCOUTFS_XATTR_MAX_NAME_LEN: u32 = 255;
pub const SCOUTFS_XATTR_MAX_VAL_LEN: u32 = 65535;
pub const SCOUTFS_LOCK_INODE_GROUP_NR: u32 = 1024;
pub const SCOUTFS_LOCK_INODE_GROUP_MASK: u32 = 1023;
pub const SCOUTFS_LOCK_SEQ_GROUP_MASK: u32 = 1023;
pub const SCOUTFS_NET_GREETING_FLAG_FAREWELL: u32 = 1;
pub const SCOUTFS_NET_GREETING_FLAG_VOTER: u32 = 2;
pub const SCOUTFS_NET_FLAG_RESPONSE: u32 = 1;
pub const SCOUTFS_NET_MAX_DATA_LEN: u32 = 1100;
pub const FILEID_SCOUTFS: u32 = 129;
pub const FILEID_SCOUTFS_WITH_PARENT: u32 = 130;
pub const SCOUTFS_IOCTL_MAGIC: u8 = 115u8;
pub const SCOUTFS_IOC_DWO_READ: u32 = 1;
pub const SCOUTFS_IOC_DWO_WRITE: u32 = 2;
pub const SCOUTFS_IOC_DWO_CHANGE_SIZE: u32 = 4;
pub const SCOUTFS_IOC_SETATTR_MORE_OFFLINE: u32 = 1;
pub const SCOUTFS_SEARCH_XATTRS_OFLAG_END: u32 = 1;
pub type __u_char = ::std::os::raw::c_uchar;
pub type __u_short = ::std::os::raw::c_ushort;
pub type __u_int = ::std::os::raw::c_uint;
pub type __u_long = ::std::os::raw::c_ulong;
pub type __int8_t = ::std::os::raw::c_schar;
pub type __uint8_t = ::std::os::raw::c_uchar;
pub type __int16_t = ::std::os::raw::c_short;
pub type __uint16_t = ::std::os::raw::c_ushort;
pub type __int32_t = ::std::os::raw::c_int;
pub type __uint32_t = ::std::os::raw::c_uint;
pub type __int64_t = ::std::os::raw::c_long;
pub type __uint64_t = ::std::os::raw::c_ulong;
pub type __int_least8_t = __int8_t;
pub type __uint_least8_t = __uint8_t;
pub type __int_least16_t = __int16_t;
pub type __uint_least16_t = __uint16_t;
pub type __int_least32_t = __int32_t;
pub type __uint_least32_t = __uint32_t;
pub type __int_least64_t = __int64_t;
pub type __uint_least64_t = __uint64_t;
pub type __quad_t = ::std::os::raw::c_long;
pub type __u_quad_t = ::std::os::raw::c_ulong;
pub type __intmax_t = ::std::os::raw::c_long;
pub type __uintmax_t = ::std::os::raw::c_ulong;
pub type __dev_t = ::std::os::raw::c_ulong;
pub type __uid_t = ::std::os::raw::c_uint;
pub type __gid_t = ::std::os::raw::c_uint;
pub type __ino_t = ::std::os::raw::c_ulong;
pub type __ino64_t = ::std::os::raw::c_ulong;
pub type __mode_t = ::std::os::raw::c_uint;
pub type __nlink_t = ::std::os::raw::c_ulong;
pub type __off_t = ::std::os::raw::c_long;
pub type __off64_t = ::std::os::raw::c_long;
pub type __pid_t = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct __fsid_t {
    pub __val: [::std::os::raw::c_int; 2usize],
}
#[test]
fn bindgen_test_layout___fsid_t() {
    assert_eq!(
        ::std::mem::size_of::<__fsid_t>(),
        8usize,
        concat!("Size of: ", stringify!(__fsid_t))
    );
    assert_eq!(
        ::std::mem::align_of::<__fsid_t>(),
        4usize,
        concat!("Alignment of ", stringify!(__fsid_t))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<__fsid_t>())).__val as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__fsid_t),
            "::",
            stringify!(__val)
        )
    );
}
pub type __clock_t = ::std::os::raw::c_long;
pub type __rlim_t = ::std::os::raw::c_ulong;
pub type __rlim64_t = ::std::os::raw::c_ulong;
pub type __id_t = ::std::os::raw::c_uint;
pub type __time_t = ::std::os::raw::c_long;
pub type __useconds_t = ::std::os::raw::c_uint;
pub type __suseconds_t = ::std::os::raw::c_long;
pub type __daddr_t = ::std::os::raw::c_int;
pub type __key_t = ::std::os::raw::c_int;
pub type __clockid_t = ::std::os::raw::c_int;
pub type __timer_t = *mut ::std::os::raw::c_void;
pub type __blksize_t = ::std::os::raw::c_long;
pub type __blkcnt_t = ::std::os::raw::c_long;
pub type __blkcnt64_t = ::std::os::raw::c_long;
pub type __fsblkcnt_t = ::std::os::raw::c_ulong;
pub type __fsblkcnt64_t = ::std::os::raw::c_ulong;
pub type __fsfilcnt_t = ::std::os::raw::c_ulong;
pub type __fsfilcnt64_t = ::std::os::raw::c_ulong;
pub type __fsword_t = ::std::os::raw::c_long;
pub type __ssize_t = ::std::os::raw::c_long;
pub type __syscall_slong_t = ::std::os::raw::c_long;
pub type __syscall_ulong_t = ::std::os::raw::c_ulong;
pub type __loff_t = __off64_t;
pub type __caddr_t = *mut ::std::os::raw::c_char;
pub type __intptr_t = ::std::os::raw::c_long;
pub type __socklen_t = ::std::os::raw::c_uint;
pub type __sig_atomic_t = ::std::os::raw::c_int;
pub type int_least8_t = __int_least8_t;
pub type int_least16_t = __int_least16_t;
pub type int_least32_t = __int_least32_t;
pub type int_least64_t = __int_least64_t;
pub type uint_least8_t = __uint_least8_t;
pub type uint_least16_t = __uint_least16_t;
pub type uint_least32_t = __uint_least32_t;
pub type uint_least64_t = __uint_least64_t;
pub type int_fast8_t = ::std::os::raw::c_schar;
pub type int_fast16_t = ::std::os::raw::c_long;
pub type int_fast32_t = ::std::os::raw::c_long;
pub type int_fast64_t = ::std::os::raw::c_long;
pub type uint_fast8_t = ::std::os::raw::c_uchar;
pub type uint_fast16_t = ::std::os::raw::c_ulong;
pub type uint_fast32_t = ::std::os::raw::c_ulong;
pub type uint_fast64_t = ::std::os::raw::c_ulong;
pub type intmax_t = __intmax_t;
pub type uintmax_t = __uintmax_t;
pub type __s8 = ::std::os::raw::c_schar;
pub type __u8 = ::std::os::raw::c_uchar;
pub type __s16 = ::std::os::raw::c_short;
pub type __u16 = ::std::os::raw::c_ushort;
pub type __s32 = ::std::os::raw::c_int;
pub type __u32 = ::std::os::raw::c_uint;
pub type __s64 = ::std::os::raw::c_longlong;
pub type __u64 = ::std::os::raw::c_ulonglong;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct __kernel_fd_set {
    pub fds_bits: [::std::os::raw::c_ulong; 16usize],
}
#[test]
fn bindgen_test_layout___kernel_fd_set() {
    assert_eq!(
        ::std::mem::size_of::<__kernel_fd_set>(),
        128usize,
        concat!("Size of: ", stringify!(__kernel_fd_set))
    );
    assert_eq!(
        ::std::mem::align_of::<__kernel_fd_set>(),
        8usize,
        concat!("Alignment of ", stringify!(__kernel_fd_set))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<__kernel_fd_set>())).fds_bits as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__kernel_fd_set),
            "::",
            stringify!(fds_bits)
        )
    );
}
pub type __kernel_sighandler_t =
    ::std::option::Option<unsafe extern "C" fn(arg1: ::std::os::raw::c_int)>;
pub type __kernel_key_t = ::std::os::raw::c_int;
pub type __kernel_mqd_t = ::std::os::raw::c_int;
pub type __kernel_old_uid_t = ::std::os::raw::c_ushort;
pub type __kernel_old_gid_t = ::std::os::raw::c_ushort;
pub type __kernel_old_dev_t = ::std::os::raw::c_ulong;
pub type __kernel_long_t = ::std::os::raw::c_long;
pub type __kernel_ulong_t = ::std::os::raw::c_ulong;
pub type __kernel_ino_t = __kernel_ulong_t;
pub type __kernel_mode_t = ::std::os::raw::c_uint;
pub type __kernel_pid_t = ::std::os::raw::c_int;
pub type __kernel_ipc_pid_t = ::std::os::raw::c_int;
pub type __kernel_uid_t = ::std::os::raw::c_uint;
pub type __kernel_gid_t = ::std::os::raw::c_uint;
pub type __kernel_suseconds_t = __kernel_long_t;
pub type __kernel_daddr_t = ::std::os::raw::c_int;
pub type __kernel_uid32_t = ::std::os::raw::c_uint;
pub type __kernel_gid32_t = ::std::os::raw::c_uint;
pub type __kernel_size_t = __kernel_ulong_t;
pub type __kernel_ssize_t = __kernel_long_t;
pub type __kernel_ptrdiff_t = __kernel_long_t;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct __kernel_fsid_t {
    pub val: [::std::os::raw::c_int; 2usize],
}
#[test]
fn bindgen_test_layout___kernel_fsid_t() {
    assert_eq!(
        ::std::mem::size_of::<__kernel_fsid_t>(),
        8usize,
        concat!("Size of: ", stringify!(__kernel_fsid_t))
    );
    assert_eq!(
        ::std::mem::align_of::<__kernel_fsid_t>(),
        4usize,
        concat!("Alignment of ", stringify!(__kernel_fsid_t))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<__kernel_fsid_t>())).val as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__kernel_fsid_t),
            "::",
            stringify!(val)
        )
    );
}
pub type __kernel_off_t = __kernel_long_t;
pub type __kernel_loff_t = ::std::os::raw::c_longlong;
pub type __kernel_time_t = __kernel_long_t;
pub type __kernel_time64_t = ::std::os::raw::c_longlong;
pub type __kernel_clock_t = __kernel_long_t;
pub type __kernel_timer_t = ::std::os::raw::c_int;
pub type __kernel_clockid_t = ::std::os::raw::c_int;
pub type __kernel_caddr_t = *mut ::std::os::raw::c_char;
pub type __kernel_uid16_t = ::std::os::raw::c_ushort;
pub type __kernel_gid16_t = ::std::os::raw::c_ushort;
pub type __le16 = __u16;
pub type __be16 = __u16;
pub type __le32 = __u32;
pub type __be32 = __u32;
pub type __le64 = __u64;
pub type __be64 = __u64;
pub type __sum16 = __u16;
pub type __wsum = __u32;
pub type __poll_t = ::std::os::raw::c_uint;
pub type u8_ = ::std::os::raw::c_uchar;
pub type u16_ = ::std::os::raw::c_ushort;
pub type u32_ = ::std::os::raw::c_uint;
pub type s32 = ::std::os::raw::c_int;
pub type u64_ = ::std::os::raw::c_ulonglong;
pub type s64 = ::std::os::raw::c_longlong;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_timespec {
    pub sec: __le64,
    pub nsec: __le32,
    pub __pad: [__u8; 4usize],
}
#[test]
fn bindgen_test_layout_scoutfs_timespec() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_timespec>(),
        16usize,
        concat!("Size of: ", stringify!(scoutfs_timespec))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_timespec>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_timespec))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_timespec>())).sec as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_timespec),
            "::",
            stringify!(sec)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_timespec>())).nsec as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_timespec),
            "::",
            stringify!(nsec)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_timespec>())).__pad as *const _ as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_timespec),
            "::",
            stringify!(__pad)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_inet_addr {
    pub addr: __le32,
    pub port: __le16,
    pub __pad: [__u8; 2usize],
}
#[test]
fn bindgen_test_layout_scoutfs_inet_addr() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_inet_addr>(),
        8usize,
        concat!("Size of: ", stringify!(scoutfs_inet_addr))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_inet_addr>(),
        4usize,
        concat!("Alignment of ", stringify!(scoutfs_inet_addr))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_inet_addr>())).addr as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_inet_addr),
            "::",
            stringify!(addr)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_inet_addr>())).port as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_inet_addr),
            "::",
            stringify!(port)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_inet_addr>())).__pad as *const _ as usize },
        6usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_inet_addr),
            "::",
            stringify!(__pad)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_block_header {
    pub crc: __le32,
    pub magic: __le32,
    pub fsid: __le64,
    pub seq: __le64,
    pub blkno: __le64,
}
#[test]
fn bindgen_test_layout_scoutfs_block_header() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_block_header>(),
        32usize,
        concat!("Size of: ", stringify!(scoutfs_block_header))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_block_header>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_block_header))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_block_header>())).crc as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_block_header),
            "::",
            stringify!(crc)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_block_header>())).magic as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_block_header),
            "::",
            stringify!(magic)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_block_header>())).fsid as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_block_header),
            "::",
            stringify!(fsid)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_block_header>())).seq as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_block_header),
            "::",
            stringify!(seq)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_block_header>())).blkno as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_block_header),
            "::",
            stringify!(blkno)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_key {
    pub _sk_first: __le64,
    pub _sk_second: __le64,
    pub _sk_third: __le64,
    pub _sk_fourth: __u8,
    pub sk_zone: __u8,
    pub sk_type: __u8,
    pub __pad: [__u8; 5usize],
}
#[test]
fn bindgen_test_layout_scoutfs_key() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_key>(),
        32usize,
        concat!("Size of: ", stringify!(scoutfs_key))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_key>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_key))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_key>()))._sk_first as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_key),
            "::",
            stringify!(_sk_first)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_key>()))._sk_second as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_key),
            "::",
            stringify!(_sk_second)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_key>()))._sk_third as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_key),
            "::",
            stringify!(_sk_third)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_key>()))._sk_fourth as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_key),
            "::",
            stringify!(_sk_fourth)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_key>())).sk_zone as *const _ as usize },
        25usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_key),
            "::",
            stringify!(sk_zone)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_key>())).sk_type as *const _ as usize },
        26usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_key),
            "::",
            stringify!(sk_type)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_key>())).__pad as *const _ as usize },
        27usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_key),
            "::",
            stringify!(__pad)
        )
    );
}
#[repr(C)]
pub struct scoutfs_radix_block {
    pub hdr: scoutfs_block_header,
    pub __bindgen_anon_1: scoutfs_radix_block__bindgen_ty_1,
}
#[repr(C)]
pub struct scoutfs_radix_block__bindgen_ty_1 {
    pub refs: __BindgenUnionField<[scoutfs_radix_block__bindgen_ty_1_scoutfs_radix_ref; 0usize]>,
    pub bits: __BindgenUnionField<[__le64; 0usize]>,
    pub bindgen_union_field: [u64; 0usize],
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_radix_block__bindgen_ty_1_scoutfs_radix_ref {
    pub blkno: __le64,
    pub seq: __le64,
    pub sm_total: __le64,
    pub lg_total: __le64,
}
#[test]
fn bindgen_test_layout_scoutfs_radix_block__bindgen_ty_1_scoutfs_radix_ref() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_radix_block__bindgen_ty_1_scoutfs_radix_ref>(),
        32usize,
        concat!(
            "Size of: ",
            stringify!(scoutfs_radix_block__bindgen_ty_1_scoutfs_radix_ref)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_radix_block__bindgen_ty_1_scoutfs_radix_ref>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(scoutfs_radix_block__bindgen_ty_1_scoutfs_radix_ref)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_radix_block__bindgen_ty_1_scoutfs_radix_ref>())).blkno
                as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_radix_block__bindgen_ty_1_scoutfs_radix_ref),
            "::",
            stringify!(blkno)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_radix_block__bindgen_ty_1_scoutfs_radix_ref>())).seq
                as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_radix_block__bindgen_ty_1_scoutfs_radix_ref),
            "::",
            stringify!(seq)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_radix_block__bindgen_ty_1_scoutfs_radix_ref>())).sm_total
                as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_radix_block__bindgen_ty_1_scoutfs_radix_ref),
            "::",
            stringify!(sm_total)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_radix_block__bindgen_ty_1_scoutfs_radix_ref>())).lg_total
                as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_radix_block__bindgen_ty_1_scoutfs_radix_ref),
            "::",
            stringify!(lg_total)
        )
    );
}
#[test]
fn bindgen_test_layout_scoutfs_radix_block__bindgen_ty_1() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_radix_block__bindgen_ty_1>(),
        0usize,
        concat!("Size of: ", stringify!(scoutfs_radix_block__bindgen_ty_1))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_radix_block__bindgen_ty_1>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(scoutfs_radix_block__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_radix_block__bindgen_ty_1>())).refs as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_radix_block__bindgen_ty_1),
            "::",
            stringify!(refs)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_radix_block__bindgen_ty_1>())).bits as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_radix_block__bindgen_ty_1),
            "::",
            stringify!(bits)
        )
    );
}
impl Default for scoutfs_radix_block__bindgen_ty_1 {
    fn default() -> Self {
        unsafe { ::std::mem::zeroed() }
    }
}
#[test]
fn bindgen_test_layout_scoutfs_radix_block() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_radix_block>(),
        32usize,
        concat!("Size of: ", stringify!(scoutfs_radix_block))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_radix_block>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_radix_block))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_radix_block>())).hdr as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_radix_block),
            "::",
            stringify!(hdr)
        )
    );
}
impl Default for scoutfs_radix_block {
    fn default() -> Self {
        unsafe { ::std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_avl_root {
    pub node: __le16,
}
#[test]
fn bindgen_test_layout_scoutfs_avl_root() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_avl_root>(),
        2usize,
        concat!("Size of: ", stringify!(scoutfs_avl_root))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_avl_root>(),
        2usize,
        concat!("Alignment of ", stringify!(scoutfs_avl_root))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_avl_root>())).node as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_avl_root),
            "::",
            stringify!(node)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_avl_node {
    pub parent: __le16,
    pub left: __le16,
    pub right: __le16,
    pub height: __u8,
    pub __pad: [__u8; 1usize],
}
#[test]
fn bindgen_test_layout_scoutfs_avl_node() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_avl_node>(),
        8usize,
        concat!("Size of: ", stringify!(scoutfs_avl_node))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_avl_node>(),
        2usize,
        concat!("Alignment of ", stringify!(scoutfs_avl_node))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_avl_node>())).parent as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_avl_node),
            "::",
            stringify!(parent)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_avl_node>())).left as *const _ as usize },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_avl_node),
            "::",
            stringify!(left)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_avl_node>())).right as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_avl_node),
            "::",
            stringify!(right)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_avl_node>())).height as *const _ as usize },
        6usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_avl_node),
            "::",
            stringify!(height)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_avl_node>())).__pad as *const _ as usize },
        7usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_avl_node),
            "::",
            stringify!(__pad)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_btree_ref {
    pub blkno: __le64,
    pub seq: __le64,
}
#[test]
fn bindgen_test_layout_scoutfs_btree_ref() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_btree_ref>(),
        16usize,
        concat!("Size of: ", stringify!(scoutfs_btree_ref))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_btree_ref>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_btree_ref))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_btree_ref>())).blkno as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_btree_ref),
            "::",
            stringify!(blkno)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_btree_ref>())).seq as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_btree_ref),
            "::",
            stringify!(seq)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_btree_root {
    pub ref_: scoutfs_btree_ref,
    pub height: __u8,
    pub __pad: [__u8; 7usize],
}
#[test]
fn bindgen_test_layout_scoutfs_btree_root() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_btree_root>(),
        24usize,
        concat!("Size of: ", stringify!(scoutfs_btree_root))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_btree_root>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_btree_root))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_btree_root>())).ref_ as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_btree_root),
            "::",
            stringify!(ref_)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_btree_root>())).height as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_btree_root),
            "::",
            stringify!(height)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_btree_root>())).__pad as *const _ as usize },
        17usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_btree_root),
            "::",
            stringify!(__pad)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_btree_item {
    pub node: scoutfs_avl_node,
    pub key: scoutfs_key,
    pub val_off: __le16,
    pub val_len: __le16,
    pub __pad: [__u8; 4usize],
}
#[test]
fn bindgen_test_layout_scoutfs_btree_item() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_btree_item>(),
        48usize,
        concat!("Size of: ", stringify!(scoutfs_btree_item))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_btree_item>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_btree_item))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_btree_item>())).node as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_btree_item),
            "::",
            stringify!(node)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_btree_item>())).key as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_btree_item),
            "::",
            stringify!(key)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_btree_item>())).val_off as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_btree_item),
            "::",
            stringify!(val_off)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_btree_item>())).val_len as *const _ as usize },
        42usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_btree_item),
            "::",
            stringify!(val_len)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_btree_item>())).__pad as *const _ as usize },
        44usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_btree_item),
            "::",
            stringify!(__pad)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct scoutfs_btree_block {
    pub hdr: scoutfs_block_header,
    pub item_root: scoutfs_avl_root,
    pub nr_items: __le16,
    pub total_item_bytes: __le16,
    pub mid_free_len: __le16,
    pub level: __u8,
    pub __pad: [__u8; 7usize],
    pub items: __IncompleteArrayField<scoutfs_btree_item>,
}
#[test]
fn bindgen_test_layout_scoutfs_btree_block() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_btree_block>(),
        48usize,
        concat!("Size of: ", stringify!(scoutfs_btree_block))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_btree_block>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_btree_block))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_btree_block>())).hdr as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_btree_block),
            "::",
            stringify!(hdr)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_btree_block>())).item_root as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_btree_block),
            "::",
            stringify!(item_root)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_btree_block>())).nr_items as *const _ as usize },
        34usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_btree_block),
            "::",
            stringify!(nr_items)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_btree_block>())).total_item_bytes as *const _ as usize
        },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_btree_block),
            "::",
            stringify!(total_item_bytes)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_btree_block>())).mid_free_len as *const _ as usize
        },
        38usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_btree_block),
            "::",
            stringify!(mid_free_len)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_btree_block>())).level as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_btree_block),
            "::",
            stringify!(level)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_btree_block>())).__pad as *const _ as usize },
        41usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_btree_block),
            "::",
            stringify!(__pad)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_btree_block>())).items as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_btree_block),
            "::",
            stringify!(items)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_alloc_list_ref {
    pub blkno: __le64,
    pub seq: __le64,
}
#[test]
fn bindgen_test_layout_scoutfs_alloc_list_ref() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_alloc_list_ref>(),
        16usize,
        concat!("Size of: ", stringify!(scoutfs_alloc_list_ref))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_alloc_list_ref>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_alloc_list_ref))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_alloc_list_ref>())).blkno as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_alloc_list_ref),
            "::",
            stringify!(blkno)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_alloc_list_ref>())).seq as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_alloc_list_ref),
            "::",
            stringify!(seq)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_alloc_list_head {
    pub ref_: scoutfs_alloc_list_ref,
    pub total_nr: __le64,
    pub first_nr: __le32,
    pub __pad: [__u8; 4usize],
}
#[test]
fn bindgen_test_layout_scoutfs_alloc_list_head() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_alloc_list_head>(),
        32usize,
        concat!("Size of: ", stringify!(scoutfs_alloc_list_head))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_alloc_list_head>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_alloc_list_head))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_alloc_list_head>())).ref_ as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_alloc_list_head),
            "::",
            stringify!(ref_)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_alloc_list_head>())).total_nr as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_alloc_list_head),
            "::",
            stringify!(total_nr)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_alloc_list_head>())).first_nr as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_alloc_list_head),
            "::",
            stringify!(first_nr)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_alloc_list_head>())).__pad as *const _ as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_alloc_list_head),
            "::",
            stringify!(__pad)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct scoutfs_alloc_list_block {
    pub hdr: scoutfs_block_header,
    pub next: scoutfs_alloc_list_ref,
    pub start: __le32,
    pub nr: __le32,
    pub blknos: __IncompleteArrayField<__le64>,
}
#[test]
fn bindgen_test_layout_scoutfs_alloc_list_block() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_alloc_list_block>(),
        56usize,
        concat!("Size of: ", stringify!(scoutfs_alloc_list_block))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_alloc_list_block>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_alloc_list_block))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_alloc_list_block>())).hdr as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_alloc_list_block),
            "::",
            stringify!(hdr)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_alloc_list_block>())).next as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_alloc_list_block),
            "::",
            stringify!(next)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_alloc_list_block>())).start as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_alloc_list_block),
            "::",
            stringify!(start)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_alloc_list_block>())).nr as *const _ as usize },
        52usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_alloc_list_block),
            "::",
            stringify!(nr)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_alloc_list_block>())).blknos as *const _ as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_alloc_list_block),
            "::",
            stringify!(blknos)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_alloc_root {
    pub total_len: __le64,
    pub root: scoutfs_btree_root,
}
#[test]
fn bindgen_test_layout_scoutfs_alloc_root() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_alloc_root>(),
        32usize,
        concat!("Size of: ", stringify!(scoutfs_alloc_root))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_alloc_root>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_alloc_root))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_alloc_root>())).total_len as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_alloc_root),
            "::",
            stringify!(total_len)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_alloc_root>())).root as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_alloc_root),
            "::",
            stringify!(root)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_mounted_client_btree_val {
    pub flags: __u8,
}
#[test]
fn bindgen_test_layout_scoutfs_mounted_client_btree_val() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_mounted_client_btree_val>(),
        1usize,
        concat!("Size of: ", stringify!(scoutfs_mounted_client_btree_val))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_mounted_client_btree_val>(),
        1usize,
        concat!(
            "Alignment of ",
            stringify!(scoutfs_mounted_client_btree_val)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_mounted_client_btree_val>())).flags as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_mounted_client_btree_val),
            "::",
            stringify!(flags)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_srch_entry {
    pub hash: __le64,
    pub ino: __le64,
    pub id: __le64,
}
#[test]
fn bindgen_test_layout_scoutfs_srch_entry() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_srch_entry>(),
        24usize,
        concat!("Size of: ", stringify!(scoutfs_srch_entry))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_srch_entry>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_srch_entry))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_srch_entry>())).hash as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_srch_entry),
            "::",
            stringify!(hash)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_srch_entry>())).ino as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_srch_entry),
            "::",
            stringify!(ino)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_srch_entry>())).id as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_srch_entry),
            "::",
            stringify!(id)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_srch_ref {
    pub blkno: __le64,
    pub seq: __le64,
}
#[test]
fn bindgen_test_layout_scoutfs_srch_ref() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_srch_ref>(),
        16usize,
        concat!("Size of: ", stringify!(scoutfs_srch_ref))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_srch_ref>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_srch_ref))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_srch_ref>())).blkno as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_srch_ref),
            "::",
            stringify!(blkno)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_srch_ref>())).seq as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_srch_ref),
            "::",
            stringify!(seq)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_srch_file {
    pub first: scoutfs_srch_entry,
    pub last: scoutfs_srch_entry,
    pub ref_: scoutfs_srch_ref,
    pub blocks: __le64,
    pub entries: __le64,
    pub height: __u8,
    pub __pad: [__u8; 7usize],
}
#[test]
fn bindgen_test_layout_scoutfs_srch_file() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_srch_file>(),
        88usize,
        concat!("Size of: ", stringify!(scoutfs_srch_file))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_srch_file>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_srch_file))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_srch_file>())).first as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_srch_file),
            "::",
            stringify!(first)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_srch_file>())).last as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_srch_file),
            "::",
            stringify!(last)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_srch_file>())).ref_ as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_srch_file),
            "::",
            stringify!(ref_)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_srch_file>())).blocks as *const _ as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_srch_file),
            "::",
            stringify!(blocks)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_srch_file>())).entries as *const _ as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_srch_file),
            "::",
            stringify!(entries)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_srch_file>())).height as *const _ as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_srch_file),
            "::",
            stringify!(height)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_srch_file>())).__pad as *const _ as usize },
        81usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_srch_file),
            "::",
            stringify!(__pad)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct scoutfs_srch_parent {
    pub hdr: scoutfs_block_header,
    pub refs: __IncompleteArrayField<scoutfs_srch_ref>,
}
#[test]
fn bindgen_test_layout_scoutfs_srch_parent() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_srch_parent>(),
        32usize,
        concat!("Size of: ", stringify!(scoutfs_srch_parent))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_srch_parent>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_srch_parent))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_srch_parent>())).hdr as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_srch_parent),
            "::",
            stringify!(hdr)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_srch_parent>())).refs as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_srch_parent),
            "::",
            stringify!(refs)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct scoutfs_srch_block {
    pub hdr: scoutfs_block_header,
    pub first: scoutfs_srch_entry,
    pub last: scoutfs_srch_entry,
    pub tail: scoutfs_srch_entry,
    pub entry_nr: __le32,
    pub entry_bytes: __le32,
    pub entries: __IncompleteArrayField<__u8>,
}
#[test]
fn bindgen_test_layout_scoutfs_srch_block() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_srch_block>(),
        112usize,
        concat!("Size of: ", stringify!(scoutfs_srch_block))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_srch_block>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_srch_block))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_srch_block>())).hdr as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_srch_block),
            "::",
            stringify!(hdr)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_srch_block>())).first as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_srch_block),
            "::",
            stringify!(first)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_srch_block>())).last as *const _ as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_srch_block),
            "::",
            stringify!(last)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_srch_block>())).tail as *const _ as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_srch_block),
            "::",
            stringify!(tail)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_srch_block>())).entry_nr as *const _ as usize },
        104usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_srch_block),
            "::",
            stringify!(entry_nr)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_srch_block>())).entry_bytes as *const _ as usize },
        108usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_srch_block),
            "::",
            stringify!(entry_bytes)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_srch_block>())).entries as *const _ as usize },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_srch_block),
            "::",
            stringify!(entries)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_srch_compact {
    pub meta_avail: scoutfs_alloc_list_head,
    pub meta_freed: scoutfs_alloc_list_head,
    pub id: __le64,
    pub nr: __u8,
    pub flags: __u8,
    pub __pad: [__u8; 6usize],
    pub out: scoutfs_srch_file,
    pub in_: [scoutfs_srch_compact_scoutfs_srch_compact_input; 4usize],
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_srch_compact_scoutfs_srch_compact_input {
    pub sfl: scoutfs_srch_file,
    pub blk: __le64,
    pub pos: __le64,
}
#[test]
fn bindgen_test_layout_scoutfs_srch_compact_scoutfs_srch_compact_input() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_srch_compact_scoutfs_srch_compact_input>(),
        104usize,
        concat!(
            "Size of: ",
            stringify!(scoutfs_srch_compact_scoutfs_srch_compact_input)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_srch_compact_scoutfs_srch_compact_input>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(scoutfs_srch_compact_scoutfs_srch_compact_input)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_srch_compact_scoutfs_srch_compact_input>())).sfl
                as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_srch_compact_scoutfs_srch_compact_input),
            "::",
            stringify!(sfl)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_srch_compact_scoutfs_srch_compact_input>())).blk
                as *const _ as usize
        },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_srch_compact_scoutfs_srch_compact_input),
            "::",
            stringify!(blk)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_srch_compact_scoutfs_srch_compact_input>())).pos
                as *const _ as usize
        },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_srch_compact_scoutfs_srch_compact_input),
            "::",
            stringify!(pos)
        )
    );
}
#[test]
fn bindgen_test_layout_scoutfs_srch_compact() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_srch_compact>(),
        584usize,
        concat!("Size of: ", stringify!(scoutfs_srch_compact))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_srch_compact>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_srch_compact))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_srch_compact>())).meta_avail as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_srch_compact),
            "::",
            stringify!(meta_avail)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_srch_compact>())).meta_freed as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_srch_compact),
            "::",
            stringify!(meta_freed)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_srch_compact>())).id as *const _ as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_srch_compact),
            "::",
            stringify!(id)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_srch_compact>())).nr as *const _ as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_srch_compact),
            "::",
            stringify!(nr)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_srch_compact>())).flags as *const _ as usize },
        73usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_srch_compact),
            "::",
            stringify!(flags)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_srch_compact>())).__pad as *const _ as usize },
        74usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_srch_compact),
            "::",
            stringify!(__pad)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_srch_compact>())).out as *const _ as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_srch_compact),
            "::",
            stringify!(out)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_srch_compact>())).in_ as *const _ as usize },
        168usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_srch_compact),
            "::",
            stringify!(in_)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_log_trees {
    pub meta_avail: scoutfs_alloc_list_head,
    pub meta_freed: scoutfs_alloc_list_head,
    pub item_root: scoutfs_btree_root,
    pub bloom_ref: scoutfs_btree_ref,
    pub data_avail: scoutfs_alloc_root,
    pub data_freed: scoutfs_alloc_root,
    pub srch_file: scoutfs_srch_file,
    pub max_item_vers: __le64,
    pub rid: __le64,
    pub nr: __le64,
}
#[test]
fn bindgen_test_layout_scoutfs_log_trees() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_log_trees>(),
        280usize,
        concat!("Size of: ", stringify!(scoutfs_log_trees))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_log_trees>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_log_trees))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_log_trees>())).meta_avail as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_log_trees),
            "::",
            stringify!(meta_avail)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_log_trees>())).meta_freed as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_log_trees),
            "::",
            stringify!(meta_freed)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_log_trees>())).item_root as *const _ as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_log_trees),
            "::",
            stringify!(item_root)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_log_trees>())).bloom_ref as *const _ as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_log_trees),
            "::",
            stringify!(bloom_ref)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_log_trees>())).data_avail as *const _ as usize },
        104usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_log_trees),
            "::",
            stringify!(data_avail)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_log_trees>())).data_freed as *const _ as usize },
        136usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_log_trees),
            "::",
            stringify!(data_freed)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_log_trees>())).srch_file as *const _ as usize },
        168usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_log_trees),
            "::",
            stringify!(srch_file)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_log_trees>())).max_item_vers as *const _ as usize },
        256usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_log_trees),
            "::",
            stringify!(max_item_vers)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_log_trees>())).rid as *const _ as usize },
        264usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_log_trees),
            "::",
            stringify!(rid)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_log_trees>())).nr as *const _ as usize },
        272usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_log_trees),
            "::",
            stringify!(nr)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct scoutfs_log_item_value {
    pub vers: __le64,
    pub flags: __u8,
    pub __pad: [__u8; 7usize],
    pub data: __IncompleteArrayField<__u8>,
}
#[test]
fn bindgen_test_layout_scoutfs_log_item_value() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_log_item_value>(),
        16usize,
        concat!("Size of: ", stringify!(scoutfs_log_item_value))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_log_item_value>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_log_item_value))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_log_item_value>())).vers as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_log_item_value),
            "::",
            stringify!(vers)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_log_item_value>())).flags as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_log_item_value),
            "::",
            stringify!(flags)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_log_item_value>())).__pad as *const _ as usize },
        9usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_log_item_value),
            "::",
            stringify!(__pad)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_log_item_value>())).data as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_log_item_value),
            "::",
            stringify!(data)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct scoutfs_bloom_block {
    pub hdr: scoutfs_block_header,
    pub total_set: __le64,
    pub bits: __IncompleteArrayField<__le64>,
}
#[test]
fn bindgen_test_layout_scoutfs_bloom_block() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_bloom_block>(),
        40usize,
        concat!("Size of: ", stringify!(scoutfs_bloom_block))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_bloom_block>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_bloom_block))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_bloom_block>())).hdr as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_bloom_block),
            "::",
            stringify!(hdr)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_bloom_block>())).total_set as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_bloom_block),
            "::",
            stringify!(total_set)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_bloom_block>())).bits as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_bloom_block),
            "::",
            stringify!(bits)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_data_extent_val {
    pub blkno: __le64,
    pub flags: __u8,
    pub __pad: [__u8; 7usize],
}
#[test]
fn bindgen_test_layout_scoutfs_data_extent_val() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_data_extent_val>(),
        16usize,
        concat!("Size of: ", stringify!(scoutfs_data_extent_val))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_data_extent_val>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_data_extent_val))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_data_extent_val>())).blkno as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_data_extent_val),
            "::",
            stringify!(blkno)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_data_extent_val>())).flags as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_data_extent_val),
            "::",
            stringify!(flags)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_data_extent_val>())).__pad as *const _ as usize },
        9usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_data_extent_val),
            "::",
            stringify!(__pad)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct scoutfs_xattr {
    pub val_len: __le16,
    pub name_len: __u8,
    pub __pad: [__u8; 5usize],
    pub name: __IncompleteArrayField<__u8>,
}
#[test]
fn bindgen_test_layout_scoutfs_xattr() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_xattr>(),
        8usize,
        concat!("Size of: ", stringify!(scoutfs_xattr))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_xattr>(),
        2usize,
        concat!("Alignment of ", stringify!(scoutfs_xattr))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_xattr>())).val_len as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_xattr),
            "::",
            stringify!(val_len)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_xattr>())).name_len as *const _ as usize },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_xattr),
            "::",
            stringify!(name_len)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_xattr>())).__pad as *const _ as usize },
        3usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_xattr),
            "::",
            stringify!(__pad)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_xattr>())).name as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_xattr),
            "::",
            stringify!(name)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct scoutfs_quorum_block {
    pub fsid: __le64,
    pub blkno: __le64,
    pub term: __le64,
    pub write_nr: __le64,
    pub voter_rid: __le64,
    pub vote_for_rid: __le64,
    pub crc: __le32,
    pub log_nr: __u8,
    pub __pad: [__u8; 3usize],
    pub log: __IncompleteArrayField<scoutfs_quorum_block_scoutfs_quorum_log>,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_quorum_block_scoutfs_quorum_log {
    pub term: __le64,
    pub rid: __le64,
    pub addr: scoutfs_inet_addr,
}
#[test]
fn bindgen_test_layout_scoutfs_quorum_block_scoutfs_quorum_log() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_quorum_block_scoutfs_quorum_log>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(scoutfs_quorum_block_scoutfs_quorum_log)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_quorum_block_scoutfs_quorum_log>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(scoutfs_quorum_block_scoutfs_quorum_log)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_quorum_block_scoutfs_quorum_log>())).term as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_quorum_block_scoutfs_quorum_log),
            "::",
            stringify!(term)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_quorum_block_scoutfs_quorum_log>())).rid as *const _
                as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_quorum_block_scoutfs_quorum_log),
            "::",
            stringify!(rid)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_quorum_block_scoutfs_quorum_log>())).addr as *const _
                as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_quorum_block_scoutfs_quorum_log),
            "::",
            stringify!(addr)
        )
    );
}
#[test]
fn bindgen_test_layout_scoutfs_quorum_block() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_quorum_block>(),
        56usize,
        concat!("Size of: ", stringify!(scoutfs_quorum_block))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_quorum_block>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_quorum_block))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_quorum_block>())).fsid as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_quorum_block),
            "::",
            stringify!(fsid)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_quorum_block>())).blkno as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_quorum_block),
            "::",
            stringify!(blkno)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_quorum_block>())).term as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_quorum_block),
            "::",
            stringify!(term)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_quorum_block>())).write_nr as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_quorum_block),
            "::",
            stringify!(write_nr)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_quorum_block>())).voter_rid as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_quorum_block),
            "::",
            stringify!(voter_rid)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_quorum_block>())).vote_for_rid as *const _ as usize
        },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_quorum_block),
            "::",
            stringify!(vote_for_rid)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_quorum_block>())).crc as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_quorum_block),
            "::",
            stringify!(crc)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_quorum_block>())).log_nr as *const _ as usize },
        52usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_quorum_block),
            "::",
            stringify!(log_nr)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_quorum_block>())).__pad as *const _ as usize },
        53usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_quorum_block),
            "::",
            stringify!(__pad)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_quorum_block>())).log as *const _ as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_quorum_block),
            "::",
            stringify!(log)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_super_block {
    pub hdr: scoutfs_block_header,
    pub id: __le64,
    pub version: __le64,
    pub flags: __le64,
    pub uuid: [__u8; 16usize],
    pub next_ino: __le64,
    pub next_trans_seq: __le64,
    pub total_meta_blocks: __le64,
    pub first_meta_blkno: __le64,
    pub last_meta_blkno: __le64,
    pub total_data_blocks: __le64,
    pub first_data_blkno: __le64,
    pub last_data_blkno: __le64,
    pub quorum_fenced_term: __le64,
    pub quorum_server_term: __le64,
    pub unmount_barrier: __le64,
    pub quorum_count: __u8,
    pub __pad: [__u8; 7usize],
    pub server_addr: scoutfs_inet_addr,
    pub meta_alloc: [scoutfs_alloc_root; 2usize],
    pub data_alloc: scoutfs_alloc_root,
    pub server_meta_avail: [scoutfs_alloc_list_head; 2usize],
    pub server_meta_freed: [scoutfs_alloc_list_head; 2usize],
    pub fs_root: scoutfs_btree_root,
    pub logs_root: scoutfs_btree_root,
    pub lock_clients: scoutfs_btree_root,
    pub trans_seqs: scoutfs_btree_root,
    pub mounted_clients: scoutfs_btree_root,
    pub srch_root: scoutfs_btree_root,
}
#[test]
fn bindgen_test_layout_scoutfs_super_block() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_super_block>(),
        544usize,
        concat!("Size of: ", stringify!(scoutfs_super_block))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_super_block>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_super_block))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_super_block>())).hdr as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_super_block),
            "::",
            stringify!(hdr)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_super_block>())).id as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_super_block),
            "::",
            stringify!(id)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_super_block>())).version as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_super_block),
            "::",
            stringify!(version)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_super_block>())).flags as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_super_block),
            "::",
            stringify!(flags)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_super_block>())).uuid as *const _ as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_super_block),
            "::",
            stringify!(uuid)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_super_block>())).next_ino as *const _ as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_super_block),
            "::",
            stringify!(next_ino)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_super_block>())).next_trans_seq as *const _ as usize
        },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_super_block),
            "::",
            stringify!(next_trans_seq)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_super_block>())).total_meta_blocks as *const _ as usize
        },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_super_block),
            "::",
            stringify!(total_meta_blocks)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_super_block>())).first_meta_blkno as *const _ as usize
        },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_super_block),
            "::",
            stringify!(first_meta_blkno)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_super_block>())).last_meta_blkno as *const _ as usize
        },
        104usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_super_block),
            "::",
            stringify!(last_meta_blkno)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_super_block>())).total_data_blocks as *const _ as usize
        },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_super_block),
            "::",
            stringify!(total_data_blocks)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_super_block>())).first_data_blkno as *const _ as usize
        },
        120usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_super_block),
            "::",
            stringify!(first_data_blkno)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_super_block>())).last_data_blkno as *const _ as usize
        },
        128usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_super_block),
            "::",
            stringify!(last_data_blkno)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_super_block>())).quorum_fenced_term as *const _ as usize
        },
        136usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_super_block),
            "::",
            stringify!(quorum_fenced_term)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_super_block>())).quorum_server_term as *const _ as usize
        },
        144usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_super_block),
            "::",
            stringify!(quorum_server_term)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_super_block>())).unmount_barrier as *const _ as usize
        },
        152usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_super_block),
            "::",
            stringify!(unmount_barrier)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_super_block>())).quorum_count as *const _ as usize
        },
        160usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_super_block),
            "::",
            stringify!(quorum_count)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_super_block>())).__pad as *const _ as usize },
        161usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_super_block),
            "::",
            stringify!(__pad)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_super_block>())).server_addr as *const _ as usize },
        168usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_super_block),
            "::",
            stringify!(server_addr)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_super_block>())).meta_alloc as *const _ as usize },
        176usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_super_block),
            "::",
            stringify!(meta_alloc)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_super_block>())).data_alloc as *const _ as usize },
        240usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_super_block),
            "::",
            stringify!(data_alloc)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_super_block>())).server_meta_avail as *const _ as usize
        },
        272usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_super_block),
            "::",
            stringify!(server_meta_avail)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_super_block>())).server_meta_freed as *const _ as usize
        },
        336usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_super_block),
            "::",
            stringify!(server_meta_freed)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_super_block>())).fs_root as *const _ as usize },
        400usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_super_block),
            "::",
            stringify!(fs_root)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_super_block>())).logs_root as *const _ as usize },
        424usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_super_block),
            "::",
            stringify!(logs_root)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_super_block>())).lock_clients as *const _ as usize
        },
        448usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_super_block),
            "::",
            stringify!(lock_clients)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_super_block>())).trans_seqs as *const _ as usize },
        472usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_super_block),
            "::",
            stringify!(trans_seqs)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_super_block>())).mounted_clients as *const _ as usize
        },
        496usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_super_block),
            "::",
            stringify!(mounted_clients)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_super_block>())).srch_root as *const _ as usize },
        520usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_super_block),
            "::",
            stringify!(srch_root)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_inode {
    pub size: __le64,
    pub meta_seq: __le64,
    pub data_seq: __le64,
    pub data_version: __le64,
    pub online_blocks: __le64,
    pub offline_blocks: __le64,
    pub next_readdir_pos: __le64,
    pub next_xattr_id: __le64,
    pub nlink: __le32,
    pub uid: __le32,
    pub gid: __le32,
    pub mode: __le32,
    pub rdev: __le32,
    pub flags: __le32,
    pub atime: scoutfs_timespec,
    pub ctime: scoutfs_timespec,
    pub mtime: scoutfs_timespec,
}
#[test]
fn bindgen_test_layout_scoutfs_inode() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_inode>(),
        136usize,
        concat!("Size of: ", stringify!(scoutfs_inode))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_inode>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_inode))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_inode>())).size as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_inode),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_inode>())).meta_seq as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_inode),
            "::",
            stringify!(meta_seq)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_inode>())).data_seq as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_inode),
            "::",
            stringify!(data_seq)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_inode>())).data_version as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_inode),
            "::",
            stringify!(data_version)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_inode>())).online_blocks as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_inode),
            "::",
            stringify!(online_blocks)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_inode>())).offline_blocks as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_inode),
            "::",
            stringify!(offline_blocks)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_inode>())).next_readdir_pos as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_inode),
            "::",
            stringify!(next_readdir_pos)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_inode>())).next_xattr_id as *const _ as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_inode),
            "::",
            stringify!(next_xattr_id)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_inode>())).nlink as *const _ as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_inode),
            "::",
            stringify!(nlink)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_inode>())).uid as *const _ as usize },
        68usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_inode),
            "::",
            stringify!(uid)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_inode>())).gid as *const _ as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_inode),
            "::",
            stringify!(gid)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_inode>())).mode as *const _ as usize },
        76usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_inode),
            "::",
            stringify!(mode)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_inode>())).rdev as *const _ as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_inode),
            "::",
            stringify!(rdev)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_inode>())).flags as *const _ as usize },
        84usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_inode),
            "::",
            stringify!(flags)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_inode>())).atime as *const _ as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_inode),
            "::",
            stringify!(atime)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_inode>())).ctime as *const _ as usize },
        104usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_inode),
            "::",
            stringify!(ctime)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_inode>())).mtime as *const _ as usize },
        120usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_inode),
            "::",
            stringify!(mtime)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct scoutfs_dirent {
    pub ino: __le64,
    pub hash: __le64,
    pub pos: __le64,
    pub type_: __u8,
    pub __pad: [__u8; 7usize],
    pub name: __IncompleteArrayField<__u8>,
}
#[test]
fn bindgen_test_layout_scoutfs_dirent() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_dirent>(),
        32usize,
        concat!("Size of: ", stringify!(scoutfs_dirent))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_dirent>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_dirent))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_dirent>())).ino as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_dirent),
            "::",
            stringify!(ino)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_dirent>())).hash as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_dirent),
            "::",
            stringify!(hash)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_dirent>())).pos as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_dirent),
            "::",
            stringify!(pos)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_dirent>())).type_ as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_dirent),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_dirent>())).__pad as *const _ as usize },
        25usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_dirent),
            "::",
            stringify!(__pad)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_dirent>())).name as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_dirent),
            "::",
            stringify!(name)
        )
    );
}
pub const scoutfs_dentry_type_SCOUTFS_DT_FIFO: scoutfs_dentry_type = 0;
pub const scoutfs_dentry_type_SCOUTFS_DT_CHR: scoutfs_dentry_type = 1;
pub const scoutfs_dentry_type_SCOUTFS_DT_DIR: scoutfs_dentry_type = 2;
pub const scoutfs_dentry_type_SCOUTFS_DT_BLK: scoutfs_dentry_type = 3;
pub const scoutfs_dentry_type_SCOUTFS_DT_REG: scoutfs_dentry_type = 4;
pub const scoutfs_dentry_type_SCOUTFS_DT_LNK: scoutfs_dentry_type = 5;
pub const scoutfs_dentry_type_SCOUTFS_DT_SOCK: scoutfs_dentry_type = 6;
pub const scoutfs_dentry_type_SCOUTFS_DT_WHT: scoutfs_dentry_type = 7;
pub type scoutfs_dentry_type = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_net_greeting {
    pub fsid: __le64,
    pub version: __le64,
    pub server_term: __le64,
    pub unmount_barrier: __le64,
    pub rid: __le64,
    pub flags: __le64,
}
#[test]
fn bindgen_test_layout_scoutfs_net_greeting() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_net_greeting>(),
        48usize,
        concat!("Size of: ", stringify!(scoutfs_net_greeting))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_net_greeting>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_net_greeting))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_net_greeting>())).fsid as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_net_greeting),
            "::",
            stringify!(fsid)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_net_greeting>())).version as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_net_greeting),
            "::",
            stringify!(version)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_net_greeting>())).server_term as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_net_greeting),
            "::",
            stringify!(server_term)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_net_greeting>())).unmount_barrier as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_net_greeting),
            "::",
            stringify!(unmount_barrier)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_net_greeting>())).rid as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_net_greeting),
            "::",
            stringify!(rid)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_net_greeting>())).flags as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_net_greeting),
            "::",
            stringify!(flags)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct scoutfs_net_header {
    pub clock_sync_id: __le64,
    pub seq: __le64,
    pub recv_seq: __le64,
    pub id: __le64,
    pub data_len: __le16,
    pub cmd: __u8,
    pub flags: __u8,
    pub error: __u8,
    pub __pad: [__u8; 3usize],
    pub data: __IncompleteArrayField<__u8>,
}
#[test]
fn bindgen_test_layout_scoutfs_net_header() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_net_header>(),
        40usize,
        concat!("Size of: ", stringify!(scoutfs_net_header))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_net_header>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_net_header))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_net_header>())).clock_sync_id as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_net_header),
            "::",
            stringify!(clock_sync_id)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_net_header>())).seq as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_net_header),
            "::",
            stringify!(seq)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_net_header>())).recv_seq as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_net_header),
            "::",
            stringify!(recv_seq)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_net_header>())).id as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_net_header),
            "::",
            stringify!(id)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_net_header>())).data_len as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_net_header),
            "::",
            stringify!(data_len)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_net_header>())).cmd as *const _ as usize },
        34usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_net_header),
            "::",
            stringify!(cmd)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_net_header>())).flags as *const _ as usize },
        35usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_net_header),
            "::",
            stringify!(flags)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_net_header>())).error as *const _ as usize },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_net_header),
            "::",
            stringify!(error)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_net_header>())).__pad as *const _ as usize },
        37usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_net_header),
            "::",
            stringify!(__pad)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_net_header>())).data as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_net_header),
            "::",
            stringify!(data)
        )
    );
}
pub const scoutfs_net_cmd_SCOUTFS_NET_CMD_GREETING: scoutfs_net_cmd = 0;
pub const scoutfs_net_cmd_SCOUTFS_NET_CMD_ALLOC_INODES: scoutfs_net_cmd = 1;
pub const scoutfs_net_cmd_SCOUTFS_NET_CMD_GET_LOG_TREES: scoutfs_net_cmd = 2;
pub const scoutfs_net_cmd_SCOUTFS_NET_CMD_COMMIT_LOG_TREES: scoutfs_net_cmd = 3;
pub const scoutfs_net_cmd_SCOUTFS_NET_CMD_GET_ROOTS: scoutfs_net_cmd = 4;
pub const scoutfs_net_cmd_SCOUTFS_NET_CMD_ADVANCE_SEQ: scoutfs_net_cmd = 5;
pub const scoutfs_net_cmd_SCOUTFS_NET_CMD_GET_LAST_SEQ: scoutfs_net_cmd = 6;
pub const scoutfs_net_cmd_SCOUTFS_NET_CMD_LOCK: scoutfs_net_cmd = 7;
pub const scoutfs_net_cmd_SCOUTFS_NET_CMD_LOCK_RECOVER: scoutfs_net_cmd = 8;
pub const scoutfs_net_cmd_SCOUTFS_NET_CMD_SRCH_GET_COMPACT: scoutfs_net_cmd = 9;
pub const scoutfs_net_cmd_SCOUTFS_NET_CMD_SRCH_COMMIT_COMPACT: scoutfs_net_cmd = 10;
pub const scoutfs_net_cmd_SCOUTFS_NET_CMD_FAREWELL: scoutfs_net_cmd = 11;
pub const scoutfs_net_cmd_SCOUTFS_NET_CMD_UNKNOWN: scoutfs_net_cmd = 12;
pub type scoutfs_net_cmd = ::std::os::raw::c_uint;
pub const scoutfs_net_errors_SCOUTFS_NET_ERR_NONE: scoutfs_net_errors = 0;
pub const scoutfs_net_errors_SCOUTFS_NET_ERR_ENOENT: scoutfs_net_errors = 1;
pub const scoutfs_net_errors_SCOUTFS_NET_ERR_ENOMEM: scoutfs_net_errors = 2;
pub const scoutfs_net_errors_SCOUTFS_NET_ERR_EIO: scoutfs_net_errors = 3;
pub const scoutfs_net_errors_SCOUTFS_NET_ERR_ENOSPC: scoutfs_net_errors = 4;
pub const scoutfs_net_errors_SCOUTFS_NET_ERR_EINVAL: scoutfs_net_errors = 5;
pub const scoutfs_net_errors_SCOUTFS_NET_ERR_UNKNOWN: scoutfs_net_errors = 6;
pub type scoutfs_net_errors = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_net_inode_alloc {
    pub ino: __le64,
    pub nr: __le64,
}
#[test]
fn bindgen_test_layout_scoutfs_net_inode_alloc() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_net_inode_alloc>(),
        16usize,
        concat!("Size of: ", stringify!(scoutfs_net_inode_alloc))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_net_inode_alloc>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_net_inode_alloc))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_net_inode_alloc>())).ino as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_net_inode_alloc),
            "::",
            stringify!(ino)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_net_inode_alloc>())).nr as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_net_inode_alloc),
            "::",
            stringify!(nr)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_net_roots {
    pub fs_root: scoutfs_btree_root,
    pub logs_root: scoutfs_btree_root,
    pub srch_root: scoutfs_btree_root,
}
#[test]
fn bindgen_test_layout_scoutfs_net_roots() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_net_roots>(),
        72usize,
        concat!("Size of: ", stringify!(scoutfs_net_roots))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_net_roots>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_net_roots))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_net_roots>())).fs_root as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_net_roots),
            "::",
            stringify!(fs_root)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_net_roots>())).logs_root as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_net_roots),
            "::",
            stringify!(logs_root)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_net_roots>())).srch_root as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_net_roots),
            "::",
            stringify!(srch_root)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_net_lock {
    pub key: scoutfs_key,
    pub write_version: __le64,
    pub old_mode: __u8,
    pub new_mode: __u8,
    pub __pad: [__u8; 6usize],
}
#[test]
fn bindgen_test_layout_scoutfs_net_lock() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_net_lock>(),
        48usize,
        concat!("Size of: ", stringify!(scoutfs_net_lock))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_net_lock>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_net_lock))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_net_lock>())).key as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_net_lock),
            "::",
            stringify!(key)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_net_lock>())).write_version as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_net_lock),
            "::",
            stringify!(write_version)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_net_lock>())).old_mode as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_net_lock),
            "::",
            stringify!(old_mode)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_net_lock>())).new_mode as *const _ as usize },
        41usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_net_lock),
            "::",
            stringify!(new_mode)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_net_lock>())).__pad as *const _ as usize },
        42usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_net_lock),
            "::",
            stringify!(__pad)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_net_lock_grant_response {
    pub nl: scoutfs_net_lock,
    pub roots: scoutfs_net_roots,
}
#[test]
fn bindgen_test_layout_scoutfs_net_lock_grant_response() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_net_lock_grant_response>(),
        120usize,
        concat!("Size of: ", stringify!(scoutfs_net_lock_grant_response))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_net_lock_grant_response>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_net_lock_grant_response))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_net_lock_grant_response>())).nl as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_net_lock_grant_response),
            "::",
            stringify!(nl)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_net_lock_grant_response>())).roots as *const _ as usize
        },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_net_lock_grant_response),
            "::",
            stringify!(roots)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct scoutfs_net_lock_recover {
    pub nr: __le16,
    pub __pad: [__u8; 6usize],
    pub locks: __IncompleteArrayField<scoutfs_net_lock>,
}
#[test]
fn bindgen_test_layout_scoutfs_net_lock_recover() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_net_lock_recover>(),
        8usize,
        concat!("Size of: ", stringify!(scoutfs_net_lock_recover))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_net_lock_recover>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_net_lock_recover))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_net_lock_recover>())).nr as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_net_lock_recover),
            "::",
            stringify!(nr)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_net_lock_recover>())).__pad as *const _ as usize },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_net_lock_recover),
            "::",
            stringify!(__pad)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_net_lock_recover>())).locks as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_net_lock_recover),
            "::",
            stringify!(locks)
        )
    );
}
pub const scoutfs_lock_trace_SLT_CLIENT: scoutfs_lock_trace = 0;
pub const scoutfs_lock_trace_SLT_SERVER: scoutfs_lock_trace = 1;
pub const scoutfs_lock_trace_SLT_GRANT: scoutfs_lock_trace = 2;
pub const scoutfs_lock_trace_SLT_INVALIDATE: scoutfs_lock_trace = 3;
pub const scoutfs_lock_trace_SLT_REQUEST: scoutfs_lock_trace = 4;
pub const scoutfs_lock_trace_SLT_RESPONSE: scoutfs_lock_trace = 5;
pub type scoutfs_lock_trace = ::std::os::raw::c_uint;
pub const scoutfs_lock_mode_SCOUTFS_LOCK_NULL: scoutfs_lock_mode = 0;
pub const scoutfs_lock_mode_SCOUTFS_LOCK_READ: scoutfs_lock_mode = 1;
pub const scoutfs_lock_mode_SCOUTFS_LOCK_WRITE: scoutfs_lock_mode = 2;
pub const scoutfs_lock_mode_SCOUTFS_LOCK_WRITE_ONLY: scoutfs_lock_mode = 3;
pub const scoutfs_lock_mode_SCOUTFS_LOCK_INVALID: scoutfs_lock_mode = 4;
pub type scoutfs_lock_mode = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_fid {
    pub ino: __le64,
    pub parent_ino: __le64,
}
#[test]
fn bindgen_test_layout_scoutfs_fid() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_fid>(),
        16usize,
        concat!("Size of: ", stringify!(scoutfs_fid))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_fid>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_fid))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_fid>())).ino as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_fid),
            "::",
            stringify!(ino)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_fid>())).parent_ino as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_fid),
            "::",
            stringify!(parent_ino)
        )
    );
}
pub const scoutfs_corruption_sources_SC_DIRENT_NAME_LEN: scoutfs_corruption_sources = 0;
pub const scoutfs_corruption_sources_SC_DIRENT_BACKREF_NAME_LEN: scoutfs_corruption_sources = 1;
pub const scoutfs_corruption_sources_SC_DIRENT_READDIR_NAME_LEN: scoutfs_corruption_sources = 2;
pub const scoutfs_corruption_sources_SC_SYMLINK_INODE_SIZE: scoutfs_corruption_sources = 3;
pub const scoutfs_corruption_sources_SC_SYMLINK_MISSING_ITEM: scoutfs_corruption_sources = 4;
pub const scoutfs_corruption_sources_SC_SYMLINK_NOT_NULL_TERM: scoutfs_corruption_sources = 5;
pub const scoutfs_corruption_sources_SC_BTREE_BLOCK_LEVEL: scoutfs_corruption_sources = 6;
pub const scoutfs_corruption_sources_SC_BTREE_NO_CHILD_REF: scoutfs_corruption_sources = 7;
pub const scoutfs_corruption_sources_SC_INODE_BLOCK_COUNTS: scoutfs_corruption_sources = 8;
pub const scoutfs_corruption_sources_SC_NR_SOURCES: scoutfs_corruption_sources = 9;
pub type scoutfs_corruption_sources = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_ioctl_key {
    pub _sk_first: __le64,
    pub _sk_second: __le64,
    pub _sk_third: __le64,
    pub _sk_fourth: __u8,
    pub sk_type: __u8,
    pub sk_zone: __u8,
    pub _pad: [__u8; 5usize],
}
#[test]
fn bindgen_test_layout_scoutfs_ioctl_key() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_ioctl_key>(),
        32usize,
        concat!("Size of: ", stringify!(scoutfs_ioctl_key))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_ioctl_key>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_ioctl_key))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_key>()))._sk_first as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_key),
            "::",
            stringify!(_sk_first)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_key>()))._sk_second as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_key),
            "::",
            stringify!(_sk_second)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_key>()))._sk_third as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_key),
            "::",
            stringify!(_sk_third)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_key>()))._sk_fourth as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_key),
            "::",
            stringify!(_sk_fourth)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_key>())).sk_type as *const _ as usize },
        25usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_key),
            "::",
            stringify!(sk_type)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_key>())).sk_zone as *const _ as usize },
        26usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_key),
            "::",
            stringify!(sk_zone)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_key>()))._pad as *const _ as usize },
        27usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_key),
            "::",
            stringify!(_pad)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_ioctl_walk_inodes_entry {
    pub major: __u64,
    pub ino: __u64,
    pub minor: __u32,
    pub _pad: [__u8; 4usize],
}
#[test]
fn bindgen_test_layout_scoutfs_ioctl_walk_inodes_entry() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_ioctl_walk_inodes_entry>(),
        24usize,
        concat!("Size of: ", stringify!(scoutfs_ioctl_walk_inodes_entry))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_ioctl_walk_inodes_entry>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_ioctl_walk_inodes_entry))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_walk_inodes_entry>())).major as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_walk_inodes_entry),
            "::",
            stringify!(major)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_walk_inodes_entry>())).ino as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_walk_inodes_entry),
            "::",
            stringify!(ino)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_walk_inodes_entry>())).minor as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_walk_inodes_entry),
            "::",
            stringify!(minor)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_walk_inodes_entry>()))._pad as *const _ as usize
        },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_walk_inodes_entry),
            "::",
            stringify!(_pad)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_ioctl_walk_inodes {
    pub first: scoutfs_ioctl_walk_inodes_entry,
    pub last: scoutfs_ioctl_walk_inodes_entry,
    pub entries_ptr: __u64,
    pub nr_entries: __u32,
    pub index: __u8,
    pub _pad: [__u8; 11usize],
}
#[test]
fn bindgen_test_layout_scoutfs_ioctl_walk_inodes() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_ioctl_walk_inodes>(),
        72usize,
        concat!("Size of: ", stringify!(scoutfs_ioctl_walk_inodes))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_ioctl_walk_inodes>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_ioctl_walk_inodes))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_walk_inodes>())).first as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_walk_inodes),
            "::",
            stringify!(first)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_walk_inodes>())).last as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_walk_inodes),
            "::",
            stringify!(last)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_walk_inodes>())).entries_ptr as *const _ as usize
        },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_walk_inodes),
            "::",
            stringify!(entries_ptr)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_walk_inodes>())).nr_entries as *const _ as usize
        },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_walk_inodes),
            "::",
            stringify!(nr_entries)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_walk_inodes>())).index as *const _ as usize },
        60usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_walk_inodes),
            "::",
            stringify!(index)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_walk_inodes>()))._pad as *const _ as usize },
        61usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_walk_inodes),
            "::",
            stringify!(_pad)
        )
    );
}
pub const scoutfs_ino_walk_seq_type_SCOUTFS_IOC_WALK_INODES_META_SEQ: scoutfs_ino_walk_seq_type = 0;
pub const scoutfs_ino_walk_seq_type_SCOUTFS_IOC_WALK_INODES_DATA_SEQ: scoutfs_ino_walk_seq_type = 1;
pub const scoutfs_ino_walk_seq_type_SCOUTFS_IOC_WALK_INODES_UNKNOWN: scoutfs_ino_walk_seq_type = 2;
pub type scoutfs_ino_walk_seq_type = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_ioctl_ino_path {
    pub ino: __u64,
    pub dir_ino: __u64,
    pub dir_pos: __u64,
    pub result_ptr: __u64,
    pub result_bytes: __u16,
    pub _pad: [__u8; 6usize],
}
#[test]
fn bindgen_test_layout_scoutfs_ioctl_ino_path() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_ioctl_ino_path>(),
        40usize,
        concat!("Size of: ", stringify!(scoutfs_ioctl_ino_path))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_ioctl_ino_path>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_ioctl_ino_path))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_ino_path>())).ino as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_ino_path),
            "::",
            stringify!(ino)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_ino_path>())).dir_ino as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_ino_path),
            "::",
            stringify!(dir_ino)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_ino_path>())).dir_pos as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_ino_path),
            "::",
            stringify!(dir_pos)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_ino_path>())).result_ptr as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_ino_path),
            "::",
            stringify!(result_ptr)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_ino_path>())).result_bytes as *const _ as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_ino_path),
            "::",
            stringify!(result_bytes)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_ino_path>()))._pad as *const _ as usize },
        34usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_ino_path),
            "::",
            stringify!(_pad)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct scoutfs_ioctl_ino_path_result {
    pub dir_ino: __u64,
    pub dir_pos: __u64,
    pub path_bytes: __u16,
    pub _pad: [__u8; 6usize],
    pub path: __IncompleteArrayField<__u8>,
}
#[test]
fn bindgen_test_layout_scoutfs_ioctl_ino_path_result() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_ioctl_ino_path_result>(),
        24usize,
        concat!("Size of: ", stringify!(scoutfs_ioctl_ino_path_result))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_ioctl_ino_path_result>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_ioctl_ino_path_result))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_ino_path_result>())).dir_ino as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_ino_path_result),
            "::",
            stringify!(dir_ino)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_ino_path_result>())).dir_pos as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_ino_path_result),
            "::",
            stringify!(dir_pos)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_ino_path_result>())).path_bytes as *const _
                as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_ino_path_result),
            "::",
            stringify!(path_bytes)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_ino_path_result>()))._pad as *const _ as usize
        },
        18usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_ino_path_result),
            "::",
            stringify!(_pad)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_ino_path_result>())).path as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_ino_path_result),
            "::",
            stringify!(path)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_ioctl_release {
    pub offset: __u64,
    pub length: __u64,
    pub data_version: __u64,
}
#[test]
fn bindgen_test_layout_scoutfs_ioctl_release() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_ioctl_release>(),
        24usize,
        concat!("Size of: ", stringify!(scoutfs_ioctl_release))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_ioctl_release>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_ioctl_release))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_release>())).offset as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_release),
            "::",
            stringify!(offset)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_release>())).length as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_release),
            "::",
            stringify!(length)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_release>())).data_version as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_release),
            "::",
            stringify!(data_version)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_ioctl_stage {
    pub data_version: __u64,
    pub buf_ptr: __u64,
    pub offset: __u64,
    pub length: __s32,
    pub _pad: __u32,
}
#[test]
fn bindgen_test_layout_scoutfs_ioctl_stage() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_ioctl_stage>(),
        32usize,
        concat!("Size of: ", stringify!(scoutfs_ioctl_stage))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_ioctl_stage>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_ioctl_stage))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_stage>())).data_version as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_stage),
            "::",
            stringify!(data_version)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_stage>())).buf_ptr as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_stage),
            "::",
            stringify!(buf_ptr)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_stage>())).offset as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_stage),
            "::",
            stringify!(offset)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_stage>())).length as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_stage),
            "::",
            stringify!(length)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_stage>()))._pad as *const _ as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_stage),
            "::",
            stringify!(_pad)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_ioctl_stat_more {
    pub valid_bytes: __u64,
    pub meta_seq: __u64,
    pub data_seq: __u64,
    pub data_version: __u64,
    pub online_blocks: __u64,
    pub offline_blocks: __u64,
}
#[test]
fn bindgen_test_layout_scoutfs_ioctl_stat_more() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_ioctl_stat_more>(),
        48usize,
        concat!("Size of: ", stringify!(scoutfs_ioctl_stat_more))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_ioctl_stat_more>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_ioctl_stat_more))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_stat_more>())).valid_bytes as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_stat_more),
            "::",
            stringify!(valid_bytes)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_stat_more>())).meta_seq as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_stat_more),
            "::",
            stringify!(meta_seq)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_stat_more>())).data_seq as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_stat_more),
            "::",
            stringify!(data_seq)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_stat_more>())).data_version as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_stat_more),
            "::",
            stringify!(data_version)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_stat_more>())).online_blocks as *const _ as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_stat_more),
            "::",
            stringify!(online_blocks)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_stat_more>())).offline_blocks as *const _ as usize
        },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_stat_more),
            "::",
            stringify!(offline_blocks)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_ioctl_data_waiting_entry {
    pub ino: __u64,
    pub iblock: __u64,
    pub op: __u8,
    pub _pad: [__u8; 7usize],
}
#[test]
fn bindgen_test_layout_scoutfs_ioctl_data_waiting_entry() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_ioctl_data_waiting_entry>(),
        24usize,
        concat!("Size of: ", stringify!(scoutfs_ioctl_data_waiting_entry))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_ioctl_data_waiting_entry>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(scoutfs_ioctl_data_waiting_entry)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_data_waiting_entry>())).ino as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_data_waiting_entry),
            "::",
            stringify!(ino)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_data_waiting_entry>())).iblock as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_data_waiting_entry),
            "::",
            stringify!(iblock)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_data_waiting_entry>())).op as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_data_waiting_entry),
            "::",
            stringify!(op)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_data_waiting_entry>()))._pad as *const _ as usize
        },
        17usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_data_waiting_entry),
            "::",
            stringify!(_pad)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_ioctl_data_waiting {
    pub flags: __u64,
    pub after_ino: __u64,
    pub after_iblock: __u64,
    pub ents_ptr: __u64,
    pub ents_nr: __u16,
    pub _pad: [__u8; 6usize],
}
#[test]
fn bindgen_test_layout_scoutfs_ioctl_data_waiting() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_ioctl_data_waiting>(),
        40usize,
        concat!("Size of: ", stringify!(scoutfs_ioctl_data_waiting))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_ioctl_data_waiting>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_ioctl_data_waiting))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_data_waiting>())).flags as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_data_waiting),
            "::",
            stringify!(flags)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_data_waiting>())).after_ino as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_data_waiting),
            "::",
            stringify!(after_ino)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_data_waiting>())).after_iblock as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_data_waiting),
            "::",
            stringify!(after_iblock)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_data_waiting>())).ents_ptr as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_data_waiting),
            "::",
            stringify!(ents_ptr)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_data_waiting>())).ents_nr as *const _ as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_data_waiting),
            "::",
            stringify!(ents_nr)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_data_waiting>()))._pad as *const _ as usize },
        34usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_data_waiting),
            "::",
            stringify!(_pad)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_ioctl_setattr_more {
    pub data_version: __u64,
    pub i_size: __u64,
    pub flags: __u64,
    pub ctime_sec: __u64,
    pub ctime_nsec: __u32,
    pub _pad: [__u8; 4usize],
}
#[test]
fn bindgen_test_layout_scoutfs_ioctl_setattr_more() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_ioctl_setattr_more>(),
        40usize,
        concat!("Size of: ", stringify!(scoutfs_ioctl_setattr_more))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_ioctl_setattr_more>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_ioctl_setattr_more))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_setattr_more>())).data_version as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_setattr_more),
            "::",
            stringify!(data_version)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_setattr_more>())).i_size as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_setattr_more),
            "::",
            stringify!(i_size)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_setattr_more>())).flags as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_setattr_more),
            "::",
            stringify!(flags)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_setattr_more>())).ctime_sec as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_setattr_more),
            "::",
            stringify!(ctime_sec)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_setattr_more>())).ctime_nsec as *const _ as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_setattr_more),
            "::",
            stringify!(ctime_nsec)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_setattr_more>()))._pad as *const _ as usize },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_setattr_more),
            "::",
            stringify!(_pad)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_ioctl_listxattr_hidden {
    pub id_pos: __u64,
    pub buf_ptr: __u64,
    pub buf_bytes: __u32,
    pub hash_pos: __u32,
}
#[test]
fn bindgen_test_layout_scoutfs_ioctl_listxattr_hidden() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_ioctl_listxattr_hidden>(),
        24usize,
        concat!("Size of: ", stringify!(scoutfs_ioctl_listxattr_hidden))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_ioctl_listxattr_hidden>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_ioctl_listxattr_hidden))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_listxattr_hidden>())).id_pos as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_listxattr_hidden),
            "::",
            stringify!(id_pos)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_listxattr_hidden>())).buf_ptr as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_listxattr_hidden),
            "::",
            stringify!(buf_ptr)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_listxattr_hidden>())).buf_bytes as *const _
                as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_listxattr_hidden),
            "::",
            stringify!(buf_bytes)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_listxattr_hidden>())).hash_pos as *const _ as usize
        },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_listxattr_hidden),
            "::",
            stringify!(hash_pos)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_ioctl_search_xattrs {
    pub next_ino: __u64,
    pub last_ino: __u64,
    pub name_ptr: __u64,
    pub inodes_ptr: __u64,
    pub output_flags: __u64,
    pub nr_inodes: __u64,
    pub name_bytes: __u16,
    pub _pad: [__u8; 6usize],
}
#[test]
fn bindgen_test_layout_scoutfs_ioctl_search_xattrs() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_ioctl_search_xattrs>(),
        56usize,
        concat!("Size of: ", stringify!(scoutfs_ioctl_search_xattrs))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_ioctl_search_xattrs>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_ioctl_search_xattrs))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_search_xattrs>())).next_ino as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_search_xattrs),
            "::",
            stringify!(next_ino)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_search_xattrs>())).last_ino as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_search_xattrs),
            "::",
            stringify!(last_ino)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_search_xattrs>())).name_ptr as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_search_xattrs),
            "::",
            stringify!(name_ptr)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_search_xattrs>())).inodes_ptr as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_search_xattrs),
            "::",
            stringify!(inodes_ptr)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_search_xattrs>())).output_flags as *const _
                as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_search_xattrs),
            "::",
            stringify!(output_flags)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_search_xattrs>())).nr_inodes as *const _ as usize
        },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_search_xattrs),
            "::",
            stringify!(nr_inodes)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_search_xattrs>())).name_bytes as *const _ as usize
        },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_search_xattrs),
            "::",
            stringify!(name_bytes)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_search_xattrs>()))._pad as *const _ as usize
        },
        50usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_search_xattrs),
            "::",
            stringify!(_pad)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_ioctl_statfs_more {
    pub valid_bytes: __u64,
    pub fsid: __u64,
    pub rid: __u64,
    pub committed_seq: __u64,
    pub total_meta_blocks: __u64,
    pub total_data_blocks: __u64,
}
#[test]
fn bindgen_test_layout_scoutfs_ioctl_statfs_more() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_ioctl_statfs_more>(),
        48usize,
        concat!("Size of: ", stringify!(scoutfs_ioctl_statfs_more))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_ioctl_statfs_more>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_ioctl_statfs_more))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_statfs_more>())).valid_bytes as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_statfs_more),
            "::",
            stringify!(valid_bytes)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_statfs_more>())).fsid as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_statfs_more),
            "::",
            stringify!(fsid)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_statfs_more>())).rid as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_statfs_more),
            "::",
            stringify!(rid)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_statfs_more>())).committed_seq as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_statfs_more),
            "::",
            stringify!(committed_seq)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_statfs_more>())).total_meta_blocks as *const _
                as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_statfs_more),
            "::",
            stringify!(total_meta_blocks)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_statfs_more>())).total_data_blocks as *const _
                as usize
        },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_statfs_more),
            "::",
            stringify!(total_data_blocks)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_ioctl_data_wait_err {
    pub ino: __u64,
    pub data_version: __u64,
    pub offset: __u64,
    pub count: __u64,
    pub op: __u64,
    pub err: __s64,
}
#[test]
fn bindgen_test_layout_scoutfs_ioctl_data_wait_err() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_ioctl_data_wait_err>(),
        48usize,
        concat!("Size of: ", stringify!(scoutfs_ioctl_data_wait_err))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_ioctl_data_wait_err>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_ioctl_data_wait_err))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_data_wait_err>())).ino as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_data_wait_err),
            "::",
            stringify!(ino)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_data_wait_err>())).data_version as *const _
                as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_data_wait_err),
            "::",
            stringify!(data_version)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_data_wait_err>())).offset as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_data_wait_err),
            "::",
            stringify!(offset)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_data_wait_err>())).count as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_data_wait_err),
            "::",
            stringify!(count)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_data_wait_err>())).op as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_data_wait_err),
            "::",
            stringify!(op)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_data_wait_err>())).err as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_data_wait_err),
            "::",
            stringify!(err)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_ioctl_alloc_detail {
    pub entries_ptr: __u64,
    pub entries_nr: __u64,
}
#[test]
fn bindgen_test_layout_scoutfs_ioctl_alloc_detail() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_ioctl_alloc_detail>(),
        16usize,
        concat!("Size of: ", stringify!(scoutfs_ioctl_alloc_detail))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_ioctl_alloc_detail>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_ioctl_alloc_detail))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_alloc_detail>())).entries_ptr as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_alloc_detail),
            "::",
            stringify!(entries_ptr)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_alloc_detail>())).entries_nr as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_alloc_detail),
            "::",
            stringify!(entries_nr)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_ioctl_alloc_detail_entry {
    pub id: __u64,
    pub blocks: __u64,
    pub type_: __u8,
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
    pub __pad: [__u8; 6usize],
}
#[test]
fn bindgen_test_layout_scoutfs_ioctl_alloc_detail_entry() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_ioctl_alloc_detail_entry>(),
        24usize,
        concat!("Size of: ", stringify!(scoutfs_ioctl_alloc_detail_entry))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_ioctl_alloc_detail_entry>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(scoutfs_ioctl_alloc_detail_entry)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_alloc_detail_entry>())).id as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_alloc_detail_entry),
            "::",
            stringify!(id)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_alloc_detail_entry>())).blocks as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_alloc_detail_entry),
            "::",
            stringify!(blocks)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_alloc_detail_entry>())).type_ as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_alloc_detail_entry),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_alloc_detail_entry>())).__pad as *const _ as usize
        },
        18usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_alloc_detail_entry),
            "::",
            stringify!(__pad)
        )
    );
}
impl scoutfs_ioctl_alloc_detail_entry {
    #[inline]
    pub fn meta(&self) -> __u8 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_meta(&mut self, val: __u8) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn avail(&self) -> __u8 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_avail(&mut self, val: __u8) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(1usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn __bit_pad(&self) -> __u8 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 6u8) as u8) }
    }
    #[inline]
    pub fn set___bit_pad(&mut self, val: __u8) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(2usize, 6u8, val as u64)
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        meta: __u8,
        avail: __u8,
        __bit_pad: __u8,
    ) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> =
            Default::default();
        __bindgen_bitfield_unit.set(0usize, 1u8, {
            let meta: u8 = unsafe { ::std::mem::transmute(meta) };
            meta as u64
        });
        __bindgen_bitfield_unit.set(1usize, 1u8, {
            let avail: u8 = unsafe { ::std::mem::transmute(avail) };
            avail as u64
        });
        __bindgen_bitfield_unit.set(2usize, 6u8, {
            let __bit_pad: u8 = unsafe { ::std::mem::transmute(__bit_pad) };
            __bit_pad as u64
        });
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_ioctl_move_blocks {
    pub from_fd: __u64,
    pub from_off: __u64,
    pub len: __u64,
    pub to_off: __u64,
}
#[test]
fn bindgen_test_layout_scoutfs_ioctl_move_blocks() {
    assert_eq!(
        ::std::mem::size_of::<scoutfs_ioctl_move_blocks>(),
        32usize,
        concat!("Size of: ", stringify!(scoutfs_ioctl_move_blocks))
    );
    assert_eq!(
        ::std::mem::align_of::<scoutfs_ioctl_move_blocks>(),
        8usize,
        concat!("Alignment of ", stringify!(scoutfs_ioctl_move_blocks))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_move_blocks>())).from_fd as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_move_blocks),
            "::",
            stringify!(from_fd)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_move_blocks>())).from_off as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_move_blocks),
            "::",
            stringify!(from_off)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_move_blocks>())).len as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_move_blocks),
            "::",
            stringify!(len)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<scoutfs_ioctl_move_blocks>())).to_off as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(scoutfs_ioctl_move_blocks),
            "::",
            stringify!(to_off)
        )
    );
}