/* automatically generated by rust-bindgen 0.72.1 */

#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct __BindgenBitfieldUnit<Storage> {
    storage: Storage,
}
impl<Storage> __BindgenBitfieldUnit<Storage> {
    #[inline]
    pub const fn new(storage: Storage) -> Self {
        Self { storage }
    }
}
impl<Storage> __BindgenBitfieldUnit<Storage>
where
    Storage: AsRef<[u8]> + AsMut<[u8]>,
{
    #[inline]
    fn extract_bit(byte: u8, index: usize) -> bool {
        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 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];
        Self::extract_bit(byte, index)
    }
    #[inline]
    pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool {
        debug_assert!(index / 8 < core::mem::size_of::<Storage>());
        let byte_index = index / 8;
        let byte = unsafe {
            *(core::ptr::addr_of!((*this).storage) as *const u8)
                .offset(byte_index as isize)
        };
        Self::extract_bit(byte, index)
    }
    #[inline]
    fn change_bit(byte: u8, index: usize, val: bool) -> u8 {
        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 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];
        *byte = Self::change_bit(*byte, index, val);
    }
    #[inline]
    pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) {
        debug_assert!(index / 8 < core::mem::size_of::<Storage>());
        let byte_index = index / 8;
        let byte = unsafe {
            (core::ptr::addr_of_mut!((*this).storage) as *mut u8)
                .offset(byte_index as isize)
        };
        unsafe { *byte = Self::change_bit(*byte, index, val) };
    }
    #[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 unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 {
        debug_assert!(bit_width <= 64);
        debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
        debug_assert!(
            (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>(),
        );
        let mut val = 0;
        for i in 0..(bit_width as usize) {
            if unsafe { Self::raw_get_bit(this, 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);
        }
    }
    #[inline]
    pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) {
        debug_assert!(bit_width <= 64);
        debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
        debug_assert!(
            (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>(),
        );
        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
            };
            unsafe { Self::raw_set_bit(this, 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
    }
}
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 BCH_PERCPU_MAX_CPUS: u32 = 256;
pub const BCH_PERCPU_DYNAMIC_SIZE: u32 = 524288;
pub const BCH_ACCOUNTING_MAX_COUNTERS: u32 = 3;
pub const BCH_SB_LABEL_SIZE: u32 = 32;
pub const BCH_LRU_BUCKET_FRAGMENTATION: u32 = 65535;
pub const BCH_LRU_STRIPE_FRAGMENTATION: u32 = 65534;
pub const BCH_ALLOC_V4_U64s_V0: u32 = 6;
pub const BCH_EXTENT_ENTRY_MAX: u32 = 9;
pub const BCH_DT_MAX: u32 = 17;
pub const BCH_NAME_MAX: u32 = 512;
pub const BCH_SB_MEMBERS_MAX: u32 = 64;
pub const BCH_SB_MEMBER_INVALID: u32 = 255;
pub const BCH_MIN_NR_NBUCKETS: u32 = 512;
pub const BCH_MI_BTREE_BITMAP_SHIFT_MAX: u32 = 58;
pub const BCH_MEMBER_V1_BYTES: u32 = 56;
pub const BCH_SB_SECTOR: u32 = 8;
pub const BCH_SB_LAYOUT_SIZE_BITS_MAX: u32 = 16;
pub const BCH_SB_LAYOUT_SECTOR: u32 = 7;
pub const BCH_SB_EXTENT_BP_SHIFT_DEFAULT: u32 = 10;
pub const BCH_REPLICAS_MAX: u32 = 4;
pub const BCH_BKEY_PTRS_MAX: u32 = 16;
pub const BCH_JOURNAL_BUCKETS_MIN: u32 = 8;
pub const BCH_WATERMARK_BITS: u32 = 3;
pub const BCH_WATERMARK_MASK: u32 = 7;
pub const BTREE_ITER_INITIAL: u32 = 64;
pub const BTREE_ITER_NORMAL_LIMIT: u32 = 256;
pub const BTREE_ITER_MAX: u32 = 1024;
pub const BCH_TRANSACTIONS_NR: u32 = 128;
pub const BCH_FORCE_IF_DATA_LOST: u32 = 1;
pub const BCH_FORCE_IF_METADATA_LOST: u32 = 2;
pub const BCH_FORCE_IF_DATA_DEGRADED: u32 = 4;
pub const BCH_FORCE_IF_METADATA_DEGRADED: u32 = 8;
pub const BCH_FORCE_IF_LOST: u32 = 3;
pub const BCH_FORCE_IF_DEGRADED: u32 = 12;
pub const BCH_BY_INDEX: u32 = 16;
pub const BCH_READ_DEV: u32 = 32;
pub const BCH_SUBVOL_SNAPSHOT_CREATE: u32 = 1;
pub const BCH_SUBVOL_SNAPSHOT_RO: u32 = 2;
pub const BCH_IOCTL_QUERY_COUNTERS_MOUNT: u32 = 1;
pub const BCH_PREAD_RAW_no_poison_check: u32 = 1;
pub const BCH_PREAD_RAW_ERR_checksum: u32 = 1;
pub const BCH_PREAD_RAW_ERR_io: u32 = 2;
pub const BCH_PREAD_RAW_ERR_decompression: u32 = 4;
pub const BCH_PREAD_RAW_ERR_ec_reconstruct: u32 = 8;
pub const BCH_SB_READ_SCRATCH_BUF_SIZE: u32 = 4096;
pub const BCH_READ_ERR_checksum: u32 = 1;
pub const BCH_READ_ERR_io: u32 = 2;
pub const BCH_READ_ERR_decompression: u32 = 4;
pub const BCH_READ_ERR_ec_reconstruct: u32 = 8;
pub const BCH_CREATE_TMPFILE: u32 = 1;
pub const BCH_CREATE_SUBVOL: u32 = 2;
pub const BCH_CREATE_SNAPSHOT: u32 = 4;
pub const BCH_CREATE_SNAPSHOT_RO: u32 = 8;
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 __u32 = ::std::os::raw::c_uint;
pub type __s64 = ::std::os::raw::c_longlong;
pub type __u64 = ::std::os::raw::c_ulonglong;
pub type __le16 = __u16;
pub type __le32 = __u32;
pub type __le64 = __u64;
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 __off64_t = ::std::os::raw::c_long;
pub type __pid_t = ::std::os::raw::c_int;
pub type __time_t = ::std::os::raw::c_long;
pub type __syscall_slong_t = ::std::os::raw::c_long;
pub type __loff_t = __off64_t;
pub type pid_t = __pid_t;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct timespec {
    pub tv_sec: __time_t,
    pub tv_nsec: __syscall_slong_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of timespec"][::std::mem::size_of::<timespec>() - 16usize];
    ["Alignment of timespec"][::std::mem::align_of::<timespec>() - 8usize];
    [
        "Offset of field: timespec::tv_sec",
    ][::std::mem::offset_of!(timespec, tv_sec) - 0usize];
    [
        "Offset of field: timespec::tv_nsec",
    ][::std::mem::offset_of!(timespec, tv_nsec) - 8usize];
};
pub type va_list = __builtin_va_list;
pub type dev_t = __dev_t;
pub type gid_t = __gid_t;
pub type uid_t = __uid_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dentry {
    pub d_sb: *mut super_block,
    pub d_inode: *mut inode,
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
    pub name: *const ::std::os::raw::c_char,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of dentry"][::std::mem::size_of::<dentry>() - 32usize];
    ["Alignment of dentry"][::std::mem::align_of::<dentry>() - 8usize];
    ["Offset of field: dentry::d_sb"][::std::mem::offset_of!(dentry, d_sb) - 0usize];
    [
        "Offset of field: dentry::d_inode",
    ][::std::mem::offset_of!(dentry, d_inode) - 8usize];
    ["Offset of field: dentry::name"][::std::mem::offset_of!(dentry, name) - 24usize];
};
impl Default for dentry {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl dentry {
    #[inline]
    pub fn is_debugfs(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_is_debugfs(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn is_debugfs_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_is_debugfs_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(is_debugfs: bool) -> __BindgenBitfieldUnit<[u8; 1usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                1u8,
                {
                    let is_debugfs: u8 = unsafe { ::std::mem::transmute(is_debugfs) };
                    is_debugfs as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct static_key {
    pub v: ::std::os::raw::c_int,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of static_key"][::std::mem::size_of::<static_key>() - 4usize];
    ["Alignment of static_key"][::std::mem::align_of::<static_key>() - 4usize];
    ["Offset of field: static_key::v"][::std::mem::offset_of!(static_key, v) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct static_key_false {
    pub key: static_key,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of static_key_false"][::std::mem::size_of::<static_key_false>() - 4usize];
    [
        "Alignment of static_key_false",
    ][::std::mem::align_of::<static_key_false>() - 4usize];
    [
        "Offset of field: static_key_false::key",
    ][::std::mem::offset_of!(static_key_false, key) - 0usize];
};
pub type umode_t = ::std::os::raw::c_ushort;
pub type gfp_t = ::std::os::raw::c_uint;
pub type u64_ = __u64;
pub type s64 = __s64;
pub type u32_ = __u32;
pub type u16_ = __u16;
pub type s16 = __s16;
pub type u8_ = __u8;
pub type ulong = ::std::os::raw::c_ulong;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct qstr {
    pub __bindgen_anon_1: qstr__bindgen_ty_1,
    pub name: *const ::std::os::raw::c_uchar,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union qstr__bindgen_ty_1 {
    pub __bindgen_anon_1: qstr__bindgen_ty_1__bindgen_ty_1,
    pub hash_len: u64_,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct qstr__bindgen_ty_1__bindgen_ty_1 {
    pub hash: u32_,
    pub len: u32_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of qstr__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<qstr__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Alignment of qstr__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<qstr__bindgen_ty_1__bindgen_ty_1>() - 4usize];
    [
        "Offset of field: qstr__bindgen_ty_1__bindgen_ty_1::hash",
    ][::std::mem::offset_of!(qstr__bindgen_ty_1__bindgen_ty_1, hash) - 0usize];
    [
        "Offset of field: qstr__bindgen_ty_1__bindgen_ty_1::len",
    ][::std::mem::offset_of!(qstr__bindgen_ty_1__bindgen_ty_1, len) - 4usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of qstr__bindgen_ty_1"][::std::mem::size_of::<qstr__bindgen_ty_1>() - 8usize];
    [
        "Alignment of qstr__bindgen_ty_1",
    ][::std::mem::align_of::<qstr__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: qstr__bindgen_ty_1::hash_len",
    ][::std::mem::offset_of!(qstr__bindgen_ty_1, hash_len) - 0usize];
};
impl Default for qstr__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of qstr"][::std::mem::size_of::<qstr>() - 16usize];
    ["Alignment of qstr"][::std::mem::align_of::<qstr>() - 8usize];
    ["Offset of field: qstr::name"][::std::mem::offset_of!(qstr, name) - 8usize];
};
impl Default for qstr {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type sector_t = u64_;
pub type loff_t = __loff_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_internal_list {
    pub __prev: *mut __pthread_internal_list,
    pub __next: *mut __pthread_internal_list,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of __pthread_internal_list",
    ][::std::mem::size_of::<__pthread_internal_list>() - 16usize];
    [
        "Alignment of __pthread_internal_list",
    ][::std::mem::align_of::<__pthread_internal_list>() - 8usize];
    [
        "Offset of field: __pthread_internal_list::__prev",
    ][::std::mem::offset_of!(__pthread_internal_list, __prev) - 0usize];
    [
        "Offset of field: __pthread_internal_list::__next",
    ][::std::mem::offset_of!(__pthread_internal_list, __next) - 8usize];
};
impl Default for __pthread_internal_list {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type __pthread_list_t = __pthread_internal_list;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_mutex_s {
    pub __lock: ::std::os::raw::c_int,
    pub __count: ::std::os::raw::c_uint,
    pub __owner: ::std::os::raw::c_int,
    pub __nusers: ::std::os::raw::c_uint,
    pub __kind: ::std::os::raw::c_int,
    pub __spins: ::std::os::raw::c_short,
    pub __unused: ::std::os::raw::c_short,
    pub __list: __pthread_list_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of __pthread_mutex_s"][::std::mem::size_of::<__pthread_mutex_s>() - 40usize];
    [
        "Alignment of __pthread_mutex_s",
    ][::std::mem::align_of::<__pthread_mutex_s>() - 8usize];
    [
        "Offset of field: __pthread_mutex_s::__lock",
    ][::std::mem::offset_of!(__pthread_mutex_s, __lock) - 0usize];
    [
        "Offset of field: __pthread_mutex_s::__count",
    ][::std::mem::offset_of!(__pthread_mutex_s, __count) - 4usize];
    [
        "Offset of field: __pthread_mutex_s::__owner",
    ][::std::mem::offset_of!(__pthread_mutex_s, __owner) - 8usize];
    [
        "Offset of field: __pthread_mutex_s::__nusers",
    ][::std::mem::offset_of!(__pthread_mutex_s, __nusers) - 12usize];
    [
        "Offset of field: __pthread_mutex_s::__kind",
    ][::std::mem::offset_of!(__pthread_mutex_s, __kind) - 16usize];
    [
        "Offset of field: __pthread_mutex_s::__spins",
    ][::std::mem::offset_of!(__pthread_mutex_s, __spins) - 20usize];
    [
        "Offset of field: __pthread_mutex_s::__unused",
    ][::std::mem::offset_of!(__pthread_mutex_s, __unused) - 22usize];
    [
        "Offset of field: __pthread_mutex_s::__list",
    ][::std::mem::offset_of!(__pthread_mutex_s, __list) - 24usize];
};
impl Default for __pthread_mutex_s {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct __pthread_rwlock_arch_t {
    pub __readers: ::std::os::raw::c_uint,
    pub __writers: ::std::os::raw::c_uint,
    pub __wrphase_futex: ::std::os::raw::c_uint,
    pub __writers_futex: ::std::os::raw::c_uint,
    pub __pad3: ::std::os::raw::c_uint,
    pub __pad4: ::std::os::raw::c_uint,
    pub __cur_writer: ::std::os::raw::c_int,
    pub __shared: ::std::os::raw::c_int,
    pub __pad1: ::std::os::raw::c_ulong,
    pub __pad2: ::std::os::raw::c_ulong,
    pub __flags: ::std::os::raw::c_uint,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of __pthread_rwlock_arch_t",
    ][::std::mem::size_of::<__pthread_rwlock_arch_t>() - 56usize];
    [
        "Alignment of __pthread_rwlock_arch_t",
    ][::std::mem::align_of::<__pthread_rwlock_arch_t>() - 8usize];
    [
        "Offset of field: __pthread_rwlock_arch_t::__readers",
    ][::std::mem::offset_of!(__pthread_rwlock_arch_t, __readers) - 0usize];
    [
        "Offset of field: __pthread_rwlock_arch_t::__writers",
    ][::std::mem::offset_of!(__pthread_rwlock_arch_t, __writers) - 4usize];
    [
        "Offset of field: __pthread_rwlock_arch_t::__wrphase_futex",
    ][::std::mem::offset_of!(__pthread_rwlock_arch_t, __wrphase_futex) - 8usize];
    [
        "Offset of field: __pthread_rwlock_arch_t::__writers_futex",
    ][::std::mem::offset_of!(__pthread_rwlock_arch_t, __writers_futex) - 12usize];
    [
        "Offset of field: __pthread_rwlock_arch_t::__pad3",
    ][::std::mem::offset_of!(__pthread_rwlock_arch_t, __pad3) - 16usize];
    [
        "Offset of field: __pthread_rwlock_arch_t::__pad4",
    ][::std::mem::offset_of!(__pthread_rwlock_arch_t, __pad4) - 20usize];
    [
        "Offset of field: __pthread_rwlock_arch_t::__cur_writer",
    ][::std::mem::offset_of!(__pthread_rwlock_arch_t, __cur_writer) - 24usize];
    [
        "Offset of field: __pthread_rwlock_arch_t::__shared",
    ][::std::mem::offset_of!(__pthread_rwlock_arch_t, __shared) - 28usize];
    [
        "Offset of field: __pthread_rwlock_arch_t::__pad1",
    ][::std::mem::offset_of!(__pthread_rwlock_arch_t, __pad1) - 32usize];
    [
        "Offset of field: __pthread_rwlock_arch_t::__pad2",
    ][::std::mem::offset_of!(__pthread_rwlock_arch_t, __pad2) - 40usize];
    [
        "Offset of field: __pthread_rwlock_arch_t::__flags",
    ][::std::mem::offset_of!(__pthread_rwlock_arch_t, __flags) - 48usize];
};
pub type pthread_t = ::std::os::raw::c_ulong;
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_mutex_t {
    pub __data: __pthread_mutex_s,
    pub __size: [::std::os::raw::c_char; 40usize],
    pub __align: ::std::os::raw::c_long,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of pthread_mutex_t"][::std::mem::size_of::<pthread_mutex_t>() - 40usize];
    ["Alignment of pthread_mutex_t"][::std::mem::align_of::<pthread_mutex_t>() - 8usize];
    [
        "Offset of field: pthread_mutex_t::__data",
    ][::std::mem::offset_of!(pthread_mutex_t, __data) - 0usize];
    [
        "Offset of field: pthread_mutex_t::__size",
    ][::std::mem::offset_of!(pthread_mutex_t, __size) - 0usize];
    [
        "Offset of field: pthread_mutex_t::__align",
    ][::std::mem::offset_of!(pthread_mutex_t, __align) - 0usize];
};
impl Default for pthread_mutex_t {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_rwlock_t {
    pub __data: __pthread_rwlock_arch_t,
    pub __size: [::std::os::raw::c_char; 56usize],
    pub __align: ::std::os::raw::c_long,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of pthread_rwlock_t"][::std::mem::size_of::<pthread_rwlock_t>() - 56usize];
    [
        "Alignment of pthread_rwlock_t",
    ][::std::mem::align_of::<pthread_rwlock_t>() - 8usize];
    [
        "Offset of field: pthread_rwlock_t::__data",
    ][::std::mem::offset_of!(pthread_rwlock_t, __data) - 0usize];
    [
        "Offset of field: pthread_rwlock_t::__size",
    ][::std::mem::offset_of!(pthread_rwlock_t, __size) - 0usize];
    [
        "Offset of field: pthread_rwlock_t::__align",
    ][::std::mem::offset_of!(pthread_rwlock_t, __align) - 0usize];
};
impl Default for pthread_rwlock_t {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct __uuid_t {
    pub b: [__u8; 16usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of __uuid_t"][::std::mem::size_of::<__uuid_t>() - 16usize];
    ["Alignment of __uuid_t"][::std::mem::align_of::<__uuid_t>() - 1usize];
    ["Offset of field: __uuid_t::b"][::std::mem::offset_of!(__uuid_t, b) - 0usize];
};
pub const linux_page_size: usize = 4096;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cds_list_head {
    pub next: *mut cds_list_head,
    pub prev: *mut cds_list_head,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of cds_list_head"][::std::mem::size_of::<cds_list_head>() - 16usize];
    ["Alignment of cds_list_head"][::std::mem::align_of::<cds_list_head>() - 8usize];
    [
        "Offset of field: cds_list_head::next",
    ][::std::mem::offset_of!(cds_list_head, next) - 0usize];
    [
        "Offset of field: cds_list_head::prev",
    ][::std::mem::offset_of!(cds_list_head, prev) - 8usize];
};
impl Default for cds_list_head {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cds_hlist_head {
    pub next: *mut cds_hlist_node,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of cds_hlist_head"][::std::mem::size_of::<cds_hlist_head>() - 8usize];
    ["Alignment of cds_hlist_head"][::std::mem::align_of::<cds_hlist_head>() - 8usize];
    [
        "Offset of field: cds_hlist_head::next",
    ][::std::mem::offset_of!(cds_hlist_head, next) - 0usize];
};
impl Default for cds_hlist_head {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cds_hlist_node {
    pub next: *mut cds_hlist_node,
    pub prev: *mut cds_hlist_node,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of cds_hlist_node"][::std::mem::size_of::<cds_hlist_node>() - 16usize];
    ["Alignment of cds_hlist_node"][::std::mem::align_of::<cds_hlist_node>() - 8usize];
    [
        "Offset of field: cds_hlist_node::next",
    ][::std::mem::offset_of!(cds_hlist_node, next) - 0usize];
    [
        "Offset of field: cds_hlist_node::prev",
    ][::std::mem::offset_of!(cds_hlist_node, prev) - 8usize];
};
impl Default for cds_hlist_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct atomic_t {
    pub counter: ::std::os::raw::c_int,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of atomic_t"][::std::mem::size_of::<atomic_t>() - 4usize];
    ["Alignment of atomic_t"][::std::mem::align_of::<atomic_t>() - 4usize];
    [
        "Offset of field: atomic_t::counter",
    ][::std::mem::offset_of!(atomic_t, counter) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct atomic_long_t {
    pub counter: ::std::os::raw::c_long,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of atomic_long_t"][::std::mem::size_of::<atomic_long_t>() - 8usize];
    ["Alignment of atomic_long_t"][::std::mem::align_of::<atomic_long_t>() - 8usize];
    [
        "Offset of field: atomic_long_t::counter",
    ][::std::mem::offset_of!(atomic_long_t, counter) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct atomic64_t {
    pub counter: u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of atomic64_t"][::std::mem::size_of::<atomic64_t>() - 8usize];
    ["Alignment of atomic64_t"][::std::mem::align_of::<atomic64_t>() - 8usize];
    [
        "Offset of field: atomic64_t::counter",
    ][::std::mem::offset_of!(atomic64_t, counter) - 0usize];
};
#[repr(C)]
#[derive(Copy, Clone)]
pub struct raw_spinlock_t {
    pub lock: pthread_mutex_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of raw_spinlock_t"][::std::mem::size_of::<raw_spinlock_t>() - 40usize];
    ["Alignment of raw_spinlock_t"][::std::mem::align_of::<raw_spinlock_t>() - 8usize];
    [
        "Offset of field: raw_spinlock_t::lock",
    ][::std::mem::offset_of!(raw_spinlock_t, lock) - 0usize];
};
impl Default for raw_spinlock_t {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type spinlock_t = raw_spinlock_t;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct wait_queue_head {
    pub lock: spinlock_t,
    pub task_list: cds_list_head,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of wait_queue_head"][::std::mem::size_of::<wait_queue_head>() - 56usize];
    ["Alignment of wait_queue_head"][::std::mem::align_of::<wait_queue_head>() - 8usize];
    [
        "Offset of field: wait_queue_head::lock",
    ][::std::mem::offset_of!(wait_queue_head, lock) - 0usize];
    [
        "Offset of field: wait_queue_head::task_list",
    ][::std::mem::offset_of!(wait_queue_head, task_list) - 40usize];
};
impl Default for wait_queue_head {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type wait_queue_head_t = wait_queue_head;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct shrink_control {
    pub gfp_mask: gfp_t,
    pub nr_to_scan: ::std::os::raw::c_ulong,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of shrink_control"][::std::mem::size_of::<shrink_control>() - 16usize];
    ["Alignment of shrink_control"][::std::mem::align_of::<shrink_control>() - 8usize];
    [
        "Offset of field: shrink_control::gfp_mask",
    ][::std::mem::offset_of!(shrink_control, gfp_mask) - 0usize];
    [
        "Offset of field: shrink_control::nr_to_scan",
    ][::std::mem::offset_of!(shrink_control, nr_to_scan) - 8usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct seq_buf {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct shrinker {
    pub count_objects: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut shrinker,
            sc: *mut shrink_control,
        ) -> ::std::os::raw::c_ulong,
    >,
    pub scan_objects: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut shrinker,
            sc: *mut shrink_control,
        ) -> ::std::os::raw::c_ulong,
    >,
    pub to_text: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut seq_buf, arg2: *mut shrinker),
    >,
    pub seeks: ::std::os::raw::c_int,
    pub batch: ::std::os::raw::c_long,
    pub list: cds_list_head,
    pub private_data: *mut ::std::os::raw::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of shrinker"][::std::mem::size_of::<shrinker>() - 64usize];
    ["Alignment of shrinker"][::std::mem::align_of::<shrinker>() - 8usize];
    [
        "Offset of field: shrinker::count_objects",
    ][::std::mem::offset_of!(shrinker, count_objects) - 0usize];
    [
        "Offset of field: shrinker::scan_objects",
    ][::std::mem::offset_of!(shrinker, scan_objects) - 8usize];
    [
        "Offset of field: shrinker::to_text",
    ][::std::mem::offset_of!(shrinker, to_text) - 16usize];
    [
        "Offset of field: shrinker::seeks",
    ][::std::mem::offset_of!(shrinker, seeks) - 24usize];
    [
        "Offset of field: shrinker::batch",
    ][::std::mem::offset_of!(shrinker, batch) - 32usize];
    [
        "Offset of field: shrinker::list",
    ][::std::mem::offset_of!(shrinker, list) - 40usize];
    [
        "Offset of field: shrinker::private_data",
    ][::std::mem::offset_of!(shrinker, private_data) - 56usize];
};
impl Default for shrinker {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C" {
    pub fn linux_shrinkers_init();
}
pub type mempool_alloc_t = ::std::option::Option<
    unsafe extern "C" fn(
        gfp_mask: gfp_t,
        pool_data: *mut ::std::os::raw::c_void,
    ) -> *mut ::std::os::raw::c_void,
>;
pub type mempool_free_t = ::std::option::Option<
    unsafe extern "C" fn(
        element: *mut ::std::os::raw::c_void,
        pool_data: *mut ::std::os::raw::c_void,
    ),
>;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct mempool_s {
    pub lock: spinlock_t,
    pub min_nr: ::std::os::raw::c_int,
    pub curr_nr: ::std::os::raw::c_int,
    pub elements: *mut *mut ::std::os::raw::c_void,
    pub pool_data: *mut ::std::os::raw::c_void,
    pub alloc: mempool_alloc_t,
    pub free: mempool_free_t,
    pub wait: wait_queue_head_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of mempool_s"][::std::mem::size_of::<mempool_s>() - 136usize];
    ["Alignment of mempool_s"][::std::mem::align_of::<mempool_s>() - 8usize];
    [
        "Offset of field: mempool_s::lock",
    ][::std::mem::offset_of!(mempool_s, lock) - 0usize];
    [
        "Offset of field: mempool_s::min_nr",
    ][::std::mem::offset_of!(mempool_s, min_nr) - 40usize];
    [
        "Offset of field: mempool_s::curr_nr",
    ][::std::mem::offset_of!(mempool_s, curr_nr) - 44usize];
    [
        "Offset of field: mempool_s::elements",
    ][::std::mem::offset_of!(mempool_s, elements) - 48usize];
    [
        "Offset of field: mempool_s::pool_data",
    ][::std::mem::offset_of!(mempool_s, pool_data) - 56usize];
    [
        "Offset of field: mempool_s::alloc",
    ][::std::mem::offset_of!(mempool_s, alloc) - 64usize];
    [
        "Offset of field: mempool_s::free",
    ][::std::mem::offset_of!(mempool_s, free) - 72usize];
    [
        "Offset of field: mempool_s::wait",
    ][::std::mem::offset_of!(mempool_s, wait) - 80usize];
};
impl Default for mempool_s {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type mempool_t = mempool_s;
pub type congested_fn = ::std::option::Option<
    unsafe extern "C" fn(
        arg1: *mut ::std::os::raw::c_void,
        arg2: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct backing_dev_info {
    pub bdi_list: cds_list_head,
    pub ra_pages: ::std::os::raw::c_uint,
    pub capabilities: ::std::os::raw::c_uint,
    pub congested_fn: congested_fn,
    pub congested_data: *mut ::std::os::raw::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of backing_dev_info"][::std::mem::size_of::<backing_dev_info>() - 40usize];
    [
        "Alignment of backing_dev_info",
    ][::std::mem::align_of::<backing_dev_info>() - 8usize];
    [
        "Offset of field: backing_dev_info::bdi_list",
    ][::std::mem::offset_of!(backing_dev_info, bdi_list) - 0usize];
    [
        "Offset of field: backing_dev_info::ra_pages",
    ][::std::mem::offset_of!(backing_dev_info, ra_pages) - 16usize];
    [
        "Offset of field: backing_dev_info::capabilities",
    ][::std::mem::offset_of!(backing_dev_info, capabilities) - 20usize];
    [
        "Offset of field: backing_dev_info::congested_fn",
    ][::std::mem::offset_of!(backing_dev_info, congested_fn) - 24usize];
    [
        "Offset of field: backing_dev_info::congested_data",
    ][::std::mem::offset_of!(backing_dev_info, congested_data) - 32usize];
};
impl Default for backing_dev_info {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bio_vec {
    pub bv_addr: *mut ::std::os::raw::c_void,
    pub bv_len: ::std::os::raw::c_uint,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bio_vec"][::std::mem::size_of::<bio_vec>() - 16usize];
    ["Alignment of bio_vec"][::std::mem::align_of::<bio_vec>() - 8usize];
    [
        "Offset of field: bio_vec::bv_addr",
    ][::std::mem::offset_of!(bio_vec, bv_addr) - 0usize];
    [
        "Offset of field: bio_vec::bv_len",
    ][::std::mem::offset_of!(bio_vec, bv_len) - 8usize];
};
impl Default for bio_vec {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bvec_iter {
    pub bi_sector: sector_t,
    pub bi_size: ::std::os::raw::c_uint,
    pub bi_idx: ::std::os::raw::c_uint,
    pub bi_bvec_done: ::std::os::raw::c_uint,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bvec_iter"][::std::mem::size_of::<bvec_iter>() - 24usize];
    ["Alignment of bvec_iter"][::std::mem::align_of::<bvec_iter>() - 8usize];
    [
        "Offset of field: bvec_iter::bi_sector",
    ][::std::mem::offset_of!(bvec_iter, bi_sector) - 0usize];
    [
        "Offset of field: bvec_iter::bi_size",
    ][::std::mem::offset_of!(bvec_iter, bi_size) - 8usize];
    [
        "Offset of field: bvec_iter::bi_idx",
    ][::std::mem::offset_of!(bvec_iter, bi_idx) - 12usize];
    [
        "Offset of field: bvec_iter::bi_bvec_done",
    ][::std::mem::offset_of!(bvec_iter, bi_bvec_done) - 16usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bvec_iter_all {
    pub idx: ::std::os::raw::c_int,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bvec_iter_all"][::std::mem::size_of::<bvec_iter_all>() - 4usize];
    ["Alignment of bvec_iter_all"][::std::mem::align_of::<bvec_iter_all>() - 4usize];
    [
        "Offset of field: bvec_iter_all::idx",
    ][::std::mem::offset_of!(bvec_iter_all, idx) - 0usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct attribute {
    pub name: *const ::std::os::raw::c_char,
    pub mode: umode_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of attribute"][::std::mem::size_of::<attribute>() - 16usize];
    ["Alignment of attribute"][::std::mem::align_of::<attribute>() - 8usize];
    [
        "Offset of field: attribute::name",
    ][::std::mem::offset_of!(attribute, name) - 0usize];
    [
        "Offset of field: attribute::mode",
    ][::std::mem::offset_of!(attribute, mode) - 8usize];
};
impl Default for attribute {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct attribute_group {
    pub attrs: *mut *mut attribute,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of attribute_group"][::std::mem::size_of::<attribute_group>() - 8usize];
    ["Alignment of attribute_group"][::std::mem::align_of::<attribute_group>() - 8usize];
    [
        "Offset of field: attribute_group::attrs",
    ][::std::mem::offset_of!(attribute_group, attrs) - 0usize];
};
impl Default for attribute_group {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bin_attribute {
    pub attr: attribute,
    pub size: usize,
    pub private: *mut ::std::os::raw::c_void,
    pub read: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut file,
            arg2: *mut kobject,
            arg3: *const bin_attribute,
            arg4: *mut ::std::os::raw::c_char,
            arg5: loff_t,
            arg6: usize,
        ) -> isize,
    >,
    pub write: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut file,
            arg2: *mut kobject,
            arg3: *const bin_attribute,
            arg4: *mut ::std::os::raw::c_char,
            arg5: loff_t,
            arg6: usize,
        ) -> isize,
    >,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bin_attribute"][::std::mem::size_of::<bin_attribute>() - 48usize];
    ["Alignment of bin_attribute"][::std::mem::align_of::<bin_attribute>() - 8usize];
    [
        "Offset of field: bin_attribute::attr",
    ][::std::mem::offset_of!(bin_attribute, attr) - 0usize];
    [
        "Offset of field: bin_attribute::size",
    ][::std::mem::offset_of!(bin_attribute, size) - 16usize];
    [
        "Offset of field: bin_attribute::private",
    ][::std::mem::offset_of!(bin_attribute, private) - 24usize];
    [
        "Offset of field: bin_attribute::read",
    ][::std::mem::offset_of!(bin_attribute, read) - 32usize];
    [
        "Offset of field: bin_attribute::write",
    ][::std::mem::offset_of!(bin_attribute, write) - 40usize];
};
impl Default for bin_attribute {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct sysfs_ops {
    pub show: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut kobject,
            arg2: *mut attribute,
            arg3: *mut ::std::os::raw::c_char,
        ) -> isize,
    >,
    pub store: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut kobject,
            arg2: *mut attribute,
            arg3: *const ::std::os::raw::c_char,
            arg4: usize,
        ) -> isize,
    >,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of sysfs_ops"][::std::mem::size_of::<sysfs_ops>() - 16usize];
    ["Alignment of sysfs_ops"][::std::mem::align_of::<sysfs_ops>() - 8usize];
    [
        "Offset of field: sysfs_ops::show",
    ][::std::mem::offset_of!(sysfs_ops, show) - 0usize];
    [
        "Offset of field: sysfs_ops::store",
    ][::std::mem::offset_of!(sysfs_ops, store) - 8usize];
};
unsafe extern "C" {
    pub fn sysfs_create_file(
        arg1: *mut kobject,
        arg2: *const attribute,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn sysfs_create_bin_file(
        arg1: *mut kobject,
        arg2: *const bin_attribute,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn sysfs_remove_bin_file(arg1: *mut kobject, arg2: *const bin_attribute);
}
unsafe extern "C" {
    #[link_name = "sysfs_create_link__extern"]
    pub fn sysfs_create_link(
        kobj: *mut kobject,
        target: *mut kobject,
        name: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "sysfs_remove_link__extern"]
    pub fn sysfs_remove_link(kobj: *mut kobject, name: *const ::std::os::raw::c_char);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct timer_list {
    pub expires: ::std::os::raw::c_ulong,
    pub function: ::std::option::Option<unsafe extern "C" fn(timer: *mut timer_list)>,
    pub pending: bool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of timer_list"][::std::mem::size_of::<timer_list>() - 24usize];
    ["Alignment of timer_list"][::std::mem::align_of::<timer_list>() - 8usize];
    [
        "Offset of field: timer_list::expires",
    ][::std::mem::offset_of!(timer_list, expires) - 0usize];
    [
        "Offset of field: timer_list::function",
    ][::std::mem::offset_of!(timer_list, function) - 8usize];
    [
        "Offset of field: timer_list::pending",
    ][::std::mem::offset_of!(timer_list, pending) - 16usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct workqueue_struct {
    _unused: [u8; 0],
}
pub type work_func_t = ::std::option::Option<
    unsafe extern "C" fn(work: *mut work_struct),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct work_struct {
    pub data: atomic_long_t,
    pub entry: cds_list_head,
    pub func: work_func_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of work_struct"][::std::mem::size_of::<work_struct>() - 32usize];
    ["Alignment of work_struct"][::std::mem::align_of::<work_struct>() - 8usize];
    [
        "Offset of field: work_struct::data",
    ][::std::mem::offset_of!(work_struct, data) - 0usize];
    [
        "Offset of field: work_struct::entry",
    ][::std::mem::offset_of!(work_struct, entry) - 8usize];
    [
        "Offset of field: work_struct::func",
    ][::std::mem::offset_of!(work_struct, func) - 24usize];
};
impl Default for work_struct {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct delayed_work {
    pub work: work_struct,
    pub timer: timer_list,
    pub wq: *mut workqueue_struct,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of delayed_work"][::std::mem::size_of::<delayed_work>() - 64usize];
    ["Alignment of delayed_work"][::std::mem::align_of::<delayed_work>() - 8usize];
    [
        "Offset of field: delayed_work::work",
    ][::std::mem::offset_of!(delayed_work, work) - 0usize];
    [
        "Offset of field: delayed_work::timer",
    ][::std::mem::offset_of!(delayed_work, timer) - 32usize];
    [
        "Offset of field: delayed_work::wq",
    ][::std::mem::offset_of!(delayed_work, wq) - 56usize];
};
impl Default for delayed_work {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug)]
pub struct darray_char {
    pub nr: usize,
    pub size: usize,
    pub data: *mut ::std::os::raw::c_char,
    pub preallocated: __IncompleteArrayField<::std::os::raw::c_char>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of darray_char"][::std::mem::size_of::<darray_char>() - 24usize];
    ["Alignment of darray_char"][::std::mem::align_of::<darray_char>() - 8usize];
    [
        "Offset of field: darray_char::nr",
    ][::std::mem::offset_of!(darray_char, nr) - 0usize];
    [
        "Offset of field: darray_char::size",
    ][::std::mem::offset_of!(darray_char, size) - 8usize];
    [
        "Offset of field: darray_char::data",
    ][::std::mem::offset_of!(darray_char, data) - 16usize];
    [
        "Offset of field: darray_char::preallocated",
    ][::std::mem::offset_of!(darray_char, preallocated) - 24usize];
};
impl Default for darray_char {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug)]
pub struct darray_u64 {
    pub nr: usize,
    pub size: usize,
    pub data: *mut u64_,
    pub preallocated: __IncompleteArrayField<u64_>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of darray_u64"][::std::mem::size_of::<darray_u64>() - 24usize];
    ["Alignment of darray_u64"][::std::mem::align_of::<darray_u64>() - 8usize];
    ["Offset of field: darray_u64::nr"][::std::mem::offset_of!(darray_u64, nr) - 0usize];
    [
        "Offset of field: darray_u64::size",
    ][::std::mem::offset_of!(darray_u64, size) - 8usize];
    [
        "Offset of field: darray_u64::data",
    ][::std::mem::offset_of!(darray_u64, data) - 16usize];
    [
        "Offset of field: darray_u64::preallocated",
    ][::std::mem::offset_of!(darray_u64, preallocated) - 24usize];
};
impl Default for darray_u64 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug)]
pub struct darray_const_str {
    pub nr: usize,
    pub size: usize,
    pub data: *mut *const ::std::os::raw::c_char,
    pub preallocated: __IncompleteArrayField<*const ::std::os::raw::c_char>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of darray_const_str"][::std::mem::size_of::<darray_const_str>() - 24usize];
    [
        "Alignment of darray_const_str",
    ][::std::mem::align_of::<darray_const_str>() - 8usize];
    [
        "Offset of field: darray_const_str::nr",
    ][::std::mem::offset_of!(darray_const_str, nr) - 0usize];
    [
        "Offset of field: darray_const_str::size",
    ][::std::mem::offset_of!(darray_const_str, size) - 8usize];
    [
        "Offset of field: darray_const_str::data",
    ][::std::mem::offset_of!(darray_const_str, data) - 16usize];
    [
        "Offset of field: darray_const_str::preallocated",
    ][::std::mem::offset_of!(darray_const_str, preallocated) - 24usize];
};
impl Default for darray_const_str {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C" {
    pub fn __bch2_darray_resize_noprof(
        arg1: *mut darray_char,
        arg2: usize,
        arg3: usize,
        arg4: gfp_t,
        arg5: bool,
        arg6: bool,
    ) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct kobj_type {
    pub release: ::std::option::Option<unsafe extern "C" fn(kobj: *mut kobject)>,
    pub sysfs_ops: *const sysfs_ops,
    pub default_groups: *mut *const attribute_group,
    pub child_ns_type: ::std::option::Option<
        unsafe extern "C" fn(kobj: *mut kobject) -> *const kobj_ns_type_operations,
    >,
    pub namespace: ::std::option::Option<
        unsafe extern "C" fn(kobj: *mut kobject) -> *const ::std::os::raw::c_void,
    >,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of kobj_type"][::std::mem::size_of::<kobj_type>() - 40usize];
    ["Alignment of kobj_type"][::std::mem::align_of::<kobj_type>() - 8usize];
    [
        "Offset of field: kobj_type::release",
    ][::std::mem::offset_of!(kobj_type, release) - 0usize];
    [
        "Offset of field: kobj_type::sysfs_ops",
    ][::std::mem::offset_of!(kobj_type, sysfs_ops) - 8usize];
    [
        "Offset of field: kobj_type::default_groups",
    ][::std::mem::offset_of!(kobj_type, default_groups) - 16usize];
    [
        "Offset of field: kobj_type::child_ns_type",
    ][::std::mem::offset_of!(kobj_type, child_ns_type) - 24usize];
    [
        "Offset of field: kobj_type::namespace",
    ][::std::mem::offset_of!(kobj_type, namespace) - 32usize];
};
impl Default for kobj_type {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug)]
pub struct kobject {
    pub name: *const ::std::os::raw::c_char,
    pub parent: *mut kobject,
    pub ktype: *const kobj_type,
    pub ref_: atomic_t,
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
    pub subdirs: kobject__bindgen_ty_1,
    pub files: kobject__bindgen_ty_2,
    pub bin_files: kobject__bindgen_ty_3,
}
#[repr(C)]
#[derive(Debug)]
pub struct kobject__bindgen_ty_1 {
    pub nr: usize,
    pub size: usize,
    pub data: *mut *mut kobject,
    pub preallocated: __IncompleteArrayField<*mut kobject>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of kobject__bindgen_ty_1",
    ][::std::mem::size_of::<kobject__bindgen_ty_1>() - 24usize];
    [
        "Alignment of kobject__bindgen_ty_1",
    ][::std::mem::align_of::<kobject__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: kobject__bindgen_ty_1::nr",
    ][::std::mem::offset_of!(kobject__bindgen_ty_1, nr) - 0usize];
    [
        "Offset of field: kobject__bindgen_ty_1::size",
    ][::std::mem::offset_of!(kobject__bindgen_ty_1, size) - 8usize];
    [
        "Offset of field: kobject__bindgen_ty_1::data",
    ][::std::mem::offset_of!(kobject__bindgen_ty_1, data) - 16usize];
    [
        "Offset of field: kobject__bindgen_ty_1::preallocated",
    ][::std::mem::offset_of!(kobject__bindgen_ty_1, preallocated) - 24usize];
};
impl Default for kobject__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug)]
pub struct kobject__bindgen_ty_2 {
    pub nr: usize,
    pub size: usize,
    pub data: *mut *const attribute,
    pub preallocated: __IncompleteArrayField<*const attribute>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of kobject__bindgen_ty_2",
    ][::std::mem::size_of::<kobject__bindgen_ty_2>() - 24usize];
    [
        "Alignment of kobject__bindgen_ty_2",
    ][::std::mem::align_of::<kobject__bindgen_ty_2>() - 8usize];
    [
        "Offset of field: kobject__bindgen_ty_2::nr",
    ][::std::mem::offset_of!(kobject__bindgen_ty_2, nr) - 0usize];
    [
        "Offset of field: kobject__bindgen_ty_2::size",
    ][::std::mem::offset_of!(kobject__bindgen_ty_2, size) - 8usize];
    [
        "Offset of field: kobject__bindgen_ty_2::data",
    ][::std::mem::offset_of!(kobject__bindgen_ty_2, data) - 16usize];
    [
        "Offset of field: kobject__bindgen_ty_2::preallocated",
    ][::std::mem::offset_of!(kobject__bindgen_ty_2, preallocated) - 24usize];
};
impl Default for kobject__bindgen_ty_2 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug)]
pub struct kobject__bindgen_ty_3 {
    pub nr: usize,
    pub size: usize,
    pub data: *mut *const bin_attribute,
    pub preallocated: __IncompleteArrayField<*const bin_attribute>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of kobject__bindgen_ty_3",
    ][::std::mem::size_of::<kobject__bindgen_ty_3>() - 24usize];
    [
        "Alignment of kobject__bindgen_ty_3",
    ][::std::mem::align_of::<kobject__bindgen_ty_3>() - 8usize];
    [
        "Offset of field: kobject__bindgen_ty_3::nr",
    ][::std::mem::offset_of!(kobject__bindgen_ty_3, nr) - 0usize];
    [
        "Offset of field: kobject__bindgen_ty_3::size",
    ][::std::mem::offset_of!(kobject__bindgen_ty_3, size) - 8usize];
    [
        "Offset of field: kobject__bindgen_ty_3::data",
    ][::std::mem::offset_of!(kobject__bindgen_ty_3, data) - 16usize];
    [
        "Offset of field: kobject__bindgen_ty_3::preallocated",
    ][::std::mem::offset_of!(kobject__bindgen_ty_3, preallocated) - 24usize];
};
impl Default for kobject__bindgen_ty_3 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of kobject"][::std::mem::size_of::<kobject>() - 104usize];
    ["Alignment of kobject"][::std::mem::align_of::<kobject>() - 8usize];
    ["Offset of field: kobject::name"][::std::mem::offset_of!(kobject, name) - 0usize];
    [
        "Offset of field: kobject::parent",
    ][::std::mem::offset_of!(kobject, parent) - 8usize];
    [
        "Offset of field: kobject::ktype",
    ][::std::mem::offset_of!(kobject, ktype) - 16usize];
    ["Offset of field: kobject::ref_"][::std::mem::offset_of!(kobject, ref_) - 24usize];
    [
        "Offset of field: kobject::subdirs",
    ][::std::mem::offset_of!(kobject, subdirs) - 32usize];
    [
        "Offset of field: kobject::files",
    ][::std::mem::offset_of!(kobject, files) - 56usize];
    [
        "Offset of field: kobject::bin_files",
    ][::std::mem::offset_of!(kobject, bin_files) - 80usize];
};
impl Default for kobject {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl kobject {
    #[inline]
    pub fn state_initialized(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_state_initialized(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn state_initialized_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_state_initialized_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn state_in_sysfs(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_state_in_sysfs(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(1usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn state_in_sysfs_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 1usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_state_in_sysfs_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                1usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn state_add_uevent_sent(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_state_add_uevent_sent(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(2usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn state_add_uevent_sent_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 2usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_state_add_uevent_sent_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                2usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn state_remove_uevent_sent(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_state_remove_uevent_sent(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(3usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn state_remove_uevent_sent_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 3usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_state_remove_uevent_sent_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                3usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn uevent_suppress(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_uevent_suppress(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(4usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn uevent_suppress_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 4usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_uevent_suppress_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                4usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        state_initialized: bool,
        state_in_sysfs: bool,
        state_add_uevent_sent: bool,
        state_remove_uevent_sent: bool,
        uevent_suppress: bool,
    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                1u8,
                {
                    let state_initialized: u8 = unsafe {
                        ::std::mem::transmute(state_initialized)
                    };
                    state_initialized as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                1usize,
                1u8,
                {
                    let state_in_sysfs: u8 = unsafe {
                        ::std::mem::transmute(state_in_sysfs)
                    };
                    state_in_sysfs as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                2usize,
                1u8,
                {
                    let state_add_uevent_sent: u8 = unsafe {
                        ::std::mem::transmute(state_add_uevent_sent)
                    };
                    state_add_uevent_sent as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                3usize,
                1u8,
                {
                    let state_remove_uevent_sent: u8 = unsafe {
                        ::std::mem::transmute(state_remove_uevent_sent)
                    };
                    state_remove_uevent_sent as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                4usize,
                1u8,
                {
                    let uevent_suppress: u8 = unsafe {
                        ::std::mem::transmute(uevent_suppress)
                    };
                    uevent_suppress as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
unsafe extern "C" {
    pub fn sysfs_read_or_html_dirlist(
        arg1: *const ::std::os::raw::c_char,
        arg2: *mut printbuf,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn sysfs_write(
        arg1: *const ::std::os::raw::c_char,
        arg2: *const ::std::os::raw::c_char,
        arg3: usize,
    ) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct mutex {
    pub lock: pthread_mutex_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of mutex"][::std::mem::size_of::<mutex>() - 40usize];
    ["Alignment of mutex"][::std::mem::align_of::<mutex>() - 8usize];
    ["Offset of field: mutex::lock"][::std::mem::offset_of!(mutex, lock) - 0usize];
};
impl Default for mutex {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct rw_semaphore {
    pub lock: pthread_rwlock_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of rw_semaphore"][::std::mem::size_of::<rw_semaphore>() - 56usize];
    ["Alignment of rw_semaphore"][::std::mem::align_of::<rw_semaphore>() - 8usize];
    [
        "Offset of field: rw_semaphore::lock",
    ][::std::mem::offset_of!(rw_semaphore, lock) - 0usize];
};
impl Default for rw_semaphore {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type bio_end_io_t = ::std::option::Option<unsafe extern "C" fn(arg1: *mut bio)>;
pub type blk_mode_t = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct inode {
    pub i_ino: ::std::os::raw::c_ulong,
    pub i_size: loff_t,
    pub i_sb: *mut super_block,
    pub mode: blk_mode_t,
    pub i_private: *mut ::std::os::raw::c_void,
    pub i_state: ::std::os::raw::c_uint,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of inode"][::std::mem::size_of::<inode>() - 48usize];
    ["Alignment of inode"][::std::mem::align_of::<inode>() - 8usize];
    ["Offset of field: inode::i_ino"][::std::mem::offset_of!(inode, i_ino) - 0usize];
    ["Offset of field: inode::i_size"][::std::mem::offset_of!(inode, i_size) - 8usize];
    ["Offset of field: inode::i_sb"][::std::mem::offset_of!(inode, i_sb) - 16usize];
    ["Offset of field: inode::mode"][::std::mem::offset_of!(inode, mode) - 24usize];
    [
        "Offset of field: inode::i_private",
    ][::std::mem::offset_of!(inode, i_private) - 32usize];
    [
        "Offset of field: inode::i_state",
    ][::std::mem::offset_of!(inode, i_state) - 40usize];
};
impl Default for inode {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct request_queue {
    pub backing_dev_info: *mut backing_dev_info,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of request_queue"][::std::mem::size_of::<request_queue>() - 8usize];
    ["Alignment of request_queue"][::std::mem::align_of::<request_queue>() - 8usize];
    [
        "Offset of field: request_queue::backing_dev_info",
    ][::std::mem::offset_of!(request_queue, backing_dev_info) - 0usize];
};
impl Default for request_queue {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[repr(align(8))]
#[derive(Debug, Default, Copy, Clone)]
pub struct gendisk {
    pub _bindgen_opaque_blob: [u64; 6usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of gendisk"][::std::mem::size_of::<gendisk>() - 48usize];
    ["Alignment of gendisk"][::std::mem::align_of::<gendisk>() - 8usize];
};
#[repr(C)]
pub struct block_device {
    pub kobj: kobject,
    pub bd_device: block_device__bindgen_ty_1,
    pub bd_dev: dev_t,
    pub name: [::std::os::raw::c_char; 32usize],
    pub bd_inode: *mut inode,
    pub __bd_inode: inode,
    pub queue: request_queue,
    pub bd_holder: *mut ::std::os::raw::c_void,
    pub bd_disk: *mut gendisk,
    pub __bd_disk: gendisk,
    pub bd_fd: ::std::os::raw::c_int,
    pub bd_holder_lock: mutex,
}
#[repr(C)]
#[derive(Debug)]
pub struct block_device__bindgen_ty_1 {
    pub kobj: kobject,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of block_device__bindgen_ty_1",
    ][::std::mem::size_of::<block_device__bindgen_ty_1>() - 104usize];
    [
        "Alignment of block_device__bindgen_ty_1",
    ][::std::mem::align_of::<block_device__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: block_device__bindgen_ty_1::kobj",
    ][::std::mem::offset_of!(block_device__bindgen_ty_1, kobj) - 0usize];
};
impl Default for block_device__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of block_device"][::std::mem::size_of::<block_device>() - 424usize];
    ["Alignment of block_device"][::std::mem::align_of::<block_device>() - 8usize];
    [
        "Offset of field: block_device::kobj",
    ][::std::mem::offset_of!(block_device, kobj) - 0usize];
    [
        "Offset of field: block_device::bd_device",
    ][::std::mem::offset_of!(block_device, bd_device) - 104usize];
    [
        "Offset of field: block_device::bd_dev",
    ][::std::mem::offset_of!(block_device, bd_dev) - 208usize];
    [
        "Offset of field: block_device::name",
    ][::std::mem::offset_of!(block_device, name) - 216usize];
    [
        "Offset of field: block_device::bd_inode",
    ][::std::mem::offset_of!(block_device, bd_inode) - 248usize];
    [
        "Offset of field: block_device::__bd_inode",
    ][::std::mem::offset_of!(block_device, __bd_inode) - 256usize];
    [
        "Offset of field: block_device::queue",
    ][::std::mem::offset_of!(block_device, queue) - 304usize];
    [
        "Offset of field: block_device::bd_holder",
    ][::std::mem::offset_of!(block_device, bd_holder) - 312usize];
    [
        "Offset of field: block_device::bd_disk",
    ][::std::mem::offset_of!(block_device, bd_disk) - 320usize];
    [
        "Offset of field: block_device::__bd_disk",
    ][::std::mem::offset_of!(block_device, __bd_disk) - 328usize];
    [
        "Offset of field: block_device::bd_fd",
    ][::std::mem::offset_of!(block_device, bd_fd) - 376usize];
    [
        "Offset of field: block_device::bd_holder_lock",
    ][::std::mem::offset_of!(block_device, bd_holder_lock) - 384usize];
};
impl Default for block_device {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type blk_status_t = u8_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bio {
    pub bi_next: *mut bio,
    pub bi_bdev: *mut block_device,
    pub bi_status: blk_status_t,
    pub bi_opf: ::std::os::raw::c_uint,
    pub bi_flags: ::std::os::raw::c_ushort,
    pub bi_ioprio: ::std::os::raw::c_ushort,
    pub bi_iter: bvec_iter,
    pub __bi_remaining: atomic_t,
    pub bi_end_io: bio_end_io_t,
    pub bi_private: *mut ::std::os::raw::c_void,
    pub bi_vcnt: ::std::os::raw::c_ushort,
    pub bi_max_vecs: ::std::os::raw::c_ushort,
    pub __bi_cnt: atomic_t,
    pub bi_io_vec: *mut bio_vec,
    pub bi_pool: *mut bio_set,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bio"][::std::mem::size_of::<bio>() - 104usize];
    ["Alignment of bio"][::std::mem::align_of::<bio>() - 8usize];
    ["Offset of field: bio::bi_next"][::std::mem::offset_of!(bio, bi_next) - 0usize];
    ["Offset of field: bio::bi_bdev"][::std::mem::offset_of!(bio, bi_bdev) - 8usize];
    [
        "Offset of field: bio::bi_status",
    ][::std::mem::offset_of!(bio, bi_status) - 16usize];
    ["Offset of field: bio::bi_opf"][::std::mem::offset_of!(bio, bi_opf) - 20usize];
    ["Offset of field: bio::bi_flags"][::std::mem::offset_of!(bio, bi_flags) - 24usize];
    [
        "Offset of field: bio::bi_ioprio",
    ][::std::mem::offset_of!(bio, bi_ioprio) - 26usize];
    ["Offset of field: bio::bi_iter"][::std::mem::offset_of!(bio, bi_iter) - 32usize];
    [
        "Offset of field: bio::__bi_remaining",
    ][::std::mem::offset_of!(bio, __bi_remaining) - 56usize];
    [
        "Offset of field: bio::bi_end_io",
    ][::std::mem::offset_of!(bio, bi_end_io) - 64usize];
    [
        "Offset of field: bio::bi_private",
    ][::std::mem::offset_of!(bio, bi_private) - 72usize];
    ["Offset of field: bio::bi_vcnt"][::std::mem::offset_of!(bio, bi_vcnt) - 80usize];
    [
        "Offset of field: bio::bi_max_vecs",
    ][::std::mem::offset_of!(bio, bi_max_vecs) - 82usize];
    ["Offset of field: bio::__bi_cnt"][::std::mem::offset_of!(bio, __bi_cnt) - 84usize];
    [
        "Offset of field: bio::bi_io_vec",
    ][::std::mem::offset_of!(bio, bi_io_vec) - 88usize];
    ["Offset of field: bio::bi_pool"][::std::mem::offset_of!(bio, bi_pool) - 96usize];
};
impl Default for bio {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C" {
    #[link_name = "bio_inline_vecs__extern"]
    pub fn bio_inline_vecs(bio: *mut bio) -> *mut bio_vec;
}
pub type blk_opf_t = __u32;
unsafe extern "C" {
    #[link_name = "bio_set_op_attrs__extern"]
    pub fn bio_set_op_attrs(
        bio: *mut bio,
        op: ::std::os::raw::c_uint,
        op_flags: ::std::os::raw::c_uint,
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct file {
    pub f_inode: *mut inode,
    pub private_data: *mut ::std::os::raw::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of file"][::std::mem::size_of::<file>() - 16usize];
    ["Alignment of file"][::std::mem::align_of::<file>() - 8usize];
    ["Offset of field: file::f_inode"][::std::mem::offset_of!(file, f_inode) - 0usize];
    [
        "Offset of field: file::private_data",
    ][::std::mem::offset_of!(file, private_data) - 8usize];
};
impl Default for file {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct blk_holder_ops {
    pub mark_dead: ::std::option::Option<
        unsafe extern "C" fn(bdev: *mut block_device, surprise: bool),
    >,
    pub sync: ::std::option::Option<unsafe extern "C" fn(bdev: *mut block_device)>,
    pub freeze: ::std::option::Option<
        unsafe extern "C" fn(bdev: *mut block_device) -> ::std::os::raw::c_int,
    >,
    pub thaw: ::std::option::Option<
        unsafe extern "C" fn(bdev: *mut block_device) -> ::std::os::raw::c_int,
    >,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of blk_holder_ops"][::std::mem::size_of::<blk_holder_ops>() - 32usize];
    ["Alignment of blk_holder_ops"][::std::mem::align_of::<blk_holder_ops>() - 8usize];
    [
        "Offset of field: blk_holder_ops::mark_dead",
    ][::std::mem::offset_of!(blk_holder_ops, mark_dead) - 0usize];
    [
        "Offset of field: blk_holder_ops::sync",
    ][::std::mem::offset_of!(blk_holder_ops, sync) - 8usize];
    [
        "Offset of field: blk_holder_ops::freeze",
    ][::std::mem::offset_of!(blk_holder_ops, freeze) - 16usize];
    [
        "Offset of field: blk_holder_ops::thaw",
    ][::std::mem::offset_of!(blk_holder_ops, thaw) - 24usize];
};
#[repr(C)]
#[derive(Copy, Clone)]
pub struct super_block {
    pub s_fs_info: *mut ::std::os::raw::c_void,
    pub s_umount: rw_semaphore,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of super_block"][::std::mem::size_of::<super_block>() - 64usize];
    ["Alignment of super_block"][::std::mem::align_of::<super_block>() - 8usize];
    [
        "Offset of field: super_block::s_fs_info",
    ][::std::mem::offset_of!(super_block, s_fs_info) - 0usize];
    [
        "Offset of field: super_block::s_umount",
    ][::std::mem::offset_of!(super_block, s_umount) - 8usize];
};
impl Default for super_block {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type filldir_t = ::std::option::Option<
    unsafe extern "C" fn(
        arg1: *mut dir_context,
        arg2: *const ::std::os::raw::c_char,
        arg3: ::std::os::raw::c_int,
        arg4: loff_t,
        arg5: u64_,
        arg6: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int,
>;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct dir_context {
    pub actor: filldir_t,
    pub pos: u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of dir_context"][::std::mem::size_of::<dir_context>() - 16usize];
    ["Alignment of dir_context"][::std::mem::align_of::<dir_context>() - 8usize];
    [
        "Offset of field: dir_context::actor",
    ][::std::mem::offset_of!(dir_context, actor) - 0usize];
    [
        "Offset of field: dir_context::pos",
    ][::std::mem::offset_of!(dir_context, pos) - 8usize];
};
unsafe extern "C" {
    #[link_name = "bio_data_dir__extern"]
    pub fn bio_data_dir(bio: *mut bio) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bio_has_data__extern"]
    pub fn bio_has_data(bio: *mut bio) -> bool;
}
unsafe extern "C" {
    #[link_name = "bio_no_advance_iter__extern"]
    pub fn bio_no_advance_iter(bio: *mut bio) -> bool;
}
unsafe extern "C" {
    #[link_name = "bio_is_rw__extern"]
    pub fn bio_is_rw(bio: *mut bio) -> bool;
}
unsafe extern "C" {
    #[link_name = "bio_mergeable__extern"]
    pub fn bio_mergeable(bio: *mut bio) -> bool;
}
unsafe extern "C" {
    #[link_name = "bio_cur_bytes__extern"]
    pub fn bio_cur_bytes(bio: *mut bio) -> ::std::os::raw::c_uint;
}
unsafe extern "C" {
    #[link_name = "bio_next_segment__extern"]
    pub fn bio_next_segment(bio: *const bio, iter: *mut bvec_iter_all) -> *mut bio_vec;
}
unsafe extern "C" {
    #[link_name = "bio_advance_iter__extern"]
    pub fn bio_advance_iter(
        bio: *mut bio,
        iter: *mut bvec_iter,
        bytes: ::std::os::raw::c_uint,
    );
}
unsafe extern "C" {
    #[link_name = "bio_segments__extern"]
    pub fn bio_segments(bio: *mut bio) -> ::std::os::raw::c_uint;
}
unsafe extern "C" {
    #[link_name = "bio_get__extern"]
    pub fn bio_get(bio: *mut bio);
}
unsafe extern "C" {
    #[link_name = "bio_flagged__extern"]
    pub fn bio_flagged(bio: *mut bio, bit: ::std::os::raw::c_uint) -> bool;
}
unsafe extern "C" {
    #[link_name = "bio_set_flag__extern"]
    pub fn bio_set_flag(bio: *mut bio, bit: ::std::os::raw::c_uint);
}
unsafe extern "C" {
    #[link_name = "bio_clear_flag__extern"]
    pub fn bio_clear_flag(bio: *mut bio, bit: ::std::os::raw::c_uint);
}
unsafe extern "C" {
    pub fn bio_split(
        bio: *mut bio,
        sectors: ::std::os::raw::c_int,
        gfp: gfp_t,
        bs: *mut bio_set,
    ) -> *mut bio;
}
unsafe extern "C" {
    #[link_name = "bio_next_split__extern"]
    pub fn bio_next_split(
        bio: *mut bio,
        sectors: ::std::os::raw::c_int,
        gfp: gfp_t,
        bs: *mut bio_set,
    ) -> *mut bio;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bio_set {
    pub front_pad: ::std::os::raw::c_uint,
    pub back_pad: ::std::os::raw::c_uint,
    pub bio_pool: mempool_t,
    pub bvec_pool: mempool_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bio_set"][::std::mem::size_of::<bio_set>() - 280usize];
    ["Alignment of bio_set"][::std::mem::align_of::<bio_set>() - 8usize];
    [
        "Offset of field: bio_set::front_pad",
    ][::std::mem::offset_of!(bio_set, front_pad) - 0usize];
    [
        "Offset of field: bio_set::back_pad",
    ][::std::mem::offset_of!(bio_set, back_pad) - 4usize];
    [
        "Offset of field: bio_set::bio_pool",
    ][::std::mem::offset_of!(bio_set, bio_pool) - 8usize];
    [
        "Offset of field: bio_set::bvec_pool",
    ][::std::mem::offset_of!(bio_set, bvec_pool) - 144usize];
};
impl Default for bio_set {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C" {
    pub fn bio_alloc_bioset(
        arg1: *mut block_device,
        arg2: ::std::os::raw::c_uint,
        arg3: blk_opf_t,
        arg4: gfp_t,
        arg5: *mut bio_set,
    ) -> *mut bio;
}
unsafe extern "C" {
    pub fn bio_put(arg1: *mut bio);
}
unsafe extern "C" {
    pub fn bio_add_virt_nofail(
        arg1: *mut bio,
        arg2: *mut ::std::os::raw::c_void,
        arg3: ::std::os::raw::c_uint,
    );
}
unsafe extern "C" {
    #[link_name = "bio_add_vmalloc__extern"]
    pub fn bio_add_vmalloc(
        bio: *mut bio,
        vaddr: *mut ::std::os::raw::c_void,
        len: ::std::os::raw::c_uint,
    );
}
unsafe extern "C" {
    pub fn bio_alloc_clone(
        arg1: *mut block_device,
        arg2: *mut bio,
        arg3: gfp_t,
        arg4: *mut bio_set,
    ) -> *mut bio;
}
unsafe extern "C" {
    pub fn bio_alloc(
        arg1: *mut block_device,
        arg2: ::std::os::raw::c_uint,
        arg3: blk_opf_t,
        arg4: gfp_t,
    ) -> *mut bio;
}
unsafe extern "C" {
    pub fn bio_kmalloc(arg1: ::std::os::raw::c_uint, arg2: gfp_t) -> *mut bio;
}
unsafe extern "C" {
    pub fn bio_endio(arg1: *mut bio);
}
unsafe extern "C" {
    pub fn bio_advance(arg1: *mut bio, arg2: ::std::os::raw::c_uint);
}
unsafe extern "C" {
    pub fn bio_reset(
        arg1: *mut bio,
        arg2: *mut block_device,
        arg3: ::std::os::raw::c_uint,
    );
}
unsafe extern "C" {
    pub fn bio_chain(arg1: *mut bio, arg2: *mut bio);
}
unsafe extern "C" {
    pub fn bio_copy_data_iter(
        dst: *mut bio,
        dst_iter: *mut bvec_iter,
        src: *mut bio,
        src_iter: *mut bvec_iter,
    );
}
unsafe extern "C" {
    pub fn bio_copy_data(dst: *mut bio, src: *mut bio);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bio_list {
    pub head: *mut bio,
    pub tail: *mut bio,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bio_list"][::std::mem::size_of::<bio_list>() - 16usize];
    ["Alignment of bio_list"][::std::mem::align_of::<bio_list>() - 8usize];
    ["Offset of field: bio_list::head"][::std::mem::offset_of!(bio_list, head) - 0usize];
    ["Offset of field: bio_list::tail"][::std::mem::offset_of!(bio_list, tail) - 8usize];
};
impl Default for bio_list {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C" {
    #[link_name = "bio_list_empty__extern"]
    pub fn bio_list_empty(bl: *const bio_list) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bio_list_init__extern"]
    pub fn bio_list_init(bl: *mut bio_list);
}
unsafe extern "C" {
    #[link_name = "bio_list_size__extern"]
    pub fn bio_list_size(bl: *const bio_list) -> ::std::os::raw::c_uint;
}
unsafe extern "C" {
    #[link_name = "bio_list_add__extern"]
    pub fn bio_list_add(bl: *mut bio_list, bio: *mut bio);
}
unsafe extern "C" {
    #[link_name = "bio_list_add_head__extern"]
    pub fn bio_list_add_head(bl: *mut bio_list, bio: *mut bio);
}
unsafe extern "C" {
    #[link_name = "bio_list_merge__extern"]
    pub fn bio_list_merge(bl: *mut bio_list, bl2: *mut bio_list);
}
unsafe extern "C" {
    #[link_name = "bio_list_merge_head__extern"]
    pub fn bio_list_merge_head(bl: *mut bio_list, bl2: *mut bio_list);
}
unsafe extern "C" {
    #[link_name = "bio_list_peek__extern"]
    pub fn bio_list_peek(bl: *mut bio_list) -> *mut bio;
}
unsafe extern "C" {
    #[link_name = "bio_list_pop__extern"]
    pub fn bio_list_pop(bl: *mut bio_list) -> *mut bio;
}
unsafe extern "C" {
    #[link_name = "bio_list_get__extern"]
    pub fn bio_list_get(bl: *mut bio_list) -> *mut bio;
}
unsafe extern "C" {
    #[link_name = "bio_inc_remaining__extern"]
    pub fn bio_inc_remaining(bio: *mut bio);
}
unsafe extern "C" {
    #[link_name = "bio_init__extern"]
    pub fn bio_init(
        bio: *mut bio,
        bdev: *mut block_device,
        table: *mut bio_vec,
        max_vecs: ::std::os::raw::c_ushort,
        opf: ::std::os::raw::c_uint,
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct llist_head {
    pub first: *mut llist_node,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of llist_head"][::std::mem::size_of::<llist_head>() - 8usize];
    ["Alignment of llist_head"][::std::mem::align_of::<llist_head>() - 8usize];
    [
        "Offset of field: llist_head::first",
    ][::std::mem::offset_of!(llist_head, first) - 0usize];
};
impl Default for llist_head {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct llist_node {
    pub next: *mut llist_node,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of llist_node"][::std::mem::size_of::<llist_node>() - 8usize];
    ["Alignment of llist_node"][::std::mem::align_of::<llist_node>() - 8usize];
    [
        "Offset of field: llist_node::next",
    ][::std::mem::offset_of!(llist_node, next) - 0usize];
};
impl Default for llist_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C" {
    pub static mut bch_percpu_nr_cpus: ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub static mut bch_percpu_my_chunk: *mut ::std::os::raw::c_void;
}
unsafe extern "C" {
    pub static mut bch_percpu_my_id: ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub static mut bch_percpu_chunks: [*mut ::std::os::raw::c_void; 256usize];
}
unsafe extern "C" {
    pub static mut bch_percpu_static_size: usize;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct completion {
    pub done: ::std::os::raw::c_uint,
    pub wait: wait_queue_head_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of completion"][::std::mem::size_of::<completion>() - 64usize];
    ["Alignment of completion"][::std::mem::align_of::<completion>() - 8usize];
    [
        "Offset of field: completion::done",
    ][::std::mem::offset_of!(completion, done) - 0usize];
    [
        "Offset of field: completion::wait",
    ][::std::mem::offset_of!(completion, wait) - 8usize];
};
impl Default for completion {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type time64_t = __s64;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct task_struct {
    pub thread: pthread_t,
    pub thread_fn: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int,
    >,
    pub thread_data: *mut ::std::os::raw::c_void,
    pub prio: ::std::os::raw::c_int,
    pub usage: atomic_t,
    pub state: ::std::os::raw::c_int,
    pub kthread_flags: ::std::os::raw::c_ulong,
    pub exited: completion,
    pub flags: ::std::os::raw::c_uint,
    pub on_cpu: bool,
    pub comm: [::std::os::raw::c_char; 16usize],
    pub pid: pid_t,
    pub bio_list: *mut bio_list,
    pub signal: *mut task_struct_signal_struct,
    pub _signal: task_struct_signal_struct,
    pub se: task_struct__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct task_struct_signal_struct {
    pub exec_update_lock: rw_semaphore,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of task_struct_signal_struct",
    ][::std::mem::size_of::<task_struct_signal_struct>() - 56usize];
    [
        "Alignment of task_struct_signal_struct",
    ][::std::mem::align_of::<task_struct_signal_struct>() - 8usize];
    [
        "Offset of field: task_struct_signal_struct::exec_update_lock",
    ][::std::mem::offset_of!(task_struct_signal_struct, exec_update_lock) - 0usize];
};
impl Default for task_struct_signal_struct {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct task_struct__bindgen_ty_1 {
    pub sum_exec_runtime: u64_,
    pub exec_start: u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of task_struct__bindgen_ty_1",
    ][::std::mem::size_of::<task_struct__bindgen_ty_1>() - 16usize];
    [
        "Alignment of task_struct__bindgen_ty_1",
    ][::std::mem::align_of::<task_struct__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: task_struct__bindgen_ty_1::sum_exec_runtime",
    ][::std::mem::offset_of!(task_struct__bindgen_ty_1, sum_exec_runtime) - 0usize];
    [
        "Offset of field: task_struct__bindgen_ty_1::exec_start",
    ][::std::mem::offset_of!(task_struct__bindgen_ty_1, exec_start) - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of task_struct"][::std::mem::size_of::<task_struct>() - 232usize];
    ["Alignment of task_struct"][::std::mem::align_of::<task_struct>() - 8usize];
    [
        "Offset of field: task_struct::thread",
    ][::std::mem::offset_of!(task_struct, thread) - 0usize];
    [
        "Offset of field: task_struct::thread_fn",
    ][::std::mem::offset_of!(task_struct, thread_fn) - 8usize];
    [
        "Offset of field: task_struct::thread_data",
    ][::std::mem::offset_of!(task_struct, thread_data) - 16usize];
    [
        "Offset of field: task_struct::prio",
    ][::std::mem::offset_of!(task_struct, prio) - 24usize];
    [
        "Offset of field: task_struct::usage",
    ][::std::mem::offset_of!(task_struct, usage) - 28usize];
    [
        "Offset of field: task_struct::state",
    ][::std::mem::offset_of!(task_struct, state) - 32usize];
    [
        "Offset of field: task_struct::kthread_flags",
    ][::std::mem::offset_of!(task_struct, kthread_flags) - 40usize];
    [
        "Offset of field: task_struct::exited",
    ][::std::mem::offset_of!(task_struct, exited) - 48usize];
    [
        "Offset of field: task_struct::flags",
    ][::std::mem::offset_of!(task_struct, flags) - 112usize];
    [
        "Offset of field: task_struct::on_cpu",
    ][::std::mem::offset_of!(task_struct, on_cpu) - 116usize];
    [
        "Offset of field: task_struct::comm",
    ][::std::mem::offset_of!(task_struct, comm) - 117usize];
    [
        "Offset of field: task_struct::pid",
    ][::std::mem::offset_of!(task_struct, pid) - 136usize];
    [
        "Offset of field: task_struct::bio_list",
    ][::std::mem::offset_of!(task_struct, bio_list) - 144usize];
    [
        "Offset of field: task_struct::signal",
    ][::std::mem::offset_of!(task_struct, signal) - 152usize];
    [
        "Offset of field: task_struct::_signal",
    ][::std::mem::offset_of!(task_struct, _signal) - 160usize];
    [
        "Offset of field: task_struct::se",
    ][::std::mem::offset_of!(task_struct, se) - 216usize];
};
impl Default for task_struct {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ratelimit_state {
    pub lock: raw_spinlock_t,
    pub interval: ::std::os::raw::c_int,
    pub burst: ::std::os::raw::c_int,
    pub rs_n_left: atomic_t,
    pub missed: atomic_t,
    pub flags: ::std::os::raw::c_uint,
    pub begin: ::std::os::raw::c_ulong,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of ratelimit_state"][::std::mem::size_of::<ratelimit_state>() - 72usize];
    ["Alignment of ratelimit_state"][::std::mem::align_of::<ratelimit_state>() - 8usize];
    [
        "Offset of field: ratelimit_state::lock",
    ][::std::mem::offset_of!(ratelimit_state, lock) - 0usize];
    [
        "Offset of field: ratelimit_state::interval",
    ][::std::mem::offset_of!(ratelimit_state, interval) - 40usize];
    [
        "Offset of field: ratelimit_state::burst",
    ][::std::mem::offset_of!(ratelimit_state, burst) - 44usize];
    [
        "Offset of field: ratelimit_state::rs_n_left",
    ][::std::mem::offset_of!(ratelimit_state, rs_n_left) - 48usize];
    [
        "Offset of field: ratelimit_state::missed",
    ][::std::mem::offset_of!(ratelimit_state, missed) - 52usize];
    [
        "Offset of field: ratelimit_state::flags",
    ][::std::mem::offset_of!(ratelimit_state, flags) - 56usize];
    [
        "Offset of field: ratelimit_state::begin",
    ][::std::mem::offset_of!(ratelimit_state, begin) - 64usize];
};
impl Default for ratelimit_state {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type closure_fn = ::std::option::Option<
    unsafe extern "C" fn(arg1: *mut work_struct),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct closure_waitlist {
    pub list: llist_head,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of closure_waitlist"][::std::mem::size_of::<closure_waitlist>() - 8usize];
    [
        "Alignment of closure_waitlist",
    ][::std::mem::align_of::<closure_waitlist>() - 8usize];
    [
        "Offset of field: closure_waitlist::list",
    ][::std::mem::offset_of!(closure_waitlist, list) - 0usize];
};
impl Default for closure_waitlist {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct closure {
    pub __bindgen_anon_1: closure__bindgen_ty_1,
    pub parent: *mut closure,
    pub remaining: atomic_t,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union closure__bindgen_ty_1 {
    pub __bindgen_anon_1: closure__bindgen_ty_1__bindgen_ty_1,
    pub work: work_struct,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct closure__bindgen_ty_1__bindgen_ty_1 {
    pub wq: *mut workqueue_struct,
    pub sleeper: *mut task_struct,
    pub list: llist_node,
    pub fn_: closure_fn,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of closure__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<closure__bindgen_ty_1__bindgen_ty_1>() - 32usize];
    [
        "Alignment of closure__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<closure__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: closure__bindgen_ty_1__bindgen_ty_1::wq",
    ][::std::mem::offset_of!(closure__bindgen_ty_1__bindgen_ty_1, wq) - 0usize];
    [
        "Offset of field: closure__bindgen_ty_1__bindgen_ty_1::sleeper",
    ][::std::mem::offset_of!(closure__bindgen_ty_1__bindgen_ty_1, sleeper) - 8usize];
    [
        "Offset of field: closure__bindgen_ty_1__bindgen_ty_1::list",
    ][::std::mem::offset_of!(closure__bindgen_ty_1__bindgen_ty_1, list) - 16usize];
    [
        "Offset of field: closure__bindgen_ty_1__bindgen_ty_1::fn_",
    ][::std::mem::offset_of!(closure__bindgen_ty_1__bindgen_ty_1, fn_) - 24usize];
};
impl Default for closure__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of closure__bindgen_ty_1",
    ][::std::mem::size_of::<closure__bindgen_ty_1>() - 32usize];
    [
        "Alignment of closure__bindgen_ty_1",
    ][::std::mem::align_of::<closure__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: closure__bindgen_ty_1::work",
    ][::std::mem::offset_of!(closure__bindgen_ty_1, work) - 0usize];
};
impl Default for closure__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of closure"][::std::mem::size_of::<closure>() - 48usize];
    ["Alignment of closure"][::std::mem::align_of::<closure>() - 8usize];
    [
        "Offset of field: closure::parent",
    ][::std::mem::offset_of!(closure, parent) - 32usize];
    [
        "Offset of field: closure::remaining",
    ][::std::mem::offset_of!(closure, remaining) - 40usize];
};
impl Default for closure {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C" {
    pub fn bch2_closure_sub(cl: *mut closure, v: ::std::os::raw::c_int);
}
unsafe extern "C" {
    pub fn __bch2_closure_wake_up(list: *mut closure_waitlist);
}
unsafe extern "C" {
    pub fn bch2_closure_wait(list: *mut closure_waitlist, cl: *mut closure) -> bool;
}
unsafe extern "C" {
    pub fn __bch2_closure_sync(cl: *mut closure);
}
unsafe extern "C" {
    pub fn __bch2_closure_sync_timeout(
        cl: *mut closure,
        timeout: ::std::os::raw::c_ulong,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_closure_sync_unbounded(arg1: *mut closure);
}
unsafe extern "C" {
    #[link_name = "bch2_closure_debug_create__extern"]
    pub fn bch2_closure_debug_create(cl: *mut closure);
}
unsafe extern "C" {
    pub fn bch2_closure_return_sync(cl: *mut closure);
}
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Default, Copy, Clone)]
pub struct u128_u {
    pub hi: u64_,
    pub lo: u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of u128_u"][::std::mem::size_of::<u128_u>() - 16usize];
    ["Alignment of u128_u"][::std::mem::align_of::<u128_u>() - 16usize];
    ["Offset of field: u128_u::hi"][::std::mem::offset_of!(u128_u, hi) - 0usize];
    ["Offset of field: u128_u::lo"][::std::mem::offset_of!(u128_u, lo) - 8usize];
};
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Default, Copy, Clone)]
pub struct mean_and_variance {
    pub n: s64,
    pub sum: s64,
    pub sum_squares: u128_u,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of mean_and_variance"][::std::mem::size_of::<mean_and_variance>() - 32usize];
    [
        "Alignment of mean_and_variance",
    ][::std::mem::align_of::<mean_and_variance>() - 16usize];
    [
        "Offset of field: mean_and_variance::n",
    ][::std::mem::offset_of!(mean_and_variance, n) - 0usize];
    [
        "Offset of field: mean_and_variance::sum",
    ][::std::mem::offset_of!(mean_and_variance, sum) - 8usize];
    [
        "Offset of field: mean_and_variance::sum_squares",
    ][::std::mem::offset_of!(mean_and_variance, sum_squares) - 16usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct mean_and_variance_weighted {
    pub mean: s64,
    pub variance: u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of mean_and_variance_weighted",
    ][::std::mem::size_of::<mean_and_variance_weighted>() - 16usize];
    [
        "Alignment of mean_and_variance_weighted",
    ][::std::mem::align_of::<mean_and_variance_weighted>() - 8usize];
    [
        "Offset of field: mean_and_variance_weighted::mean",
    ][::std::mem::offset_of!(mean_and_variance_weighted, mean) - 0usize];
    [
        "Offset of field: mean_and_variance_weighted::variance",
    ][::std::mem::offset_of!(mean_and_variance_weighted, variance) - 8usize];
};
unsafe extern "C" {
    pub fn match_string(
        arg1: *const *const ::std::os::raw::c_char,
        arg2: usize,
        arg3: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct time_unit {
    pub name: *const ::std::os::raw::c_char,
    pub nsecs: u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of time_unit"][::std::mem::size_of::<time_unit>() - 16usize];
    ["Alignment of time_unit"][::std::mem::align_of::<time_unit>() - 8usize];
    [
        "Offset of field: time_unit::name",
    ][::std::mem::offset_of!(time_unit, name) - 0usize];
    [
        "Offset of field: time_unit::nsecs",
    ][::std::mem::offset_of!(time_unit, nsecs) - 8usize];
};
impl Default for time_unit {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C" {
    pub fn bch2_pick_time_units(ns: u64_) -> *const time_unit;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct quantiles {
    pub entries: [quantiles_quantile_entry; 15usize],
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct quantiles_quantile_entry {
    pub m: u64_,
    pub step: u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of quantiles_quantile_entry",
    ][::std::mem::size_of::<quantiles_quantile_entry>() - 16usize];
    [
        "Alignment of quantiles_quantile_entry",
    ][::std::mem::align_of::<quantiles_quantile_entry>() - 8usize];
    [
        "Offset of field: quantiles_quantile_entry::m",
    ][::std::mem::offset_of!(quantiles_quantile_entry, m) - 0usize];
    [
        "Offset of field: quantiles_quantile_entry::step",
    ][::std::mem::offset_of!(quantiles_quantile_entry, step) - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of quantiles"][::std::mem::size_of::<quantiles>() - 240usize];
    ["Alignment of quantiles"][::std::mem::align_of::<quantiles>() - 8usize];
    [
        "Offset of field: quantiles::entries",
    ][::std::mem::offset_of!(quantiles, entries) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct time_stat_buffer {
    pub nr: ::std::os::raw::c_uint,
    pub entries: [time_stat_buffer_time_stat_buffer_entry; 31usize],
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct time_stat_buffer_time_stat_buffer_entry {
    pub start: u64_,
    pub end: u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of time_stat_buffer_time_stat_buffer_entry",
    ][::std::mem::size_of::<time_stat_buffer_time_stat_buffer_entry>() - 16usize];
    [
        "Alignment of time_stat_buffer_time_stat_buffer_entry",
    ][::std::mem::align_of::<time_stat_buffer_time_stat_buffer_entry>() - 8usize];
    [
        "Offset of field: time_stat_buffer_time_stat_buffer_entry::start",
    ][::std::mem::offset_of!(time_stat_buffer_time_stat_buffer_entry, start) - 0usize];
    [
        "Offset of field: time_stat_buffer_time_stat_buffer_entry::end",
    ][::std::mem::offset_of!(time_stat_buffer_time_stat_buffer_entry, end) - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of time_stat_buffer"][::std::mem::size_of::<time_stat_buffer>() - 504usize];
    [
        "Alignment of time_stat_buffer",
    ][::std::mem::align_of::<time_stat_buffer>() - 8usize];
    [
        "Offset of field: time_stat_buffer::nr",
    ][::std::mem::offset_of!(time_stat_buffer, nr) - 0usize];
    [
        "Offset of field: time_stat_buffer::entries",
    ][::std::mem::offset_of!(time_stat_buffer, entries) - 8usize];
};
#[repr(C)]
#[repr(align(16))]
#[derive(Copy, Clone)]
pub struct bch2_time_stats {
    pub lock: spinlock_t,
    pub have_quantiles: bool,
    pub buffer: *mut time_stat_buffer,
    pub min_duration: u64_,
    pub max_duration: u64_,
    pub total_duration: u64_,
    pub max_freq: u64_,
    pub min_freq: u64_,
    pub last_event: u64_,
    pub last_event_start: u64_,
    pub start_time: u64_,
    pub __bindgen_padding_0: u64,
    pub duration_stats: mean_and_variance,
    pub freq_stats: mean_and_variance,
    pub duration_stats_weighted: mean_and_variance_weighted,
    pub freq_stats_weighted: mean_and_variance_weighted,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch2_time_stats"][::std::mem::size_of::<bch2_time_stats>() - 224usize];
    [
        "Alignment of bch2_time_stats",
    ][::std::mem::align_of::<bch2_time_stats>() - 16usize];
    [
        "Offset of field: bch2_time_stats::lock",
    ][::std::mem::offset_of!(bch2_time_stats, lock) - 0usize];
    [
        "Offset of field: bch2_time_stats::have_quantiles",
    ][::std::mem::offset_of!(bch2_time_stats, have_quantiles) - 40usize];
    [
        "Offset of field: bch2_time_stats::buffer",
    ][::std::mem::offset_of!(bch2_time_stats, buffer) - 48usize];
    [
        "Offset of field: bch2_time_stats::min_duration",
    ][::std::mem::offset_of!(bch2_time_stats, min_duration) - 56usize];
    [
        "Offset of field: bch2_time_stats::max_duration",
    ][::std::mem::offset_of!(bch2_time_stats, max_duration) - 64usize];
    [
        "Offset of field: bch2_time_stats::total_duration",
    ][::std::mem::offset_of!(bch2_time_stats, total_duration) - 72usize];
    [
        "Offset of field: bch2_time_stats::max_freq",
    ][::std::mem::offset_of!(bch2_time_stats, max_freq) - 80usize];
    [
        "Offset of field: bch2_time_stats::min_freq",
    ][::std::mem::offset_of!(bch2_time_stats, min_freq) - 88usize];
    [
        "Offset of field: bch2_time_stats::last_event",
    ][::std::mem::offset_of!(bch2_time_stats, last_event) - 96usize];
    [
        "Offset of field: bch2_time_stats::last_event_start",
    ][::std::mem::offset_of!(bch2_time_stats, last_event_start) - 104usize];
    [
        "Offset of field: bch2_time_stats::start_time",
    ][::std::mem::offset_of!(bch2_time_stats, start_time) - 112usize];
    [
        "Offset of field: bch2_time_stats::duration_stats",
    ][::std::mem::offset_of!(bch2_time_stats, duration_stats) - 128usize];
    [
        "Offset of field: bch2_time_stats::freq_stats",
    ][::std::mem::offset_of!(bch2_time_stats, freq_stats) - 160usize];
    [
        "Offset of field: bch2_time_stats::duration_stats_weighted",
    ][::std::mem::offset_of!(bch2_time_stats, duration_stats_weighted) - 192usize];
    [
        "Offset of field: bch2_time_stats::freq_stats_weighted",
    ][::std::mem::offset_of!(bch2_time_stats, freq_stats_weighted) - 208usize];
};
impl Default for bch2_time_stats {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[repr(align(16))]
#[derive(Copy, Clone)]
pub struct bch2_time_stats_quantiles {
    pub stats: bch2_time_stats,
    pub quantiles: quantiles,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch2_time_stats_quantiles",
    ][::std::mem::size_of::<bch2_time_stats_quantiles>() - 464usize];
    [
        "Alignment of bch2_time_stats_quantiles",
    ][::std::mem::align_of::<bch2_time_stats_quantiles>() - 16usize];
    [
        "Offset of field: bch2_time_stats_quantiles::stats",
    ][::std::mem::offset_of!(bch2_time_stats_quantiles, stats) - 0usize];
    [
        "Offset of field: bch2_time_stats_quantiles::quantiles",
    ][::std::mem::offset_of!(bch2_time_stats_quantiles, quantiles) - 224usize];
};
impl Default for bch2_time_stats_quantiles {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C" {
    pub fn __bch2_time_stats_clear_buffer(
        arg1: *mut bch2_time_stats,
        arg2: *mut time_stat_buffer,
    );
}
unsafe extern "C" {
    pub fn __bch2_time_stats_update(stats: *mut bch2_time_stats, arg1: u64_, arg2: u64_);
}
unsafe extern "C" {
    /** time_stats_update - collect a new event being tracked

 @stats	- bch2_time_stats to update
 @start	- start time of event, recorded with local_clock()

 The end duration of the event will be the current time*/
    #[link_name = "bch2_time_stats_update__extern"]
    pub fn bch2_time_stats_update(stats: *mut bch2_time_stats, start: u64_);
}
unsafe extern "C" {
    pub fn bch2_time_stats_reset(arg1: *mut bch2_time_stats);
}
unsafe extern "C" {
    pub fn bch2_time_stats_to_seq_buf(
        arg1: *mut seq_buf,
        arg2: *mut bch2_time_stats,
        epoch_name: *const ::std::os::raw::c_char,
        flags: ::std::os::raw::c_uint,
    );
}
unsafe extern "C" {
    pub fn bch2_time_stats_to_json(
        arg1: *mut seq_buf,
        arg2: *mut bch2_time_stats,
        epoch_name: *const ::std::os::raw::c_char,
        flags: ::std::os::raw::c_uint,
    );
}
unsafe extern "C" {
    pub fn bch2_time_stats_exit(arg1: *mut bch2_time_stats);
}
unsafe extern "C" {
    pub fn bch2_time_stats_init(arg1: *mut bch2_time_stats);
}
unsafe extern "C" {
    pub fn bch2_time_stats_init_no_pcpu(arg1: *mut bch2_time_stats);
}
unsafe extern "C" {
    #[link_name = "bch2_time_stats_quantiles_exit__extern"]
    pub fn bch2_time_stats_quantiles_exit(statq: *mut bch2_time_stats_quantiles);
}
unsafe extern "C" {
    #[link_name = "bch2_time_stats_quantiles_init__extern"]
    pub fn bch2_time_stats_quantiles_init(statq: *mut bch2_time_stats_quantiles);
}
unsafe extern "C" {
    #[link_name = "bch2_kvmalloc_noprof__extern"]
    pub fn bch2_kvmalloc_noprof(n: usize, flags: gfp_t) -> *mut ::std::os::raw::c_void;
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum printbuf_si {
    PRINTBUF_UNITS_2 = 0,
    PRINTBUF_UNITS_10 = 1,
}
#[repr(C)]
#[derive(Debug)]
pub struct printbuf {
    pub buf: *mut ::std::os::raw::c_char,
    pub size: ::std::os::raw::c_uint,
    pub pos: ::std::os::raw::c_uint,
    pub last_newline: ::std::os::raw::c_uint,
    pub last_field: ::std::os::raw::c_uint,
    pub indent: ::std::os::raw::c_uint,
    pub atomic: u8_,
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
    pub nr_tabstops: u8_,
    pub cur_tabstop: u8_,
    pub _tabstops: [u8_; 8usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of printbuf"][::std::mem::size_of::<printbuf>() - 40usize];
    ["Alignment of printbuf"][::std::mem::align_of::<printbuf>() - 8usize];
    ["Offset of field: printbuf::buf"][::std::mem::offset_of!(printbuf, buf) - 0usize];
    ["Offset of field: printbuf::size"][::std::mem::offset_of!(printbuf, size) - 8usize];
    ["Offset of field: printbuf::pos"][::std::mem::offset_of!(printbuf, pos) - 12usize];
    [
        "Offset of field: printbuf::last_newline",
    ][::std::mem::offset_of!(printbuf, last_newline) - 16usize];
    [
        "Offset of field: printbuf::last_field",
    ][::std::mem::offset_of!(printbuf, last_field) - 20usize];
    [
        "Offset of field: printbuf::indent",
    ][::std::mem::offset_of!(printbuf, indent) - 24usize];
    [
        "Offset of field: printbuf::atomic",
    ][::std::mem::offset_of!(printbuf, atomic) - 28usize];
    [
        "Offset of field: printbuf::nr_tabstops",
    ][::std::mem::offset_of!(printbuf, nr_tabstops) - 30usize];
    [
        "Offset of field: printbuf::cur_tabstop",
    ][::std::mem::offset_of!(printbuf, cur_tabstop) - 31usize];
    [
        "Offset of field: printbuf::_tabstops",
    ][::std::mem::offset_of!(printbuf, _tabstops) - 32usize];
};
impl Default for printbuf {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl printbuf {
    #[inline]
    pub fn allocation_failure(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_allocation_failure(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn allocation_failure_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_allocation_failure_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn heap_allocated(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_heap_allocated(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(1usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn heap_allocated_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 1usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_heap_allocated_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                1usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn overflow(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_overflow(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(2usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn overflow_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 2usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_overflow_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                2usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn suppress(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_suppress(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(3usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn suppress_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 3usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_suppress_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                3usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn si_units(&self) -> printbuf_si {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_si_units(&mut self, val: printbuf_si) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(4usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn si_units_raw(this: *const Self) -> printbuf_si {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 4usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_si_units_raw(this: *mut Self, val: printbuf_si) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                4usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn human_readable_units(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_human_readable_units(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(5usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn human_readable_units_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 5usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_human_readable_units_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                5usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn has_indent_or_tabstops(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_has_indent_or_tabstops(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(6usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn has_indent_or_tabstops_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 6usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_has_indent_or_tabstops_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                6usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn may_vmalloc(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_may_vmalloc(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(7usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn may_vmalloc_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 7usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_may_vmalloc_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                7usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        allocation_failure: bool,
        heap_allocated: bool,
        overflow: bool,
        suppress: bool,
        si_units: printbuf_si,
        human_readable_units: bool,
        has_indent_or_tabstops: bool,
        may_vmalloc: bool,
    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                1u8,
                {
                    let allocation_failure: u8 = unsafe {
                        ::std::mem::transmute(allocation_failure)
                    };
                    allocation_failure as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                1usize,
                1u8,
                {
                    let heap_allocated: u8 = unsafe {
                        ::std::mem::transmute(heap_allocated)
                    };
                    heap_allocated as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                2usize,
                1u8,
                {
                    let overflow: u8 = unsafe { ::std::mem::transmute(overflow) };
                    overflow as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                3usize,
                1u8,
                {
                    let suppress: u8 = unsafe { ::std::mem::transmute(suppress) };
                    suppress as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                4usize,
                1u8,
                {
                    let si_units: u32 = unsafe { ::std::mem::transmute(si_units) };
                    si_units as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                5usize,
                1u8,
                {
                    let human_readable_units: u8 = unsafe {
                        ::std::mem::transmute(human_readable_units)
                    };
                    human_readable_units as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                6usize,
                1u8,
                {
                    let has_indent_or_tabstops: u8 = unsafe {
                        ::std::mem::transmute(has_indent_or_tabstops)
                    };
                    has_indent_or_tabstops as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                7usize,
                1u8,
                {
                    let may_vmalloc: u8 = unsafe { ::std::mem::transmute(may_vmalloc) };
                    may_vmalloc as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct printbuf_restore {
    pub pos: ::std::os::raw::c_uint,
    pub last_newline: ::std::os::raw::c_uint,
    pub last_field: ::std::os::raw::c_uint,
    pub indent: ::std::os::raw::c_uint,
    pub cur_tabstop: u8_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of printbuf_restore"][::std::mem::size_of::<printbuf_restore>() - 20usize];
    [
        "Alignment of printbuf_restore",
    ][::std::mem::align_of::<printbuf_restore>() - 4usize];
    [
        "Offset of field: printbuf_restore::pos",
    ][::std::mem::offset_of!(printbuf_restore, pos) - 0usize];
    [
        "Offset of field: printbuf_restore::last_newline",
    ][::std::mem::offset_of!(printbuf_restore, last_newline) - 4usize];
    [
        "Offset of field: printbuf_restore::last_field",
    ][::std::mem::offset_of!(printbuf_restore, last_field) - 8usize];
    [
        "Offset of field: printbuf_restore::indent",
    ][::std::mem::offset_of!(printbuf_restore, indent) - 12usize];
    [
        "Offset of field: printbuf_restore::cur_tabstop",
    ][::std::mem::offset_of!(printbuf_restore, cur_tabstop) - 16usize];
};
unsafe extern "C" {
    #[link_name = "printbuf_state_save__extern"]
    pub fn printbuf_state_save(buf: *mut printbuf) -> printbuf_restore;
}
unsafe extern "C" {
    #[link_name = "printbuf_state_restore__extern"]
    pub fn printbuf_state_restore(buf: *mut printbuf, s: printbuf_restore);
}
unsafe extern "C" {
    pub fn bch2_printbuf_make_room_gfp(
        arg1: *mut printbuf,
        arg2: ::std::os::raw::c_uint,
        arg3: gfp_t,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_printbuf_make_room(
        arg1: *mut printbuf,
        arg2: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_prt_printf(out: *mut printbuf, fmt: *const ::std::os::raw::c_char, ...);
}
unsafe extern "C" {
    pub fn bch2_printbuf_str(arg1: *const printbuf) -> *const ::std::os::raw::c_char;
}
unsafe extern "C" {
    pub fn bch2_printbuf_exit(arg1: *mut printbuf);
}
unsafe extern "C" {
    pub fn bch2_printbuf_tabstops_reset(arg1: *mut printbuf);
}
unsafe extern "C" {
    pub fn bch2_printbuf_tabstop_pop(arg1: *mut printbuf);
}
unsafe extern "C" {
    pub fn bch2_printbuf_tabstop_push(
        arg1: *mut printbuf,
        arg2: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_printbuf_indent_add(arg1: *mut printbuf, arg2: ::std::os::raw::c_uint);
}
unsafe extern "C" {
    pub fn bch2_printbuf_indent_add_nextline(
        arg1: *mut printbuf,
        arg2: ::std::os::raw::c_uint,
    );
}
unsafe extern "C" {
    pub fn bch2_printbuf_indent_sub(arg1: *mut printbuf, arg2: ::std::os::raw::c_uint);
}
unsafe extern "C" {
    pub fn bch2_prt_newline(arg1: *mut printbuf);
}
unsafe extern "C" {
    pub fn bch2_printbuf_strip_trailing_newline(arg1: *mut printbuf);
}
unsafe extern "C" {
    pub fn bch2_prt_tab(arg1: *mut printbuf);
}
unsafe extern "C" {
    pub fn bch2_prt_tab_rjust(arg1: *mut printbuf);
}
unsafe extern "C" {
    pub fn bch2_printbuf_tabstop_align(arg1: *mut printbuf);
}
unsafe extern "C" {
    pub fn bch2_prt_bytes_indented(
        arg1: *mut printbuf,
        arg2: *const ::std::os::raw::c_char,
        arg3: ::std::os::raw::c_uint,
    );
}
unsafe extern "C" {
    pub fn bch2_prt_human_readable_u64(arg1: *mut printbuf, arg2: u64_);
}
unsafe extern "C" {
    pub fn bch2_prt_human_readable_s64(arg1: *mut printbuf, arg2: s64);
}
unsafe extern "C" {
    pub fn bch2_prt_units_u64(arg1: *mut printbuf, arg2: u64_);
}
unsafe extern "C" {
    pub fn bch2_prt_units_s64(arg1: *mut printbuf, arg2: s64);
}
unsafe extern "C" {
    pub fn bch2_prt_string_option(
        arg1: *mut printbuf,
        arg2: *const *const ::std::os::raw::c_char,
        arg3: usize,
    );
}
unsafe extern "C" {
    pub fn bch2_prt_bitflags(
        arg1: *mut printbuf,
        arg2: *const *const ::std::os::raw::c_char,
        arg3: u64_,
    );
}
unsafe extern "C" {
    pub fn bch2_prt_bitflags_vector(
        arg1: *mut printbuf,
        arg2: *const *const ::std::os::raw::c_char,
        arg3: *mut ::std::os::raw::c_ulong,
        arg4: ::std::os::raw::c_uint,
    );
}
unsafe extern "C" {
    #[link_name = "bch2_printbuf_init__extern"]
    pub fn bch2_printbuf_init() -> printbuf;
}
unsafe extern "C" {
    #[link_name = "printbuf_remaining_size__extern"]
    pub fn printbuf_remaining_size(out: *mut printbuf) -> ::std::os::raw::c_uint;
}
unsafe extern "C" {
    #[link_name = "printbuf_remaining__extern"]
    pub fn printbuf_remaining(out: *mut printbuf) -> ::std::os::raw::c_uint;
}
unsafe extern "C" {
    #[link_name = "printbuf_written__extern"]
    pub fn printbuf_written(out: *mut printbuf) -> ::std::os::raw::c_uint;
}
unsafe extern "C" {
    #[link_name = "printbuf_nul_terminate_reserved__extern"]
    pub fn printbuf_nul_terminate_reserved(out: *mut printbuf);
}
unsafe extern "C" {
    #[link_name = "printbuf_nul_terminate__extern"]
    pub fn printbuf_nul_terminate(out: *mut printbuf);
}
unsafe extern "C" {
    #[link_name = "printbuf_reset_keep_tabstops__extern"]
    pub fn printbuf_reset_keep_tabstops(buf: *mut printbuf);
}
unsafe extern "C" {
    /// printbuf_reset - re-use a printbuf without freeing and re-initializing it:
    #[link_name = "printbuf_reset__extern"]
    pub fn printbuf_reset(buf: *mut printbuf);
}
unsafe extern "C" {
    /// printbuf_atomic_inc - mark as entering an atomic section
    #[link_name = "printbuf_atomic_inc__extern"]
    pub fn printbuf_atomic_inc(buf: *mut printbuf);
}
unsafe extern "C" {
    /// printbuf_atomic_inc - mark as leaving an atomic section
    #[link_name = "printbuf_atomic_dec__extern"]
    pub fn printbuf_atomic_dec(buf: *mut printbuf);
}
unsafe extern "C" {
    pub fn bch2_pr_time_units(arg1: *mut printbuf, arg2: u64_);
}
unsafe extern "C" {
    pub fn bch2_prt_datetime(arg1: *mut printbuf, arg2: time64_t);
}
unsafe extern "C" {
    pub fn bch2_strtoint_h(
        arg1: *const ::std::os::raw::c_char,
        arg2: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_strtouint_h(
        arg1: *const ::std::os::raw::c_char,
        arg2: *mut ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_strtoll_h(
        arg1: *const ::std::os::raw::c_char,
        arg2: *mut ::std::os::raw::c_longlong,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_strtoull_h(
        arg1: *const ::std::os::raw::c_char,
        arg2: *mut ::std::os::raw::c_ulonglong,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_strtou64_h(
        arg1: *const ::std::os::raw::c_char,
        arg2: *mut u64_,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_strtol_h__extern"]
    pub fn bch2_strtol_h(
        cp: *const ::std::os::raw::c_char,
        res: *mut ::std::os::raw::c_long,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_strtoul_h__extern"]
    pub fn bch2_strtoul_h(
        cp: *const ::std::os::raw::c_char,
        res: *mut ::std::os::raw::c_long,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_is_zero(arg1: *const ::std::os::raw::c_void, arg2: usize) -> bool;
}
unsafe extern "C" {
    pub fn bch2_read_flag_list(
        arg1: *const ::std::os::raw::c_char,
        arg2: *const *const ::std::os::raw::c_char,
    ) -> u64_;
}
unsafe extern "C" {
    pub fn bch2_prt_u64_base2_nbits(
        arg1: *mut printbuf,
        arg2: u64_,
        arg3: ::std::os::raw::c_uint,
    );
}
unsafe extern "C" {
    pub fn bch2_prt_u64_base2(arg1: *mut printbuf, arg2: u64_);
}
unsafe extern "C" {
    pub fn bch2_print_string_as_lines(
        arg1: *const ::std::os::raw::c_char,
        arg2: *const ::std::os::raw::c_char,
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct bch_stacktrace {
    pub nr: usize,
    pub size: usize,
    pub data: *mut ::std::os::raw::c_ulong,
    pub preallocated: __IncompleteArrayField<::std::os::raw::c_ulong>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_stacktrace"][::std::mem::size_of::<bch_stacktrace>() - 24usize];
    ["Alignment of bch_stacktrace"][::std::mem::align_of::<bch_stacktrace>() - 8usize];
    [
        "Offset of field: bch_stacktrace::nr",
    ][::std::mem::offset_of!(bch_stacktrace, nr) - 0usize];
    [
        "Offset of field: bch_stacktrace::size",
    ][::std::mem::offset_of!(bch_stacktrace, size) - 8usize];
    [
        "Offset of field: bch_stacktrace::data",
    ][::std::mem::offset_of!(bch_stacktrace, data) - 16usize];
    [
        "Offset of field: bch_stacktrace::preallocated",
    ][::std::mem::offset_of!(bch_stacktrace, preallocated) - 24usize];
};
impl Default for bch_stacktrace {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C" {
    pub fn bch2_save_backtrace(
        stack: *mut bch_stacktrace,
        arg1: *mut task_struct,
        arg2: ::std::os::raw::c_uint,
        arg3: gfp_t,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_prt_backtrace(arg1: *mut printbuf, arg2: *mut bch_stacktrace);
}
unsafe extern "C" {
    pub fn bch2_prt_task_backtrace(
        arg1: *mut printbuf,
        arg2: *mut task_struct,
        arg3: ::std::os::raw::c_uint,
        arg4: gfp_t,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_time_stats_to_text(arg1: *mut printbuf, arg2: *mut bch2_time_stats);
}
unsafe extern "C" {
    pub fn bch2_time_stats_json_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch2_time_stats,
        epoch_name: *const ::std::os::raw::c_char,
        flags: ::std::os::raw::c_uint,
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_ratelimit {
    pub next: u64_,
    pub rate: ::std::os::raw::c_uint,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_ratelimit"][::std::mem::size_of::<bch_ratelimit>() - 16usize];
    ["Alignment of bch_ratelimit"][::std::mem::align_of::<bch_ratelimit>() - 8usize];
    [
        "Offset of field: bch_ratelimit::next",
    ][::std::mem::offset_of!(bch_ratelimit, next) - 0usize];
    [
        "Offset of field: bch_ratelimit::rate",
    ][::std::mem::offset_of!(bch_ratelimit, rate) - 8usize];
};
unsafe extern "C" {
    #[link_name = "bch2_ratelimit_reset__extern"]
    pub fn bch2_ratelimit_reset(d: *mut bch_ratelimit);
}
unsafe extern "C" {
    pub fn bch2_ratelimit_delay(arg1: *mut bch_ratelimit) -> u64_;
}
unsafe extern "C" {
    pub fn bch2_ratelimit_increment(arg1: *mut bch_ratelimit, arg2: u64_);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_pd_controller {
    pub rate: bch_ratelimit,
    pub last_update: ::std::os::raw::c_ulong,
    pub last_actual: s64,
    pub smoothed_derivative: s64,
    pub p_term_inverse: ::std::os::raw::c_uint,
    pub d_smooth: ::std::os::raw::c_uint,
    pub d_term: ::std::os::raw::c_uint,
    pub last_derivative: s64,
    pub last_proportional: s64,
    pub last_change: s64,
    pub last_target: s64,
    pub backpressure: bool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_pd_controller"][::std::mem::size_of::<bch_pd_controller>() - 96usize];
    [
        "Alignment of bch_pd_controller",
    ][::std::mem::align_of::<bch_pd_controller>() - 8usize];
    [
        "Offset of field: bch_pd_controller::rate",
    ][::std::mem::offset_of!(bch_pd_controller, rate) - 0usize];
    [
        "Offset of field: bch_pd_controller::last_update",
    ][::std::mem::offset_of!(bch_pd_controller, last_update) - 16usize];
    [
        "Offset of field: bch_pd_controller::last_actual",
    ][::std::mem::offset_of!(bch_pd_controller, last_actual) - 24usize];
    [
        "Offset of field: bch_pd_controller::smoothed_derivative",
    ][::std::mem::offset_of!(bch_pd_controller, smoothed_derivative) - 32usize];
    [
        "Offset of field: bch_pd_controller::p_term_inverse",
    ][::std::mem::offset_of!(bch_pd_controller, p_term_inverse) - 40usize];
    [
        "Offset of field: bch_pd_controller::d_smooth",
    ][::std::mem::offset_of!(bch_pd_controller, d_smooth) - 44usize];
    [
        "Offset of field: bch_pd_controller::d_term",
    ][::std::mem::offset_of!(bch_pd_controller, d_term) - 48usize];
    [
        "Offset of field: bch_pd_controller::last_derivative",
    ][::std::mem::offset_of!(bch_pd_controller, last_derivative) - 56usize];
    [
        "Offset of field: bch_pd_controller::last_proportional",
    ][::std::mem::offset_of!(bch_pd_controller, last_proportional) - 64usize];
    [
        "Offset of field: bch_pd_controller::last_change",
    ][::std::mem::offset_of!(bch_pd_controller, last_change) - 72usize];
    [
        "Offset of field: bch_pd_controller::last_target",
    ][::std::mem::offset_of!(bch_pd_controller, last_target) - 80usize];
    [
        "Offset of field: bch_pd_controller::backpressure",
    ][::std::mem::offset_of!(bch_pd_controller, backpressure) - 88usize];
};
unsafe extern "C" {
    pub fn bch2_pd_controller_update(
        arg1: *mut bch_pd_controller,
        arg2: s64,
        arg3: s64,
        arg4: ::std::os::raw::c_int,
    );
}
unsafe extern "C" {
    pub fn bch2_pd_controller_init(arg1: *mut bch_pd_controller);
}
unsafe extern "C" {
    pub fn bch2_pd_controller_debug_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_pd_controller,
    );
}
unsafe extern "C" {
    pub fn bch2_bio_map(bio: *mut bio, base: *mut ::std::os::raw::c_void, arg1: usize);
}
unsafe extern "C" {
    pub fn bch2_bio_map_and_chain(
        arg1: *mut block_device,
        arg2: *mut ::std::os::raw::c_void,
        arg3: usize,
        arg4: sector_t,
        arg5: blk_opf_t,
        arg6: gfp_t,
        arg7: *mut bio_set,
    ) -> *mut bio;
}
unsafe extern "C" {
    pub fn bch2_bio_submit_buf_wait(
        arg1: *mut block_device,
        arg2: *mut ::std::os::raw::c_void,
        arg3: usize,
        arg4: sector_t,
        arg5: blk_opf_t,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_bio_alloc_pages(
        arg1: *mut bio,
        arg2: ::std::os::raw::c_uint,
        arg3: usize,
        arg4: gfp_t,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_get_random_u64_below(arg1: u64_) -> u64_;
}
unsafe extern "C" {
    pub fn bch2_bio_to_text(arg1: *mut printbuf, arg2: *mut bio);
}
unsafe extern "C" {
    pub fn bch2_acc_percpu_u64s(
        arg1: *mut u64_,
        arg2: ::std::os::raw::c_uint,
    ) -> *mut u64_;
}
unsafe extern "C" {
    pub fn bch2_split_devs(
        arg1: *const ::std::os::raw::c_char,
        arg2: *mut darray_const_str,
    ) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct wait_bit_key {
    pub flags: *mut ::std::os::raw::c_void,
    pub bit_nr: ::std::os::raw::c_int,
    pub timeout: ::std::os::raw::c_ulong,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of wait_bit_key"][::std::mem::size_of::<wait_bit_key>() - 24usize];
    ["Alignment of wait_bit_key"][::std::mem::align_of::<wait_bit_key>() - 8usize];
    [
        "Offset of field: wait_bit_key::flags",
    ][::std::mem::offset_of!(wait_bit_key, flags) - 0usize];
    [
        "Offset of field: wait_bit_key::bit_nr",
    ][::std::mem::offset_of!(wait_bit_key, bit_nr) - 8usize];
    [
        "Offset of field: wait_bit_key::timeout",
    ][::std::mem::offset_of!(wait_bit_key, timeout) - 16usize];
};
impl Default for wait_bit_key {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C" {
    pub fn bch2_bit_wait_io_timeout(
        arg1: *mut wait_bit_key,
        arg2: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn __bch2_alloc_percpu_init(
        pcv: *mut ::std::os::raw::c_void,
        init: ::std::option::Option<
            unsafe extern "C" fn(
                arg1: *mut ::std::os::raw::c_void,
                arg2: *mut ::std::os::raw::c_void,
                arg3: ::std::os::raw::c_uint,
            ),
        >,
        ctx: *mut ::std::os::raw::c_void,
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bkey_format {
    pub key_u64s: __u8,
    pub nr_fields: __u8,
    pub bits_per_field: [__u8; 6usize],
    pub field_offset: [__le64; 6usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_format"][::std::mem::size_of::<bkey_format>() - 56usize];
    ["Alignment of bkey_format"][::std::mem::align_of::<bkey_format>() - 8usize];
    [
        "Offset of field: bkey_format::key_u64s",
    ][::std::mem::offset_of!(bkey_format, key_u64s) - 0usize];
    [
        "Offset of field: bkey_format::nr_fields",
    ][::std::mem::offset_of!(bkey_format, nr_fields) - 1usize];
    [
        "Offset of field: bkey_format::bits_per_field",
    ][::std::mem::offset_of!(bkey_format, bits_per_field) - 2usize];
    [
        "Offset of field: bkey_format::field_offset",
    ][::std::mem::offset_of!(bkey_format, field_offset) - 8usize];
};
#[repr(C, packed(4))]
#[derive(Debug, Default, Copy, Clone)]
pub struct bpos {
    pub snapshot: __u32,
    pub offset: __u64,
    pub inode: __u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bpos"][::std::mem::size_of::<bpos>() - 20usize];
    ["Alignment of bpos"][::std::mem::align_of::<bpos>() - 4usize];
    ["Offset of field: bpos::snapshot"][::std::mem::offset_of!(bpos, snapshot) - 0usize];
    ["Offset of field: bpos::offset"][::std::mem::offset_of!(bpos, offset) - 4usize];
    ["Offset of field: bpos::inode"][::std::mem::offset_of!(bpos, inode) - 12usize];
};
#[repr(C)]
#[derive(Debug, Default)]
pub struct bch_val {
    pub __nothing: __IncompleteArrayField<__u64>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_val"][::std::mem::size_of::<bch_val>() - 0usize];
    ["Alignment of bch_val"][::std::mem::align_of::<bch_val>() - 8usize];
    [
        "Offset of field: bch_val::__nothing",
    ][::std::mem::offset_of!(bch_val, __nothing) - 0usize];
};
#[repr(C, packed(4))]
#[derive(Debug, Default, Copy, Clone)]
pub struct bversion {
    pub lo: __u64,
    pub hi: __u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bversion"][::std::mem::size_of::<bversion>() - 12usize];
    ["Alignment of bversion"][::std::mem::align_of::<bversion>() - 4usize];
    ["Offset of field: bversion::lo"][::std::mem::offset_of!(bversion, lo) - 0usize];
    ["Offset of field: bversion::hi"][::std::mem::offset_of!(bversion, hi) - 8usize];
};
#[repr(C)]
#[repr(align(8))]
#[derive(Debug, Default, Copy, Clone)]
pub struct bkey {
    pub u64s: __u8,
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
    pub type_: __u8,
    pub pad: [__u8; 1usize],
    pub bversion: bversion,
    pub size: __u32,
    pub p: bpos,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey"][::std::mem::size_of::<bkey>() - 40usize];
    ["Alignment of bkey"][::std::mem::align_of::<bkey>() - 8usize];
    ["Offset of field: bkey::u64s"][::std::mem::offset_of!(bkey, u64s) - 0usize];
    ["Offset of field: bkey::type_"][::std::mem::offset_of!(bkey, type_) - 2usize];
    ["Offset of field: bkey::pad"][::std::mem::offset_of!(bkey, pad) - 3usize];
    ["Offset of field: bkey::bversion"][::std::mem::offset_of!(bkey, bversion) - 4usize];
    ["Offset of field: bkey::size"][::std::mem::offset_of!(bkey, size) - 16usize];
    ["Offset of field: bkey::p"][::std::mem::offset_of!(bkey, p) - 20usize];
};
impl bkey {
    #[inline]
    pub fn format(&self) -> __u8 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 7u8) as u8) }
    }
    #[inline]
    pub fn set_format(&mut self, val: __u8) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 7u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn format_raw(this: *const Self) -> __u8 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 7u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_format_raw(this: *mut Self, val: __u8) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                7u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn needs_whiteout(&self) -> __u8 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_needs_whiteout(&mut self, val: __u8) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(7usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn needs_whiteout_raw(this: *const Self) -> __u8 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 7usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_needs_whiteout_raw(this: *mut Self, val: __u8) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                7usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        format: __u8,
        needs_whiteout: __u8,
    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                7u8,
                {
                    let format: u8 = unsafe { ::std::mem::transmute(format) };
                    format as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                7usize,
                1u8,
                {
                    let needs_whiteout: u8 = unsafe {
                        ::std::mem::transmute(needs_whiteout)
                    };
                    needs_whiteout as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
#[repr(C, packed(8))]
pub struct bkey_packed {
    pub _data: __IncompleteArrayField<__u64>,
    pub u64s: __u8,
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
    pub type_: __u8,
    pub key_start: __IncompleteArrayField<__u8>,
    pub pad: [__u8; 37usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_packed"][::std::mem::size_of::<bkey_packed>() - 40usize];
    ["Alignment of bkey_packed"][::std::mem::align_of::<bkey_packed>() - 8usize];
    [
        "Offset of field: bkey_packed::_data",
    ][::std::mem::offset_of!(bkey_packed, _data) - 0usize];
    [
        "Offset of field: bkey_packed::u64s",
    ][::std::mem::offset_of!(bkey_packed, u64s) - 0usize];
    [
        "Offset of field: bkey_packed::type_",
    ][::std::mem::offset_of!(bkey_packed, type_) - 2usize];
    [
        "Offset of field: bkey_packed::key_start",
    ][::std::mem::offset_of!(bkey_packed, key_start) - 3usize];
    [
        "Offset of field: bkey_packed::pad",
    ][::std::mem::offset_of!(bkey_packed, pad) - 3usize];
};
impl Default for bkey_packed {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl bkey_packed {
    #[inline]
    pub fn format(&self) -> __u8 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 7u8) as u8) }
    }
    #[inline]
    pub fn set_format(&mut self, val: __u8) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 7u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn format_raw(this: *const Self) -> __u8 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 7u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_format_raw(this: *mut Self, val: __u8) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                7u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn needs_whiteout(&self) -> __u8 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_needs_whiteout(&mut self, val: __u8) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(7usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn needs_whiteout_raw(this: *const Self) -> __u8 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 7usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_needs_whiteout_raw(this: *mut Self, val: __u8) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                7usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        format: __u8,
        needs_whiteout: __u8,
    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                7u8,
                {
                    let format: u8 = unsafe { ::std::mem::transmute(format) };
                    format as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                7usize,
                1u8,
                {
                    let needs_whiteout: u8 = unsafe {
                        ::std::mem::transmute(needs_whiteout)
                    };
                    needs_whiteout as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_le128 {
    pub lo: __le64,
    pub hi: __le64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_le128"][::std::mem::size_of::<bch_le128>() - 16usize];
    ["Alignment of bch_le128"][::std::mem::align_of::<bch_le128>() - 8usize];
    ["Offset of field: bch_le128::lo"][::std::mem::offset_of!(bch_le128, lo) - 0usize];
    ["Offset of field: bch_le128::hi"][::std::mem::offset_of!(bch_le128, hi) - 8usize];
};
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_bkey_fields {
    BKEY_FIELD_INODE = 0,
    BKEY_FIELD_OFFSET = 1,
    BKEY_FIELD_SNAPSHOT = 2,
    BKEY_FIELD_SIZE = 3,
    BKEY_FIELD_VERSION_HI = 4,
    BKEY_FIELD_VERSION_LO = 5,
    BKEY_NR_FIELDS = 6,
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct bkey_i {
    pub _data: __IncompleteArrayField<__u64>,
    pub k: bkey,
    pub v: bch_val,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_i"][::std::mem::size_of::<bkey_i>() - 40usize];
    ["Alignment of bkey_i"][::std::mem::align_of::<bkey_i>() - 8usize];
    ["Offset of field: bkey_i::_data"][::std::mem::offset_of!(bkey_i, _data) - 0usize];
    ["Offset of field: bkey_i::k"][::std::mem::offset_of!(bkey_i, k) - 0usize];
    ["Offset of field: bkey_i::v"][::std::mem::offset_of!(bkey_i, v) - 40usize];
};
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_bkey_type_flags {
    BKEY_TYPE_strict_btree_checks = 1,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_bkey_type {
    KEY_TYPE_deleted = 0,
    KEY_TYPE_whiteout = 1,
    KEY_TYPE_error = 2,
    KEY_TYPE_cookie = 3,
    KEY_TYPE_hash_whiteout = 4,
    KEY_TYPE_btree_ptr = 5,
    KEY_TYPE_extent = 6,
    KEY_TYPE_reservation = 7,
    KEY_TYPE_inode = 8,
    KEY_TYPE_inode_generation = 9,
    KEY_TYPE_dirent = 10,
    KEY_TYPE_xattr = 11,
    KEY_TYPE_alloc = 12,
    KEY_TYPE_quota = 13,
    KEY_TYPE_stripe = 14,
    KEY_TYPE_reflink_p = 15,
    KEY_TYPE_reflink_v = 16,
    KEY_TYPE_inline_data = 17,
    KEY_TYPE_btree_ptr_v2 = 18,
    KEY_TYPE_indirect_inline_data = 19,
    KEY_TYPE_alloc_v2 = 20,
    KEY_TYPE_subvolume = 21,
    KEY_TYPE_snapshot = 22,
    KEY_TYPE_inode_v2 = 23,
    KEY_TYPE_alloc_v3 = 24,
    KEY_TYPE_set = 25,
    KEY_TYPE_lru = 26,
    KEY_TYPE_alloc_v4 = 27,
    KEY_TYPE_backpointer = 28,
    KEY_TYPE_inode_v3 = 29,
    KEY_TYPE_bucket_gens = 30,
    KEY_TYPE_snapshot_tree = 31,
    KEY_TYPE_logged_op_truncate = 32,
    KEY_TYPE_logged_op_finsert = 33,
    KEY_TYPE_accounting = 34,
    KEY_TYPE_inode_alloc_cursor = 35,
    KEY_TYPE_extent_whiteout = 36,
    KEY_TYPE_logged_op_stripe_update = 37,
    KEY_TYPE_MAX = 38,
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct bch_deleted {
    pub v: bch_val,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_deleted"][::std::mem::size_of::<bch_deleted>() - 0usize];
    ["Alignment of bch_deleted"][::std::mem::align_of::<bch_deleted>() - 8usize];
    ["Offset of field: bch_deleted::v"][::std::mem::offset_of!(bch_deleted, v) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default)]
pub struct bch_whiteout {
    pub v: bch_val,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_whiteout"][::std::mem::size_of::<bch_whiteout>() - 0usize];
    ["Alignment of bch_whiteout"][::std::mem::align_of::<bch_whiteout>() - 8usize];
    [
        "Offset of field: bch_whiteout::v",
    ][::std::mem::offset_of!(bch_whiteout, v) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default)]
pub struct bch_extent_whiteout {
    pub v: bch_val,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_extent_whiteout",
    ][::std::mem::size_of::<bch_extent_whiteout>() - 0usize];
    [
        "Alignment of bch_extent_whiteout",
    ][::std::mem::align_of::<bch_extent_whiteout>() - 8usize];
    [
        "Offset of field: bch_extent_whiteout::v",
    ][::std::mem::offset_of!(bch_extent_whiteout, v) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default)]
pub struct bch_error {
    pub v: bch_val,
    pub err: u8_,
    pub pad: [u8_; 7usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_error"][::std::mem::size_of::<bch_error>() - 8usize];
    ["Alignment of bch_error"][::std::mem::align_of::<bch_error>() - 8usize];
    ["Offset of field: bch_error::v"][::std::mem::offset_of!(bch_error, v) - 0usize];
    ["Offset of field: bch_error::err"][::std::mem::offset_of!(bch_error, err) - 0usize];
    ["Offset of field: bch_error::pad"][::std::mem::offset_of!(bch_error, pad) - 1usize];
};
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_key_type_errors {
    KEY_TYPE_ERROR_unknown = 0,
    KEY_TYPE_ERROR_device_removed = 1,
    KEY_TYPE_ERROR_double_allocation = 2,
    KEY_TYPE_ERROR_no_valid_pointers_repair = 3,
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct bch_cookie {
    pub v: bch_val,
    pub cookie: __le64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_cookie"][::std::mem::size_of::<bch_cookie>() - 8usize];
    ["Alignment of bch_cookie"][::std::mem::align_of::<bch_cookie>() - 8usize];
    ["Offset of field: bch_cookie::v"][::std::mem::offset_of!(bch_cookie, v) - 0usize];
    [
        "Offset of field: bch_cookie::cookie",
    ][::std::mem::offset_of!(bch_cookie, cookie) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default)]
pub struct bch_hash_whiteout {
    pub v: bch_val,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_hash_whiteout"][::std::mem::size_of::<bch_hash_whiteout>() - 0usize];
    [
        "Alignment of bch_hash_whiteout",
    ][::std::mem::align_of::<bch_hash_whiteout>() - 8usize];
    [
        "Offset of field: bch_hash_whiteout::v",
    ][::std::mem::offset_of!(bch_hash_whiteout, v) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default)]
pub struct bch_set {
    pub v: bch_val,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_set"][::std::mem::size_of::<bch_set>() - 0usize];
    ["Alignment of bch_set"][::std::mem::align_of::<bch_set>() - 8usize];
    ["Offset of field: bch_set::v"][::std::mem::offset_of!(bch_set, v) - 0usize];
};
#[repr(C, packed(8))]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_csum {
    pub lo: __le64,
    pub hi: __le64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_csum"][::std::mem::size_of::<bch_csum>() - 16usize];
    ["Alignment of bch_csum"][::std::mem::align_of::<bch_csum>() - 8usize];
    ["Offset of field: bch_csum::lo"][::std::mem::offset_of!(bch_csum, lo) - 0usize];
    ["Offset of field: bch_csum::hi"][::std::mem::offset_of!(bch_csum, hi) - 8usize];
};
#[repr(C, packed(8))]
pub struct bch_backpointer {
    pub v: bch_val,
    pub btree_id: __u8,
    pub level: __u8,
    pub data_type: __u8,
    pub bucket_gen: __u8,
    pub flags: __u32,
    pub bucket_len: __u32,
    pub pos: bpos,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_backpointer"][::std::mem::size_of::<bch_backpointer>() - 32usize];
    ["Alignment of bch_backpointer"][::std::mem::align_of::<bch_backpointer>() - 8usize];
    [
        "Offset of field: bch_backpointer::v",
    ][::std::mem::offset_of!(bch_backpointer, v) - 0usize];
    [
        "Offset of field: bch_backpointer::btree_id",
    ][::std::mem::offset_of!(bch_backpointer, btree_id) - 0usize];
    [
        "Offset of field: bch_backpointer::level",
    ][::std::mem::offset_of!(bch_backpointer, level) - 1usize];
    [
        "Offset of field: bch_backpointer::data_type",
    ][::std::mem::offset_of!(bch_backpointer, data_type) - 2usize];
    [
        "Offset of field: bch_backpointer::bucket_gen",
    ][::std::mem::offset_of!(bch_backpointer, bucket_gen) - 3usize];
    [
        "Offset of field: bch_backpointer::flags",
    ][::std::mem::offset_of!(bch_backpointer, flags) - 4usize];
    [
        "Offset of field: bch_backpointer::bucket_len",
    ][::std::mem::offset_of!(bch_backpointer, bucket_len) - 8usize];
    [
        "Offset of field: bch_backpointer::pos",
    ][::std::mem::offset_of!(bch_backpointer, pos) - 12usize];
};
impl Default for bch_backpointer {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct bch_sb_field {
    pub _data: __IncompleteArrayField<__u64>,
    pub u64s: __le32,
    pub type_: __le32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_sb_field"][::std::mem::size_of::<bch_sb_field>() - 8usize];
    ["Alignment of bch_sb_field"][::std::mem::align_of::<bch_sb_field>() - 8usize];
    [
        "Offset of field: bch_sb_field::_data",
    ][::std::mem::offset_of!(bch_sb_field, _data) - 0usize];
    [
        "Offset of field: bch_sb_field::u64s",
    ][::std::mem::offset_of!(bch_sb_field, u64s) - 0usize];
    [
        "Offset of field: bch_sb_field::type_",
    ][::std::mem::offset_of!(bch_sb_field, type_) - 4usize];
};
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum btree_id {
    BTREE_ID_extents = 0,
    BTREE_ID_inodes = 1,
    BTREE_ID_dirents = 2,
    BTREE_ID_xattrs = 3,
    BTREE_ID_alloc = 4,
    BTREE_ID_quotas = 5,
    BTREE_ID_stripes = 6,
    BTREE_ID_reflink = 7,
    BTREE_ID_subvolumes = 8,
    BTREE_ID_snapshots = 9,
    BTREE_ID_lru = 10,
    BTREE_ID_freespace = 11,
    BTREE_ID_need_discard = 12,
    BTREE_ID_backpointers = 13,
    BTREE_ID_bucket_gens = 14,
    BTREE_ID_snapshot_trees = 15,
    BTREE_ID_deleted_inodes = 16,
    BTREE_ID_logged_ops = 17,
    BTREE_ID_reconcile_work = 18,
    BTREE_ID_subvolume_children = 19,
    BTREE_ID_accounting = 20,
    BTREE_ID_reconcile_hipri = 21,
    BTREE_ID_reconcile_pending = 22,
    BTREE_ID_reconcile_scan = 23,
    BTREE_ID_reconcile_work_phys = 24,
    BTREE_ID_reconcile_hipri_phys = 25,
    BTREE_ID_bucket_to_stripe = 26,
    BTREE_ID_stripe_backpointers = 27,
    BTREE_ID_NR = 28,
}
#[repr(C, packed)]
pub struct bch_replicas_entry_v0 {
    pub data_type: __u8,
    pub nr_devs: __u8,
    pub devs: __IncompleteArrayField<__u8>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_replicas_entry_v0",
    ][::std::mem::size_of::<bch_replicas_entry_v0>() - 2usize];
    [
        "Alignment of bch_replicas_entry_v0",
    ][::std::mem::align_of::<bch_replicas_entry_v0>() - 1usize];
    [
        "Offset of field: bch_replicas_entry_v0::data_type",
    ][::std::mem::offset_of!(bch_replicas_entry_v0, data_type) - 0usize];
    [
        "Offset of field: bch_replicas_entry_v0::nr_devs",
    ][::std::mem::offset_of!(bch_replicas_entry_v0, nr_devs) - 1usize];
    [
        "Offset of field: bch_replicas_entry_v0::devs",
    ][::std::mem::offset_of!(bch_replicas_entry_v0, devs) - 2usize];
};
impl Default for bch_replicas_entry_v0 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C, packed(8))]
pub struct bch_sb_field_replicas_v0 {
    pub field: bch_sb_field,
    pub entries: __IncompleteArrayField<bch_replicas_entry_v0>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_sb_field_replicas_v0",
    ][::std::mem::size_of::<bch_sb_field_replicas_v0>() - 8usize];
    [
        "Alignment of bch_sb_field_replicas_v0",
    ][::std::mem::align_of::<bch_sb_field_replicas_v0>() - 8usize];
    [
        "Offset of field: bch_sb_field_replicas_v0::field",
    ][::std::mem::offset_of!(bch_sb_field_replicas_v0, field) - 0usize];
    [
        "Offset of field: bch_sb_field_replicas_v0::entries",
    ][::std::mem::offset_of!(bch_sb_field_replicas_v0, entries) - 8usize];
};
impl Default for bch_sb_field_replicas_v0 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C, packed)]
pub struct bch_replicas_entry_v1 {
    pub data_type: __u8,
    pub nr_devs: __u8,
    pub nr_required: __u8,
    pub devs: __IncompleteArrayField<__u8>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_replicas_entry_v1",
    ][::std::mem::size_of::<bch_replicas_entry_v1>() - 3usize];
    [
        "Alignment of bch_replicas_entry_v1",
    ][::std::mem::align_of::<bch_replicas_entry_v1>() - 1usize];
    [
        "Offset of field: bch_replicas_entry_v1::data_type",
    ][::std::mem::offset_of!(bch_replicas_entry_v1, data_type) - 0usize];
    [
        "Offset of field: bch_replicas_entry_v1::nr_devs",
    ][::std::mem::offset_of!(bch_replicas_entry_v1, nr_devs) - 1usize];
    [
        "Offset of field: bch_replicas_entry_v1::nr_required",
    ][::std::mem::offset_of!(bch_replicas_entry_v1, nr_required) - 2usize];
    [
        "Offset of field: bch_replicas_entry_v1::devs",
    ][::std::mem::offset_of!(bch_replicas_entry_v1, devs) - 3usize];
};
impl Default for bch_replicas_entry_v1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C, packed(8))]
pub struct bch_sb_field_replicas {
    pub field: bch_sb_field,
    pub entries: __IncompleteArrayField<bch_replicas_entry_v1>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_sb_field_replicas",
    ][::std::mem::size_of::<bch_sb_field_replicas>() - 8usize];
    [
        "Alignment of bch_sb_field_replicas",
    ][::std::mem::align_of::<bch_sb_field_replicas>() - 8usize];
    [
        "Offset of field: bch_sb_field_replicas::field",
    ][::std::mem::offset_of!(bch_sb_field_replicas, field) - 0usize];
    [
        "Offset of field: bch_sb_field_replicas::entries",
    ][::std::mem::offset_of!(bch_sb_field_replicas, entries) - 8usize];
};
impl Default for bch_sb_field_replicas {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct bch_accounting {
    pub v: bch_val,
    pub d: __IncompleteArrayField<__u64>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_accounting"][::std::mem::size_of::<bch_accounting>() - 0usize];
    ["Alignment of bch_accounting"][::std::mem::align_of::<bch_accounting>() - 8usize];
    [
        "Offset of field: bch_accounting::v",
    ][::std::mem::offset_of!(bch_accounting, v) - 0usize];
    [
        "Offset of field: bch_accounting::d",
    ][::std::mem::offset_of!(bch_accounting, d) - 0usize];
};
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_data_type {
    BCH_DATA_free = 0,
    BCH_DATA_sb = 1,
    BCH_DATA_journal = 2,
    BCH_DATA_btree = 3,
    BCH_DATA_user = 4,
    BCH_DATA_cached = 5,
    BCH_DATA_parity = 6,
    BCH_DATA_stripe = 7,
    BCH_DATA_need_gc_gens = 8,
    BCH_DATA_need_discard = 9,
    BCH_DATA_unstriped = 10,
    BCH_DATA_NR = 11,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum disk_accounting_type {
    BCH_DISK_ACCOUNTING_nr_inodes = 0,
    BCH_DISK_ACCOUNTING_persistent_reserved = 1,
    BCH_DISK_ACCOUNTING_replicas = 2,
    BCH_DISK_ACCOUNTING_dev_data_type = 3,
    BCH_DISK_ACCOUNTING_compression = 4,
    BCH_DISK_ACCOUNTING_snapshot = 5,
    BCH_DISK_ACCOUNTING_btree = 6,
    BCH_DISK_ACCOUNTING_rebalance_work = 7,
    BCH_DISK_ACCOUNTING_inum = 8,
    BCH_DISK_ACCOUNTING_reconcile_work = 9,
    BCH_DISK_ACCOUNTING_dev_leaving = 10,
    BCH_DISK_ACCOUNTING_TYPE_NR = 11,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_acct_nr_inodes {}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_acct_nr_inodes"][::std::mem::size_of::<bch_acct_nr_inodes>() - 0usize];
    [
        "Alignment of bch_acct_nr_inodes",
    ][::std::mem::align_of::<bch_acct_nr_inodes>() - 1usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_acct_persistent_reserved {
    pub nr_replicas: __u8,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_acct_persistent_reserved",
    ][::std::mem::size_of::<bch_acct_persistent_reserved>() - 1usize];
    [
        "Alignment of bch_acct_persistent_reserved",
    ][::std::mem::align_of::<bch_acct_persistent_reserved>() - 1usize];
    [
        "Offset of field: bch_acct_persistent_reserved::nr_replicas",
    ][::std::mem::offset_of!(bch_acct_persistent_reserved, nr_replicas) - 0usize];
};
pub type bch_acct_replicas = bch_replicas_entry_v1;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_acct_dev_data_type {
    pub dev: __u8,
    pub data_type: __u8,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_acct_dev_data_type",
    ][::std::mem::size_of::<bch_acct_dev_data_type>() - 2usize];
    [
        "Alignment of bch_acct_dev_data_type",
    ][::std::mem::align_of::<bch_acct_dev_data_type>() - 1usize];
    [
        "Offset of field: bch_acct_dev_data_type::dev",
    ][::std::mem::offset_of!(bch_acct_dev_data_type, dev) - 0usize];
    [
        "Offset of field: bch_acct_dev_data_type::data_type",
    ][::std::mem::offset_of!(bch_acct_dev_data_type, data_type) - 1usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_acct_compression {
    pub type_: __u8,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_acct_compression",
    ][::std::mem::size_of::<bch_acct_compression>() - 1usize];
    [
        "Alignment of bch_acct_compression",
    ][::std::mem::align_of::<bch_acct_compression>() - 1usize];
    [
        "Offset of field: bch_acct_compression::type_",
    ][::std::mem::offset_of!(bch_acct_compression, type_) - 0usize];
};
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_acct_snapshot {
    pub id: __u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_acct_snapshot"][::std::mem::size_of::<bch_acct_snapshot>() - 4usize];
    [
        "Alignment of bch_acct_snapshot",
    ][::std::mem::align_of::<bch_acct_snapshot>() - 1usize];
    [
        "Offset of field: bch_acct_snapshot::id",
    ][::std::mem::offset_of!(bch_acct_snapshot, id) - 0usize];
};
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_acct_btree {
    pub id: __u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_acct_btree"][::std::mem::size_of::<bch_acct_btree>() - 4usize];
    ["Alignment of bch_acct_btree"][::std::mem::align_of::<bch_acct_btree>() - 1usize];
    [
        "Offset of field: bch_acct_btree::id",
    ][::std::mem::offset_of!(bch_acct_btree, id) - 0usize];
};
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_acct_inum {
    pub inum: __u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_acct_inum"][::std::mem::size_of::<bch_acct_inum>() - 8usize];
    ["Alignment of bch_acct_inum"][::std::mem::align_of::<bch_acct_inum>() - 1usize];
    [
        "Offset of field: bch_acct_inum::inum",
    ][::std::mem::offset_of!(bch_acct_inum, inum) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_acct_rebalance_work {}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_acct_rebalance_work",
    ][::std::mem::size_of::<bch_acct_rebalance_work>() - 0usize];
    [
        "Alignment of bch_acct_rebalance_work",
    ][::std::mem::align_of::<bch_acct_rebalance_work>() - 1usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_acct_reconcile_work {
    pub type_: __u8,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_acct_reconcile_work",
    ][::std::mem::size_of::<bch_acct_reconcile_work>() - 1usize];
    [
        "Alignment of bch_acct_reconcile_work",
    ][::std::mem::align_of::<bch_acct_reconcile_work>() - 1usize];
    [
        "Offset of field: bch_acct_reconcile_work::type_",
    ][::std::mem::offset_of!(bch_acct_reconcile_work, type_) - 0usize];
};
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_acct_dev_leaving {
    pub dev: __u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_acct_dev_leaving",
    ][::std::mem::size_of::<bch_acct_dev_leaving>() - 4usize];
    [
        "Alignment of bch_acct_dev_leaving",
    ][::std::mem::align_of::<bch_acct_dev_leaving>() - 1usize];
    [
        "Offset of field: bch_acct_dev_leaving::dev",
    ][::std::mem::offset_of!(bch_acct_dev_leaving, dev) - 0usize];
};
#[repr(C)]
pub struct disk_accounting_pos {
    pub __bindgen_anon_1: disk_accounting_pos__bindgen_ty_1,
}
#[repr(C)]
pub struct disk_accounting_pos__bindgen_ty_1 {
    pub __bindgen_anon_1: __BindgenUnionField<
        disk_accounting_pos__bindgen_ty_1__bindgen_ty_1,
    >,
    pub _pad: __BindgenUnionField<bpos>,
    pub bindgen_union_field: [u32; 5usize],
}
#[repr(C, packed)]
pub struct disk_accounting_pos__bindgen_ty_1__bindgen_ty_1 {
    pub type_: __u8,
    pub __bindgen_anon_1: disk_accounting_pos__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
}
#[repr(C, packed)]
pub struct disk_accounting_pos__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
    pub nr_inodes: __BindgenUnionField<bch_acct_nr_inodes>,
    pub persistent_reserved: __BindgenUnionField<bch_acct_persistent_reserved>,
    pub replicas: __BindgenUnionField<bch_acct_replicas>,
    pub dev_data_type: __BindgenUnionField<bch_acct_dev_data_type>,
    pub compression: __BindgenUnionField<bch_acct_compression>,
    pub snapshot: __BindgenUnionField<bch_acct_snapshot>,
    pub btree: __BindgenUnionField<bch_acct_btree>,
    pub rebalance_work: __BindgenUnionField<bch_acct_rebalance_work>,
    pub inum: __BindgenUnionField<bch_acct_inum>,
    pub reconcile_work: __BindgenUnionField<bch_acct_reconcile_work>,
    pub dev_leaving: __BindgenUnionField<bch_acct_dev_leaving>,
    pub bindgen_union_field: [u8; 8usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of disk_accounting_pos__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<
        disk_accounting_pos__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
    >() - 8usize];
    [
        "Alignment of disk_accounting_pos__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<
        disk_accounting_pos__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
    >() - 1usize];
    [
        "Offset of field: disk_accounting_pos__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::nr_inodes",
    ][::std::mem::offset_of!(
        disk_accounting_pos__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, nr_inodes
    ) - 0usize];
    [
        "Offset of field: disk_accounting_pos__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::persistent_reserved",
    ][::std::mem::offset_of!(
        disk_accounting_pos__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
        persistent_reserved
    ) - 0usize];
    [
        "Offset of field: disk_accounting_pos__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::replicas",
    ][::std::mem::offset_of!(
        disk_accounting_pos__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, replicas
    ) - 0usize];
    [
        "Offset of field: disk_accounting_pos__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::dev_data_type",
    ][::std::mem::offset_of!(
        disk_accounting_pos__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, dev_data_type
    ) - 0usize];
    [
        "Offset of field: disk_accounting_pos__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::compression",
    ][::std::mem::offset_of!(
        disk_accounting_pos__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, compression
    ) - 0usize];
    [
        "Offset of field: disk_accounting_pos__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::snapshot",
    ][::std::mem::offset_of!(
        disk_accounting_pos__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, snapshot
    ) - 0usize];
    [
        "Offset of field: disk_accounting_pos__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::btree",
    ][::std::mem::offset_of!(
        disk_accounting_pos__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, btree
    ) - 0usize];
    [
        "Offset of field: disk_accounting_pos__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::rebalance_work",
    ][::std::mem::offset_of!(
        disk_accounting_pos__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, rebalance_work
    ) - 0usize];
    [
        "Offset of field: disk_accounting_pos__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::inum",
    ][::std::mem::offset_of!(
        disk_accounting_pos__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, inum
    ) - 0usize];
    [
        "Offset of field: disk_accounting_pos__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::reconcile_work",
    ][::std::mem::offset_of!(
        disk_accounting_pos__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, reconcile_work
    ) - 0usize];
    [
        "Offset of field: disk_accounting_pos__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::dev_leaving",
    ][::std::mem::offset_of!(
        disk_accounting_pos__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, dev_leaving
    ) - 0usize];
};
impl Default for disk_accounting_pos__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of disk_accounting_pos__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<disk_accounting_pos__bindgen_ty_1__bindgen_ty_1>() - 9usize];
    [
        "Alignment of disk_accounting_pos__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<disk_accounting_pos__bindgen_ty_1__bindgen_ty_1>()
        - 1usize];
    [
        "Offset of field: disk_accounting_pos__bindgen_ty_1__bindgen_ty_1::type_",
    ][::std::mem::offset_of!(disk_accounting_pos__bindgen_ty_1__bindgen_ty_1, type_)
        - 0usize];
};
impl Default for disk_accounting_pos__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of disk_accounting_pos__bindgen_ty_1",
    ][::std::mem::size_of::<disk_accounting_pos__bindgen_ty_1>() - 20usize];
    [
        "Alignment of disk_accounting_pos__bindgen_ty_1",
    ][::std::mem::align_of::<disk_accounting_pos__bindgen_ty_1>() - 4usize];
    [
        "Offset of field: disk_accounting_pos__bindgen_ty_1::_pad",
    ][::std::mem::offset_of!(disk_accounting_pos__bindgen_ty_1, _pad) - 0usize];
};
impl Default for disk_accounting_pos__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of disk_accounting_pos",
    ][::std::mem::size_of::<disk_accounting_pos>() - 20usize];
    [
        "Alignment of disk_accounting_pos",
    ][::std::mem::align_of::<disk_accounting_pos>() - 4usize];
};
impl Default for disk_accounting_pos {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C, packed(8))]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_disk_group {
    pub label: [__u8; 32usize],
    pub flags: [__le64; 2usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_disk_group"][::std::mem::size_of::<bch_disk_group>() - 48usize];
    ["Alignment of bch_disk_group"][::std::mem::align_of::<bch_disk_group>() - 8usize];
    [
        "Offset of field: bch_disk_group::label",
    ][::std::mem::offset_of!(bch_disk_group, label) - 0usize];
    [
        "Offset of field: bch_disk_group::flags",
    ][::std::mem::offset_of!(bch_disk_group, flags) - 32usize];
};
pub const BCH_GROUP_DELETED_OFFSET: ::std::os::raw::c_uint = 0;
pub const BCH_GROUP_DELETED_BITS: ::std::os::raw::c_uint = 1;
pub const BCH_GROUP_DELETED_MAX: __u64 = 1;
pub const BCH_GROUP_DATA_ALLOWED_OFFSET: ::std::os::raw::c_uint = 1;
pub const BCH_GROUP_DATA_ALLOWED_BITS: ::std::os::raw::c_uint = 5;
pub const BCH_GROUP_DATA_ALLOWED_MAX: __u64 = 31;
pub const BCH_GROUP_PARENT_OFFSET: ::std::os::raw::c_uint = 6;
pub const BCH_GROUP_PARENT_BITS: ::std::os::raw::c_uint = 18;
pub const BCH_GROUP_PARENT_MAX: __u64 = 262143;
#[repr(C, packed(8))]
pub struct bch_sb_field_disk_groups {
    pub field: bch_sb_field,
    pub entries: __IncompleteArrayField<bch_disk_group>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_sb_field_disk_groups",
    ][::std::mem::size_of::<bch_sb_field_disk_groups>() - 8usize];
    [
        "Alignment of bch_sb_field_disk_groups",
    ][::std::mem::align_of::<bch_sb_field_disk_groups>() - 8usize];
    [
        "Offset of field: bch_sb_field_disk_groups::field",
    ][::std::mem::offset_of!(bch_sb_field_disk_groups, field) - 0usize];
    [
        "Offset of field: bch_sb_field_disk_groups::entries",
    ][::std::mem::offset_of!(bch_sb_field_disk_groups, entries) - 8usize];
};
impl Default for bch_sb_field_disk_groups {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C, packed(8))]
pub struct bch_lru {
    pub v: bch_val,
    pub idx: __le64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_lru"][::std::mem::size_of::<bch_lru>() - 8usize];
    ["Alignment of bch_lru"][::std::mem::align_of::<bch_lru>() - 8usize];
    ["Offset of field: bch_lru::v"][::std::mem::offset_of!(bch_lru, v) - 0usize];
    ["Offset of field: bch_lru::idx"][::std::mem::offset_of!(bch_lru, idx) - 0usize];
};
impl Default for bch_lru {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_lru_type {
    BCH_LRU_read = 0,
    BCH_LRU_fragmentation = 1,
    BCH_LRU_stripes = 2,
}
#[repr(C, packed(8))]
pub struct bch_alloc {
    pub v: bch_val,
    pub fields: __u8,
    pub gen_: __u8,
    pub data: __IncompleteArrayField<__u8>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_alloc"][::std::mem::size_of::<bch_alloc>() - 8usize];
    ["Alignment of bch_alloc"][::std::mem::align_of::<bch_alloc>() - 8usize];
    ["Offset of field: bch_alloc::v"][::std::mem::offset_of!(bch_alloc, v) - 0usize];
    [
        "Offset of field: bch_alloc::fields",
    ][::std::mem::offset_of!(bch_alloc, fields) - 0usize];
    [
        "Offset of field: bch_alloc::gen_",
    ][::std::mem::offset_of!(bch_alloc, gen_) - 1usize];
    [
        "Offset of field: bch_alloc::data",
    ][::std::mem::offset_of!(bch_alloc, data) - 2usize];
};
impl Default for bch_alloc {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub const BCH_ALLOC_FIELD_V1_read_time: _bindgen_ty_17 = _bindgen_ty_17::BCH_ALLOC_FIELD_V1_read_time;
pub const BCH_ALLOC_FIELD_V1_write_time: _bindgen_ty_17 = _bindgen_ty_17::BCH_ALLOC_FIELD_V1_write_time;
pub const BCH_ALLOC_FIELD_V1_data_type: _bindgen_ty_17 = _bindgen_ty_17::BCH_ALLOC_FIELD_V1_data_type;
pub const BCH_ALLOC_FIELD_V1_dirty_sectors: _bindgen_ty_17 = _bindgen_ty_17::BCH_ALLOC_FIELD_V1_dirty_sectors;
pub const BCH_ALLOC_FIELD_V1_cached_sectors: _bindgen_ty_17 = _bindgen_ty_17::BCH_ALLOC_FIELD_V1_cached_sectors;
pub const BCH_ALLOC_FIELD_V1_oldest_gen: _bindgen_ty_17 = _bindgen_ty_17::BCH_ALLOC_FIELD_V1_oldest_gen;
pub const BCH_ALLOC_FIELD_V1_stripe: _bindgen_ty_17 = _bindgen_ty_17::BCH_ALLOC_FIELD_V1_stripe;
pub const BCH_ALLOC_FIELD_V1_stripe_redundancy: _bindgen_ty_17 = _bindgen_ty_17::BCH_ALLOC_FIELD_V1_stripe_redundancy;
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_17 {
    BCH_ALLOC_FIELD_V1_read_time = 0,
    BCH_ALLOC_FIELD_V1_write_time = 1,
    BCH_ALLOC_FIELD_V1_data_type = 2,
    BCH_ALLOC_FIELD_V1_dirty_sectors = 3,
    BCH_ALLOC_FIELD_V1_cached_sectors = 4,
    BCH_ALLOC_FIELD_V1_oldest_gen = 5,
    BCH_ALLOC_FIELD_V1_stripe = 6,
    BCH_ALLOC_FIELD_V1_stripe_redundancy = 7,
}
#[repr(C, packed(8))]
pub struct bch_alloc_v2 {
    pub v: bch_val,
    pub nr_fields: __u8,
    pub gen_: __u8,
    pub oldest_gen: __u8,
    pub data_type: __u8,
    pub data: __IncompleteArrayField<__u8>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_alloc_v2"][::std::mem::size_of::<bch_alloc_v2>() - 8usize];
    ["Alignment of bch_alloc_v2"][::std::mem::align_of::<bch_alloc_v2>() - 8usize];
    [
        "Offset of field: bch_alloc_v2::v",
    ][::std::mem::offset_of!(bch_alloc_v2, v) - 0usize];
    [
        "Offset of field: bch_alloc_v2::nr_fields",
    ][::std::mem::offset_of!(bch_alloc_v2, nr_fields) - 0usize];
    [
        "Offset of field: bch_alloc_v2::gen_",
    ][::std::mem::offset_of!(bch_alloc_v2, gen_) - 1usize];
    [
        "Offset of field: bch_alloc_v2::oldest_gen",
    ][::std::mem::offset_of!(bch_alloc_v2, oldest_gen) - 2usize];
    [
        "Offset of field: bch_alloc_v2::data_type",
    ][::std::mem::offset_of!(bch_alloc_v2, data_type) - 3usize];
    [
        "Offset of field: bch_alloc_v2::data",
    ][::std::mem::offset_of!(bch_alloc_v2, data) - 4usize];
};
impl Default for bch_alloc_v2 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C, packed(8))]
pub struct bch_alloc_v3 {
    pub v: bch_val,
    pub journal_seq: __le64,
    pub flags: __le32,
    pub nr_fields: __u8,
    pub gen_: __u8,
    pub oldest_gen: __u8,
    pub data_type: __u8,
    pub data: __IncompleteArrayField<__u8>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_alloc_v3"][::std::mem::size_of::<bch_alloc_v3>() - 16usize];
    ["Alignment of bch_alloc_v3"][::std::mem::align_of::<bch_alloc_v3>() - 8usize];
    [
        "Offset of field: bch_alloc_v3::v",
    ][::std::mem::offset_of!(bch_alloc_v3, v) - 0usize];
    [
        "Offset of field: bch_alloc_v3::journal_seq",
    ][::std::mem::offset_of!(bch_alloc_v3, journal_seq) - 0usize];
    [
        "Offset of field: bch_alloc_v3::flags",
    ][::std::mem::offset_of!(bch_alloc_v3, flags) - 8usize];
    [
        "Offset of field: bch_alloc_v3::nr_fields",
    ][::std::mem::offset_of!(bch_alloc_v3, nr_fields) - 12usize];
    [
        "Offset of field: bch_alloc_v3::gen_",
    ][::std::mem::offset_of!(bch_alloc_v3, gen_) - 13usize];
    [
        "Offset of field: bch_alloc_v3::oldest_gen",
    ][::std::mem::offset_of!(bch_alloc_v3, oldest_gen) - 14usize];
    [
        "Offset of field: bch_alloc_v3::data_type",
    ][::std::mem::offset_of!(bch_alloc_v3, data_type) - 15usize];
    [
        "Offset of field: bch_alloc_v3::data",
    ][::std::mem::offset_of!(bch_alloc_v3, data) - 16usize];
};
impl Default for bch_alloc_v3 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub const BCH_ALLOC_V3_NEED_DISCARD_OFFSET: ::std::os::raw::c_uint = 0;
pub const BCH_ALLOC_V3_NEED_DISCARD_BITS: ::std::os::raw::c_uint = 1;
pub const BCH_ALLOC_V3_NEED_DISCARD_MAX: __u32 = 1;
pub const BCH_ALLOC_V3_NEED_INC_GEN_OFFSET: ::std::os::raw::c_uint = 1;
pub const BCH_ALLOC_V3_NEED_INC_GEN_BITS: ::std::os::raw::c_uint = 1;
pub const BCH_ALLOC_V3_NEED_INC_GEN_MAX: __u32 = 1;
#[repr(C, packed(8))]
pub struct bch_alloc_v4 {
    pub v: bch_val,
    pub journal_seq_nonempty: __u64,
    pub flags: __u32,
    pub gen_: __u8,
    pub oldest_gen: __u8,
    pub data_type: __u8,
    pub stripe_redundancy_obsolete: __u8,
    pub dirty_sectors: __u32,
    pub cached_sectors: __u32,
    pub io_time: [__u64; 2usize],
    pub stripe_refcount: __u32,
    pub nr_external_backpointers: __u32,
    pub journal_seq_empty: __u64,
    pub stripe_sectors: __u32,
    pub pad: __u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_alloc_v4"][::std::mem::size_of::<bch_alloc_v4>() - 64usize];
    ["Alignment of bch_alloc_v4"][::std::mem::align_of::<bch_alloc_v4>() - 8usize];
    [
        "Offset of field: bch_alloc_v4::v",
    ][::std::mem::offset_of!(bch_alloc_v4, v) - 0usize];
    [
        "Offset of field: bch_alloc_v4::journal_seq_nonempty",
    ][::std::mem::offset_of!(bch_alloc_v4, journal_seq_nonempty) - 0usize];
    [
        "Offset of field: bch_alloc_v4::flags",
    ][::std::mem::offset_of!(bch_alloc_v4, flags) - 8usize];
    [
        "Offset of field: bch_alloc_v4::gen_",
    ][::std::mem::offset_of!(bch_alloc_v4, gen_) - 12usize];
    [
        "Offset of field: bch_alloc_v4::oldest_gen",
    ][::std::mem::offset_of!(bch_alloc_v4, oldest_gen) - 13usize];
    [
        "Offset of field: bch_alloc_v4::data_type",
    ][::std::mem::offset_of!(bch_alloc_v4, data_type) - 14usize];
    [
        "Offset of field: bch_alloc_v4::stripe_redundancy_obsolete",
    ][::std::mem::offset_of!(bch_alloc_v4, stripe_redundancy_obsolete) - 15usize];
    [
        "Offset of field: bch_alloc_v4::dirty_sectors",
    ][::std::mem::offset_of!(bch_alloc_v4, dirty_sectors) - 16usize];
    [
        "Offset of field: bch_alloc_v4::cached_sectors",
    ][::std::mem::offset_of!(bch_alloc_v4, cached_sectors) - 20usize];
    [
        "Offset of field: bch_alloc_v4::io_time",
    ][::std::mem::offset_of!(bch_alloc_v4, io_time) - 24usize];
    [
        "Offset of field: bch_alloc_v4::stripe_refcount",
    ][::std::mem::offset_of!(bch_alloc_v4, stripe_refcount) - 40usize];
    [
        "Offset of field: bch_alloc_v4::nr_external_backpointers",
    ][::std::mem::offset_of!(bch_alloc_v4, nr_external_backpointers) - 44usize];
    [
        "Offset of field: bch_alloc_v4::journal_seq_empty",
    ][::std::mem::offset_of!(bch_alloc_v4, journal_seq_empty) - 48usize];
    [
        "Offset of field: bch_alloc_v4::stripe_sectors",
    ][::std::mem::offset_of!(bch_alloc_v4, stripe_sectors) - 56usize];
    [
        "Offset of field: bch_alloc_v4::pad",
    ][::std::mem::offset_of!(bch_alloc_v4, pad) - 60usize];
};
impl Default for bch_alloc_v4 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub const BCH_ALLOC_V4_NEED_DISCARD_OFFSET: ::std::os::raw::c_uint = 0;
pub const BCH_ALLOC_V4_NEED_DISCARD_BITS: ::std::os::raw::c_uint = 1;
pub const BCH_ALLOC_V4_NEED_INC_GEN_OFFSET: ::std::os::raw::c_uint = 1;
pub const BCH_ALLOC_V4_NEED_INC_GEN_BITS: ::std::os::raw::c_uint = 1;
pub const BCH_ALLOC_V4_BACKPOINTERS_START_OFFSET: ::std::os::raw::c_uint = 2;
pub const BCH_ALLOC_V4_BACKPOINTERS_START_BITS: ::std::os::raw::c_uint = 6;
pub const BCH_ALLOC_V4_NR_BACKPOINTERS_OFFSET: ::std::os::raw::c_uint = 8;
pub const BCH_ALLOC_V4_NR_BACKPOINTERS_BITS: ::std::os::raw::c_uint = 6;
#[repr(C, packed(8))]
pub struct bch_bucket_gens {
    pub v: bch_val,
    pub gens: [u8_; 256usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_bucket_gens"][::std::mem::size_of::<bch_bucket_gens>() - 256usize];
    ["Alignment of bch_bucket_gens"][::std::mem::align_of::<bch_bucket_gens>() - 8usize];
    [
        "Offset of field: bch_bucket_gens::v",
    ][::std::mem::offset_of!(bch_bucket_gens, v) - 0usize];
    [
        "Offset of field: bch_bucket_gens::gens",
    ][::std::mem::offset_of!(bch_bucket_gens, gens) - 0usize];
};
impl Default for bch_bucket_gens {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_extent_entry_type {
    BCH_EXTENT_ENTRY_ptr = 0,
    BCH_EXTENT_ENTRY_crc32 = 1,
    BCH_EXTENT_ENTRY_crc64 = 2,
    BCH_EXTENT_ENTRY_crc128 = 3,
    BCH_EXTENT_ENTRY_stripe_ptr = 4,
    BCH_EXTENT_ENTRY_rebalance_v1 = 5,
    BCH_EXTENT_ENTRY_flags = 6,
    BCH_EXTENT_ENTRY_reconcile = 7,
    BCH_EXTENT_ENTRY_reconcile_bp = 8,
}
#[repr(C)]
#[repr(align(8))]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_extent_crc32 {
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
    pub csum: __u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_extent_crc32"][::std::mem::size_of::<bch_extent_crc32>() - 8usize];
    [
        "Alignment of bch_extent_crc32",
    ][::std::mem::align_of::<bch_extent_crc32>() - 8usize];
    [
        "Offset of field: bch_extent_crc32::csum",
    ][::std::mem::offset_of!(bch_extent_crc32, csum) - 4usize];
};
impl bch_extent_crc32 {
    #[inline]
    pub fn type_(&self) -> __u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) }
    }
    #[inline]
    pub fn set_type(&mut self, val: __u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 2u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn type__raw(this: *const Self) -> __u32 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 4usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 2u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_type_raw(this: *mut Self, val: __u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 4usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                2u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn _compressed_size(&self) -> __u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 7u8) as u32) }
    }
    #[inline]
    pub fn set__compressed_size(&mut self, val: __u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(2usize, 7u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn _compressed_size_raw(this: *const Self) -> __u32 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 4usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 2usize, 7u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set__compressed_size_raw(this: *mut Self, val: __u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 4usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                2usize,
                7u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn _uncompressed_size(&self) -> __u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 7u8) as u32) }
    }
    #[inline]
    pub fn set__uncompressed_size(&mut self, val: __u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(9usize, 7u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn _uncompressed_size_raw(this: *const Self) -> __u32 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 4usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 9usize, 7u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set__uncompressed_size_raw(this: *mut Self, val: __u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 4usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                9usize,
                7u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn offset(&self) -> __u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 7u8) as u32) }
    }
    #[inline]
    pub fn set_offset(&mut self, val: __u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(16usize, 7u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn offset_raw(this: *const Self) -> __u32 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 4usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 16usize, 7u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_offset_raw(this: *mut Self, val: __u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 4usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                16usize,
                7u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn _unused(&self) -> __u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set__unused(&mut self, val: __u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(23usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn _unused_raw(this: *const Self) -> __u32 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 4usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 23usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set__unused_raw(this: *mut Self, val: __u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 4usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                23usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn csum_type(&self) -> __u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 4u8) as u32) }
    }
    #[inline]
    pub fn set_csum_type(&mut self, val: __u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(24usize, 4u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn csum_type_raw(this: *const Self) -> __u32 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 4usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 24usize, 4u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_csum_type_raw(this: *mut Self, val: __u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 4usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                24usize,
                4u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn compression_type(&self) -> __u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 4u8) as u32) }
    }
    #[inline]
    pub fn set_compression_type(&mut self, val: __u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(28usize, 4u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn compression_type_raw(this: *const Self) -> __u32 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 4usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 28usize, 4u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_compression_type_raw(this: *mut Self, val: __u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 4usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                28usize,
                4u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        type_: __u32,
        _compressed_size: __u32,
        _uncompressed_size: __u32,
        offset: __u32,
        _unused: __u32,
        csum_type: __u32,
        compression_type: __u32,
    ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                2u8,
                {
                    let type_: u32 = unsafe { ::std::mem::transmute(type_) };
                    type_ as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                2usize,
                7u8,
                {
                    let _compressed_size: u32 = unsafe {
                        ::std::mem::transmute(_compressed_size)
                    };
                    _compressed_size as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                9usize,
                7u8,
                {
                    let _uncompressed_size: u32 = unsafe {
                        ::std::mem::transmute(_uncompressed_size)
                    };
                    _uncompressed_size as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                16usize,
                7u8,
                {
                    let offset: u32 = unsafe { ::std::mem::transmute(offset) };
                    offset as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                23usize,
                1u8,
                {
                    let _unused: u32 = unsafe { ::std::mem::transmute(_unused) };
                    _unused as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                24usize,
                4u8,
                {
                    let csum_type: u32 = unsafe { ::std::mem::transmute(csum_type) };
                    csum_type as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                28usize,
                4u8,
                {
                    let compression_type: u32 = unsafe {
                        ::std::mem::transmute(compression_type)
                    };
                    compression_type as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
#[repr(C, packed(8))]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_extent_crc64 {
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
    pub csum_lo: __u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_extent_crc64"][::std::mem::size_of::<bch_extent_crc64>() - 16usize];
    [
        "Alignment of bch_extent_crc64",
    ][::std::mem::align_of::<bch_extent_crc64>() - 8usize];
    [
        "Offset of field: bch_extent_crc64::csum_lo",
    ][::std::mem::offset_of!(bch_extent_crc64, csum_lo) - 8usize];
};
impl bch_extent_crc64 {
    #[inline]
    pub fn type_(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u64) }
    }
    #[inline]
    pub fn set_type(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 3u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn type__raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 3u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_type_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                3u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn _compressed_size(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 9u8) as u64) }
    }
    #[inline]
    pub fn set__compressed_size(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(3usize, 9u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn _compressed_size_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 3usize, 9u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set__compressed_size_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                3usize,
                9u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn _uncompressed_size(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 9u8) as u64) }
    }
    #[inline]
    pub fn set__uncompressed_size(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(12usize, 9u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn _uncompressed_size_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 12usize, 9u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set__uncompressed_size_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                12usize,
                9u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn offset(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 9u8) as u64) }
    }
    #[inline]
    pub fn set_offset(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(21usize, 9u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn offset_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 21usize, 9u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_offset_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                21usize,
                9u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn nonce(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 10u8) as u64) }
    }
    #[inline]
    pub fn set_nonce(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(30usize, 10u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn nonce_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 30usize, 10u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_nonce_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                30usize,
                10u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn csum_type(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(40usize, 4u8) as u64) }
    }
    #[inline]
    pub fn set_csum_type(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(40usize, 4u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn csum_type_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 40usize, 4u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_csum_type_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                40usize,
                4u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn compression_type(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(44usize, 4u8) as u64) }
    }
    #[inline]
    pub fn set_compression_type(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(44usize, 4u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn compression_type_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 44usize, 4u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_compression_type_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                44usize,
                4u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn csum_hi(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 16u8) as u64) }
    }
    #[inline]
    pub fn set_csum_hi(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(48usize, 16u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn csum_hi_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 48usize, 16u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_csum_hi_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                48usize,
                16u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        type_: __u64,
        _compressed_size: __u64,
        _uncompressed_size: __u64,
        offset: __u64,
        nonce: __u64,
        csum_type: __u64,
        compression_type: __u64,
        csum_hi: __u64,
    ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                3u8,
                {
                    let type_: u64 = unsafe { ::std::mem::transmute(type_) };
                    type_ as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                3usize,
                9u8,
                {
                    let _compressed_size: u64 = unsafe {
                        ::std::mem::transmute(_compressed_size)
                    };
                    _compressed_size as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                12usize,
                9u8,
                {
                    let _uncompressed_size: u64 = unsafe {
                        ::std::mem::transmute(_uncompressed_size)
                    };
                    _uncompressed_size as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                21usize,
                9u8,
                {
                    let offset: u64 = unsafe { ::std::mem::transmute(offset) };
                    offset as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                30usize,
                10u8,
                {
                    let nonce: u64 = unsafe { ::std::mem::transmute(nonce) };
                    nonce as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                40usize,
                4u8,
                {
                    let csum_type: u64 = unsafe { ::std::mem::transmute(csum_type) };
                    csum_type as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                44usize,
                4u8,
                {
                    let compression_type: u64 = unsafe {
                        ::std::mem::transmute(compression_type)
                    };
                    compression_type as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                48usize,
                16u8,
                {
                    let csum_hi: u64 = unsafe { ::std::mem::transmute(csum_hi) };
                    csum_hi as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
#[repr(C, align(8))]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_extent_crc128 {
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
    pub csum: bch_csum,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_extent_crc128"][::std::mem::size_of::<bch_extent_crc128>() - 24usize];
    [
        "Alignment of bch_extent_crc128",
    ][::std::mem::align_of::<bch_extent_crc128>() - 8usize];
    [
        "Offset of field: bch_extent_crc128::csum",
    ][::std::mem::offset_of!(bch_extent_crc128, csum) - 8usize];
};
impl bch_extent_crc128 {
    #[inline]
    pub fn type_(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u64) }
    }
    #[inline]
    pub fn set_type(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 4u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn type__raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 4u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_type_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                4u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn _compressed_size(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 13u8) as u64) }
    }
    #[inline]
    pub fn set__compressed_size(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(4usize, 13u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn _compressed_size_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 4usize, 13u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set__compressed_size_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                4usize,
                13u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn _uncompressed_size(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 13u8) as u64) }
    }
    #[inline]
    pub fn set__uncompressed_size(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(17usize, 13u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn _uncompressed_size_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 17usize, 13u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set__uncompressed_size_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                17usize,
                13u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn offset(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 13u8) as u64) }
    }
    #[inline]
    pub fn set_offset(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(30usize, 13u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn offset_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 30usize, 13u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_offset_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                30usize,
                13u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn nonce(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(43usize, 13u8) as u64) }
    }
    #[inline]
    pub fn set_nonce(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(43usize, 13u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn nonce_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 43usize, 13u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_nonce_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                43usize,
                13u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn csum_type(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(56usize, 4u8) as u64) }
    }
    #[inline]
    pub fn set_csum_type(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(56usize, 4u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn csum_type_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 56usize, 4u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_csum_type_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                56usize,
                4u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn compression_type(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(60usize, 4u8) as u64) }
    }
    #[inline]
    pub fn set_compression_type(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(60usize, 4u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn compression_type_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 60usize, 4u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_compression_type_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                60usize,
                4u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        type_: __u64,
        _compressed_size: __u64,
        _uncompressed_size: __u64,
        offset: __u64,
        nonce: __u64,
        csum_type: __u64,
        compression_type: __u64,
    ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                4u8,
                {
                    let type_: u64 = unsafe { ::std::mem::transmute(type_) };
                    type_ as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                4usize,
                13u8,
                {
                    let _compressed_size: u64 = unsafe {
                        ::std::mem::transmute(_compressed_size)
                    };
                    _compressed_size as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                17usize,
                13u8,
                {
                    let _uncompressed_size: u64 = unsafe {
                        ::std::mem::transmute(_uncompressed_size)
                    };
                    _uncompressed_size as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                30usize,
                13u8,
                {
                    let offset: u64 = unsafe { ::std::mem::transmute(offset) };
                    offset as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                43usize,
                13u8,
                {
                    let nonce: u64 = unsafe { ::std::mem::transmute(nonce) };
                    nonce as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                56usize,
                4u8,
                {
                    let csum_type: u64 = unsafe { ::std::mem::transmute(csum_type) };
                    csum_type as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                60usize,
                4u8,
                {
                    let compression_type: u64 = unsafe {
                        ::std::mem::transmute(compression_type)
                    };
                    compression_type as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[repr(align(8))]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_extent_ptr {
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_extent_ptr"][::std::mem::size_of::<bch_extent_ptr>() - 8usize];
    ["Alignment of bch_extent_ptr"][::std::mem::align_of::<bch_extent_ptr>() - 8usize];
};
impl bch_extent_ptr {
    #[inline]
    pub fn type_(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
    }
    #[inline]
    pub fn set_type(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn type__raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_type_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn cached(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
    }
    #[inline]
    pub fn set_cached(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(1usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn cached_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 1usize, 1u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_cached_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                1usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn unused(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
    }
    #[inline]
    pub fn set_unused(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(2usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn unused_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 2usize, 1u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_unused_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                2usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn unwritten(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
    }
    #[inline]
    pub fn set_unwritten(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(3usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn unwritten_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 3usize, 1u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_unwritten_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                3usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn offset(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 44u8) as u64) }
    }
    #[inline]
    pub fn set_offset(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(4usize, 44u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn offset_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 4usize, 44u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_offset_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                4usize,
                44u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn dev(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 8u8) as u64) }
    }
    #[inline]
    pub fn set_dev(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(48usize, 8u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn dev_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 48usize, 8u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_dev_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                48usize,
                8u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn gen_(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(56usize, 8u8) as u64) }
    }
    #[inline]
    pub fn set_gen(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(56usize, 8u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn gen__raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 56usize, 8u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_gen_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                56usize,
                8u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        type_: __u64,
        cached: __u64,
        unused: __u64,
        unwritten: __u64,
        offset: __u64,
        dev: __u64,
        gen_: __u64,
    ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                1u8,
                {
                    let type_: u64 = unsafe { ::std::mem::transmute(type_) };
                    type_ as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                1usize,
                1u8,
                {
                    let cached: u64 = unsafe { ::std::mem::transmute(cached) };
                    cached as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                2usize,
                1u8,
                {
                    let unused: u64 = unsafe { ::std::mem::transmute(unused) };
                    unused as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                3usize,
                1u8,
                {
                    let unwritten: u64 = unsafe { ::std::mem::transmute(unwritten) };
                    unwritten as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                4usize,
                44u8,
                {
                    let offset: u64 = unsafe { ::std::mem::transmute(offset) };
                    offset as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                48usize,
                8u8,
                {
                    let dev: u64 = unsafe { ::std::mem::transmute(dev) };
                    dev as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                56usize,
                8u8,
                {
                    let gen_: u64 = unsafe { ::std::mem::transmute(gen_) };
                    gen_ as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_extent_stripe_ptr {
    pub _bitfield_align_1: [u64; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_extent_stripe_ptr",
    ][::std::mem::size_of::<bch_extent_stripe_ptr>() - 8usize];
    [
        "Alignment of bch_extent_stripe_ptr",
    ][::std::mem::align_of::<bch_extent_stripe_ptr>() - 8usize];
};
impl bch_extent_stripe_ptr {
    #[inline]
    pub fn type_(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 5u8) as u64) }
    }
    #[inline]
    pub fn set_type(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 5u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn type__raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 5u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_type_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                5u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn block(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 8u8) as u64) }
    }
    #[inline]
    pub fn set_block(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(5usize, 8u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn block_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 5usize, 8u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_block_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                5usize,
                8u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn redundancy(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 4u8) as u64) }
    }
    #[inline]
    pub fn set_redundancy(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(13usize, 4u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn redundancy_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 13usize, 4u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_redundancy_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                13usize,
                4u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn idx(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 47u8) as u64) }
    }
    #[inline]
    pub fn set_idx(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(17usize, 47u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn idx_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 17usize, 47u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_idx_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                17usize,
                47u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        type_: __u64,
        block: __u64,
        redundancy: __u64,
        idx: __u64,
    ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                5u8,
                {
                    let type_: u64 = unsafe { ::std::mem::transmute(type_) };
                    type_ as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                5usize,
                8u8,
                {
                    let block: u64 = unsafe { ::std::mem::transmute(block) };
                    block as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                13usize,
                4u8,
                {
                    let redundancy: u64 = unsafe { ::std::mem::transmute(redundancy) };
                    redundancy as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                17usize,
                47u8,
                {
                    let idx: u64 = unsafe { ::std::mem::transmute(idx) };
                    idx as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_extent_flags_e {
    BCH_EXTENT_FLAG_poisoned = 0,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_extent_flags {
    pub _bitfield_align_1: [u64; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_extent_flags"][::std::mem::size_of::<bch_extent_flags>() - 8usize];
    [
        "Alignment of bch_extent_flags",
    ][::std::mem::align_of::<bch_extent_flags>() - 8usize];
};
impl bch_extent_flags {
    #[inline]
    pub fn type_(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 7u8) as u64) }
    }
    #[inline]
    pub fn set_type(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 7u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn type__raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 7u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_type_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                7u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn flags(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 57u8) as u64) }
    }
    #[inline]
    pub fn set_flags(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(7usize, 57u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn flags_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 7usize, 57u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_flags_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                7usize,
                57u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        type_: __u64,
        flags: __u64,
    ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                7u8,
                {
                    let type_: u64 = unsafe { ::std::mem::transmute(type_) };
                    type_ as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                7usize,
                57u8,
                {
                    let flags: u64 = unsafe { ::std::mem::transmute(flags) };
                    flags as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[repr(align(8))]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_extent_rebalance_v1 {
    pub _bitfield_align_1: [u16; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_extent_rebalance_v1",
    ][::std::mem::size_of::<bch_extent_rebalance_v1>() - 8usize];
    [
        "Alignment of bch_extent_rebalance_v1",
    ][::std::mem::align_of::<bch_extent_rebalance_v1>() - 8usize];
};
impl bch_extent_rebalance_v1 {
    #[inline]
    pub fn type_(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 6u8) as u64) }
    }
    #[inline]
    pub fn set_type(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 6u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn type__raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 6u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_type_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                6u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn unused(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 3u8) as u64) }
    }
    #[inline]
    pub fn set_unused(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(6usize, 3u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn unused_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 6usize, 3u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_unused_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                6usize,
                3u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn promote_target_from_inode(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u64) }
    }
    #[inline]
    pub fn set_promote_target_from_inode(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(9usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn promote_target_from_inode_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 9usize, 1u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_promote_target_from_inode_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                9usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn erasure_code_from_inode(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u64) }
    }
    #[inline]
    pub fn set_erasure_code_from_inode(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(10usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn erasure_code_from_inode_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 10usize, 1u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_erasure_code_from_inode_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                10usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn data_checksum_from_inode(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u64) }
    }
    #[inline]
    pub fn set_data_checksum_from_inode(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(11usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn data_checksum_from_inode_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 11usize, 1u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_data_checksum_from_inode_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                11usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn background_compression_from_inode(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u64) }
    }
    #[inline]
    pub fn set_background_compression_from_inode(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(12usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn background_compression_from_inode_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 12usize, 1u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_background_compression_from_inode_raw(
        this: *mut Self,
        val: __u64,
    ) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                12usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn data_replicas_from_inode(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u64) }
    }
    #[inline]
    pub fn set_data_replicas_from_inode(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(13usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn data_replicas_from_inode_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 13usize, 1u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_data_replicas_from_inode_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                13usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn background_target_from_inode(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u64) }
    }
    #[inline]
    pub fn set_background_target_from_inode(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(14usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn background_target_from_inode_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 14usize, 1u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_background_target_from_inode_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                14usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn promote_target(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 16u8) as u64) }
    }
    #[inline]
    pub fn set_promote_target(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(15usize, 16u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn promote_target_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 15usize, 16u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_promote_target_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                15usize,
                16u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn erasure_code(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u64) }
    }
    #[inline]
    pub fn set_erasure_code(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(31usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn erasure_code_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 31usize, 1u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_erasure_code_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                31usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn data_checksum(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 4u8) as u64) }
    }
    #[inline]
    pub fn set_data_checksum(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(32usize, 4u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn data_checksum_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 32usize, 4u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_data_checksum_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                32usize,
                4u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn data_replicas(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(36usize, 4u8) as u64) }
    }
    #[inline]
    pub fn set_data_replicas(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(36usize, 4u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn data_replicas_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 36usize, 4u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_data_replicas_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                36usize,
                4u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn background_compression(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(40usize, 8u8) as u64) }
    }
    #[inline]
    pub fn set_background_compression(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(40usize, 8u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn background_compression_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 40usize, 8u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_background_compression_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                40usize,
                8u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn background_target(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 16u8) as u64) }
    }
    #[inline]
    pub fn set_background_target(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(48usize, 16u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn background_target_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 48usize, 16u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_background_target_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                48usize,
                16u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        type_: __u64,
        unused: __u64,
        promote_target_from_inode: __u64,
        erasure_code_from_inode: __u64,
        data_checksum_from_inode: __u64,
        background_compression_from_inode: __u64,
        data_replicas_from_inode: __u64,
        background_target_from_inode: __u64,
        promote_target: __u64,
        erasure_code: __u64,
        data_checksum: __u64,
        data_replicas: __u64,
        background_compression: __u64,
        background_target: __u64,
    ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                6u8,
                {
                    let type_: u64 = unsafe { ::std::mem::transmute(type_) };
                    type_ as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                6usize,
                3u8,
                {
                    let unused: u64 = unsafe { ::std::mem::transmute(unused) };
                    unused as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                9usize,
                1u8,
                {
                    let promote_target_from_inode: u64 = unsafe {
                        ::std::mem::transmute(promote_target_from_inode)
                    };
                    promote_target_from_inode as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                10usize,
                1u8,
                {
                    let erasure_code_from_inode: u64 = unsafe {
                        ::std::mem::transmute(erasure_code_from_inode)
                    };
                    erasure_code_from_inode as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                11usize,
                1u8,
                {
                    let data_checksum_from_inode: u64 = unsafe {
                        ::std::mem::transmute(data_checksum_from_inode)
                    };
                    data_checksum_from_inode as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                12usize,
                1u8,
                {
                    let background_compression_from_inode: u64 = unsafe {
                        ::std::mem::transmute(background_compression_from_inode)
                    };
                    background_compression_from_inode as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                13usize,
                1u8,
                {
                    let data_replicas_from_inode: u64 = unsafe {
                        ::std::mem::transmute(data_replicas_from_inode)
                    };
                    data_replicas_from_inode as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                14usize,
                1u8,
                {
                    let background_target_from_inode: u64 = unsafe {
                        ::std::mem::transmute(background_target_from_inode)
                    };
                    background_target_from_inode as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                15usize,
                16u8,
                {
                    let promote_target: u64 = unsafe {
                        ::std::mem::transmute(promote_target)
                    };
                    promote_target as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                31usize,
                1u8,
                {
                    let erasure_code: u64 = unsafe {
                        ::std::mem::transmute(erasure_code)
                    };
                    erasure_code as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                32usize,
                4u8,
                {
                    let data_checksum: u64 = unsafe {
                        ::std::mem::transmute(data_checksum)
                    };
                    data_checksum as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                36usize,
                4u8,
                {
                    let data_replicas: u64 = unsafe {
                        ::std::mem::transmute(data_replicas)
                    };
                    data_replicas as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                40usize,
                8u8,
                {
                    let background_compression: u64 = unsafe {
                        ::std::mem::transmute(background_compression)
                    };
                    background_compression as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                48usize,
                16u8,
                {
                    let background_target: u64 = unsafe {
                        ::std::mem::transmute(background_target)
                    };
                    background_target as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[repr(align(8))]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_extent_reconcile {
    pub _bitfield_align_1: [u16; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_extent_reconcile",
    ][::std::mem::size_of::<bch_extent_reconcile>() - 8usize];
    [
        "Alignment of bch_extent_reconcile",
    ][::std::mem::align_of::<bch_extent_reconcile>() - 8usize];
};
impl bch_extent_reconcile {
    #[inline]
    pub fn type_(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u64) }
    }
    #[inline]
    pub fn set_type(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 8u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn type__raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 8u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_type_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                8u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn unused(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 2u8) as u64) }
    }
    #[inline]
    pub fn set_unused(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(8usize, 2u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn unused_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 8usize, 2u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_unused_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                8usize,
                2u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn ptrs_moving(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 5u8) as u64) }
    }
    #[inline]
    pub fn set_ptrs_moving(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(10usize, 5u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn ptrs_moving_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 10usize, 5u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_ptrs_moving_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                10usize,
                5u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn hipri(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u64) }
    }
    #[inline]
    pub fn set_hipri(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(15usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn hipri_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 15usize, 1u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_hipri_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                15usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn pending(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u64) }
    }
    #[inline]
    pub fn set_pending(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(16usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn pending_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 16usize, 1u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_pending_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                16usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn need_rb(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 5u8) as u64) }
    }
    #[inline]
    pub fn set_need_rb(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(17usize, 5u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn need_rb_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 17usize, 5u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_need_rb_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                17usize,
                5u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn data_replicas_from_inode(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u64) }
    }
    #[inline]
    pub fn set_data_replicas_from_inode(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(22usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn data_replicas_from_inode_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 22usize, 1u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_data_replicas_from_inode_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                22usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn data_checksum_from_inode(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u64) }
    }
    #[inline]
    pub fn set_data_checksum_from_inode(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(23usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn data_checksum_from_inode_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 23usize, 1u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_data_checksum_from_inode_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                23usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn erasure_code_from_inode(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u64) }
    }
    #[inline]
    pub fn set_erasure_code_from_inode(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(24usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn erasure_code_from_inode_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 24usize, 1u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_erasure_code_from_inode_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                24usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn background_compression_from_inode(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u64) }
    }
    #[inline]
    pub fn set_background_compression_from_inode(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(25usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn background_compression_from_inode_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 25usize, 1u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_background_compression_from_inode_raw(
        this: *mut Self,
        val: __u64,
    ) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                25usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn background_target_from_inode(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u64) }
    }
    #[inline]
    pub fn set_background_target_from_inode(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(26usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn background_target_from_inode_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 26usize, 1u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_background_target_from_inode_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                26usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn promote_target_from_inode(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u64) }
    }
    #[inline]
    pub fn set_promote_target_from_inode(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(27usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn promote_target_from_inode_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 27usize, 1u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_promote_target_from_inode_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                27usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn data_replicas(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 3u8) as u64) }
    }
    #[inline]
    pub fn set_data_replicas(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(28usize, 3u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn data_replicas_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 28usize, 3u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_data_replicas_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                28usize,
                3u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn data_checksum(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 4u8) as u64) }
    }
    #[inline]
    pub fn set_data_checksum(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(31usize, 4u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn data_checksum_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 31usize, 4u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_data_checksum_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                31usize,
                4u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn erasure_code(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(35usize, 1u8) as u64) }
    }
    #[inline]
    pub fn set_erasure_code(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(35usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn erasure_code_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 35usize, 1u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_erasure_code_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                35usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn background_compression(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(36usize, 8u8) as u64) }
    }
    #[inline]
    pub fn set_background_compression(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(36usize, 8u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn background_compression_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 36usize, 8u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_background_compression_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                36usize,
                8u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn background_target(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(44usize, 10u8) as u64) }
    }
    #[inline]
    pub fn set_background_target(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(44usize, 10u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn background_target_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 44usize, 10u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_background_target_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                44usize,
                10u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn promote_target(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(54usize, 10u8) as u64) }
    }
    #[inline]
    pub fn set_promote_target(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(54usize, 10u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn promote_target_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 54usize, 10u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_promote_target_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                54usize,
                10u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        type_: __u64,
        unused: __u64,
        ptrs_moving: __u64,
        hipri: __u64,
        pending: __u64,
        need_rb: __u64,
        data_replicas_from_inode: __u64,
        data_checksum_from_inode: __u64,
        erasure_code_from_inode: __u64,
        background_compression_from_inode: __u64,
        background_target_from_inode: __u64,
        promote_target_from_inode: __u64,
        data_replicas: __u64,
        data_checksum: __u64,
        erasure_code: __u64,
        background_compression: __u64,
        background_target: __u64,
        promote_target: __u64,
    ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                8u8,
                {
                    let type_: u64 = unsafe { ::std::mem::transmute(type_) };
                    type_ as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                8usize,
                2u8,
                {
                    let unused: u64 = unsafe { ::std::mem::transmute(unused) };
                    unused as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                10usize,
                5u8,
                {
                    let ptrs_moving: u64 = unsafe { ::std::mem::transmute(ptrs_moving) };
                    ptrs_moving as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                15usize,
                1u8,
                {
                    let hipri: u64 = unsafe { ::std::mem::transmute(hipri) };
                    hipri as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                16usize,
                1u8,
                {
                    let pending: u64 = unsafe { ::std::mem::transmute(pending) };
                    pending as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                17usize,
                5u8,
                {
                    let need_rb: u64 = unsafe { ::std::mem::transmute(need_rb) };
                    need_rb as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                22usize,
                1u8,
                {
                    let data_replicas_from_inode: u64 = unsafe {
                        ::std::mem::transmute(data_replicas_from_inode)
                    };
                    data_replicas_from_inode as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                23usize,
                1u8,
                {
                    let data_checksum_from_inode: u64 = unsafe {
                        ::std::mem::transmute(data_checksum_from_inode)
                    };
                    data_checksum_from_inode as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                24usize,
                1u8,
                {
                    let erasure_code_from_inode: u64 = unsafe {
                        ::std::mem::transmute(erasure_code_from_inode)
                    };
                    erasure_code_from_inode as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                25usize,
                1u8,
                {
                    let background_compression_from_inode: u64 = unsafe {
                        ::std::mem::transmute(background_compression_from_inode)
                    };
                    background_compression_from_inode as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                26usize,
                1u8,
                {
                    let background_target_from_inode: u64 = unsafe {
                        ::std::mem::transmute(background_target_from_inode)
                    };
                    background_target_from_inode as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                27usize,
                1u8,
                {
                    let promote_target_from_inode: u64 = unsafe {
                        ::std::mem::transmute(promote_target_from_inode)
                    };
                    promote_target_from_inode as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                28usize,
                3u8,
                {
                    let data_replicas: u64 = unsafe {
                        ::std::mem::transmute(data_replicas)
                    };
                    data_replicas as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                31usize,
                4u8,
                {
                    let data_checksum: u64 = unsafe {
                        ::std::mem::transmute(data_checksum)
                    };
                    data_checksum as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                35usize,
                1u8,
                {
                    let erasure_code: u64 = unsafe {
                        ::std::mem::transmute(erasure_code)
                    };
                    erasure_code as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                36usize,
                8u8,
                {
                    let background_compression: u64 = unsafe {
                        ::std::mem::transmute(background_compression)
                    };
                    background_compression as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                44usize,
                10u8,
                {
                    let background_target: u64 = unsafe {
                        ::std::mem::transmute(background_target)
                    };
                    background_target as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                54usize,
                10u8,
                {
                    let promote_target: u64 = unsafe {
                        ::std::mem::transmute(promote_target)
                    };
                    promote_target as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_extent_reconcile_bp {
    pub _bitfield_align_1: [u64; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_extent_reconcile_bp",
    ][::std::mem::size_of::<bch_extent_reconcile_bp>() - 8usize];
    [
        "Alignment of bch_extent_reconcile_bp",
    ][::std::mem::align_of::<bch_extent_reconcile_bp>() - 8usize];
};
impl bch_extent_reconcile_bp {
    #[inline]
    pub fn type_(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 9u8) as u64) }
    }
    #[inline]
    pub fn set_type(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 9u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn type__raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 9u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_type_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                9u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn idx(&self) -> __u64 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 55u8) as u64) }
    }
    #[inline]
    pub fn set_idx(&mut self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(9usize, 55u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn idx_raw(this: *const Self) -> __u64 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 9usize, 55u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_idx_raw(this: *mut Self, val: __u64) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                9usize,
                55u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        type_: __u64,
        idx: __u64,
    ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                9u8,
                {
                    let type_: u64 = unsafe { ::std::mem::transmute(type_) };
                    type_ as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                9usize,
                55u8,
                {
                    let idx: u64 = unsafe { ::std::mem::transmute(idx) };
                    idx as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_reconcile_opts {
    BCH_RECONCILE_data_replicas = 0,
    BCH_RECONCILE_data_checksum = 1,
    BCH_RECONCILE_erasure_code = 2,
    BCH_RECONCILE_background_compression = 3,
    BCH_RECONCILE_background_target = 4,
    BCH_RECONCILE_promote_target = 5,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_reconcile_accounting_type {
    BCH_RECONCILE_ACCOUNTING_replicas = 0,
    BCH_RECONCILE_ACCOUNTING_checksum = 1,
    BCH_RECONCILE_ACCOUNTING_erasure_code = 2,
    BCH_RECONCILE_ACCOUNTING_compression = 3,
    BCH_RECONCILE_ACCOUNTING_target = 4,
    BCH_RECONCILE_ACCOUNTING_high_priority = 5,
    BCH_RECONCILE_ACCOUNTING_pending = 6,
    BCH_RECONCILE_ACCOUNTING_stripes = 7,
    BCH_RECONCILE_ACCOUNTING_NR = 8,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum reconcile_work_id {
    RECONCILE_WORK_none = 0,
    RECONCILE_WORK_hipri = 1,
    RECONCILE_WORK_normal = 2,
    RECONCILE_WORK_pending = 3,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bch_extent_entry {
    pub type_: ::std::os::raw::c_ulong,
    pub ptr: bch_extent_ptr,
    pub crc32: bch_extent_crc32,
    pub crc64: bch_extent_crc64,
    pub crc128: bch_extent_crc128,
    pub stripe_ptr: bch_extent_stripe_ptr,
    pub rebalance_v1: bch_extent_rebalance_v1,
    pub flags: bch_extent_flags,
    pub reconcile: bch_extent_reconcile,
    pub reconcile_bp: bch_extent_reconcile_bp,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_extent_entry"][::std::mem::size_of::<bch_extent_entry>() - 24usize];
    [
        "Alignment of bch_extent_entry",
    ][::std::mem::align_of::<bch_extent_entry>() - 8usize];
    [
        "Offset of field: bch_extent_entry::type_",
    ][::std::mem::offset_of!(bch_extent_entry, type_) - 0usize];
    [
        "Offset of field: bch_extent_entry::ptr",
    ][::std::mem::offset_of!(bch_extent_entry, ptr) - 0usize];
    [
        "Offset of field: bch_extent_entry::crc32",
    ][::std::mem::offset_of!(bch_extent_entry, crc32) - 0usize];
    [
        "Offset of field: bch_extent_entry::crc64",
    ][::std::mem::offset_of!(bch_extent_entry, crc64) - 0usize];
    [
        "Offset of field: bch_extent_entry::crc128",
    ][::std::mem::offset_of!(bch_extent_entry, crc128) - 0usize];
    [
        "Offset of field: bch_extent_entry::stripe_ptr",
    ][::std::mem::offset_of!(bch_extent_entry, stripe_ptr) - 0usize];
    [
        "Offset of field: bch_extent_entry::rebalance_v1",
    ][::std::mem::offset_of!(bch_extent_entry, rebalance_v1) - 0usize];
    [
        "Offset of field: bch_extent_entry::flags",
    ][::std::mem::offset_of!(bch_extent_entry, flags) - 0usize];
    [
        "Offset of field: bch_extent_entry::reconcile",
    ][::std::mem::offset_of!(bch_extent_entry, reconcile) - 0usize];
    [
        "Offset of field: bch_extent_entry::reconcile_bp",
    ][::std::mem::offset_of!(bch_extent_entry, reconcile_bp) - 0usize];
};
impl Default for bch_extent_entry {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C, packed(8))]
pub struct bch_btree_ptr {
    pub v: bch_val,
    pub _data: __IncompleteArrayField<__u64>,
    pub start: __IncompleteArrayField<bch_extent_ptr>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_btree_ptr"][::std::mem::size_of::<bch_btree_ptr>() - 0usize];
    ["Alignment of bch_btree_ptr"][::std::mem::align_of::<bch_btree_ptr>() - 8usize];
    [
        "Offset of field: bch_btree_ptr::v",
    ][::std::mem::offset_of!(bch_btree_ptr, v) - 0usize];
    [
        "Offset of field: bch_btree_ptr::_data",
    ][::std::mem::offset_of!(bch_btree_ptr, _data) - 0usize];
    [
        "Offset of field: bch_btree_ptr::start",
    ][::std::mem::offset_of!(bch_btree_ptr, start) - 0usize];
};
impl Default for bch_btree_ptr {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C, packed(8))]
pub struct bch_btree_ptr_v2 {
    pub v: bch_val,
    pub mem_ptr: __u64,
    pub seq: __le64,
    pub sectors_written: __le16,
    pub flags: __le16,
    pub min_key: bpos,
    pub _data: __IncompleteArrayField<__u64>,
    pub start: __IncompleteArrayField<bch_extent_ptr>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_btree_ptr_v2"][::std::mem::size_of::<bch_btree_ptr_v2>() - 40usize];
    [
        "Alignment of bch_btree_ptr_v2",
    ][::std::mem::align_of::<bch_btree_ptr_v2>() - 8usize];
    [
        "Offset of field: bch_btree_ptr_v2::v",
    ][::std::mem::offset_of!(bch_btree_ptr_v2, v) - 0usize];
    [
        "Offset of field: bch_btree_ptr_v2::mem_ptr",
    ][::std::mem::offset_of!(bch_btree_ptr_v2, mem_ptr) - 0usize];
    [
        "Offset of field: bch_btree_ptr_v2::seq",
    ][::std::mem::offset_of!(bch_btree_ptr_v2, seq) - 8usize];
    [
        "Offset of field: bch_btree_ptr_v2::sectors_written",
    ][::std::mem::offset_of!(bch_btree_ptr_v2, sectors_written) - 16usize];
    [
        "Offset of field: bch_btree_ptr_v2::flags",
    ][::std::mem::offset_of!(bch_btree_ptr_v2, flags) - 18usize];
    [
        "Offset of field: bch_btree_ptr_v2::min_key",
    ][::std::mem::offset_of!(bch_btree_ptr_v2, min_key) - 20usize];
    [
        "Offset of field: bch_btree_ptr_v2::_data",
    ][::std::mem::offset_of!(bch_btree_ptr_v2, _data) - 40usize];
    [
        "Offset of field: bch_btree_ptr_v2::start",
    ][::std::mem::offset_of!(bch_btree_ptr_v2, start) - 40usize];
};
impl Default for bch_btree_ptr_v2 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C, packed(8))]
pub struct bch_extent {
    pub v: bch_val,
    pub _data: __IncompleteArrayField<__u64>,
    pub start: __IncompleteArrayField<bch_extent_entry>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_extent"][::std::mem::size_of::<bch_extent>() - 0usize];
    ["Alignment of bch_extent"][::std::mem::align_of::<bch_extent>() - 8usize];
    ["Offset of field: bch_extent::v"][::std::mem::offset_of!(bch_extent, v) - 0usize];
    [
        "Offset of field: bch_extent::_data",
    ][::std::mem::offset_of!(bch_extent, _data) - 0usize];
    [
        "Offset of field: bch_extent::start",
    ][::std::mem::offset_of!(bch_extent, start) - 0usize];
};
impl Default for bch_extent {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C, packed(8))]
pub struct bch_reservation {
    pub v: bch_val,
    pub generation: __le32,
    pub nr_replicas: __u8,
    pub pad: [__u8; 3usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_reservation"][::std::mem::size_of::<bch_reservation>() - 8usize];
    ["Alignment of bch_reservation"][::std::mem::align_of::<bch_reservation>() - 8usize];
    [
        "Offset of field: bch_reservation::v",
    ][::std::mem::offset_of!(bch_reservation, v) - 0usize];
    [
        "Offset of field: bch_reservation::generation",
    ][::std::mem::offset_of!(bch_reservation, generation) - 0usize];
    [
        "Offset of field: bch_reservation::nr_replicas",
    ][::std::mem::offset_of!(bch_reservation, nr_replicas) - 4usize];
    [
        "Offset of field: bch_reservation::pad",
    ][::std::mem::offset_of!(bch_reservation, pad) - 5usize];
};
impl Default for bch_reservation {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct bch_inline_data {
    pub v: bch_val,
    pub data: __IncompleteArrayField<u8_>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_inline_data"][::std::mem::size_of::<bch_inline_data>() - 0usize];
    ["Alignment of bch_inline_data"][::std::mem::align_of::<bch_inline_data>() - 8usize];
    [
        "Offset of field: bch_inline_data::v",
    ][::std::mem::offset_of!(bch_inline_data, v) - 0usize];
    [
        "Offset of field: bch_inline_data::data",
    ][::std::mem::offset_of!(bch_inline_data, data) - 0usize];
};
#[repr(C, packed(8))]
pub struct bch_stripe {
    pub v: bch_val,
    pub sectors: __le16,
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
    pub nr_blocks: __u8,
    pub nr_redundant: __u8,
    pub csum_granularity_bits: __u8,
    pub csum_type: __u8,
    pub disk_label: __u8,
    pub ptrs: __IncompleteArrayField<bch_extent_ptr>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_stripe"][::std::mem::size_of::<bch_stripe>() - 8usize];
    ["Alignment of bch_stripe"][::std::mem::align_of::<bch_stripe>() - 8usize];
    ["Offset of field: bch_stripe::v"][::std::mem::offset_of!(bch_stripe, v) - 0usize];
    [
        "Offset of field: bch_stripe::sectors",
    ][::std::mem::offset_of!(bch_stripe, sectors) - 0usize];
    [
        "Offset of field: bch_stripe::nr_blocks",
    ][::std::mem::offset_of!(bch_stripe, nr_blocks) - 3usize];
    [
        "Offset of field: bch_stripe::nr_redundant",
    ][::std::mem::offset_of!(bch_stripe, nr_redundant) - 4usize];
    [
        "Offset of field: bch_stripe::csum_granularity_bits",
    ][::std::mem::offset_of!(bch_stripe, csum_granularity_bits) - 5usize];
    [
        "Offset of field: bch_stripe::csum_type",
    ][::std::mem::offset_of!(bch_stripe, csum_type) - 6usize];
    [
        "Offset of field: bch_stripe::disk_label",
    ][::std::mem::offset_of!(bch_stripe, disk_label) - 7usize];
    [
        "Offset of field: bch_stripe::ptrs",
    ][::std::mem::offset_of!(bch_stripe, ptrs) - 8usize];
};
impl Default for bch_stripe {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl bch_stripe {
    #[inline]
    pub fn algorithm(&self) -> __u8 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u8) }
    }
    #[inline]
    pub fn set_algorithm(&mut self, val: __u8) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 4u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn algorithm_raw(this: *const Self) -> __u8 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 4u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_algorithm_raw(this: *mut Self, val: __u8) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                4u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn needs_reconcile(&self) -> __u8 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_needs_reconcile(&mut self, val: __u8) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(4usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn needs_reconcile_raw(this: *const Self) -> __u8 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 4usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_needs_reconcile_raw(this: *mut Self, val: __u8) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                4usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn can_widen(&self) -> __u8 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 3u8) as u8) }
    }
    #[inline]
    pub fn set_can_widen(&mut self, val: __u8) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(5usize, 3u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn can_widen_raw(this: *const Self) -> __u8 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 5usize, 3u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_can_widen_raw(this: *mut Self, val: __u8) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                5usize,
                3u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        algorithm: __u8,
        needs_reconcile: __u8,
        can_widen: __u8,
    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                4u8,
                {
                    let algorithm: u8 = unsafe { ::std::mem::transmute(algorithm) };
                    algorithm as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                4usize,
                1u8,
                {
                    let needs_reconcile: u8 = unsafe {
                        ::std::mem::transmute(needs_reconcile)
                    };
                    needs_reconcile as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                5usize,
                3u8,
                {
                    let can_widen: u8 = unsafe { ::std::mem::transmute(can_widen) };
                    can_widen as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct bch_sb_field_extent_type_u64s {
    pub field: bch_sb_field,
    pub d: __IncompleteArrayField<u8_>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_sb_field_extent_type_u64s",
    ][::std::mem::size_of::<bch_sb_field_extent_type_u64s>() - 8usize];
    [
        "Alignment of bch_sb_field_extent_type_u64s",
    ][::std::mem::align_of::<bch_sb_field_extent_type_u64s>() - 8usize];
    [
        "Offset of field: bch_sb_field_extent_type_u64s::field",
    ][::std::mem::offset_of!(bch_sb_field_extent_type_u64s, field) - 0usize];
    [
        "Offset of field: bch_sb_field_extent_type_u64s::d",
    ][::std::mem::offset_of!(bch_sb_field_extent_type_u64s, d) - 8usize];
};
#[repr(C, packed(8))]
pub struct bch_reflink_p {
    pub v: bch_val,
    pub idx_flags: __le64,
    pub front_pad: __le32,
    pub back_pad: __le32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_reflink_p"][::std::mem::size_of::<bch_reflink_p>() - 16usize];
    ["Alignment of bch_reflink_p"][::std::mem::align_of::<bch_reflink_p>() - 8usize];
    [
        "Offset of field: bch_reflink_p::v",
    ][::std::mem::offset_of!(bch_reflink_p, v) - 0usize];
    [
        "Offset of field: bch_reflink_p::idx_flags",
    ][::std::mem::offset_of!(bch_reflink_p, idx_flags) - 0usize];
    [
        "Offset of field: bch_reflink_p::front_pad",
    ][::std::mem::offset_of!(bch_reflink_p, front_pad) - 8usize];
    [
        "Offset of field: bch_reflink_p::back_pad",
    ][::std::mem::offset_of!(bch_reflink_p, back_pad) - 12usize];
};
impl Default for bch_reflink_p {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C, packed(8))]
pub struct bch_reflink_v {
    pub v: bch_val,
    pub refcount: __le64,
    pub start: __IncompleteArrayField<bch_extent_entry>,
    pub _data: __IncompleteArrayField<__u64>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_reflink_v"][::std::mem::size_of::<bch_reflink_v>() - 8usize];
    ["Alignment of bch_reflink_v"][::std::mem::align_of::<bch_reflink_v>() - 8usize];
    [
        "Offset of field: bch_reflink_v::v",
    ][::std::mem::offset_of!(bch_reflink_v, v) - 0usize];
    [
        "Offset of field: bch_reflink_v::refcount",
    ][::std::mem::offset_of!(bch_reflink_v, refcount) - 0usize];
    [
        "Offset of field: bch_reflink_v::start",
    ][::std::mem::offset_of!(bch_reflink_v, start) - 8usize];
    [
        "Offset of field: bch_reflink_v::_data",
    ][::std::mem::offset_of!(bch_reflink_v, _data) - 8usize];
};
impl Default for bch_reflink_v {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct bch_indirect_inline_data {
    pub v: bch_val,
    pub refcount: __le64,
    pub data: __IncompleteArrayField<u8_>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_indirect_inline_data",
    ][::std::mem::size_of::<bch_indirect_inline_data>() - 8usize];
    [
        "Alignment of bch_indirect_inline_data",
    ][::std::mem::align_of::<bch_indirect_inline_data>() - 8usize];
    [
        "Offset of field: bch_indirect_inline_data::v",
    ][::std::mem::offset_of!(bch_indirect_inline_data, v) - 0usize];
    [
        "Offset of field: bch_indirect_inline_data::refcount",
    ][::std::mem::offset_of!(bch_indirect_inline_data, refcount) - 0usize];
    [
        "Offset of field: bch_indirect_inline_data::data",
    ][::std::mem::offset_of!(bch_indirect_inline_data, data) - 8usize];
};
#[repr(C, packed(8))]
pub struct bch_dirent {
    pub v: bch_val,
    pub __bindgen_anon_1: bch_dirent__bindgen_ty_1,
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
    pub __bindgen_anon_2: bch_dirent__bindgen_ty_2,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bch_dirent__bindgen_ty_1 {
    pub d_inum: __le64,
    pub __bindgen_anon_1: bch_dirent__bindgen_ty_1__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_dirent__bindgen_ty_1__bindgen_ty_1 {
    pub d_child_subvol: __le32,
    pub d_parent_subvol: __le32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_dirent__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bch_dirent__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Alignment of bch_dirent__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bch_dirent__bindgen_ty_1__bindgen_ty_1>() - 4usize];
    [
        "Offset of field: bch_dirent__bindgen_ty_1__bindgen_ty_1::d_child_subvol",
    ][::std::mem::offset_of!(bch_dirent__bindgen_ty_1__bindgen_ty_1, d_child_subvol)
        - 0usize];
    [
        "Offset of field: bch_dirent__bindgen_ty_1__bindgen_ty_1::d_parent_subvol",
    ][::std::mem::offset_of!(bch_dirent__bindgen_ty_1__bindgen_ty_1, d_parent_subvol)
        - 4usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_dirent__bindgen_ty_1",
    ][::std::mem::size_of::<bch_dirent__bindgen_ty_1>() - 8usize];
    [
        "Alignment of bch_dirent__bindgen_ty_1",
    ][::std::mem::align_of::<bch_dirent__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bch_dirent__bindgen_ty_1::d_inum",
    ][::std::mem::offset_of!(bch_dirent__bindgen_ty_1, d_inum) - 0usize];
};
impl Default for bch_dirent__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C, packed)]
pub struct bch_dirent__bindgen_ty_2 {
    pub d_cf_name_block: __BindgenUnionField<bch_dirent__bindgen_ty_2__bindgen_ty_1>,
    pub __bindgen_anon_1: __BindgenUnionField<bch_dirent__bindgen_ty_2__bindgen_ty_2>,
    pub bindgen_union_field: [u8; 6usize],
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct bch_dirent__bindgen_ty_2__bindgen_ty_1 {
    pub d_pad: __u8,
    pub d_name_len: __le16,
    pub d_cf_name_len: __le16,
    pub d_names: __IncompleteArrayField<__u8>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_dirent__bindgen_ty_2__bindgen_ty_1",
    ][::std::mem::size_of::<bch_dirent__bindgen_ty_2__bindgen_ty_1>() - 6usize];
    [
        "Alignment of bch_dirent__bindgen_ty_2__bindgen_ty_1",
    ][::std::mem::align_of::<bch_dirent__bindgen_ty_2__bindgen_ty_1>() - 2usize];
    [
        "Offset of field: bch_dirent__bindgen_ty_2__bindgen_ty_1::d_pad",
    ][::std::mem::offset_of!(bch_dirent__bindgen_ty_2__bindgen_ty_1, d_pad) - 0usize];
    [
        "Offset of field: bch_dirent__bindgen_ty_2__bindgen_ty_1::d_name_len",
    ][::std::mem::offset_of!(bch_dirent__bindgen_ty_2__bindgen_ty_1, d_name_len)
        - 2usize];
    [
        "Offset of field: bch_dirent__bindgen_ty_2__bindgen_ty_1::d_cf_name_len",
    ][::std::mem::offset_of!(bch_dirent__bindgen_ty_2__bindgen_ty_1, d_cf_name_len)
        - 4usize];
    [
        "Offset of field: bch_dirent__bindgen_ty_2__bindgen_ty_1::d_names",
    ][::std::mem::offset_of!(bch_dirent__bindgen_ty_2__bindgen_ty_1, d_names) - 6usize];
};
#[repr(C)]
#[derive(Debug, Default)]
pub struct bch_dirent__bindgen_ty_2__bindgen_ty_2 {
    pub __empty_d_name: bch_dirent__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1,
    pub d_name: __IncompleteArrayField<__u8>,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_dirent__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1 {}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_dirent__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1",
    ][::std::mem::size_of::<bch_dirent__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1>()
        - 0usize];
    [
        "Alignment of bch_dirent__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1",
    ][::std::mem::align_of::<bch_dirent__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1>()
        - 1usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_dirent__bindgen_ty_2__bindgen_ty_2",
    ][::std::mem::size_of::<bch_dirent__bindgen_ty_2__bindgen_ty_2>() - 0usize];
    [
        "Alignment of bch_dirent__bindgen_ty_2__bindgen_ty_2",
    ][::std::mem::align_of::<bch_dirent__bindgen_ty_2__bindgen_ty_2>() - 1usize];
    [
        "Offset of field: bch_dirent__bindgen_ty_2__bindgen_ty_2::__empty_d_name",
    ][::std::mem::offset_of!(bch_dirent__bindgen_ty_2__bindgen_ty_2, __empty_d_name)
        - 0usize];
    [
        "Offset of field: bch_dirent__bindgen_ty_2__bindgen_ty_2::d_name",
    ][::std::mem::offset_of!(bch_dirent__bindgen_ty_2__bindgen_ty_2, d_name) - 0usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_dirent__bindgen_ty_2",
    ][::std::mem::size_of::<bch_dirent__bindgen_ty_2>() - 6usize];
    [
        "Alignment of bch_dirent__bindgen_ty_2",
    ][::std::mem::align_of::<bch_dirent__bindgen_ty_2>() - 1usize];
    [
        "Offset of field: bch_dirent__bindgen_ty_2::d_cf_name_block",
    ][::std::mem::offset_of!(bch_dirent__bindgen_ty_2, d_cf_name_block) - 0usize];
};
impl Default for bch_dirent__bindgen_ty_2 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_dirent"][::std::mem::size_of::<bch_dirent>() - 16usize];
    ["Alignment of bch_dirent"][::std::mem::align_of::<bch_dirent>() - 8usize];
    ["Offset of field: bch_dirent::v"][::std::mem::offset_of!(bch_dirent, v) - 0usize];
};
impl Default for bch_dirent {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl bch_dirent {
    #[inline]
    pub fn d_type(&self) -> __u8 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 5u8) as u8) }
    }
    #[inline]
    pub fn set_d_type(&mut self, val: __u8) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 5u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn d_type_raw(this: *const Self) -> __u8 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 5u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_d_type_raw(this: *mut Self, val: __u8) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                5u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn d_unused(&self) -> __u8 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 2u8) as u8) }
    }
    #[inline]
    pub fn set_d_unused(&mut self, val: __u8) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(5usize, 2u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn d_unused_raw(this: *const Self) -> __u8 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 5usize, 2u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_d_unused_raw(this: *mut Self, val: __u8) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                5usize,
                2u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn d_casefold(&self) -> __u8 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_d_casefold(&mut self, val: __u8) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(7usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn d_casefold_raw(this: *const Self) -> __u8 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 7usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_d_casefold_raw(this: *mut Self, val: __u8) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                7usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        d_type: __u8,
        d_unused: __u8,
        d_casefold: __u8,
    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                5u8,
                {
                    let d_type: u8 = unsafe { ::std::mem::transmute(d_type) };
                    d_type as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                5usize,
                2u8,
                {
                    let d_unused: u8 = unsafe { ::std::mem::transmute(d_unused) };
                    d_unused as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                7usize,
                1u8,
                {
                    let d_casefold: u8 = unsafe { ::std::mem::transmute(d_casefold) };
                    d_casefold as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
#[repr(C, packed(8))]
pub struct bch_inode {
    pub v: bch_val,
    pub bi_hash_seed: __le64,
    pub bi_flags: __le32,
    pub bi_mode: __le16,
    pub fields: __IncompleteArrayField<__u8>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_inode"][::std::mem::size_of::<bch_inode>() - 16usize];
    ["Alignment of bch_inode"][::std::mem::align_of::<bch_inode>() - 8usize];
    ["Offset of field: bch_inode::v"][::std::mem::offset_of!(bch_inode, v) - 0usize];
    [
        "Offset of field: bch_inode::bi_hash_seed",
    ][::std::mem::offset_of!(bch_inode, bi_hash_seed) - 0usize];
    [
        "Offset of field: bch_inode::bi_flags",
    ][::std::mem::offset_of!(bch_inode, bi_flags) - 8usize];
    [
        "Offset of field: bch_inode::bi_mode",
    ][::std::mem::offset_of!(bch_inode, bi_mode) - 12usize];
    [
        "Offset of field: bch_inode::fields",
    ][::std::mem::offset_of!(bch_inode, fields) - 14usize];
};
impl Default for bch_inode {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C, packed(8))]
pub struct bch_inode_v2 {
    pub v: bch_val,
    pub bi_journal_seq: __le64,
    pub bi_hash_seed: __le64,
    pub bi_flags: __le64,
    pub bi_mode: __le16,
    pub fields: __IncompleteArrayField<__u8>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_inode_v2"][::std::mem::size_of::<bch_inode_v2>() - 32usize];
    ["Alignment of bch_inode_v2"][::std::mem::align_of::<bch_inode_v2>() - 8usize];
    [
        "Offset of field: bch_inode_v2::v",
    ][::std::mem::offset_of!(bch_inode_v2, v) - 0usize];
    [
        "Offset of field: bch_inode_v2::bi_journal_seq",
    ][::std::mem::offset_of!(bch_inode_v2, bi_journal_seq) - 0usize];
    [
        "Offset of field: bch_inode_v2::bi_hash_seed",
    ][::std::mem::offset_of!(bch_inode_v2, bi_hash_seed) - 8usize];
    [
        "Offset of field: bch_inode_v2::bi_flags",
    ][::std::mem::offset_of!(bch_inode_v2, bi_flags) - 16usize];
    [
        "Offset of field: bch_inode_v2::bi_mode",
    ][::std::mem::offset_of!(bch_inode_v2, bi_mode) - 24usize];
    [
        "Offset of field: bch_inode_v2::fields",
    ][::std::mem::offset_of!(bch_inode_v2, fields) - 26usize];
};
impl Default for bch_inode_v2 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C, packed(8))]
pub struct bch_inode_v3 {
    pub v: bch_val,
    pub bi_journal_seq: __le64,
    pub bi_hash_seed: __le64,
    pub bi_flags: __le64,
    pub bi_sectors: __le64,
    pub bi_size: __le64,
    pub bi_version: __le64,
    pub fields: __IncompleteArrayField<__u8>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_inode_v3"][::std::mem::size_of::<bch_inode_v3>() - 48usize];
    ["Alignment of bch_inode_v3"][::std::mem::align_of::<bch_inode_v3>() - 8usize];
    [
        "Offset of field: bch_inode_v3::v",
    ][::std::mem::offset_of!(bch_inode_v3, v) - 0usize];
    [
        "Offset of field: bch_inode_v3::bi_journal_seq",
    ][::std::mem::offset_of!(bch_inode_v3, bi_journal_seq) - 0usize];
    [
        "Offset of field: bch_inode_v3::bi_hash_seed",
    ][::std::mem::offset_of!(bch_inode_v3, bi_hash_seed) - 8usize];
    [
        "Offset of field: bch_inode_v3::bi_flags",
    ][::std::mem::offset_of!(bch_inode_v3, bi_flags) - 16usize];
    [
        "Offset of field: bch_inode_v3::bi_sectors",
    ][::std::mem::offset_of!(bch_inode_v3, bi_sectors) - 24usize];
    [
        "Offset of field: bch_inode_v3::bi_size",
    ][::std::mem::offset_of!(bch_inode_v3, bi_size) - 32usize];
    [
        "Offset of field: bch_inode_v3::bi_version",
    ][::std::mem::offset_of!(bch_inode_v3, bi_version) - 40usize];
    [
        "Offset of field: bch_inode_v3::fields",
    ][::std::mem::offset_of!(bch_inode_v3, fields) - 48usize];
};
impl Default for bch_inode_v3 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C, packed(8))]
pub struct bch_inode_generation {
    pub v: bch_val,
    pub bi_generation: __le32,
    pub pad: __le32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_inode_generation",
    ][::std::mem::size_of::<bch_inode_generation>() - 8usize];
    [
        "Alignment of bch_inode_generation",
    ][::std::mem::align_of::<bch_inode_generation>() - 8usize];
    [
        "Offset of field: bch_inode_generation::v",
    ][::std::mem::offset_of!(bch_inode_generation, v) - 0usize];
    [
        "Offset of field: bch_inode_generation::bi_generation",
    ][::std::mem::offset_of!(bch_inode_generation, bi_generation) - 0usize];
    [
        "Offset of field: bch_inode_generation::pad",
    ][::std::mem::offset_of!(bch_inode_generation, pad) - 4usize];
};
impl Default for bch_inode_generation {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum inode_opt_id {
    Inode_opt_data_checksum = 0,
    Inode_opt_compression = 1,
    Inode_opt_project = 2,
    Inode_opt_background_compression = 3,
    Inode_opt_data_replicas = 4,
    Inode_opt_promote_target = 5,
    Inode_opt_foreground_target = 6,
    Inode_opt_background_target = 7,
    Inode_opt_erasure_code = 8,
    Inode_opt_nocow = 9,
    Inode_opt_inodes_32bit = 10,
    Inode_opt_casefold = 11,
    Inode_opt_nr = 12,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_inode_flags {
    BCH_INODE_sync = 1,
    BCH_INODE_immutable = 2,
    BCH_INODE_append = 4,
    BCH_INODE_nodump = 8,
    BCH_INODE_noatime = 16,
    BCH_INODE_i_size_dirty = 32,
    BCH_INODE_i_sectors_dirty = 64,
    BCH_INODE_unlinked = 128,
    BCH_INODE_backptr_untrusted = 256,
    BCH_INODE_has_child_snapshot = 512,
    BCH_INODE_has_case_insensitive = 1024,
    BCH_INODE_31bit_dirent_offset = 2048,
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct bch_inode_alloc_cursor {
    pub v: bch_val,
    pub bits: __u8,
    pub pad: __u8,
    pub gen_: __le32,
    pub idx: __le64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_inode_alloc_cursor",
    ][::std::mem::size_of::<bch_inode_alloc_cursor>() - 16usize];
    [
        "Alignment of bch_inode_alloc_cursor",
    ][::std::mem::align_of::<bch_inode_alloc_cursor>() - 8usize];
    [
        "Offset of field: bch_inode_alloc_cursor::v",
    ][::std::mem::offset_of!(bch_inode_alloc_cursor, v) - 0usize];
    [
        "Offset of field: bch_inode_alloc_cursor::bits",
    ][::std::mem::offset_of!(bch_inode_alloc_cursor, bits) - 0usize];
    [
        "Offset of field: bch_inode_alloc_cursor::pad",
    ][::std::mem::offset_of!(bch_inode_alloc_cursor, pad) - 1usize];
    [
        "Offset of field: bch_inode_alloc_cursor::gen_",
    ][::std::mem::offset_of!(bch_inode_alloc_cursor, gen_) - 4usize];
    [
        "Offset of field: bch_inode_alloc_cursor::idx",
    ][::std::mem::offset_of!(bch_inode_alloc_cursor, idx) - 8usize];
};
#[repr(C)]
#[derive(Debug, Default)]
pub struct bch_logged_op_truncate {
    pub v: bch_val,
    pub subvol: __le32,
    pub pad: __le32,
    pub inum: __le64,
    pub new_i_size: __le64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_logged_op_truncate",
    ][::std::mem::size_of::<bch_logged_op_truncate>() - 24usize];
    [
        "Alignment of bch_logged_op_truncate",
    ][::std::mem::align_of::<bch_logged_op_truncate>() - 8usize];
    [
        "Offset of field: bch_logged_op_truncate::v",
    ][::std::mem::offset_of!(bch_logged_op_truncate, v) - 0usize];
    [
        "Offset of field: bch_logged_op_truncate::subvol",
    ][::std::mem::offset_of!(bch_logged_op_truncate, subvol) - 0usize];
    [
        "Offset of field: bch_logged_op_truncate::pad",
    ][::std::mem::offset_of!(bch_logged_op_truncate, pad) - 4usize];
    [
        "Offset of field: bch_logged_op_truncate::inum",
    ][::std::mem::offset_of!(bch_logged_op_truncate, inum) - 8usize];
    [
        "Offset of field: bch_logged_op_truncate::new_i_size",
    ][::std::mem::offset_of!(bch_logged_op_truncate, new_i_size) - 16usize];
};
#[repr(C)]
#[derive(Debug, Default)]
pub struct bch_logged_op_finsert {
    pub v: bch_val,
    pub state: __u8,
    pub pad: [__u8; 3usize],
    pub subvol: __le32,
    pub inum: __le64,
    pub dst_offset: __le64,
    pub src_offset: __le64,
    pub pos: __le64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_logged_op_finsert",
    ][::std::mem::size_of::<bch_logged_op_finsert>() - 40usize];
    [
        "Alignment of bch_logged_op_finsert",
    ][::std::mem::align_of::<bch_logged_op_finsert>() - 8usize];
    [
        "Offset of field: bch_logged_op_finsert::v",
    ][::std::mem::offset_of!(bch_logged_op_finsert, v) - 0usize];
    [
        "Offset of field: bch_logged_op_finsert::state",
    ][::std::mem::offset_of!(bch_logged_op_finsert, state) - 0usize];
    [
        "Offset of field: bch_logged_op_finsert::pad",
    ][::std::mem::offset_of!(bch_logged_op_finsert, pad) - 1usize];
    [
        "Offset of field: bch_logged_op_finsert::subvol",
    ][::std::mem::offset_of!(bch_logged_op_finsert, subvol) - 4usize];
    [
        "Offset of field: bch_logged_op_finsert::inum",
    ][::std::mem::offset_of!(bch_logged_op_finsert, inum) - 8usize];
    [
        "Offset of field: bch_logged_op_finsert::dst_offset",
    ][::std::mem::offset_of!(bch_logged_op_finsert, dst_offset) - 16usize];
    [
        "Offset of field: bch_logged_op_finsert::src_offset",
    ][::std::mem::offset_of!(bch_logged_op_finsert, src_offset) - 24usize];
    [
        "Offset of field: bch_logged_op_finsert::pos",
    ][::std::mem::offset_of!(bch_logged_op_finsert, pos) - 32usize];
};
#[repr(C)]
#[derive(Debug, Default)]
pub struct bch_logged_op_stripe_update {
    pub v: bch_val,
    pub old_idx: __le64,
    pub new_idx: __le64,
    pub old_blocks_nr: __u8,
    pub old_block_map: [__u8; 16usize],
    pub pad: [__u8; 7usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_logged_op_stripe_update",
    ][::std::mem::size_of::<bch_logged_op_stripe_update>() - 40usize];
    [
        "Alignment of bch_logged_op_stripe_update",
    ][::std::mem::align_of::<bch_logged_op_stripe_update>() - 8usize];
    [
        "Offset of field: bch_logged_op_stripe_update::v",
    ][::std::mem::offset_of!(bch_logged_op_stripe_update, v) - 0usize];
    [
        "Offset of field: bch_logged_op_stripe_update::old_idx",
    ][::std::mem::offset_of!(bch_logged_op_stripe_update, old_idx) - 0usize];
    [
        "Offset of field: bch_logged_op_stripe_update::new_idx",
    ][::std::mem::offset_of!(bch_logged_op_stripe_update, new_idx) - 8usize];
    [
        "Offset of field: bch_logged_op_stripe_update::old_blocks_nr",
    ][::std::mem::offset_of!(bch_logged_op_stripe_update, old_blocks_nr) - 16usize];
    [
        "Offset of field: bch_logged_op_stripe_update::old_block_map",
    ][::std::mem::offset_of!(bch_logged_op_stripe_update, old_block_map) - 17usize];
    [
        "Offset of field: bch_logged_op_stripe_update::pad",
    ][::std::mem::offset_of!(bch_logged_op_stripe_update, pad) - 33usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_quota_counter {
    pub hardlimit: __le64,
    pub softlimit: __le64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_quota_counter"][::std::mem::size_of::<bch_quota_counter>() - 16usize];
    [
        "Alignment of bch_quota_counter",
    ][::std::mem::align_of::<bch_quota_counter>() - 8usize];
    [
        "Offset of field: bch_quota_counter::hardlimit",
    ][::std::mem::offset_of!(bch_quota_counter, hardlimit) - 0usize];
    [
        "Offset of field: bch_quota_counter::softlimit",
    ][::std::mem::offset_of!(bch_quota_counter, softlimit) - 8usize];
};
#[repr(C, packed(8))]
pub struct bch_quota {
    pub v: bch_val,
    pub c: [bch_quota_counter; 2usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_quota"][::std::mem::size_of::<bch_quota>() - 32usize];
    ["Alignment of bch_quota"][::std::mem::align_of::<bch_quota>() - 8usize];
    ["Offset of field: bch_quota::v"][::std::mem::offset_of!(bch_quota, v) - 0usize];
    ["Offset of field: bch_quota::c"][::std::mem::offset_of!(bch_quota, c) - 0usize];
};
impl Default for bch_quota {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_sb_quota_counter {
    pub timelimit: __le32,
    pub warnlimit: __le32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_sb_quota_counter",
    ][::std::mem::size_of::<bch_sb_quota_counter>() - 8usize];
    [
        "Alignment of bch_sb_quota_counter",
    ][::std::mem::align_of::<bch_sb_quota_counter>() - 4usize];
    [
        "Offset of field: bch_sb_quota_counter::timelimit",
    ][::std::mem::offset_of!(bch_sb_quota_counter, timelimit) - 0usize];
    [
        "Offset of field: bch_sb_quota_counter::warnlimit",
    ][::std::mem::offset_of!(bch_sb_quota_counter, warnlimit) - 4usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_sb_quota_type {
    pub flags: __le64,
    pub c: [bch_sb_quota_counter; 2usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_sb_quota_type"][::std::mem::size_of::<bch_sb_quota_type>() - 24usize];
    [
        "Alignment of bch_sb_quota_type",
    ][::std::mem::align_of::<bch_sb_quota_type>() - 8usize];
    [
        "Offset of field: bch_sb_quota_type::flags",
    ][::std::mem::offset_of!(bch_sb_quota_type, flags) - 0usize];
    [
        "Offset of field: bch_sb_quota_type::c",
    ][::std::mem::offset_of!(bch_sb_quota_type, c) - 8usize];
};
#[repr(C, packed(8))]
pub struct bch_sb_field_quota {
    pub field: bch_sb_field,
    pub q: [bch_sb_quota_type; 3usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_sb_field_quota",
    ][::std::mem::size_of::<bch_sb_field_quota>() - 80usize];
    [
        "Alignment of bch_sb_field_quota",
    ][::std::mem::align_of::<bch_sb_field_quota>() - 8usize];
    [
        "Offset of field: bch_sb_field_quota::field",
    ][::std::mem::offset_of!(bch_sb_field_quota, field) - 0usize];
    [
        "Offset of field: bch_sb_field_quota::q",
    ][::std::mem::offset_of!(bch_sb_field_quota, q) - 8usize];
};
impl Default for bch_sb_field_quota {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C, packed(8))]
pub struct bch_xattr {
    pub v: bch_val,
    pub x_type: __u8,
    pub x_name_len: __u8,
    pub x_val_len: __le16,
    pub x_name_and_value: __IncompleteArrayField<__u8>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_xattr"][::std::mem::size_of::<bch_xattr>() - 8usize];
    ["Alignment of bch_xattr"][::std::mem::align_of::<bch_xattr>() - 8usize];
    ["Offset of field: bch_xattr::v"][::std::mem::offset_of!(bch_xattr, v) - 0usize];
    [
        "Offset of field: bch_xattr::x_type",
    ][::std::mem::offset_of!(bch_xattr, x_type) - 0usize];
    [
        "Offset of field: bch_xattr::x_name_len",
    ][::std::mem::offset_of!(bch_xattr, x_name_len) - 1usize];
    [
        "Offset of field: bch_xattr::x_val_len",
    ][::std::mem::offset_of!(bch_xattr, x_val_len) - 2usize];
    [
        "Offset of field: bch_xattr::x_name_and_value",
    ][::std::mem::offset_of!(bch_xattr, x_name_and_value) - 4usize];
};
impl Default for bch_xattr {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_recovery_pass {
    BCH_RECOVERY_PASS_recovery_pass_empty = 0,
    BCH_RECOVERY_PASS_scan_for_btree_nodes = 1,
    BCH_RECOVERY_PASS_check_topology = 2,
    BCH_RECOVERY_PASS_accounting_read = 3,
    BCH_RECOVERY_PASS_alloc_read = 4,
    BCH_RECOVERY_PASS_stripes_read = 5,
    BCH_RECOVERY_PASS_initialize_subvolumes = 6,
    BCH_RECOVERY_PASS_snapshots_read = 7,
    BCH_RECOVERY_PASS_check_allocations = 8,
    BCH_RECOVERY_PASS_trans_mark_dev_sbs = 9,
    BCH_RECOVERY_PASS_fs_journal_alloc = 10,
    BCH_RECOVERY_PASS_set_may_go_rw = 11,
    BCH_RECOVERY_PASS_journal_replay = 12,
    BCH_RECOVERY_PASS_merge_btree_nodes = 13,
    BCH_RECOVERY_PASS_check_alloc_info = 14,
    BCH_RECOVERY_PASS_check_lrus = 15,
    BCH_RECOVERY_PASS_check_btree_backpointers = 16,
    BCH_RECOVERY_PASS_check_backpointers_to_extents = 17,
    BCH_RECOVERY_PASS_check_extents_to_backpointers = 18,
    BCH_RECOVERY_PASS_check_alloc_to_lru_refs = 19,
    BCH_RECOVERY_PASS_fs_freespace_init = 20,
    BCH_RECOVERY_PASS_bucket_gens_init = 21,
    BCH_RECOVERY_PASS_reconstruct_snapshots = 22,
    BCH_RECOVERY_PASS_delete_dead_interior_snapshots = 23,
    BCH_RECOVERY_PASS_check_snapshot_trees = 24,
    BCH_RECOVERY_PASS_check_snapshots = 25,
    BCH_RECOVERY_PASS_check_subvols = 26,
    BCH_RECOVERY_PASS_check_subvol_children = 27,
    BCH_RECOVERY_PASS_delete_dead_snapshots = 28,
    BCH_RECOVERY_PASS_fs_upgrade_for_subvolumes = 29,
    BCH_RECOVERY_PASS_check_inodes = 30,
    BCH_RECOVERY_PASS_check_extents = 31,
    BCH_RECOVERY_PASS_check_indirect_extents = 32,
    BCH_RECOVERY_PASS_check_dirents = 33,
    BCH_RECOVERY_PASS_check_xattrs = 34,
    BCH_RECOVERY_PASS_check_root = 35,
    BCH_RECOVERY_PASS_check_unreachable_inodes = 36,
    BCH_RECOVERY_PASS_check_subvolume_structure = 37,
    BCH_RECOVERY_PASS_check_directory_structure = 38,
    BCH_RECOVERY_PASS_check_nlinks = 39,
    BCH_RECOVERY_PASS_check_reconcile_work = 40,
    BCH_RECOVERY_PASS_resume_logged_ops = 41,
    BCH_RECOVERY_PASS_delete_dead_inodes = 42,
    BCH_RECOVERY_PASS_kill_i_generation_keys = 43,
    BCH_RECOVERY_PASS_fix_reflink_p = 44,
    BCH_RECOVERY_PASS_set_fs_needs_reconcile = 45,
    BCH_RECOVERY_PASS_btree_bitmap_gc = 46,
    BCH_RECOVERY_PASS_lookup_root_inode = 47,
    BCH_RECOVERY_PASS_NR = 48,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_recovery_pass_stable {
    BCH_RECOVERY_PASS_STABLE_recovery_pass_empty = 41,
    BCH_RECOVERY_PASS_STABLE_scan_for_btree_nodes = 37,
    BCH_RECOVERY_PASS_STABLE_check_topology = 4,
    BCH_RECOVERY_PASS_STABLE_accounting_read = 39,
    BCH_RECOVERY_PASS_STABLE_alloc_read = 0,
    BCH_RECOVERY_PASS_STABLE_stripes_read = 1,
    BCH_RECOVERY_PASS_STABLE_initialize_subvolumes = 2,
    BCH_RECOVERY_PASS_STABLE_snapshots_read = 3,
    BCH_RECOVERY_PASS_STABLE_check_allocations = 5,
    BCH_RECOVERY_PASS_STABLE_trans_mark_dev_sbs = 6,
    BCH_RECOVERY_PASS_STABLE_fs_journal_alloc = 7,
    BCH_RECOVERY_PASS_STABLE_set_may_go_rw = 8,
    BCH_RECOVERY_PASS_STABLE_journal_replay = 9,
    BCH_RECOVERY_PASS_STABLE_merge_btree_nodes = 45,
    BCH_RECOVERY_PASS_STABLE_check_alloc_info = 10,
    BCH_RECOVERY_PASS_STABLE_check_lrus = 11,
    BCH_RECOVERY_PASS_STABLE_check_btree_backpointers = 12,
    BCH_RECOVERY_PASS_STABLE_check_backpointers_to_extents = 13,
    BCH_RECOVERY_PASS_STABLE_check_extents_to_backpointers = 14,
    BCH_RECOVERY_PASS_STABLE_check_alloc_to_lru_refs = 15,
    BCH_RECOVERY_PASS_STABLE_fs_freespace_init = 16,
    BCH_RECOVERY_PASS_STABLE_bucket_gens_init = 17,
    BCH_RECOVERY_PASS_STABLE_reconstruct_snapshots = 38,
    BCH_RECOVERY_PASS_STABLE_delete_dead_interior_snapshots = 44,
    BCH_RECOVERY_PASS_STABLE_check_snapshot_trees = 18,
    BCH_RECOVERY_PASS_STABLE_check_snapshots = 19,
    BCH_RECOVERY_PASS_STABLE_check_subvols = 20,
    BCH_RECOVERY_PASS_STABLE_check_subvol_children = 35,
    BCH_RECOVERY_PASS_STABLE_delete_dead_snapshots = 21,
    BCH_RECOVERY_PASS_STABLE_fs_upgrade_for_subvolumes = 22,
    BCH_RECOVERY_PASS_STABLE_check_inodes = 24,
    BCH_RECOVERY_PASS_STABLE_check_extents = 25,
    BCH_RECOVERY_PASS_STABLE_check_indirect_extents = 26,
    BCH_RECOVERY_PASS_STABLE_check_dirents = 27,
    BCH_RECOVERY_PASS_STABLE_check_xattrs = 28,
    BCH_RECOVERY_PASS_STABLE_check_root = 29,
    BCH_RECOVERY_PASS_STABLE_check_unreachable_inodes = 40,
    BCH_RECOVERY_PASS_STABLE_check_subvolume_structure = 36,
    BCH_RECOVERY_PASS_STABLE_check_directory_structure = 30,
    BCH_RECOVERY_PASS_STABLE_check_nlinks = 31,
    BCH_RECOVERY_PASS_STABLE_check_reconcile_work = 43,
    BCH_RECOVERY_PASS_STABLE_resume_logged_ops = 23,
    BCH_RECOVERY_PASS_STABLE_delete_dead_inodes = 32,
    BCH_RECOVERY_PASS_STABLE_kill_i_generation_keys = 47,
    BCH_RECOVERY_PASS_STABLE_fix_reflink_p = 33,
    BCH_RECOVERY_PASS_STABLE_set_fs_needs_reconcile = 34,
    BCH_RECOVERY_PASS_STABLE_btree_bitmap_gc = 46,
    BCH_RECOVERY_PASS_STABLE_lookup_root_inode = 42,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct recovery_pass_entry {
    pub last_run: __le64,
    pub last_runtime: __le32,
    pub flags: __le32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of recovery_pass_entry",
    ][::std::mem::size_of::<recovery_pass_entry>() - 16usize];
    [
        "Alignment of recovery_pass_entry",
    ][::std::mem::align_of::<recovery_pass_entry>() - 8usize];
    [
        "Offset of field: recovery_pass_entry::last_run",
    ][::std::mem::offset_of!(recovery_pass_entry, last_run) - 0usize];
    [
        "Offset of field: recovery_pass_entry::last_runtime",
    ][::std::mem::offset_of!(recovery_pass_entry, last_runtime) - 8usize];
    [
        "Offset of field: recovery_pass_entry::flags",
    ][::std::mem::offset_of!(recovery_pass_entry, flags) - 12usize];
};
pub const BCH_RECOVERY_PASS_NO_RATELIMIT_OFFSET: ::std::os::raw::c_uint = 0;
pub const BCH_RECOVERY_PASS_NO_RATELIMIT_BITS: ::std::os::raw::c_uint = 1;
pub const BCH_RECOVERY_PASS_NO_RATELIMIT_MAX: __u32 = 1;
#[repr(C)]
#[derive(Debug, Default)]
pub struct bch_sb_field_recovery_passes {
    pub field: bch_sb_field,
    pub start: __IncompleteArrayField<recovery_pass_entry>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_sb_field_recovery_passes",
    ][::std::mem::size_of::<bch_sb_field_recovery_passes>() - 8usize];
    [
        "Alignment of bch_sb_field_recovery_passes",
    ][::std::mem::align_of::<bch_sb_field_recovery_passes>() - 8usize];
    [
        "Offset of field: bch_sb_field_recovery_passes::field",
    ][::std::mem::offset_of!(bch_sb_field_recovery_passes, field) - 0usize];
    [
        "Offset of field: bch_sb_field_recovery_passes::start",
    ][::std::mem::offset_of!(bch_sb_field_recovery_passes, start) - 8usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct journal_seq_blacklist_entry {
    pub start: __le64,
    pub end: __le64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of journal_seq_blacklist_entry",
    ][::std::mem::size_of::<journal_seq_blacklist_entry>() - 16usize];
    [
        "Alignment of journal_seq_blacklist_entry",
    ][::std::mem::align_of::<journal_seq_blacklist_entry>() - 8usize];
    [
        "Offset of field: journal_seq_blacklist_entry::start",
    ][::std::mem::offset_of!(journal_seq_blacklist_entry, start) - 0usize];
    [
        "Offset of field: journal_seq_blacklist_entry::end",
    ][::std::mem::offset_of!(journal_seq_blacklist_entry, end) - 8usize];
};
#[repr(C)]
#[derive(Debug, Default)]
pub struct bch_sb_field_journal_seq_blacklist {
    pub field: bch_sb_field,
    pub start: __IncompleteArrayField<journal_seq_blacklist_entry>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_sb_field_journal_seq_blacklist",
    ][::std::mem::size_of::<bch_sb_field_journal_seq_blacklist>() - 8usize];
    [
        "Alignment of bch_sb_field_journal_seq_blacklist",
    ][::std::mem::align_of::<bch_sb_field_journal_seq_blacklist>() - 8usize];
    [
        "Offset of field: bch_sb_field_journal_seq_blacklist::field",
    ][::std::mem::offset_of!(bch_sb_field_journal_seq_blacklist, field) - 0usize];
    [
        "Offset of field: bch_sb_field_journal_seq_blacklist::start",
    ][::std::mem::offset_of!(bch_sb_field_journal_seq_blacklist, start) - 8usize];
};
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_counters_flags {
    TYPE_COUNTER = 1,
    TYPE_SECTORS = 2,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_persistent_counters {
    BCH_COUNTER_sync_fs = 0,
    BCH_COUNTER_fsync = 1,
    BCH_COUNTER_data_read = 2,
    BCH_COUNTER_data_read_inline = 3,
    BCH_COUNTER_data_read_hole = 4,
    BCH_COUNTER_data_read_promote = 5,
    BCH_COUNTER_data_read_nopromote = 6,
    BCH_COUNTER_data_read_nopromote_may_not = 7,
    BCH_COUNTER_data_read_nopromote_already_promoted = 8,
    BCH_COUNTER_data_read_nopromote_unwritten = 9,
    BCH_COUNTER_data_read_nopromote_congested = 10,
    BCH_COUNTER_data_read_bounce = 11,
    BCH_COUNTER_data_read_split = 12,
    BCH_COUNTER_data_read_reuse_race = 13,
    BCH_COUNTER_data_read_retry = 14,
    BCH_COUNTER_data_read_fail_and_poison = 15,
    BCH_COUNTER_data_read_narrow_crcs = 16,
    BCH_COUNTER_data_read_narrow_crcs_fail = 17,
    BCH_COUNTER_data_write = 18,
    BCH_COUNTER_data_update_pred = 19,
    BCH_COUNTER_data_update = 20,
    BCH_COUNTER_data_update_no_io = 21,
    BCH_COUNTER_data_update_in_flight = 22,
    BCH_COUNTER_data_update_fail = 23,
    BCH_COUNTER_data_update_read = 24,
    BCH_COUNTER_data_update_write = 25,
    BCH_COUNTER_data_update_key = 26,
    BCH_COUNTER_data_update_key_fail = 27,
    BCH_COUNTER_data_update_useless_write_fail = 28,
    BCH_COUNTER_data_update_start_fail_obsolete = 29,
    BCH_COUNTER_data_update_noop_obsolete = 30,
    BCH_COUNTER_reconcile_scan_fs = 31,
    BCH_COUNTER_reconcile_scan_metadata = 32,
    BCH_COUNTER_reconcile_scan_pending = 33,
    BCH_COUNTER_reconcile_scan_stripes = 34,
    BCH_COUNTER_reconcile_scan_device = 35,
    BCH_COUNTER_reconcile_scan_inum = 36,
    BCH_COUNTER_reconcile_clear_scan = 37,
    BCH_COUNTER_reconcile_btree = 38,
    BCH_COUNTER_reconcile_data = 39,
    BCH_COUNTER_reconcile_phys = 40,
    BCH_COUNTER_reconcile_stripe = 41,
    BCH_COUNTER_reconcile_set_pending = 42,
    BCH_COUNTER_evacuate_bucket = 43,
    BCH_COUNTER_stripe_alloc = 44,
    BCH_COUNTER_stripe_create = 45,
    BCH_COUNTER_stripe_reuse = 46,
    BCH_COUNTER_stripe_create_fail = 47,
    BCH_COUNTER_stripe_delete = 48,
    BCH_COUNTER_stripe_update_bucket = 49,
    BCH_COUNTER_stripe_update_extent = 50,
    BCH_COUNTER_stripe_update_extent_fail = 51,
    BCH_COUNTER_stripe_repair_race = 52,
    BCH_COUNTER_copygc = 53,
    BCH_COUNTER_copygc_wait_obsolete = 54,
    BCH_COUNTER_cached_ptr_drop = 55,
    BCH_COUNTER_bucket_invalidate = 56,
    BCH_COUNTER_bucket_discard_worker = 57,
    BCH_COUNTER_bucket_discard_fast_worker = 58,
    BCH_COUNTER_bucket_discard = 59,
    BCH_COUNTER_bucket_discard_fast = 60,
    BCH_COUNTER_bucket_alloc = 61,
    BCH_COUNTER_bucket_alloc_fail = 62,
    BCH_COUNTER_open_bucket_alloc_fail = 63,
    BCH_COUNTER_bucket_alloc_from_stripe = 64,
    BCH_COUNTER_sectors_alloc = 65,
    BCH_COUNTER_bkey_pack_pos_fail = 66,
    BCH_COUNTER_btree_cache_scan = 67,
    BCH_COUNTER_btree_cache_reap = 68,
    BCH_COUNTER_btree_cache_cannibalize = 69,
    BCH_COUNTER_btree_cache_cannibalize_lock = 70,
    BCH_COUNTER_btree_cache_cannibalize_lock_fail = 71,
    BCH_COUNTER_btree_cache_cannibalize_unlock = 72,
    BCH_COUNTER_btree_node_write = 73,
    BCH_COUNTER_btree_node_read = 74,
    BCH_COUNTER_btree_node_compact = 75,
    BCH_COUNTER_btree_node_merge = 76,
    BCH_COUNTER_btree_node_merge_attempt = 77,
    BCH_COUNTER_btree_node_split = 78,
    BCH_COUNTER_btree_node_rewrite = 79,
    BCH_COUNTER_btree_node_alloc = 80,
    BCH_COUNTER_btree_node_free = 81,
    BCH_COUNTER_btree_node_set_root = 82,
    BCH_COUNTER_btree_key_cache_fill = 83,
    BCH_COUNTER_btree_path_relock_fail = 84,
    BCH_COUNTER_btree_path_upgrade_fail = 85,
    BCH_COUNTER_btree_reserve_get_fail = 86,
    BCH_COUNTER_journal_res_get_blocked = 87,
    BCH_COUNTER_journal_full = 88,
    BCH_COUNTER_journal_reclaim_finish = 89,
    BCH_COUNTER_journal_reclaim_start = 90,
    BCH_COUNTER_journal_write = 91,
    BCH_COUNTER_gc_gens_end = 92,
    BCH_COUNTER_gc_gens_start = 93,
    BCH_COUNTER_trans_blocked_journal_reclaim = 94,
    BCH_COUNTER_trans_restart_btree_node_reused = 95,
    BCH_COUNTER_trans_restart_btree_node_split = 96,
    BCH_COUNTER_trans_restart_fault_inject = 97,
    BCH_COUNTER_trans_restart_iter_upgrade = 98,
    BCH_COUNTER_trans_restart_journal_preres_get = 99,
    BCH_COUNTER_trans_restart_journal_reclaim = 100,
    BCH_COUNTER_trans_restart_journal_res_get = 101,
    BCH_COUNTER_trans_restart_key_cache_key_realloced = 102,
    BCH_COUNTER_trans_restart_key_cache_raced = 103,
    BCH_COUNTER_trans_restart_mark_replicas = 104,
    BCH_COUNTER_trans_restart_mem_realloced = 105,
    BCH_COUNTER_trans_restart_memory_allocation_failure = 106,
    BCH_COUNTER_trans_restart_relock = 107,
    BCH_COUNTER_trans_restart_relock_after_fill = 108,
    BCH_COUNTER_trans_restart_relock_key_cache_fill_obsolete = 109,
    BCH_COUNTER_trans_restart_relock_next_node = 110,
    BCH_COUNTER_trans_restart_relock_parent_for_fill_obsolete = 111,
    BCH_COUNTER_trans_restart_relock_path = 112,
    BCH_COUNTER_trans_restart_relock_path_intent = 113,
    BCH_COUNTER_trans_restart_too_many_iters = 114,
    BCH_COUNTER_trans_restart_traverse = 115,
    BCH_COUNTER_trans_restart_upgrade = 116,
    BCH_COUNTER_trans_restart_would_deadlock = 117,
    BCH_COUNTER_trans_restart_would_deadlock_write = 118,
    BCH_COUNTER_trans_restart_injected = 119,
    BCH_COUNTER_trans_restart_key_cache_upgrade = 120,
    BCH_COUNTER_trans_traverse_all = 121,
    BCH_COUNTER_transaction_commit = 122,
    BCH_COUNTER_write_super = 123,
    BCH_COUNTER_trans_restart_would_deadlock_recursion_limit = 124,
    BCH_COUNTER_trans_restart_deadlock_waitlist_alloc = 125,
    BCH_COUNTER_trans_restart_write_buffer_flush = 126,
    BCH_COUNTER_trans_restart_split_race = 127,
    BCH_COUNTER_write_buffer_flush = 128,
    BCH_COUNTER_write_buffer_flush_slowpath = 129,
    BCH_COUNTER_write_buffer_flush_sync = 130,
    BCH_COUNTER_write_buffer_maybe_flush = 131,
    BCH_COUNTER_accounting_key_to_wb_slowpath = 132,
    BCH_COUNTER_error_throw = 133,
    BCH_COUNTER_NR = 134,
}
unsafe extern "C" {
    pub static bch2_counter_flags: [bch_counters_flags; 134usize];
}
impl bch_persistent_counters_stable {
    pub const BCH_COUNTER_STABLE_NR: bch_persistent_counters_stable = bch_persistent_counters_stable::BCH_COUNTER_STABLE_accounting_key_to_wb_slowpath;
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_persistent_counters_stable {
    BCH_COUNTER_STABLE_sync_fs = 110,
    BCH_COUNTER_STABLE_fsync = 111,
    BCH_COUNTER_STABLE_data_read = 0,
    BCH_COUNTER_STABLE_data_read_inline = 80,
    BCH_COUNTER_STABLE_data_read_hole = 81,
    BCH_COUNTER_STABLE_data_read_promote = 30,
    BCH_COUNTER_STABLE_data_read_nopromote = 85,
    BCH_COUNTER_STABLE_data_read_nopromote_may_not = 86,
    BCH_COUNTER_STABLE_data_read_nopromote_already_promoted = 87,
    BCH_COUNTER_STABLE_data_read_nopromote_unwritten = 88,
    BCH_COUNTER_STABLE_data_read_nopromote_congested = 89,
    BCH_COUNTER_STABLE_data_read_bounce = 31,
    BCH_COUNTER_STABLE_data_read_split = 33,
    BCH_COUNTER_STABLE_data_read_reuse_race = 34,
    BCH_COUNTER_STABLE_data_read_retry = 32,
    BCH_COUNTER_STABLE_data_read_fail_and_poison = 95,
    BCH_COUNTER_STABLE_data_read_narrow_crcs = 97,
    BCH_COUNTER_STABLE_data_read_narrow_crcs_fail = 98,
    BCH_COUNTER_STABLE_data_write = 1,
    BCH_COUNTER_STABLE_data_update_pred = 96,
    BCH_COUNTER_STABLE_data_update = 2,
    BCH_COUNTER_STABLE_data_update_no_io = 91,
    BCH_COUNTER_STABLE_data_update_in_flight = 90,
    BCH_COUNTER_STABLE_data_update_fail = 82,
    BCH_COUNTER_STABLE_data_update_read = 35,
    BCH_COUNTER_STABLE_data_update_write = 36,
    BCH_COUNTER_STABLE_data_update_key = 37,
    BCH_COUNTER_STABLE_data_update_key_fail = 38,
    BCH_COUNTER_STABLE_data_update_useless_write_fail = 128,
    BCH_COUNTER_STABLE_data_update_start_fail_obsolete = 39,
    BCH_COUNTER_STABLE_data_update_noop_obsolete = 92,
    BCH_COUNTER_STABLE_reconcile_scan_fs = 113,
    BCH_COUNTER_STABLE_reconcile_scan_metadata = 114,
    BCH_COUNTER_STABLE_reconcile_scan_pending = 115,
    BCH_COUNTER_STABLE_reconcile_scan_stripes = 133,
    BCH_COUNTER_STABLE_reconcile_scan_device = 116,
    BCH_COUNTER_STABLE_reconcile_scan_inum = 117,
    BCH_COUNTER_STABLE_reconcile_clear_scan = 129,
    BCH_COUNTER_STABLE_reconcile_btree = 118,
    BCH_COUNTER_STABLE_reconcile_data = 119,
    BCH_COUNTER_STABLE_reconcile_phys = 120,
    BCH_COUNTER_STABLE_reconcile_stripe = 130,
    BCH_COUNTER_STABLE_reconcile_set_pending = 83,
    BCH_COUNTER_STABLE_evacuate_bucket = 84,
    BCH_COUNTER_STABLE_stripe_alloc = 125,
    BCH_COUNTER_STABLE_stripe_create = 102,
    BCH_COUNTER_STABLE_stripe_reuse = 123,
    BCH_COUNTER_STABLE_stripe_create_fail = 103,
    BCH_COUNTER_STABLE_stripe_delete = 124,
    BCH_COUNTER_STABLE_stripe_update_bucket = 104,
    BCH_COUNTER_STABLE_stripe_update_extent = 99,
    BCH_COUNTER_STABLE_stripe_update_extent_fail = 100,
    BCH_COUNTER_STABLE_stripe_repair_race = 131,
    BCH_COUNTER_STABLE_copygc = 40,
    BCH_COUNTER_STABLE_copygc_wait_obsolete = 41,
    BCH_COUNTER_STABLE_cached_ptr_drop = 121,
    BCH_COUNTER_STABLE_bucket_invalidate = 3,
    BCH_COUNTER_STABLE_bucket_discard_worker = 108,
    BCH_COUNTER_STABLE_bucket_discard_fast_worker = 109,
    BCH_COUNTER_STABLE_bucket_discard = 4,
    BCH_COUNTER_STABLE_bucket_discard_fast = 79,
    BCH_COUNTER_STABLE_bucket_alloc = 5,
    BCH_COUNTER_STABLE_bucket_alloc_fail = 6,
    BCH_COUNTER_STABLE_open_bucket_alloc_fail = 122,
    BCH_COUNTER_STABLE_bucket_alloc_from_stripe = 127,
    BCH_COUNTER_STABLE_sectors_alloc = 126,
    BCH_COUNTER_STABLE_bkey_pack_pos_fail = 112,
    BCH_COUNTER_STABLE_btree_cache_scan = 7,
    BCH_COUNTER_STABLE_btree_cache_reap = 8,
    BCH_COUNTER_STABLE_btree_cache_cannibalize = 9,
    BCH_COUNTER_STABLE_btree_cache_cannibalize_lock = 10,
    BCH_COUNTER_STABLE_btree_cache_cannibalize_lock_fail = 11,
    BCH_COUNTER_STABLE_btree_cache_cannibalize_unlock = 12,
    BCH_COUNTER_STABLE_btree_node_write = 13,
    BCH_COUNTER_STABLE_btree_node_read = 14,
    BCH_COUNTER_STABLE_btree_node_compact = 15,
    BCH_COUNTER_STABLE_btree_node_merge = 16,
    BCH_COUNTER_STABLE_btree_node_merge_attempt = 101,
    BCH_COUNTER_STABLE_btree_node_split = 17,
    BCH_COUNTER_STABLE_btree_node_rewrite = 18,
    BCH_COUNTER_STABLE_btree_node_alloc = 19,
    BCH_COUNTER_STABLE_btree_node_free = 20,
    BCH_COUNTER_STABLE_btree_node_set_root = 21,
    BCH_COUNTER_STABLE_btree_key_cache_fill = 107,
    BCH_COUNTER_STABLE_btree_path_relock_fail = 22,
    BCH_COUNTER_STABLE_btree_path_upgrade_fail = 23,
    BCH_COUNTER_STABLE_btree_reserve_get_fail = 24,
    BCH_COUNTER_STABLE_journal_res_get_blocked = 25,
    BCH_COUNTER_STABLE_journal_full = 26,
    BCH_COUNTER_STABLE_journal_reclaim_finish = 27,
    BCH_COUNTER_STABLE_journal_reclaim_start = 28,
    BCH_COUNTER_STABLE_journal_write = 29,
    BCH_COUNTER_STABLE_gc_gens_end = 42,
    BCH_COUNTER_STABLE_gc_gens_start = 43,
    BCH_COUNTER_STABLE_trans_blocked_journal_reclaim = 44,
    BCH_COUNTER_STABLE_trans_restart_btree_node_reused = 45,
    BCH_COUNTER_STABLE_trans_restart_btree_node_split = 46,
    BCH_COUNTER_STABLE_trans_restart_fault_inject = 47,
    BCH_COUNTER_STABLE_trans_restart_iter_upgrade = 48,
    BCH_COUNTER_STABLE_trans_restart_journal_preres_get = 49,
    BCH_COUNTER_STABLE_trans_restart_journal_reclaim = 50,
    BCH_COUNTER_STABLE_trans_restart_journal_res_get = 51,
    BCH_COUNTER_STABLE_trans_restart_key_cache_key_realloced = 52,
    BCH_COUNTER_STABLE_trans_restart_key_cache_raced = 53,
    BCH_COUNTER_STABLE_trans_restart_mark_replicas = 54,
    BCH_COUNTER_STABLE_trans_restart_mem_realloced = 55,
    BCH_COUNTER_STABLE_trans_restart_memory_allocation_failure = 56,
    BCH_COUNTER_STABLE_trans_restart_relock = 57,
    BCH_COUNTER_STABLE_trans_restart_relock_after_fill = 58,
    BCH_COUNTER_STABLE_trans_restart_relock_key_cache_fill_obsolete = 59,
    BCH_COUNTER_STABLE_trans_restart_relock_next_node = 60,
    BCH_COUNTER_STABLE_trans_restart_relock_parent_for_fill_obsolete = 61,
    BCH_COUNTER_STABLE_trans_restart_relock_path = 62,
    BCH_COUNTER_STABLE_trans_restart_relock_path_intent = 63,
    BCH_COUNTER_STABLE_trans_restart_too_many_iters = 64,
    BCH_COUNTER_STABLE_trans_restart_traverse = 65,
    BCH_COUNTER_STABLE_trans_restart_upgrade = 66,
    BCH_COUNTER_STABLE_trans_restart_would_deadlock = 67,
    BCH_COUNTER_STABLE_trans_restart_would_deadlock_write = 68,
    BCH_COUNTER_STABLE_trans_restart_injected = 69,
    BCH_COUNTER_STABLE_trans_restart_key_cache_upgrade = 70,
    BCH_COUNTER_STABLE_trans_traverse_all = 71,
    BCH_COUNTER_STABLE_transaction_commit = 72,
    BCH_COUNTER_STABLE_write_super = 73,
    BCH_COUNTER_STABLE_trans_restart_would_deadlock_recursion_limit = 74,
    BCH_COUNTER_STABLE_trans_restart_deadlock_waitlist_alloc = 132,
    BCH_COUNTER_STABLE_trans_restart_write_buffer_flush = 75,
    BCH_COUNTER_STABLE_trans_restart_split_race = 76,
    BCH_COUNTER_STABLE_write_buffer_flush = 105,
    BCH_COUNTER_STABLE_write_buffer_flush_slowpath = 77,
    BCH_COUNTER_STABLE_write_buffer_flush_sync = 78,
    BCH_COUNTER_STABLE_write_buffer_maybe_flush = 106,
    BCH_COUNTER_STABLE_accounting_key_to_wb_slowpath = 94,
    BCH_COUNTER_STABLE_error_throw = 93,
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct bch_sb_field_counters {
    pub field: bch_sb_field,
    pub d: __IncompleteArrayField<__le64>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_sb_field_counters",
    ][::std::mem::size_of::<bch_sb_field_counters>() - 8usize];
    [
        "Alignment of bch_sb_field_counters",
    ][::std::mem::align_of::<bch_sb_field_counters>() - 8usize];
    [
        "Offset of field: bch_sb_field_counters::field",
    ][::std::mem::offset_of!(bch_sb_field_counters, field) - 0usize];
    [
        "Offset of field: bch_sb_field_counters::d",
    ][::std::mem::offset_of!(bch_sb_field_counters, d) - 8usize];
};
#[repr(C, packed(2))]
pub struct bch_sb_field_downgrade_entry {
    pub version: __le16,
    pub recovery_passes: [__le64; 2usize],
    pub nr_errors: __le16,
    pub errors: __IncompleteArrayField<__le16>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_sb_field_downgrade_entry",
    ][::std::mem::size_of::<bch_sb_field_downgrade_entry>() - 20usize];
    [
        "Alignment of bch_sb_field_downgrade_entry",
    ][::std::mem::align_of::<bch_sb_field_downgrade_entry>() - 2usize];
    [
        "Offset of field: bch_sb_field_downgrade_entry::version",
    ][::std::mem::offset_of!(bch_sb_field_downgrade_entry, version) - 0usize];
    [
        "Offset of field: bch_sb_field_downgrade_entry::recovery_passes",
    ][::std::mem::offset_of!(bch_sb_field_downgrade_entry, recovery_passes) - 2usize];
    [
        "Offset of field: bch_sb_field_downgrade_entry::nr_errors",
    ][::std::mem::offset_of!(bch_sb_field_downgrade_entry, nr_errors) - 18usize];
    [
        "Offset of field: bch_sb_field_downgrade_entry::errors",
    ][::std::mem::offset_of!(bch_sb_field_downgrade_entry, errors) - 20usize];
};
impl Default for bch_sb_field_downgrade_entry {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct bch_sb_field_downgrade {
    pub field: bch_sb_field,
    pub entries: __IncompleteArrayField<bch_sb_field_downgrade_entry>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_sb_field_downgrade",
    ][::std::mem::size_of::<bch_sb_field_downgrade>() - 8usize];
    [
        "Alignment of bch_sb_field_downgrade",
    ][::std::mem::align_of::<bch_sb_field_downgrade>() - 8usize];
    [
        "Offset of field: bch_sb_field_downgrade::field",
    ][::std::mem::offset_of!(bch_sb_field_downgrade, field) - 0usize];
    [
        "Offset of field: bch_sb_field_downgrade::entries",
    ][::std::mem::offset_of!(bch_sb_field_downgrade, entries) - 8usize];
};
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_fsck_flags {
    FSCK_CAN_FIX = 1,
    FSCK_CAN_IGNORE = 2,
    FSCK_AUTOFIX = 4,
    FSCK_ERR_NO_LOG = 8,
    FSCK_ERR_SILENT = 16,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_sb_error_id {
    BCH_FSCK_ERR_clean_but_journal_not_empty = 0,
    BCH_FSCK_ERR_dirty_but_no_journal_entries = 1,
    BCH_FSCK_ERR_dirty_but_no_journal_entries_post_drop_nonflushes = 2,
    BCH_FSCK_ERR_sb_clean_journal_seq_mismatch = 3,
    BCH_FSCK_ERR_sb_clean_btree_root_mismatch = 4,
    BCH_FSCK_ERR_sb_clean_missing = 5,
    BCH_FSCK_ERR_jset_unsupported_version = 6,
    BCH_FSCK_ERR_jset_unknown_csum = 7,
    BCH_FSCK_ERR_jset_last_seq_newer_than_seq = 8,
    BCH_FSCK_ERR_jset_past_bucket_end = 9,
    BCH_FSCK_ERR_jset_seq_blacklisted = 10,
    BCH_FSCK_ERR_journal_entries_missing = 11,
    BCH_FSCK_ERR_journal_entry_replicas_not_marked = 12,
    BCH_FSCK_ERR_journal_entry_past_jset_end = 13,
    BCH_FSCK_ERR_journal_entry_replicas_data_mismatch = 14,
    BCH_FSCK_ERR_journal_entry_bkey_u64s_0 = 15,
    BCH_FSCK_ERR_journal_entry_bkey_past_end = 16,
    BCH_FSCK_ERR_journal_entry_bkey_bad_format = 17,
    BCH_FSCK_ERR_journal_entry_bkey_invalid = 18,
    BCH_FSCK_ERR_journal_entry_btree_root_bad_size = 19,
    BCH_FSCK_ERR_journal_entry_blacklist_bad_size = 20,
    BCH_FSCK_ERR_journal_entry_blacklist_v2_bad_size = 21,
    BCH_FSCK_ERR_journal_entry_blacklist_v2_start_past_end = 22,
    BCH_FSCK_ERR_journal_entry_usage_bad_size = 23,
    BCH_FSCK_ERR_journal_entry_data_usage_bad_size = 24,
    BCH_FSCK_ERR_journal_entry_clock_bad_size = 25,
    BCH_FSCK_ERR_journal_entry_clock_bad_rw = 26,
    BCH_FSCK_ERR_journal_entry_dev_usage_bad_size = 27,
    BCH_FSCK_ERR_journal_entry_dev_usage_bad_dev = 28,
    BCH_FSCK_ERR_journal_entry_dev_usage_bad_pad = 29,
    BCH_FSCK_ERR_journal_entry_rewind_limit_bad_size = 355,
    BCH_FSCK_ERR_journal_entry_rewind_bad_size = 356,
    BCH_FSCK_ERR_btree_node_unreadable = 30,
    BCH_FSCK_ERR_btree_node_fault_injected = 31,
    BCH_FSCK_ERR_btree_node_bad_magic = 32,
    BCH_FSCK_ERR_btree_node_bad_seq = 33,
    BCH_FSCK_ERR_btree_node_unsupported_version = 34,
    BCH_FSCK_ERR_btree_node_bset_older_than_sb_min = 35,
    BCH_FSCK_ERR_btree_node_bset_newer_than_sb = 36,
    BCH_FSCK_ERR_btree_node_data_missing = 37,
    BCH_FSCK_ERR_btree_node_bset_after_end = 38,
    BCH_FSCK_ERR_btree_node_replicas_sectors_written_mismatch = 39,
    BCH_FSCK_ERR_btree_node_replicas_data_mismatch = 40,
    BCH_FSCK_ERR_bset_unknown_csum = 41,
    BCH_FSCK_ERR_bset_bad_csum = 42,
    BCH_FSCK_ERR_bset_past_end_of_btree_node = 43,
    BCH_FSCK_ERR_bset_wrong_sector_offset = 44,
    BCH_FSCK_ERR_bset_empty = 45,
    BCH_FSCK_ERR_bset_bad_seq = 46,
    BCH_FSCK_ERR_bset_blacklisted_journal_seq = 47,
    BCH_FSCK_ERR_first_bset_blacklisted_journal_seq = 48,
    BCH_FSCK_ERR_btree_node_bad_btree = 49,
    BCH_FSCK_ERR_btree_node_bad_level = 50,
    BCH_FSCK_ERR_btree_node_bad_min_key = 51,
    BCH_FSCK_ERR_btree_node_bad_max_key = 52,
    BCH_FSCK_ERR_btree_node_bad_format = 53,
    BCH_FSCK_ERR_btree_node_bkey_past_bset_end = 54,
    BCH_FSCK_ERR_btree_node_bkey_bad_format = 55,
    BCH_FSCK_ERR_btree_node_bad_bkey = 56,
    BCH_FSCK_ERR_btree_node_bkey_out_of_order = 57,
    BCH_FSCK_ERR_btree_root_bkey_invalid = 58,
    BCH_FSCK_ERR_btree_root_read_error = 59,
    BCH_FSCK_ERR_btree_root_bad_min_key = 60,
    BCH_FSCK_ERR_btree_root_bad_max_key = 61,
    BCH_FSCK_ERR_btree_node_read_error = 62,
    BCH_FSCK_ERR_btree_node_topology_gap_between_nodes = 328,
    BCH_FSCK_ERR_btree_node_topology_bad_min_key = 63,
    BCH_FSCK_ERR_btree_node_topology_bad_max_key = 64,
    BCH_FSCK_ERR_btree_node_topology_bad_root_min_key = 323,
    BCH_FSCK_ERR_btree_node_topology_bad_root_max_key = 324,
    BCH_FSCK_ERR_btree_node_topology_overwritten_by_prev_node = 65,
    BCH_FSCK_ERR_btree_node_topology_overwritten_by_next_node = 66,
    BCH_FSCK_ERR_btree_node_topology_interior_node_empty = 67,
    BCH_FSCK_ERR_fs_usage_hidden_wrong = 68,
    BCH_FSCK_ERR_fs_usage_btree_wrong = 69,
    BCH_FSCK_ERR_fs_usage_data_wrong = 70,
    BCH_FSCK_ERR_fs_usage_cached_wrong = 71,
    BCH_FSCK_ERR_fs_usage_reserved_wrong = 72,
    BCH_FSCK_ERR_fs_usage_persistent_reserved_wrong = 73,
    BCH_FSCK_ERR_fs_usage_nr_inodes_wrong = 74,
    BCH_FSCK_ERR_fs_usage_replicas_wrong = 75,
    BCH_FSCK_ERR_dev_usage_buckets_wrong = 76,
    BCH_FSCK_ERR_dev_usage_sectors_wrong = 77,
    BCH_FSCK_ERR_dev_usage_fragmented_wrong = 78,
    BCH_FSCK_ERR_dev_usage_buckets_ec_wrong = 79,
    BCH_FSCK_ERR_bkey_version_in_future = 80,
    BCH_FSCK_ERR_bkey_u64s_too_small = 81,
    BCH_FSCK_ERR_bkey_invalid_type_for_btree = 82,
    BCH_FSCK_ERR_bkey_extent_size_zero = 83,
    BCH_FSCK_ERR_bkey_extent_size_greater_than_offset = 84,
    BCH_FSCK_ERR_bkey_size_nonzero = 85,
    BCH_FSCK_ERR_bkey_snapshot_nonzero = 86,
    BCH_FSCK_ERR_bkey_snapshot_zero = 87,
    BCH_FSCK_ERR_bkey_at_pos_max = 88,
    BCH_FSCK_ERR_bkey_before_start_of_btree_node = 89,
    BCH_FSCK_ERR_bkey_after_end_of_btree_node = 90,
    BCH_FSCK_ERR_bkey_val_size_nonzero = 91,
    BCH_FSCK_ERR_bkey_val_size_too_small = 92,
    BCH_FSCK_ERR_alloc_v1_val_size_bad = 93,
    BCH_FSCK_ERR_alloc_v2_unpack_error = 94,
    BCH_FSCK_ERR_alloc_v3_unpack_error = 95,
    BCH_FSCK_ERR_alloc_v4_val_size_bad = 96,
    BCH_FSCK_ERR_alloc_v4_backpointers_start_bad = 97,
    BCH_FSCK_ERR_alloc_key_data_type_bad = 98,
    BCH_FSCK_ERR_alloc_key_empty_but_have_data = 99,
    BCH_FSCK_ERR_alloc_key_dirty_sectors_0 = 100,
    BCH_FSCK_ERR_alloc_key_data_type_inconsistency = 101,
    BCH_FSCK_ERR_alloc_key_to_missing_dev_bucket = 102,
    BCH_FSCK_ERR_alloc_key_cached_inconsistency = 103,
    BCH_FSCK_ERR_alloc_key_cached_but_read_time_zero = 104,
    BCH_FSCK_ERR_alloc_key_to_missing_lru_entry = 105,
    BCH_FSCK_ERR_alloc_key_data_type_wrong = 106,
    BCH_FSCK_ERR_alloc_key_gen_wrong = 107,
    BCH_FSCK_ERR_alloc_key_dirty_sectors_wrong = 108,
    BCH_FSCK_ERR_alloc_key_cached_sectors_wrong = 109,
    BCH_FSCK_ERR_alloc_key_stripe_wrong = 110,
    BCH_FSCK_ERR_alloc_key_stripe_redundancy_wrong = 111,
    BCH_FSCK_ERR_alloc_key_journal_seq_in_future = 298,
    BCH_FSCK_ERR_alloc_key_stripe_refcount_wrong = 345,
    BCH_FSCK_ERR_alloc_key_bucket_nonempty_to_empty_not_open = 353,
    BCH_FSCK_ERR_alloc_key_data_type_free_dirty_bookkeeping = 359,
    BCH_FSCK_ERR_bucket_sector_count_overflow = 112,
    BCH_FSCK_ERR_bucket_metadata_type_mismatch = 113,
    BCH_FSCK_ERR_need_discard_key_wrong = 114,
    BCH_FSCK_ERR_freespace_key_wrong = 115,
    BCH_FSCK_ERR_freespace_hole_missing = 116,
    BCH_FSCK_ERR_bucket_gens_val_size_bad = 117,
    BCH_FSCK_ERR_bucket_gens_key_wrong = 118,
    BCH_FSCK_ERR_bucket_gens_hole_wrong = 119,
    BCH_FSCK_ERR_bucket_gens_to_invalid_dev = 120,
    BCH_FSCK_ERR_bucket_gens_to_invalid_buckets = 121,
    BCH_FSCK_ERR_bucket_gens_nonzero_for_invalid_buckets = 122,
    BCH_FSCK_ERR_need_discard_freespace_key_to_invalid_dev_bucket = 123,
    BCH_FSCK_ERR_need_discard_freespace_key_bad = 124,
    BCH_FSCK_ERR_discarding_bucket_not_in_need_discard_btree = 291,
    BCH_FSCK_ERR_backpointer_bucket_offset_wrong = 125,
    BCH_FSCK_ERR_backpointer_level_bad = 294,
    BCH_FSCK_ERR_backpointer_dev_bad = 297,
    BCH_FSCK_ERR_backpointer_to_missing_device = 126,
    BCH_FSCK_ERR_backpointer_to_missing_alloc = 127,
    BCH_FSCK_ERR_backpointer_to_missing_ptr = 128,
    BCH_FSCK_ERR_lru_entry_at_time_0 = 129,
    BCH_FSCK_ERR_lru_entry_to_invalid_bucket = 130,
    BCH_FSCK_ERR_lru_entry_bad = 131,
    BCH_FSCK_ERR_btree_ptr_val_too_big = 132,
    BCH_FSCK_ERR_btree_ptr_v2_val_too_big = 133,
    BCH_FSCK_ERR_btree_ptr_has_non_ptr = 134,
    BCH_FSCK_ERR_extent_ptrs_invalid_entry = 135,
    BCH_FSCK_ERR_extent_ptrs_no_ptrs = 136,
    BCH_FSCK_ERR_extent_ptrs_too_many_ptrs = 137,
    BCH_FSCK_ERR_extent_ptrs_redundant_crc = 138,
    BCH_FSCK_ERR_extent_ptrs_redundant_stripe = 139,
    BCH_FSCK_ERR_extent_ptrs_unwritten = 140,
    BCH_FSCK_ERR_extent_ptrs_written_and_unwritten = 141,
    BCH_FSCK_ERR_extent_ptrs_all_invalid = 338,
    BCH_FSCK_ERR_extent_ptrs_all_invalid_but_cached = 351,
    BCH_FSCK_ERR_extent_reconcile_bad_pending = 332,
    BCH_FSCK_ERR_extent_reconcile_bad_hipri = 333,
    BCH_FSCK_ERR_extent_reconcile_bad_replicas = 339,
    BCH_FSCK_ERR_ptr_to_invalid_device = 142,
    BCH_FSCK_ERR_ptr_to_removed_device = 322,
    BCH_FSCK_ERR_ptr_to_duplicate_device = 143,
    BCH_FSCK_ERR_ptr_after_last_bucket = 144,
    BCH_FSCK_ERR_ptr_before_first_bucket = 145,
    BCH_FSCK_ERR_ptr_spans_multiple_buckets = 146,
    BCH_FSCK_ERR_ptr_to_missing_backpointer = 147,
    BCH_FSCK_ERR_ptr_to_missing_alloc_key = 148,
    BCH_FSCK_ERR_ptr_to_missing_replicas_entry = 149,
    BCH_FSCK_ERR_ptr_to_missing_stripe = 150,
    BCH_FSCK_ERR_ptr_to_incorrect_stripe = 151,
    BCH_FSCK_ERR_ptr_gen_newer_than_bucket_gen = 152,
    BCH_FSCK_ERR_ptr_too_stale = 153,
    BCH_FSCK_ERR_stale_dirty_ptr = 154,
    BCH_FSCK_ERR_stale_ptr_with_no_stale_ptrs_feature = 327,
    BCH_FSCK_ERR_ptr_bucket_data_type_mismatch = 155,
    BCH_FSCK_ERR_ptr_cached_and_erasure_coded = 156,
    BCH_FSCK_ERR_ptr_crc_uncompressed_size_too_small = 157,
    BCH_FSCK_ERR_ptr_crc_uncompressed_size_too_big = 161,
    BCH_FSCK_ERR_ptr_crc_uncompressed_size_mismatch = 300,
    BCH_FSCK_ERR_ptr_crc_csum_type_unknown = 158,
    BCH_FSCK_ERR_ptr_crc_compression_type_unknown = 159,
    BCH_FSCK_ERR_ptr_crc_redundant = 160,
    BCH_FSCK_ERR_ptr_crc_nonce_mismatch = 162,
    BCH_FSCK_ERR_ptr_stripe_redundant = 163,
    BCH_FSCK_ERR_extent_flags_not_at_start = 306,
    BCH_FSCK_ERR_reservation_key_nr_replicas_invalid = 164,
    BCH_FSCK_ERR_reflink_v_refcount_wrong = 165,
    BCH_FSCK_ERR_reflink_v_pos_bad = 292,
    BCH_FSCK_ERR_reflink_p_to_missing_reflink_v = 166,
    BCH_FSCK_ERR_reflink_refcount_underflow = 293,
    BCH_FSCK_ERR_stripe_pos_bad = 167,
    BCH_FSCK_ERR_stripe_val_size_bad = 168,
    BCH_FSCK_ERR_stripe_csum_granularity_bad = 290,
    BCH_FSCK_ERR_stripe_sectors_zero = 340,
    BCH_FSCK_ERR_stripe_sector_count_wrong = 169,
    BCH_FSCK_ERR_stripe_parity_block_sector_count_wrong = 360,
    BCH_FSCK_ERR_stripe_to_missing_bucket_ref = 346,
    BCH_FSCK_ERR_bucket_stripe_ref_to_missing_stripe = 347,
    BCH_FSCK_ERR_bucket_stripe_ref_to_incorrect_stripe = 348,
    BCH_FSCK_ERR_stripe_update_stale_stripe_ptr = 354,
    BCH_FSCK_ERR_snapshot_tree_pos_bad = 170,
    BCH_FSCK_ERR_snapshot_tree_to_missing_snapshot = 171,
    BCH_FSCK_ERR_snapshot_tree_to_missing_subvol = 172,
    BCH_FSCK_ERR_snapshot_tree_to_wrong_subvol = 173,
    BCH_FSCK_ERR_snapshot_tree_to_snapshot_subvol = 174,
    BCH_FSCK_ERR_snapshot_pos_bad = 175,
    BCH_FSCK_ERR_snapshot_parent_bad = 176,
    BCH_FSCK_ERR_snapshot_children_not_normalized = 177,
    BCH_FSCK_ERR_snapshot_child_duplicate = 178,
    BCH_FSCK_ERR_snapshot_child_bad = 179,
    BCH_FSCK_ERR_snapshot_skiplist_not_normalized = 180,
    BCH_FSCK_ERR_snapshot_skiplist_bad = 181,
    BCH_FSCK_ERR_snapshot_should_not_have_subvol = 182,
    BCH_FSCK_ERR_snapshot_to_bad_snapshot_tree = 183,
    BCH_FSCK_ERR_snapshot_bad_depth = 184,
    BCH_FSCK_ERR_snapshot_bad_skiplist = 185,
    BCH_FSCK_ERR_subvol_pos_bad = 186,
    BCH_FSCK_ERR_subvol_not_master_and_not_snapshot = 187,
    BCH_FSCK_ERR_subvol_to_missing_root = 188,
    BCH_FSCK_ERR_subvol_root_wrong_bi_subvol = 189,
    BCH_FSCK_ERR_bkey_in_missing_snapshot = 190,
    BCH_FSCK_ERR_bkey_in_deleted_snapshot = 315,
    BCH_FSCK_ERR_inode_pos_inode_nonzero = 191,
    BCH_FSCK_ERR_inode_pos_blockdev_range = 192,
    BCH_FSCK_ERR_inode_alloc_cursor_inode_bad = 301,
    BCH_FSCK_ERR_inode_unpack_error = 193,
    BCH_FSCK_ERR_inode_str_hash_invalid = 194,
    BCH_FSCK_ERR_inode_v3_fields_start_bad = 195,
    BCH_FSCK_ERR_inode_snapshot_mismatch = 196,
    BCH_FSCK_ERR_snapshot_key_missing_inode_snapshot = 314,
    BCH_FSCK_ERR_inode_unlinked_but_clean = 197,
    BCH_FSCK_ERR_inode_unlinked_but_nlink_nonzero = 198,
    BCH_FSCK_ERR_inode_unlinked_and_not_open = 281,
    BCH_FSCK_ERR_inode_unlinked_but_has_dirent = 285,
    BCH_FSCK_ERR_unlinked_inode_not_on_deleted_list = 244,
    BCH_FSCK_ERR_inode_checksum_type_invalid = 199,
    BCH_FSCK_ERR_inode_compression_type_invalid = 200,
    BCH_FSCK_ERR_inode_subvol_root_but_not_dir = 201,
    BCH_FSCK_ERR_inode_i_size_dirty_but_clean = 202,
    BCH_FSCK_ERR_inode_i_sectors_dirty_but_clean = 203,
    BCH_FSCK_ERR_inode_i_sectors_wrong = 204,
    BCH_FSCK_ERR_inode_dir_wrong_nlink = 205,
    BCH_FSCK_ERR_inode_dir_multiple_links = 206,
    BCH_FSCK_ERR_inode_dir_missing_backpointer = 284,
    BCH_FSCK_ERR_inode_dir_unlinked_but_not_empty = 286,
    BCH_FSCK_ERR_inode_dir_has_nonzero_i_size = 319,
    BCH_FSCK_ERR_inode_multiple_links_but_nlink_0 = 207,
    BCH_FSCK_ERR_inode_wrong_backpointer = 208,
    BCH_FSCK_ERR_inode_wrong_nlink = 209,
    BCH_FSCK_ERR_inode_has_child_snapshots_wrong = 287,
    BCH_FSCK_ERR_inode_unreachable = 210,
    BCH_FSCK_ERR_inode_journal_seq_in_future = 299,
    BCH_FSCK_ERR_inode_i_sectors_underflow = 312,
    BCH_FSCK_ERR_inode_has_case_insensitive_not_set = 316,
    BCH_FSCK_ERR_inode_parent_has_case_insensitive_not_set = 317,
    BCH_FSCK_ERR_vfs_inode_i_blocks_underflow = 311,
    BCH_FSCK_ERR_vfs_inode_i_blocks_not_zero_at_truncate = 313,
    BCH_FSCK_ERR_vfs_bad_inode_rm = 320,
    BCH_FSCK_ERR_deleted_inode_but_clean = 211,
    BCH_FSCK_ERR_deleted_inode_missing = 212,
    BCH_FSCK_ERR_deleted_inode_is_dir = 213,
    BCH_FSCK_ERR_deleted_inode_not_unlinked = 214,
    BCH_FSCK_ERR_deleted_inode_has_child_snapshots = 288,
    BCH_FSCK_ERR_extent_overlapping = 215,
    BCH_FSCK_ERR_key_in_missing_inode = 216,
    BCH_FSCK_ERR_key_in_wrong_inode_type = 217,
    BCH_FSCK_ERR_extent_past_end_of_inode = 218,
    BCH_FSCK_ERR_dirent_empty_name = 219,
    BCH_FSCK_ERR_dirent_val_too_big = 220,
    BCH_FSCK_ERR_dirent_name_too_long = 221,
    BCH_FSCK_ERR_dirent_name_embedded_nul = 222,
    BCH_FSCK_ERR_dirent_name_dot_or_dotdot = 223,
    BCH_FSCK_ERR_dirent_name_has_slash = 224,
    BCH_FSCK_ERR_dirent_d_type_wrong = 225,
    BCH_FSCK_ERR_inode_bi_parent_wrong = 226,
    BCH_FSCK_ERR_dirent_in_missing_dir_inode = 227,
    BCH_FSCK_ERR_dirent_in_non_dir_inode = 228,
    BCH_FSCK_ERR_dirent_to_missing_inode = 229,
    BCH_FSCK_ERR_dirent_to_overwritten_inode = 302,
    BCH_FSCK_ERR_dirent_to_missing_subvol = 230,
    BCH_FSCK_ERR_dirent_to_itself = 231,
    BCH_FSCK_ERR_dirent_casefold_mismatch = 318,
    BCH_FSCK_ERR_quota_type_invalid = 232,
    BCH_FSCK_ERR_xattr_val_size_too_small = 233,
    BCH_FSCK_ERR_xattr_val_size_too_big = 234,
    BCH_FSCK_ERR_xattr_invalid_type = 235,
    BCH_FSCK_ERR_xattr_name_invalid_chars = 236,
    BCH_FSCK_ERR_xattr_in_missing_inode = 237,
    BCH_FSCK_ERR_root_subvol_missing = 238,
    BCH_FSCK_ERR_root_dir_missing = 239,
    BCH_FSCK_ERR_root_inode_not_dir = 240,
    BCH_FSCK_ERR_dir_loop = 241,
    BCH_FSCK_ERR_hash_table_key_duplicate = 242,
    BCH_FSCK_ERR_hash_table_key_wrong_offset = 243,
    BCH_FSCK_ERR_reflink_p_front_pad_bad = 245,
    BCH_FSCK_ERR_journal_entry_dup_same_device = 246,
    BCH_FSCK_ERR_inode_bi_subvol_missing = 247,
    BCH_FSCK_ERR_inode_bi_subvol_wrong = 248,
    BCH_FSCK_ERR_inode_points_to_missing_dirent = 249,
    BCH_FSCK_ERR_inode_points_to_wrong_dirent = 250,
    BCH_FSCK_ERR_inode_bi_parent_nonzero = 251,
    BCH_FSCK_ERR_missing_inode_with_contents = 321,
    BCH_FSCK_ERR_dirent_to_missing_parent_subvol = 252,
    BCH_FSCK_ERR_dirent_not_visible_in_parent_subvol = 253,
    BCH_FSCK_ERR_subvol_fs_path_parent_wrong = 254,
    BCH_FSCK_ERR_subvol_root_fs_path_parent_nonzero = 255,
    BCH_FSCK_ERR_subvol_children_not_set = 256,
    BCH_FSCK_ERR_subvol_children_bad = 257,
    BCH_FSCK_ERR_subvol_loop = 258,
    BCH_FSCK_ERR_subvol_unreachable = 259,
    BCH_FSCK_ERR_btree_node_bkey_bad_u64s = 260,
    BCH_FSCK_ERR_btree_node_topology_empty_interior_node = 261,
    BCH_FSCK_ERR_btree_ptr_v2_min_key_bad = 262,
    BCH_FSCK_ERR_btree_root_unreadable_and_scan_found_nothing = 263,
    BCH_FSCK_ERR_snapshot_node_missing = 264,
    BCH_FSCK_ERR_dup_backpointer_to_bad_csum_extent = 265,
    BCH_FSCK_ERR_btree_bitmap_not_marked = 266,
    BCH_FSCK_ERR_sb_clean_entry_overrun = 267,
    BCH_FSCK_ERR_btree_ptr_v2_written_0 = 268,
    BCH_FSCK_ERR_subvol_snapshot_bad = 269,
    BCH_FSCK_ERR_subvol_inode_bad = 270,
    BCH_FSCK_ERR_subvol_missing = 308,
    BCH_FSCK_ERR_alloc_key_stripe_sectors_wrong = 271,
    BCH_FSCK_ERR_accounting_mismatch = 272,
    BCH_FSCK_ERR_accounting_replicas_not_marked = 273,
    BCH_FSCK_ERR_accounting_to_invalid_device = 289,
    BCH_FSCK_ERR_invalid_btree_id = 274,
    BCH_FSCK_ERR_alloc_key_io_time_bad = 275,
    BCH_FSCK_ERR_alloc_key_fragmentation_lru_wrong = 276,
    BCH_FSCK_ERR_accounting_key_junk_at_end = 277,
    BCH_FSCK_ERR_accounting_key_replicas_nr_devs_0 = 278,
    BCH_FSCK_ERR_accounting_key_replicas_nr_required_bad = 279,
    BCH_FSCK_ERR_accounting_key_replicas_devs_unsorted = 280,
    BCH_FSCK_ERR_accounting_key_version_0 = 282,
    BCH_FSCK_ERR_accounting_key_nr_counters_wrong = 307,
    BCH_FSCK_ERR_accounting_key_underflow = 325,
    BCH_FSCK_ERR_accounting_key_version_out_of_order = 326,
    BCH_FSCK_ERR_logged_op_but_clean = 283,
    BCH_FSCK_ERR_compression_opt_not_marked_in_sb = 295,
    BCH_FSCK_ERR_compression_type_not_marked_in_sb = 296,
    BCH_FSCK_ERR_compression_error = 342,
    BCH_FSCK_ERR_data_update_got_non_extent = 350,
    BCH_FSCK_ERR_directory_size_mismatch = 303,
    BCH_FSCK_ERR_dirent_cf_name_too_big = 304,
    BCH_FSCK_ERR_dirent_stray_data_after_cf_name = 305,
    BCH_FSCK_ERR_reconcile_work_incorrectly_set = 309,
    BCH_FSCK_ERR_reconcile_work_phys_incorrectly_set = 341,
    BCH_FSCK_ERR_validate_error_in_commit = 329,
    BCH_FSCK_ERR_extent_io_opts_not_set = 330,
    BCH_FSCK_ERR_stripe_needs_reconcile_not_set = 352,
    BCH_FSCK_ERR_stripe_can_widen_wrong = 361,
    BCH_FSCK_ERR_extent_io_opts_unneeded = 331,
    BCH_FSCK_ERR_reconcile_bp_to_missing_btree_ptr = 310,
    BCH_FSCK_ERR_reconcile_bp_to_leaf_node_key = 334,
    BCH_FSCK_ERR_btree_ptr_with_no_reconcile_bp = 335,
    BCH_FSCK_ERR_btree_ptr_with_bad_reconcile_bp = 336,
    BCH_FSCK_ERR_btree_ptr_to_bad_reconcile_bp = 337,
    BCH_FSCK_ERR_vfs_i_size_bad = 343,
    BCH_FSCK_ERR_vfs_i_sectors_bad = 344,
    BCH_FSCK_ERR_vfs_unlink_got_wrong_inum = 349,
    BCH_FSCK_ERR_device_bad_flush = 357,
    BCH_FSCK_ERR_journal_bucket_seq_not_monotonic = 358,
    BCH_FSCK_ERR_dup_extents_to_reflink = 362,
    BCH_FSCK_ERR_MAX = 363,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_sb_field_error_entry {
    pub v: __le64,
    pub last_error_time: __le64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_sb_field_error_entry",
    ][::std::mem::size_of::<bch_sb_field_error_entry>() - 16usize];
    [
        "Alignment of bch_sb_field_error_entry",
    ][::std::mem::align_of::<bch_sb_field_error_entry>() - 8usize];
    [
        "Offset of field: bch_sb_field_error_entry::v",
    ][::std::mem::offset_of!(bch_sb_field_error_entry, v) - 0usize];
    [
        "Offset of field: bch_sb_field_error_entry::last_error_time",
    ][::std::mem::offset_of!(bch_sb_field_error_entry, last_error_time) - 8usize];
};
#[repr(C)]
#[derive(Debug, Default)]
pub struct bch_sb_field_errors {
    pub field: bch_sb_field,
    pub entries: __IncompleteArrayField<bch_sb_field_error_entry>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_sb_field_errors",
    ][::std::mem::size_of::<bch_sb_field_errors>() - 8usize];
    [
        "Alignment of bch_sb_field_errors",
    ][::std::mem::align_of::<bch_sb_field_errors>() - 8usize];
    [
        "Offset of field: bch_sb_field_errors::field",
    ][::std::mem::offset_of!(bch_sb_field_errors, field) - 0usize];
    [
        "Offset of field: bch_sb_field_errors::entries",
    ][::std::mem::offset_of!(bch_sb_field_errors, entries) - 8usize];
};
pub const BCH_SB_ERROR_ENTRY_ID_OFFSET: ::std::os::raw::c_uint = 0;
pub const BCH_SB_ERROR_ENTRY_ID_BITS: ::std::os::raw::c_uint = 16;
pub const BCH_SB_ERROR_ENTRY_ID_MAX: __u64 = 65535;
pub const BCH_SB_ERROR_ENTRY_NR_OFFSET: ::std::os::raw::c_uint = 16;
pub const BCH_SB_ERROR_ENTRY_NR_BITS: ::std::os::raw::c_uint = 48;
pub const BCH_SB_ERROR_ENTRY_NR_MAX: __u64 = 281474976710655;
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_iops_measurement {
    BCH_IOPS_seqread = 0,
    BCH_IOPS_seqwrite = 1,
    BCH_IOPS_randread = 2,
    BCH_IOPS_randwrite = 3,
    BCH_IOPS_NR = 4,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_member_error_type {
    BCH_MEMBER_ERROR_read = 0,
    BCH_MEMBER_ERROR_write = 1,
    BCH_MEMBER_ERROR_checksum = 2,
    BCH_MEMBER_ERROR_NR = 3,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bch_member {
    pub uuid: __uuid_t,
    pub nbuckets: __le64,
    pub first_bucket: __le16,
    pub bucket_size: __le16,
    pub btree_bitmap_shift: __u8,
    pub pad: [__u8; 3usize],
    pub last_mount: __le64,
    pub flags: __le64,
    pub iops: [__le32; 4usize],
    pub errors: [__le64; 3usize],
    pub errors_at_reset: [__le64; 3usize],
    pub errors_reset_time: __le64,
    pub seq: __le64,
    pub btree_allocated_bitmap: __le64,
    pub last_journal_bucket: __le32,
    pub last_journal_bucket_offset: __le32,
    pub device_name: [__u8; 16usize],
    pub device_model: [__u8; 64usize],
    pub flush_errors: __le64,
    pub device_serial: [__u8; 64usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_member"][::std::mem::size_of::<bch_member>() - 296usize];
    ["Alignment of bch_member"][::std::mem::align_of::<bch_member>() - 8usize];
    [
        "Offset of field: bch_member::uuid",
    ][::std::mem::offset_of!(bch_member, uuid) - 0usize];
    [
        "Offset of field: bch_member::nbuckets",
    ][::std::mem::offset_of!(bch_member, nbuckets) - 16usize];
    [
        "Offset of field: bch_member::first_bucket",
    ][::std::mem::offset_of!(bch_member, first_bucket) - 24usize];
    [
        "Offset of field: bch_member::bucket_size",
    ][::std::mem::offset_of!(bch_member, bucket_size) - 26usize];
    [
        "Offset of field: bch_member::btree_bitmap_shift",
    ][::std::mem::offset_of!(bch_member, btree_bitmap_shift) - 28usize];
    [
        "Offset of field: bch_member::pad",
    ][::std::mem::offset_of!(bch_member, pad) - 29usize];
    [
        "Offset of field: bch_member::last_mount",
    ][::std::mem::offset_of!(bch_member, last_mount) - 32usize];
    [
        "Offset of field: bch_member::flags",
    ][::std::mem::offset_of!(bch_member, flags) - 40usize];
    [
        "Offset of field: bch_member::iops",
    ][::std::mem::offset_of!(bch_member, iops) - 48usize];
    [
        "Offset of field: bch_member::errors",
    ][::std::mem::offset_of!(bch_member, errors) - 64usize];
    [
        "Offset of field: bch_member::errors_at_reset",
    ][::std::mem::offset_of!(bch_member, errors_at_reset) - 88usize];
    [
        "Offset of field: bch_member::errors_reset_time",
    ][::std::mem::offset_of!(bch_member, errors_reset_time) - 112usize];
    [
        "Offset of field: bch_member::seq",
    ][::std::mem::offset_of!(bch_member, seq) - 120usize];
    [
        "Offset of field: bch_member::btree_allocated_bitmap",
    ][::std::mem::offset_of!(bch_member, btree_allocated_bitmap) - 128usize];
    [
        "Offset of field: bch_member::last_journal_bucket",
    ][::std::mem::offset_of!(bch_member, last_journal_bucket) - 136usize];
    [
        "Offset of field: bch_member::last_journal_bucket_offset",
    ][::std::mem::offset_of!(bch_member, last_journal_bucket_offset) - 140usize];
    [
        "Offset of field: bch_member::device_name",
    ][::std::mem::offset_of!(bch_member, device_name) - 144usize];
    [
        "Offset of field: bch_member::device_model",
    ][::std::mem::offset_of!(bch_member, device_model) - 160usize];
    [
        "Offset of field: bch_member::flush_errors",
    ][::std::mem::offset_of!(bch_member, flush_errors) - 224usize];
    [
        "Offset of field: bch_member::device_serial",
    ][::std::mem::offset_of!(bch_member, device_serial) - 232usize];
};
impl Default for bch_member {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub const BCH_MEMBER_BUCKET_SIZE_OFFSET: ::std::os::raw::c_uint = 0;
pub const BCH_MEMBER_BUCKET_SIZE_BITS: ::std::os::raw::c_uint = 16;
pub const BCH_MEMBER_BUCKET_SIZE_MAX: __u16 = 65535;
pub const BCH_MEMBER_STATE_OFFSET: ::std::os::raw::c_uint = 0;
pub const BCH_MEMBER_STATE_BITS: ::std::os::raw::c_uint = 4;
pub const BCH_MEMBER_STATE_MAX: __u64 = 15;
pub const BCH_MEMBER_DISCARD_OFFSET: ::std::os::raw::c_uint = 14;
pub const BCH_MEMBER_DISCARD_BITS: ::std::os::raw::c_uint = 1;
pub const BCH_MEMBER_DISCARD_MAX: __u64 = 1;
pub const BCH_MEMBER_DATA_ALLOWED_OFFSET: ::std::os::raw::c_uint = 15;
pub const BCH_MEMBER_DATA_ALLOWED_BITS: ::std::os::raw::c_uint = 5;
pub const BCH_MEMBER_DATA_ALLOWED_MAX: __u64 = 31;
pub const BCH_MEMBER_GROUP_OFFSET: ::std::os::raw::c_uint = 20;
pub const BCH_MEMBER_GROUP_BITS: ::std::os::raw::c_uint = 8;
pub const BCH_MEMBER_GROUP_MAX: __u64 = 255;
pub const BCH_MEMBER_DURABILITY_OFFSET: ::std::os::raw::c_uint = 28;
pub const BCH_MEMBER_DURABILITY_BITS: ::std::os::raw::c_uint = 2;
pub const BCH_MEMBER_DURABILITY_MAX: __u64 = 3;
pub const BCH_MEMBER_FREESPACE_INITIALIZED_OFFSET: ::std::os::raw::c_uint = 30;
pub const BCH_MEMBER_FREESPACE_INITIALIZED_BITS: ::std::os::raw::c_uint = 1;
pub const BCH_MEMBER_FREESPACE_INITIALIZED_MAX: __u64 = 1;
pub const BCH_MEMBER_RESIZE_ON_MOUNT_OFFSET: ::std::os::raw::c_uint = 31;
pub const BCH_MEMBER_RESIZE_ON_MOUNT_BITS: ::std::os::raw::c_uint = 1;
pub const BCH_MEMBER_RESIZE_ON_MOUNT_MAX: __u64 = 1;
pub const BCH_MEMBER_ROTATIONAL_OFFSET: ::std::os::raw::c_uint = 32;
pub const BCH_MEMBER_ROTATIONAL_BITS: ::std::os::raw::c_uint = 1;
pub const BCH_MEMBER_ROTATIONAL_MAX: __u64 = 1;
pub const BCH_MEMBER_ROTATIONAL_SET_OFFSET: ::std::os::raw::c_uint = 33;
pub const BCH_MEMBER_ROTATIONAL_SET_BITS: ::std::os::raw::c_uint = 1;
pub const BCH_MEMBER_ROTATIONAL_SET_MAX: __u64 = 1;
pub const BCH_MEMBER_INITIALIZED_OFFSET: ::std::os::raw::c_uint = 34;
pub const BCH_MEMBER_INITIALIZED_BITS: ::std::os::raw::c_uint = 4;
pub const BCH_MEMBER_INITIALIZED_MAX: __u64 = 15;
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_member_state {
    BCH_MEMBER_STATE_rw = 0,
    BCH_MEMBER_STATE_ro = 1,
    BCH_MEMBER_STATE_evacuating = 2,
    BCH_MEMBER_STATE_spare = 3,
    BCH_MEMBER_STATE_NR = 4,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_member_initialized {
    BCH_MEMBER_INITIALIZED_initialized = 0,
    BCH_MEMBER_INITIALIZED_pre_dev_usage = 1,
    BCH_MEMBER_INITIALIZED_pre_mark_sb = 2,
    BCH_MEMBER_INITIALIZED_pre_freespace_init = 3,
    BCH_MEMBER_INITIALIZED_pre_journal_alloc = 4,
    BCH_MEMBER_INITIALIZED_NR = 5,
}
#[repr(C)]
#[derive(Debug)]
pub struct bch_sb_field_members_v1 {
    pub field: bch_sb_field,
    pub _members: __IncompleteArrayField<bch_member>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_sb_field_members_v1",
    ][::std::mem::size_of::<bch_sb_field_members_v1>() - 8usize];
    [
        "Alignment of bch_sb_field_members_v1",
    ][::std::mem::align_of::<bch_sb_field_members_v1>() - 8usize];
    [
        "Offset of field: bch_sb_field_members_v1::field",
    ][::std::mem::offset_of!(bch_sb_field_members_v1, field) - 0usize];
    [
        "Offset of field: bch_sb_field_members_v1::_members",
    ][::std::mem::offset_of!(bch_sb_field_members_v1, _members) - 8usize];
};
impl Default for bch_sb_field_members_v1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug)]
pub struct bch_sb_field_members_v2 {
    pub field: bch_sb_field,
    pub member_bytes: __le16,
    pub pad: [u8_; 6usize],
    pub _members: __IncompleteArrayField<bch_member>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_sb_field_members_v2",
    ][::std::mem::size_of::<bch_sb_field_members_v2>() - 16usize];
    [
        "Alignment of bch_sb_field_members_v2",
    ][::std::mem::align_of::<bch_sb_field_members_v2>() - 8usize];
    [
        "Offset of field: bch_sb_field_members_v2::field",
    ][::std::mem::offset_of!(bch_sb_field_members_v2, field) - 0usize];
    [
        "Offset of field: bch_sb_field_members_v2::member_bytes",
    ][::std::mem::offset_of!(bch_sb_field_members_v2, member_bytes) - 8usize];
    [
        "Offset of field: bch_sb_field_members_v2::pad",
    ][::std::mem::offset_of!(bch_sb_field_members_v2, pad) - 10usize];
    [
        "Offset of field: bch_sb_field_members_v2::_members",
    ][::std::mem::offset_of!(bch_sb_field_members_v2, _members) - 16usize];
};
impl Default for bch_sb_field_members_v2 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct bch_subvolume {
    pub v: bch_val,
    pub flags: __le32,
    pub snapshot: __le32,
    pub inode: __le64,
    pub creation_parent: __le32,
    pub fs_path_parent: __le32,
    pub otime: bch_le128,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_subvolume"][::std::mem::size_of::<bch_subvolume>() - 40usize];
    ["Alignment of bch_subvolume"][::std::mem::align_of::<bch_subvolume>() - 8usize];
    [
        "Offset of field: bch_subvolume::v",
    ][::std::mem::offset_of!(bch_subvolume, v) - 0usize];
    [
        "Offset of field: bch_subvolume::flags",
    ][::std::mem::offset_of!(bch_subvolume, flags) - 0usize];
    [
        "Offset of field: bch_subvolume::snapshot",
    ][::std::mem::offset_of!(bch_subvolume, snapshot) - 4usize];
    [
        "Offset of field: bch_subvolume::inode",
    ][::std::mem::offset_of!(bch_subvolume, inode) - 8usize];
    [
        "Offset of field: bch_subvolume::creation_parent",
    ][::std::mem::offset_of!(bch_subvolume, creation_parent) - 16usize];
    [
        "Offset of field: bch_subvolume::fs_path_parent",
    ][::std::mem::offset_of!(bch_subvolume, fs_path_parent) - 20usize];
    [
        "Offset of field: bch_subvolume::otime",
    ][::std::mem::offset_of!(bch_subvolume, otime) - 24usize];
};
pub const BCH_SUBVOLUME_RO_OFFSET: ::std::os::raw::c_uint = 0;
pub const BCH_SUBVOLUME_RO_BITS: ::std::os::raw::c_uint = 1;
pub const BCH_SUBVOLUME_RO_MAX: __u32 = 1;
pub const BCH_SUBVOLUME_SNAP_OFFSET: ::std::os::raw::c_uint = 1;
pub const BCH_SUBVOLUME_SNAP_BITS: ::std::os::raw::c_uint = 1;
pub const BCH_SUBVOLUME_SNAP_MAX: __u32 = 1;
pub const BCH_SUBVOLUME_UNLINKED_OFFSET: ::std::os::raw::c_uint = 2;
pub const BCH_SUBVOLUME_UNLINKED_BITS: ::std::os::raw::c_uint = 1;
pub const BCH_SUBVOLUME_UNLINKED_MAX: __u32 = 1;
#[repr(C)]
#[derive(Debug, Default)]
pub struct bch_snapshot {
    pub v: bch_val,
    pub flags: __le32,
    pub parent: __le32,
    pub children: [__le32; 2usize],
    pub subvol: __le32,
    pub tree: __le32,
    pub depth: __le32,
    pub skip: [__le32; 3usize],
    pub btime: bch_le128,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_snapshot"][::std::mem::size_of::<bch_snapshot>() - 56usize];
    ["Alignment of bch_snapshot"][::std::mem::align_of::<bch_snapshot>() - 8usize];
    [
        "Offset of field: bch_snapshot::v",
    ][::std::mem::offset_of!(bch_snapshot, v) - 0usize];
    [
        "Offset of field: bch_snapshot::flags",
    ][::std::mem::offset_of!(bch_snapshot, flags) - 0usize];
    [
        "Offset of field: bch_snapshot::parent",
    ][::std::mem::offset_of!(bch_snapshot, parent) - 4usize];
    [
        "Offset of field: bch_snapshot::children",
    ][::std::mem::offset_of!(bch_snapshot, children) - 8usize];
    [
        "Offset of field: bch_snapshot::subvol",
    ][::std::mem::offset_of!(bch_snapshot, subvol) - 16usize];
    [
        "Offset of field: bch_snapshot::tree",
    ][::std::mem::offset_of!(bch_snapshot, tree) - 20usize];
    [
        "Offset of field: bch_snapshot::depth",
    ][::std::mem::offset_of!(bch_snapshot, depth) - 24usize];
    [
        "Offset of field: bch_snapshot::skip",
    ][::std::mem::offset_of!(bch_snapshot, skip) - 28usize];
    [
        "Offset of field: bch_snapshot::btime",
    ][::std::mem::offset_of!(bch_snapshot, btime) - 40usize];
};
pub const BCH_SNAPSHOT_WILL_DELETE_OFFSET: ::std::os::raw::c_uint = 0;
pub const BCH_SNAPSHOT_WILL_DELETE_BITS: ::std::os::raw::c_uint = 1;
pub const BCH_SNAPSHOT_WILL_DELETE_MAX: __u32 = 1;
pub const BCH_SNAPSHOT_SUBVOL_OFFSET: ::std::os::raw::c_uint = 1;
pub const BCH_SNAPSHOT_SUBVOL_BITS: ::std::os::raw::c_uint = 1;
pub const BCH_SNAPSHOT_SUBVOL_MAX: __u32 = 1;
pub const BCH_SNAPSHOT_DELETED_OFFSET: ::std::os::raw::c_uint = 2;
pub const BCH_SNAPSHOT_DELETED_BITS: ::std::os::raw::c_uint = 1;
pub const BCH_SNAPSHOT_DELETED_MAX: __u32 = 1;
pub const BCH_SNAPSHOT_NO_KEYS_OFFSET: ::std::os::raw::c_uint = 3;
pub const BCH_SNAPSHOT_NO_KEYS_BITS: ::std::os::raw::c_uint = 1;
pub const BCH_SNAPSHOT_NO_KEYS_MAX: __u32 = 1;
#[repr(C)]
#[derive(Debug, Default)]
pub struct bch_snapshot_tree {
    pub v: bch_val,
    pub master_subvol: __le32,
    pub root_snapshot: __le32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_snapshot_tree"][::std::mem::size_of::<bch_snapshot_tree>() - 8usize];
    [
        "Alignment of bch_snapshot_tree",
    ][::std::mem::align_of::<bch_snapshot_tree>() - 8usize];
    [
        "Offset of field: bch_snapshot_tree::v",
    ][::std::mem::offset_of!(bch_snapshot_tree, v) - 0usize];
    [
        "Offset of field: bch_snapshot_tree::master_subvol",
    ][::std::mem::offset_of!(bch_snapshot_tree, master_subvol) - 0usize];
    [
        "Offset of field: bch_snapshot_tree::root_snapshot",
    ][::std::mem::offset_of!(bch_snapshot_tree, root_snapshot) - 4usize];
};
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_sb_field_type {
    BCH_SB_FIELD_journal = 0,
    BCH_SB_FIELD_members_v1 = 1,
    BCH_SB_FIELD_crypt = 2,
    BCH_SB_FIELD_replicas_v0 = 3,
    BCH_SB_FIELD_quota = 4,
    BCH_SB_FIELD_disk_groups = 5,
    BCH_SB_FIELD_clean = 6,
    BCH_SB_FIELD_replicas = 7,
    BCH_SB_FIELD_journal_seq_blacklist = 8,
    BCH_SB_FIELD_journal_v2 = 9,
    BCH_SB_FIELD_counters = 10,
    BCH_SB_FIELD_members_v2 = 11,
    BCH_SB_FIELD_errors = 12,
    BCH_SB_FIELD_ext = 13,
    BCH_SB_FIELD_downgrade = 14,
    BCH_SB_FIELD_recovery_passes = 15,
    BCH_SB_FIELD_extent_type_u64s = 16,
    BCH_SB_FIELD_NR = 17,
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct bch_sb_field_journal {
    pub field: bch_sb_field,
    pub buckets: __IncompleteArrayField<__le64>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_sb_field_journal",
    ][::std::mem::size_of::<bch_sb_field_journal>() - 8usize];
    [
        "Alignment of bch_sb_field_journal",
    ][::std::mem::align_of::<bch_sb_field_journal>() - 8usize];
    [
        "Offset of field: bch_sb_field_journal::field",
    ][::std::mem::offset_of!(bch_sb_field_journal, field) - 0usize];
    [
        "Offset of field: bch_sb_field_journal::buckets",
    ][::std::mem::offset_of!(bch_sb_field_journal, buckets) - 8usize];
};
#[repr(C)]
#[derive(Debug, Default)]
pub struct bch_sb_field_journal_v2 {
    pub field: bch_sb_field,
    pub d: __IncompleteArrayField<bch_sb_field_journal_v2_bch_sb_field_journal_v2_entry>,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_sb_field_journal_v2_bch_sb_field_journal_v2_entry {
    pub start: __le64,
    pub nr: __le64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_sb_field_journal_v2_bch_sb_field_journal_v2_entry",
    ][::std::mem::size_of::<bch_sb_field_journal_v2_bch_sb_field_journal_v2_entry>()
        - 16usize];
    [
        "Alignment of bch_sb_field_journal_v2_bch_sb_field_journal_v2_entry",
    ][::std::mem::align_of::<bch_sb_field_journal_v2_bch_sb_field_journal_v2_entry>()
        - 8usize];
    [
        "Offset of field: bch_sb_field_journal_v2_bch_sb_field_journal_v2_entry::start",
    ][::std::mem::offset_of!(
        bch_sb_field_journal_v2_bch_sb_field_journal_v2_entry, start
    ) - 0usize];
    [
        "Offset of field: bch_sb_field_journal_v2_bch_sb_field_journal_v2_entry::nr",
    ][::std::mem::offset_of!(bch_sb_field_journal_v2_bch_sb_field_journal_v2_entry, nr)
        - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_sb_field_journal_v2",
    ][::std::mem::size_of::<bch_sb_field_journal_v2>() - 8usize];
    [
        "Alignment of bch_sb_field_journal_v2",
    ][::std::mem::align_of::<bch_sb_field_journal_v2>() - 8usize];
    [
        "Offset of field: bch_sb_field_journal_v2::field",
    ][::std::mem::offset_of!(bch_sb_field_journal_v2, field) - 0usize];
    [
        "Offset of field: bch_sb_field_journal_v2::d",
    ][::std::mem::offset_of!(bch_sb_field_journal_v2, d) - 8usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct nonce {
    pub d: [__le32; 4usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of nonce"][::std::mem::size_of::<nonce>() - 16usize];
    ["Alignment of nonce"][::std::mem::align_of::<nonce>() - 4usize];
    ["Offset of field: nonce::d"][::std::mem::offset_of!(nonce, d) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_key {
    pub key: [__le64; 4usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_key"][::std::mem::size_of::<bch_key>() - 32usize];
    ["Alignment of bch_key"][::std::mem::align_of::<bch_key>() - 8usize];
    ["Offset of field: bch_key::key"][::std::mem::offset_of!(bch_key, key) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_encrypted_key {
    pub magic: __le64,
    pub key: bch_key,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_encrypted_key"][::std::mem::size_of::<bch_encrypted_key>() - 40usize];
    [
        "Alignment of bch_encrypted_key",
    ][::std::mem::align_of::<bch_encrypted_key>() - 8usize];
    [
        "Offset of field: bch_encrypted_key::magic",
    ][::std::mem::offset_of!(bch_encrypted_key, magic) - 0usize];
    [
        "Offset of field: bch_encrypted_key::key",
    ][::std::mem::offset_of!(bch_encrypted_key, key) - 8usize];
};
#[repr(C)]
#[derive(Debug, Default)]
pub struct bch_sb_field_crypt {
    pub field: bch_sb_field,
    pub flags: __le64,
    pub kdf_flags: __le64,
    pub key: bch_encrypted_key,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_sb_field_crypt",
    ][::std::mem::size_of::<bch_sb_field_crypt>() - 64usize];
    [
        "Alignment of bch_sb_field_crypt",
    ][::std::mem::align_of::<bch_sb_field_crypt>() - 8usize];
    [
        "Offset of field: bch_sb_field_crypt::field",
    ][::std::mem::offset_of!(bch_sb_field_crypt, field) - 0usize];
    [
        "Offset of field: bch_sb_field_crypt::flags",
    ][::std::mem::offset_of!(bch_sb_field_crypt, flags) - 8usize];
    [
        "Offset of field: bch_sb_field_crypt::kdf_flags",
    ][::std::mem::offset_of!(bch_sb_field_crypt, kdf_flags) - 16usize];
    [
        "Offset of field: bch_sb_field_crypt::key",
    ][::std::mem::offset_of!(bch_sb_field_crypt, key) - 24usize];
};
pub const BCH_CRYPT_KDF_TYPE_OFFSET: ::std::os::raw::c_uint = 0;
pub const BCH_CRYPT_KDF_TYPE_BITS: ::std::os::raw::c_uint = 4;
pub const BCH_CRYPT_KDF_TYPE_MAX: __u64 = 15;
impl bch_kdf_types {
    pub const BCH_KDF_SCRYPT: bch_kdf_types = bch_kdf_types(0);
    pub const BCH_KDF_NR: bch_kdf_types = bch_kdf_types(1);
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct bch_kdf_types(pub ::std::os::raw::c_uint);
pub const BCH_KDF_SCRYPT_N_OFFSET: ::std::os::raw::c_uint = 0;
pub const BCH_KDF_SCRYPT_N_BITS: ::std::os::raw::c_uint = 16;
pub const BCH_KDF_SCRYPT_N_MAX: __u64 = 65535;
pub const BCH_KDF_SCRYPT_R_OFFSET: ::std::os::raw::c_uint = 16;
pub const BCH_KDF_SCRYPT_R_BITS: ::std::os::raw::c_uint = 16;
pub const BCH_KDF_SCRYPT_R_MAX: __u64 = 65535;
pub const BCH_KDF_SCRYPT_P_OFFSET: ::std::os::raw::c_uint = 32;
pub const BCH_KDF_SCRYPT_P_BITS: ::std::os::raw::c_uint = 16;
pub const BCH_KDF_SCRYPT_P_MAX: __u64 = 65535;
#[repr(C)]
#[derive(Debug, Default)]
pub struct jset_entry {
    pub u64s: __le16,
    pub btree_id: __u8,
    pub level: __u8,
    pub type_: __u8,
    pub pad: [__u8; 3usize],
    pub start: __IncompleteArrayField<bkey_i>,
    pub _data: __IncompleteArrayField<__u64>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of jset_entry"][::std::mem::size_of::<jset_entry>() - 8usize];
    ["Alignment of jset_entry"][::std::mem::align_of::<jset_entry>() - 8usize];
    [
        "Offset of field: jset_entry::u64s",
    ][::std::mem::offset_of!(jset_entry, u64s) - 0usize];
    [
        "Offset of field: jset_entry::btree_id",
    ][::std::mem::offset_of!(jset_entry, btree_id) - 2usize];
    [
        "Offset of field: jset_entry::level",
    ][::std::mem::offset_of!(jset_entry, level) - 3usize];
    [
        "Offset of field: jset_entry::type_",
    ][::std::mem::offset_of!(jset_entry, type_) - 4usize];
    [
        "Offset of field: jset_entry::pad",
    ][::std::mem::offset_of!(jset_entry, pad) - 5usize];
    [
        "Offset of field: jset_entry::start",
    ][::std::mem::offset_of!(jset_entry, start) - 8usize];
    [
        "Offset of field: jset_entry::_data",
    ][::std::mem::offset_of!(jset_entry, _data) - 8usize];
};
#[repr(C)]
#[derive(Debug, Default)]
pub struct bch_sb_field_clean {
    pub field: bch_sb_field,
    pub flags: __le32,
    pub _read_clock: __le16,
    pub _write_clock: __le16,
    pub journal_seq: __le64,
    pub start: __IncompleteArrayField<jset_entry>,
    pub _data: __IncompleteArrayField<__u64>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_sb_field_clean",
    ][::std::mem::size_of::<bch_sb_field_clean>() - 24usize];
    [
        "Alignment of bch_sb_field_clean",
    ][::std::mem::align_of::<bch_sb_field_clean>() - 8usize];
    [
        "Offset of field: bch_sb_field_clean::field",
    ][::std::mem::offset_of!(bch_sb_field_clean, field) - 0usize];
    [
        "Offset of field: bch_sb_field_clean::flags",
    ][::std::mem::offset_of!(bch_sb_field_clean, flags) - 8usize];
    [
        "Offset of field: bch_sb_field_clean::_read_clock",
    ][::std::mem::offset_of!(bch_sb_field_clean, _read_clock) - 12usize];
    [
        "Offset of field: bch_sb_field_clean::_write_clock",
    ][::std::mem::offset_of!(bch_sb_field_clean, _write_clock) - 14usize];
    [
        "Offset of field: bch_sb_field_clean::journal_seq",
    ][::std::mem::offset_of!(bch_sb_field_clean, journal_seq) - 16usize];
    [
        "Offset of field: bch_sb_field_clean::start",
    ][::std::mem::offset_of!(bch_sb_field_clean, start) - 24usize];
    [
        "Offset of field: bch_sb_field_clean::_data",
    ][::std::mem::offset_of!(bch_sb_field_clean, _data) - 24usize];
};
#[repr(C)]
#[derive(Debug, Default)]
pub struct bch_sb_field_ext {
    pub field: bch_sb_field,
    pub recovery_passes_required: [__le64; 2usize],
    pub errors_silent: [__le64; 8usize],
    pub btrees_lost_data: __le64,
    pub flags0: __le64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_sb_field_ext"][::std::mem::size_of::<bch_sb_field_ext>() - 104usize];
    [
        "Alignment of bch_sb_field_ext",
    ][::std::mem::align_of::<bch_sb_field_ext>() - 8usize];
    [
        "Offset of field: bch_sb_field_ext::field",
    ][::std::mem::offset_of!(bch_sb_field_ext, field) - 0usize];
    [
        "Offset of field: bch_sb_field_ext::recovery_passes_required",
    ][::std::mem::offset_of!(bch_sb_field_ext, recovery_passes_required) - 8usize];
    [
        "Offset of field: bch_sb_field_ext::errors_silent",
    ][::std::mem::offset_of!(bch_sb_field_ext, errors_silent) - 24usize];
    [
        "Offset of field: bch_sb_field_ext::btrees_lost_data",
    ][::std::mem::offset_of!(bch_sb_field_ext, btrees_lost_data) - 88usize];
    [
        "Offset of field: bch_sb_field_ext::flags0",
    ][::std::mem::offset_of!(bch_sb_field_ext, flags0) - 96usize];
};
pub const BCH_SB_EXT_DEV_READAHEAD_OFFSET: ::std::os::raw::c_uint = 0;
pub const BCH_SB_EXT_DEV_READAHEAD_BITS: ::std::os::raw::c_uint = 20;
pub const BCH_SB_EXT_DEV_READAHEAD_MAX: __u64 = 1048575;
pub const BCH_SB_EXT_EC_STRIPE_BUF_LIMIT_OFFSET: ::std::os::raw::c_uint = 20;
pub const BCH_SB_EXT_EC_STRIPE_BUF_LIMIT_BITS: ::std::os::raw::c_uint = 6;
pub const BCH_SB_EXT_EC_STRIPE_BUF_LIMIT_MAX: __u64 = 63;
pub const BCH_SB_EXT_SCRUB_MAX_REWIND_SECS_OFFSET: ::std::os::raw::c_uint = 26;
pub const BCH_SB_EXT_SCRUB_MAX_REWIND_SECS_BITS: ::std::os::raw::c_uint = 12;
pub const BCH_SB_EXT_SCRUB_MAX_REWIND_SECS_MAX: __u64 = 4095;
pub const BCH_SB_EXT_DISCARD_BUFFER_OFFSET: ::std::os::raw::c_uint = 38;
pub const BCH_SB_EXT_DISCARD_BUFFER_BITS: ::std::os::raw::c_uint = 4;
pub const BCH_SB_EXT_DISCARD_BUFFER_MAX: __u64 = 15;
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bcachefs_metadata_version {
    bcachefs_metadata_version_min = 9,
    bcachefs_metadata_version_bkey_renumber = 10,
    bcachefs_metadata_version_inode_btree_change = 11,
    bcachefs_metadata_version_snapshot = 12,
    bcachefs_metadata_version_inode_backpointers = 13,
    bcachefs_metadata_version_btree_ptr_sectors_written = 14,
    bcachefs_metadata_version_snapshot_2 = 15,
    bcachefs_metadata_version_reflink_p_fix = 16,
    bcachefs_metadata_version_subvol_dirent = 17,
    bcachefs_metadata_version_inode_v2 = 18,
    bcachefs_metadata_version_freespace = 19,
    bcachefs_metadata_version_alloc_v4 = 20,
    bcachefs_metadata_version_new_data_types = 21,
    bcachefs_metadata_version_backpointers = 22,
    bcachefs_metadata_version_inode_v3 = 23,
    bcachefs_metadata_version_unwritten_extents = 24,
    bcachefs_metadata_version_bucket_gens = 25,
    bcachefs_metadata_version_lru_v2 = 26,
    bcachefs_metadata_version_fragmentation_lru = 27,
    bcachefs_metadata_version_no_bps_in_alloc_keys = 28,
    bcachefs_metadata_version_snapshot_trees = 29,
    bcachefs_metadata_version_major_minor = 1024,
    bcachefs_metadata_version_snapshot_skiplists = 1025,
    bcachefs_metadata_version_deleted_inodes = 1026,
    bcachefs_metadata_version_rebalance_work = 1027,
    bcachefs_metadata_version_member_seq = 1028,
    bcachefs_metadata_version_subvolume_fs_parent = 1029,
    bcachefs_metadata_version_btree_subvolume_children = 1030,
    bcachefs_metadata_version_mi_btree_bitmap = 1031,
    bcachefs_metadata_version_bucket_stripe_sectors = 1032,
    bcachefs_metadata_version_disk_accounting_v2 = 1033,
    bcachefs_metadata_version_disk_accounting_v3 = 1034,
    bcachefs_metadata_version_disk_accounting_inum = 1035,
    bcachefs_metadata_version_rebalance_work_acct_fix = 1036,
    bcachefs_metadata_version_inode_has_child_snapshots = 1037,
    bcachefs_metadata_version_backpointer_bucket_gen = 1038,
    bcachefs_metadata_version_disk_accounting_big_endian = 1039,
    bcachefs_metadata_version_reflink_p_may_update_opts = 1040,
    bcachefs_metadata_version_inode_depth = 1041,
    bcachefs_metadata_version_persistent_inode_cursors = 1042,
    bcachefs_metadata_version_autofix_errors = 1043,
    bcachefs_metadata_version_directory_size = 1044,
    bcachefs_metadata_version_cached_backpointers = 1045,
    bcachefs_metadata_version_stripe_backpointers = 1046,
    bcachefs_metadata_version_stripe_lru = 1047,
    bcachefs_metadata_version_casefolding = 1048,
    bcachefs_metadata_version_extent_flags = 1049,
    bcachefs_metadata_version_snapshot_deletion_v2 = 1050,
    bcachefs_metadata_version_fast_device_removal = 1051,
    bcachefs_metadata_version_inode_has_case_insensitive = 1052,
    bcachefs_metadata_version_extent_snapshot_whiteouts = 1053,
    bcachefs_metadata_version_31bit_dirent_offset = 1054,
    bcachefs_metadata_version_btree_node_accounting = 1055,
    bcachefs_metadata_version_sb_field_extent_type_u64s = 1056,
    bcachefs_metadata_version_reconcile = 1057,
    bcachefs_metadata_version_extented_key_type_error = 1058,
    bcachefs_metadata_version_bucket_stripe_index = 1059,
    bcachefs_metadata_version_no_sb_user_data_replicas = 1060,
    bcachefs_metadata_version_erasure_coding = 1061,
    bcachefs_metadata_version_need_discard_by_journal_seq = 1062,
    bcachefs_metadata_version_max = 1063,
}
#[repr(C, packed(8))]
#[derive(Debug, Copy, Clone)]
pub struct bch_sb_layout {
    pub magic: __uuid_t,
    pub layout_type: __u8,
    pub sb_max_size_bits: __u8,
    pub nr_superblocks: __u8,
    pub pad: [__u8; 5usize],
    pub sb_offset: [__le64; 61usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_sb_layout"][::std::mem::size_of::<bch_sb_layout>() - 512usize];
    ["Alignment of bch_sb_layout"][::std::mem::align_of::<bch_sb_layout>() - 8usize];
    [
        "Offset of field: bch_sb_layout::magic",
    ][::std::mem::offset_of!(bch_sb_layout, magic) - 0usize];
    [
        "Offset of field: bch_sb_layout::layout_type",
    ][::std::mem::offset_of!(bch_sb_layout, layout_type) - 16usize];
    [
        "Offset of field: bch_sb_layout::sb_max_size_bits",
    ][::std::mem::offset_of!(bch_sb_layout, sb_max_size_bits) - 17usize];
    [
        "Offset of field: bch_sb_layout::nr_superblocks",
    ][::std::mem::offset_of!(bch_sb_layout, nr_superblocks) - 18usize];
    [
        "Offset of field: bch_sb_layout::pad",
    ][::std::mem::offset_of!(bch_sb_layout, pad) - 19usize];
    [
        "Offset of field: bch_sb_layout::sb_offset",
    ][::std::mem::offset_of!(bch_sb_layout, sb_offset) - 24usize];
};
impl Default for bch_sb_layout {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C, align(8))]
pub struct bch_sb {
    pub csum: bch_csum,
    pub version: __le16,
    pub version_min: __le16,
    pub pad: [__le16; 2usize],
    pub magic: __uuid_t,
    pub uuid: __uuid_t,
    pub user_uuid: __uuid_t,
    pub label: [__u8; 32usize],
    pub offset: __le64,
    pub seq: __le64,
    pub block_size: __le16,
    pub dev_idx: __u8,
    pub nr_devices: __u8,
    pub u64s: __le32,
    pub time_base_lo: __le64,
    pub time_base_hi: __le32,
    pub time_precision: __le32,
    pub flags: [__le64; 7usize],
    pub write_time: __le64,
    pub features: [__le64; 2usize],
    pub compat: [__le64; 2usize],
    pub layout: bch_sb_layout,
    pub start: __IncompleteArrayField<bch_sb_field>,
    pub _data: __IncompleteArrayField<__le64>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_sb"][::std::mem::size_of::<bch_sb>() - 752usize];
    ["Alignment of bch_sb"][::std::mem::align_of::<bch_sb>() - 8usize];
    ["Offset of field: bch_sb::csum"][::std::mem::offset_of!(bch_sb, csum) - 0usize];
    [
        "Offset of field: bch_sb::version",
    ][::std::mem::offset_of!(bch_sb, version) - 16usize];
    [
        "Offset of field: bch_sb::version_min",
    ][::std::mem::offset_of!(bch_sb, version_min) - 18usize];
    ["Offset of field: bch_sb::pad"][::std::mem::offset_of!(bch_sb, pad) - 20usize];
    ["Offset of field: bch_sb::magic"][::std::mem::offset_of!(bch_sb, magic) - 24usize];
    ["Offset of field: bch_sb::uuid"][::std::mem::offset_of!(bch_sb, uuid) - 40usize];
    [
        "Offset of field: bch_sb::user_uuid",
    ][::std::mem::offset_of!(bch_sb, user_uuid) - 56usize];
    ["Offset of field: bch_sb::label"][::std::mem::offset_of!(bch_sb, label) - 72usize];
    [
        "Offset of field: bch_sb::offset",
    ][::std::mem::offset_of!(bch_sb, offset) - 104usize];
    ["Offset of field: bch_sb::seq"][::std::mem::offset_of!(bch_sb, seq) - 112usize];
    [
        "Offset of field: bch_sb::block_size",
    ][::std::mem::offset_of!(bch_sb, block_size) - 120usize];
    [
        "Offset of field: bch_sb::dev_idx",
    ][::std::mem::offset_of!(bch_sb, dev_idx) - 122usize];
    [
        "Offset of field: bch_sb::nr_devices",
    ][::std::mem::offset_of!(bch_sb, nr_devices) - 123usize];
    ["Offset of field: bch_sb::u64s"][::std::mem::offset_of!(bch_sb, u64s) - 124usize];
    [
        "Offset of field: bch_sb::time_base_lo",
    ][::std::mem::offset_of!(bch_sb, time_base_lo) - 128usize];
    [
        "Offset of field: bch_sb::time_base_hi",
    ][::std::mem::offset_of!(bch_sb, time_base_hi) - 136usize];
    [
        "Offset of field: bch_sb::time_precision",
    ][::std::mem::offset_of!(bch_sb, time_precision) - 140usize];
    ["Offset of field: bch_sb::flags"][::std::mem::offset_of!(bch_sb, flags) - 144usize];
    [
        "Offset of field: bch_sb::write_time",
    ][::std::mem::offset_of!(bch_sb, write_time) - 200usize];
    [
        "Offset of field: bch_sb::features",
    ][::std::mem::offset_of!(bch_sb, features) - 208usize];
    [
        "Offset of field: bch_sb::compat",
    ][::std::mem::offset_of!(bch_sb, compat) - 224usize];
    [
        "Offset of field: bch_sb::layout",
    ][::std::mem::offset_of!(bch_sb, layout) - 240usize];
    ["Offset of field: bch_sb::start"][::std::mem::offset_of!(bch_sb, start) - 752usize];
    ["Offset of field: bch_sb::_data"][::std::mem::offset_of!(bch_sb, _data) - 752usize];
};
impl Default for bch_sb {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub const BCH_SB_BLOCK_SIZE_OFFSET: ::std::os::raw::c_uint = 0;
pub const BCH_SB_BLOCK_SIZE_BITS: ::std::os::raw::c_uint = 16;
pub const BCH_SB_BLOCK_SIZE_MAX: __u16 = 65535;
pub const BCH_SB_INITIALIZED_OFFSET: ::std::os::raw::c_uint = 0;
pub const BCH_SB_INITIALIZED_BITS: ::std::os::raw::c_uint = 1;
pub const BCH_SB_INITIALIZED_MAX: __u64 = 1;
pub const BCH_SB_CLEAN_OFFSET: ::std::os::raw::c_uint = 1;
pub const BCH_SB_CLEAN_BITS: ::std::os::raw::c_uint = 1;
pub const BCH_SB_CLEAN_MAX: __u64 = 1;
pub const BCH_SB_CSUM_TYPE_OFFSET: ::std::os::raw::c_uint = 2;
pub const BCH_SB_CSUM_TYPE_BITS: ::std::os::raw::c_uint = 6;
pub const BCH_SB_CSUM_TYPE_MAX: __u64 = 63;
pub const BCH_SB_ERROR_ACTION_OFFSET: ::std::os::raw::c_uint = 8;
pub const BCH_SB_ERROR_ACTION_BITS: ::std::os::raw::c_uint = 4;
pub const BCH_SB_ERROR_ACTION_MAX: __u64 = 15;
pub const BCH_SB_BTREE_NODE_SIZE_OFFSET: ::std::os::raw::c_uint = 12;
pub const BCH_SB_BTREE_NODE_SIZE_BITS: ::std::os::raw::c_uint = 16;
pub const BCH_SB_BTREE_NODE_SIZE_MAX: __u64 = 65535;
pub const BCH_SB_GC_RESERVE_OFFSET: ::std::os::raw::c_uint = 28;
pub const BCH_SB_GC_RESERVE_BITS: ::std::os::raw::c_uint = 5;
pub const BCH_SB_GC_RESERVE_MAX: __u64 = 31;
pub const BCH_SB_ROOT_RESERVE_OFFSET: ::std::os::raw::c_uint = 33;
pub const BCH_SB_ROOT_RESERVE_BITS: ::std::os::raw::c_uint = 7;
pub const BCH_SB_ROOT_RESERVE_MAX: __u64 = 127;
pub const BCH_SB_META_CSUM_TYPE_OFFSET: ::std::os::raw::c_uint = 40;
pub const BCH_SB_META_CSUM_TYPE_BITS: ::std::os::raw::c_uint = 4;
pub const BCH_SB_META_CSUM_TYPE_MAX: __u64 = 15;
pub const BCH_SB_DATA_CSUM_TYPE_OFFSET: ::std::os::raw::c_uint = 44;
pub const BCH_SB_DATA_CSUM_TYPE_BITS: ::std::os::raw::c_uint = 4;
pub const BCH_SB_DATA_CSUM_TYPE_MAX: __u64 = 15;
pub const BCH_SB_META_REPLICAS_WANT_OFFSET: ::std::os::raw::c_uint = 48;
pub const BCH_SB_META_REPLICAS_WANT_BITS: ::std::os::raw::c_uint = 4;
pub const BCH_SB_META_REPLICAS_WANT_MAX: __u64 = 15;
pub const BCH_SB_DATA_REPLICAS_WANT_OFFSET: ::std::os::raw::c_uint = 52;
pub const BCH_SB_DATA_REPLICAS_WANT_BITS: ::std::os::raw::c_uint = 4;
pub const BCH_SB_DATA_REPLICAS_WANT_MAX: __u64 = 15;
pub const BCH_SB_POSIX_ACL_OFFSET: ::std::os::raw::c_uint = 56;
pub const BCH_SB_POSIX_ACL_BITS: ::std::os::raw::c_uint = 1;
pub const BCH_SB_POSIX_ACL_MAX: __u64 = 1;
pub const BCH_SB_USRQUOTA_OFFSET: ::std::os::raw::c_uint = 57;
pub const BCH_SB_USRQUOTA_BITS: ::std::os::raw::c_uint = 1;
pub const BCH_SB_USRQUOTA_MAX: __u64 = 1;
pub const BCH_SB_GRPQUOTA_OFFSET: ::std::os::raw::c_uint = 58;
pub const BCH_SB_GRPQUOTA_BITS: ::std::os::raw::c_uint = 1;
pub const BCH_SB_GRPQUOTA_MAX: __u64 = 1;
pub const BCH_SB_PRJQUOTA_OFFSET: ::std::os::raw::c_uint = 59;
pub const BCH_SB_PRJQUOTA_BITS: ::std::os::raw::c_uint = 1;
pub const BCH_SB_PRJQUOTA_MAX: __u64 = 1;
pub const BCH_SB_HAS_ERRORS_OFFSET: ::std::os::raw::c_uint = 60;
pub const BCH_SB_HAS_ERRORS_BITS: ::std::os::raw::c_uint = 1;
pub const BCH_SB_HAS_ERRORS_MAX: __u64 = 1;
pub const BCH_SB_HAS_TOPOLOGY_ERRORS_OFFSET: ::std::os::raw::c_uint = 61;
pub const BCH_SB_HAS_TOPOLOGY_ERRORS_BITS: ::std::os::raw::c_uint = 1;
pub const BCH_SB_HAS_TOPOLOGY_ERRORS_MAX: __u64 = 1;
pub const BCH_SB_BIG_ENDIAN_OFFSET: ::std::os::raw::c_uint = 62;
pub const BCH_SB_BIG_ENDIAN_BITS: ::std::os::raw::c_uint = 1;
pub const BCH_SB_BIG_ENDIAN_MAX: __u64 = 1;
pub const BCH_SB_PROMOTE_WHOLE_EXTENTS_OFFSET: ::std::os::raw::c_uint = 63;
pub const BCH_SB_PROMOTE_WHOLE_EXTENTS_BITS: ::std::os::raw::c_uint = 1;
pub const BCH_SB_PROMOTE_WHOLE_EXTENTS_MAX: __u64 = 1;
pub const BCH_SB_STR_HASH_TYPE_OFFSET: ::std::os::raw::c_uint = 0;
pub const BCH_SB_STR_HASH_TYPE_BITS: ::std::os::raw::c_uint = 4;
pub const BCH_SB_STR_HASH_TYPE_MAX: __u64 = 15;
pub const BCH_SB_COMPRESSION_TYPE_LO_OFFSET: ::std::os::raw::c_uint = 4;
pub const BCH_SB_COMPRESSION_TYPE_LO_BITS: ::std::os::raw::c_uint = 4;
pub const BCH_SB_COMPRESSION_TYPE_LO_MAX: __u64 = 15;
pub const BCH_SB_INODE_32BIT_OFFSET: ::std::os::raw::c_uint = 8;
pub const BCH_SB_INODE_32BIT_BITS: ::std::os::raw::c_uint = 1;
pub const BCH_SB_INODE_32BIT_MAX: __u64 = 1;
pub const BCH_SB_128_BIT_MACS_OFFSET: ::std::os::raw::c_uint = 9;
pub const BCH_SB_128_BIT_MACS_BITS: ::std::os::raw::c_uint = 1;
pub const BCH_SB_128_BIT_MACS_MAX: __u64 = 1;
pub const BCH_SB_ENCRYPTION_TYPE_OFFSET: ::std::os::raw::c_uint = 10;
pub const BCH_SB_ENCRYPTION_TYPE_BITS: ::std::os::raw::c_uint = 4;
pub const BCH_SB_ENCRYPTION_TYPE_MAX: __u64 = 15;
pub const BCH_SB_ENCODED_EXTENT_MAX_BITS_OFFSET: ::std::os::raw::c_uint = 14;
pub const BCH_SB_ENCODED_EXTENT_MAX_BITS_BITS: ::std::os::raw::c_uint = 6;
pub const BCH_SB_ENCODED_EXTENT_MAX_BITS_MAX: __u64 = 63;
pub const BCH_SB_META_REPLICAS_REQ_OFFSET: ::std::os::raw::c_uint = 20;
pub const BCH_SB_META_REPLICAS_REQ_BITS: ::std::os::raw::c_uint = 4;
pub const BCH_SB_META_REPLICAS_REQ_MAX: __u64 = 15;
pub const BCH_SB_DATA_REPLICAS_REQ_OFFSET: ::std::os::raw::c_uint = 24;
pub const BCH_SB_DATA_REPLICAS_REQ_BITS: ::std::os::raw::c_uint = 4;
pub const BCH_SB_DATA_REPLICAS_REQ_MAX: __u64 = 15;
pub const BCH_SB_PROMOTE_TARGET_OFFSET: ::std::os::raw::c_uint = 28;
pub const BCH_SB_PROMOTE_TARGET_BITS: ::std::os::raw::c_uint = 12;
pub const BCH_SB_PROMOTE_TARGET_MAX: __u64 = 4095;
pub const BCH_SB_FOREGROUND_TARGET_OFFSET: ::std::os::raw::c_uint = 40;
pub const BCH_SB_FOREGROUND_TARGET_BITS: ::std::os::raw::c_uint = 12;
pub const BCH_SB_FOREGROUND_TARGET_MAX: __u64 = 4095;
pub const BCH_SB_BACKGROUND_TARGET_OFFSET: ::std::os::raw::c_uint = 52;
pub const BCH_SB_BACKGROUND_TARGET_BITS: ::std::os::raw::c_uint = 12;
pub const BCH_SB_BACKGROUND_TARGET_MAX: __u64 = 4095;
pub const BCH_SB_BACKGROUND_COMPRESSION_TYPE_LO_OFFSET: ::std::os::raw::c_uint = 0;
pub const BCH_SB_BACKGROUND_COMPRESSION_TYPE_LO_BITS: ::std::os::raw::c_uint = 4;
pub const BCH_SB_BACKGROUND_COMPRESSION_TYPE_LO_MAX: __u64 = 15;
pub const BCH_SB_GC_RESERVE_BYTES_OFFSET: ::std::os::raw::c_uint = 4;
pub const BCH_SB_GC_RESERVE_BYTES_BITS: ::std::os::raw::c_uint = 60;
pub const BCH_SB_GC_RESERVE_BYTES_MAX: __u64 = 1152921504606846975;
pub const BCH_SB_ERASURE_CODE_OFFSET: ::std::os::raw::c_uint = 0;
pub const BCH_SB_ERASURE_CODE_BITS: ::std::os::raw::c_uint = 16;
pub const BCH_SB_ERASURE_CODE_MAX: __u64 = 65535;
pub const BCH_SB_METADATA_TARGET_OFFSET: ::std::os::raw::c_uint = 16;
pub const BCH_SB_METADATA_TARGET_BITS: ::std::os::raw::c_uint = 12;
pub const BCH_SB_METADATA_TARGET_MAX: __u64 = 4095;
pub const BCH_SB_SHARD_INUMS_OFFSET: ::std::os::raw::c_uint = 28;
pub const BCH_SB_SHARD_INUMS_BITS: ::std::os::raw::c_uint = 1;
pub const BCH_SB_SHARD_INUMS_MAX: __u64 = 1;
pub const BCH_SB_JOURNAL_FLUSH_DELAY_OFFSET: ::std::os::raw::c_uint = 30;
pub const BCH_SB_JOURNAL_FLUSH_DELAY_BITS: ::std::os::raw::c_uint = 32;
pub const BCH_SB_JOURNAL_FLUSH_DELAY_MAX: __u64 = 4294967295;
pub const BCH_SB_JOURNAL_FLUSH_DISABLED_OFFSET: ::std::os::raw::c_uint = 62;
pub const BCH_SB_JOURNAL_FLUSH_DISABLED_BITS: ::std::os::raw::c_uint = 1;
pub const BCH_SB_JOURNAL_FLUSH_DISABLED_MAX: __u64 = 1;
pub const BCH_SB_MULTI_DEVICE_OFFSET: ::std::os::raw::c_uint = 63;
pub const BCH_SB_MULTI_DEVICE_BITS: ::std::os::raw::c_uint = 1;
pub const BCH_SB_MULTI_DEVICE_MAX: __u64 = 1;
pub const BCH_SB_JOURNAL_RECLAIM_DELAY_OFFSET: ::std::os::raw::c_uint = 0;
pub const BCH_SB_JOURNAL_RECLAIM_DELAY_BITS: ::std::os::raw::c_uint = 32;
pub const BCH_SB_JOURNAL_RECLAIM_DELAY_MAX: __u64 = 4294967295;
pub const BCH_SB_JOURNAL_TRANSACTION_NAMES_OFFSET: ::std::os::raw::c_uint = 32;
pub const BCH_SB_JOURNAL_TRANSACTION_NAMES_BITS: ::std::os::raw::c_uint = 1;
pub const BCH_SB_JOURNAL_TRANSACTION_NAMES_MAX: __u64 = 1;
pub const BCH_SB_NOCOW_OFFSET: ::std::os::raw::c_uint = 33;
pub const BCH_SB_NOCOW_BITS: ::std::os::raw::c_uint = 1;
pub const BCH_SB_NOCOW_MAX: __u64 = 1;
pub const BCH_SB_WRITE_BUFFER_SIZE_OFFSET: ::std::os::raw::c_uint = 34;
pub const BCH_SB_WRITE_BUFFER_SIZE_BITS: ::std::os::raw::c_uint = 20;
pub const BCH_SB_WRITE_BUFFER_SIZE_MAX: __u64 = 1048575;
pub const BCH_SB_VERSION_UPGRADE_OFFSET: ::std::os::raw::c_uint = 54;
pub const BCH_SB_VERSION_UPGRADE_BITS: ::std::os::raw::c_uint = 2;
pub const BCH_SB_VERSION_UPGRADE_MAX: __u64 = 3;
pub const BCH_SB_COMPRESSION_TYPE_HI_OFFSET: ::std::os::raw::c_uint = 56;
pub const BCH_SB_COMPRESSION_TYPE_HI_BITS: ::std::os::raw::c_uint = 4;
pub const BCH_SB_COMPRESSION_TYPE_HI_MAX: __u64 = 15;
pub const BCH_SB_BACKGROUND_COMPRESSION_TYPE_HI_OFFSET: ::std::os::raw::c_uint = 60;
pub const BCH_SB_BACKGROUND_COMPRESSION_TYPE_HI_BITS: ::std::os::raw::c_uint = 4;
pub const BCH_SB_BACKGROUND_COMPRESSION_TYPE_HI_MAX: __u64 = 15;
pub const BCH_SB_VERSION_UPGRADE_COMPLETE_OFFSET: ::std::os::raw::c_uint = 0;
pub const BCH_SB_VERSION_UPGRADE_COMPLETE_BITS: ::std::os::raw::c_uint = 16;
pub const BCH_SB_VERSION_UPGRADE_COMPLETE_MAX: __u64 = 65535;
pub const BCH_SB_ALLOCATOR_STUCK_TIMEOUT_OFFSET: ::std::os::raw::c_uint = 16;
pub const BCH_SB_ALLOCATOR_STUCK_TIMEOUT_BITS: ::std::os::raw::c_uint = 16;
pub const BCH_SB_ALLOCATOR_STUCK_TIMEOUT_MAX: __u64 = 65535;
pub const BCH_SB_VERSION_INCOMPAT_OFFSET: ::std::os::raw::c_uint = 32;
pub const BCH_SB_VERSION_INCOMPAT_BITS: ::std::os::raw::c_uint = 16;
pub const BCH_SB_VERSION_INCOMPAT_MAX: __u64 = 65535;
pub const BCH_SB_VERSION_INCOMPAT_ALLOWED_OFFSET: ::std::os::raw::c_uint = 48;
pub const BCH_SB_VERSION_INCOMPAT_ALLOWED_BITS: ::std::os::raw::c_uint = 16;
pub const BCH_SB_VERSION_INCOMPAT_ALLOWED_MAX: __u64 = 65535;
pub const BCH_SB_SHARD_INUMS_NBITS_OFFSET: ::std::os::raw::c_uint = 0;
pub const BCH_SB_SHARD_INUMS_NBITS_BITS: ::std::os::raw::c_uint = 4;
pub const BCH_SB_SHARD_INUMS_NBITS_MAX: __u64 = 15;
pub const BCH_SB_WRITE_ERROR_TIMEOUT_OFFSET: ::std::os::raw::c_uint = 4;
pub const BCH_SB_WRITE_ERROR_TIMEOUT_BITS: ::std::os::raw::c_uint = 10;
pub const BCH_SB_WRITE_ERROR_TIMEOUT_MAX: __u64 = 1023;
pub const BCH_SB_CSUM_ERR_RETRY_NR_OFFSET: ::std::os::raw::c_uint = 14;
pub const BCH_SB_CSUM_ERR_RETRY_NR_BITS: ::std::os::raw::c_uint = 6;
pub const BCH_SB_CSUM_ERR_RETRY_NR_MAX: __u64 = 63;
pub const BCH_SB_DEGRADED_ACTION_OFFSET: ::std::os::raw::c_uint = 20;
pub const BCH_SB_DEGRADED_ACTION_BITS: ::std::os::raw::c_uint = 2;
pub const BCH_SB_DEGRADED_ACTION_MAX: __u64 = 3;
pub const BCH_SB_CASEFOLD_OFFSET: ::std::os::raw::c_uint = 22;
pub const BCH_SB_CASEFOLD_BITS: ::std::os::raw::c_uint = 1;
pub const BCH_SB_CASEFOLD_MAX: __u64 = 1;
pub const BCH_SB_REBALANCE_AC_ONLY_OFFSET: ::std::os::raw::c_uint = 23;
pub const BCH_SB_REBALANCE_AC_ONLY_BITS: ::std::os::raw::c_uint = 1;
pub const BCH_SB_REBALANCE_AC_ONLY_MAX: __u64 = 1;
pub const BCH_SB_WRITEBACK_TIMEOUT_OFFSET: ::std::os::raw::c_uint = 24;
pub const BCH_SB_WRITEBACK_TIMEOUT_BITS: ::std::os::raw::c_uint = 16;
pub const BCH_SB_WRITEBACK_TIMEOUT_MAX: __u64 = 65535;
pub const BCH_SB_EXTENT_BP_SHIFT_OFFSET: ::std::os::raw::c_uint = 40;
pub const BCH_SB_EXTENT_BP_SHIFT_BITS: ::std::os::raw::c_uint = 8;
pub const BCH_SB_EXTENT_BP_SHIFT_MAX: __u64 = 255;
pub const BCH_SB_SCRUB_JOURNAL_OFFSET: ::std::os::raw::c_uint = 48;
pub const BCH_SB_SCRUB_JOURNAL_BITS: ::std::os::raw::c_uint = 2;
pub const BCH_SB_SCRUB_JOURNAL_MAX: __u64 = 3;
pub const BCH_SB_EC_MAX_DATA_BLOCKS_OFFSET: ::std::os::raw::c_uint = 50;
pub const BCH_SB_EC_MAX_DATA_BLOCKS_BITS: ::std::os::raw::c_uint = 8;
pub const BCH_SB_EC_MAX_DATA_BLOCKS_MAX: __u64 = 255;
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_sb_feature {
    BCH_FEATURE_lz4 = 0,
    BCH_FEATURE_gzip = 1,
    BCH_FEATURE_zstd = 2,
    BCH_FEATURE_atomic_nlink = 3,
    BCH_FEATURE_ec = 4,
    BCH_FEATURE_journal_seq_blacklist_v3 = 5,
    BCH_FEATURE_reflink = 6,
    BCH_FEATURE_new_siphash = 7,
    BCH_FEATURE_inline_data = 8,
    BCH_FEATURE_new_extent_overwrite = 9,
    BCH_FEATURE_incompressible = 10,
    BCH_FEATURE_btree_ptr_v2 = 11,
    BCH_FEATURE_extents_above_btree_updates = 12,
    BCH_FEATURE_btree_updates_journalled = 13,
    BCH_FEATURE_reflink_inline_data = 14,
    BCH_FEATURE_new_varint = 15,
    BCH_FEATURE_journal_no_flush = 16,
    BCH_FEATURE_alloc_v2 = 17,
    BCH_FEATURE_extents_across_btree_nodes = 18,
    BCH_FEATURE_incompat_version_field = 19,
    BCH_FEATURE_casefolding = 20,
    BCH_FEATURE_no_alloc_info = 21,
    BCH_FEATURE_small_image = 22,
    BCH_FEATURE_no_default_sb = 23,
    BCH_FEATURE_NR = 24,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_sb_compat {
    BCH_COMPAT_alloc_info = 0,
    BCH_COMPAT_alloc_metadata = 1,
    BCH_COMPAT_extents_above_btree_updates_done = 2,
    BCH_COMPAT_bformat_overflow_done = 3,
    BCH_COMPAT_no_stale_ptrs = 4,
    BCH_COMPAT_NR = 5,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_version_upgrade_opts {
    BCH_VERSION_UPGRADE_compatible = 0,
    BCH_VERSION_UPGRADE_incompatible = 1,
    BCH_VERSION_UPGRADE_none = 2,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_error_actions {
    BCH_ON_ERROR_continue = 0,
    BCH_ON_ERROR_fix_safe = 1,
    BCH_ON_ERROR_panic = 2,
    BCH_ON_ERROR_ro = 3,
    BCH_ON_ERROR_NR = 4,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_degraded_actions {
    BCH_DEGRADED_ask = 0,
    BCH_DEGRADED_yes = 1,
    BCH_DEGRADED_very = 2,
    BCH_DEGRADED_no = 3,
    BCH_DEGRADED_ACTIONS_NR = 4,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_str_hash_type {
    BCH_STR_HASH_crc32c = 0,
    BCH_STR_HASH_crc64 = 1,
    BCH_STR_HASH_siphash_old = 2,
    BCH_STR_HASH_siphash = 3,
    BCH_STR_HASH_NR = 4,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_str_hash_opts {
    BCH_STR_HASH_OPT_crc32c = 0,
    BCH_STR_HASH_OPT_crc64 = 1,
    BCH_STR_HASH_OPT_siphash = 2,
    BCH_STR_HASH_OPT_NR = 3,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_csum_type {
    BCH_CSUM_none = 0,
    BCH_CSUM_crc32c_nonzero = 1,
    BCH_CSUM_crc64_nonzero = 2,
    BCH_CSUM_chacha20_poly1305_80 = 3,
    BCH_CSUM_chacha20_poly1305_128 = 4,
    BCH_CSUM_crc32c = 5,
    BCH_CSUM_crc64 = 6,
    BCH_CSUM_xxhash = 7,
    BCH_CSUM_NR = 8,
}
unsafe extern "C" {
    pub static bch_crc_bytes: [::std::os::raw::c_uint; 8usize];
}
unsafe extern "C" {
    #[link_name = "bch2_csum_type_is_encryption__extern"]
    pub fn bch2_csum_type_is_encryption(type_: bch_csum_type) -> bool;
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_csum_opt {
    BCH_CSUM_OPT_none = 0,
    BCH_CSUM_OPT_crc32c = 1,
    BCH_CSUM_OPT_crc64 = 2,
    BCH_CSUM_OPT_xxhash = 3,
    BCH_CSUM_OPT_NR = 4,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_compression_type {
    BCH_COMPRESSION_TYPE_none = 0,
    BCH_COMPRESSION_TYPE_lz4_old = 1,
    BCH_COMPRESSION_TYPE_gzip = 2,
    BCH_COMPRESSION_TYPE_lz4 = 3,
    BCH_COMPRESSION_TYPE_zstd = 4,
    BCH_COMPRESSION_TYPE_incompressible = 5,
    BCH_COMPRESSION_TYPE_NR = 6,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_compression_opts {
    BCH_COMPRESSION_OPT_none = 0,
    BCH_COMPRESSION_OPT_lz4 = 1,
    BCH_COMPRESSION_OPT_gzip = 2,
    BCH_COMPRESSION_OPT_zstd = 3,
    BCH_COMPRESSION_OPT_NR = 4,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_scrub_journal_opts {
    BCH_SCRUB_JOURNAL_unclean = 0,
    BCH_SCRUB_JOURNAL_no = 1,
    BCH_SCRUB_JOURNAL_always = 2,
    BCH_SCRUB_JOURNAL_OPT_NR = 3,
}
unsafe extern "C" {
    #[link_name = "__bch2_sb_magic__extern"]
    pub fn __bch2_sb_magic(sb: *mut bch_sb) -> __le64;
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_jset_entry_type {
    BCH_JSET_ENTRY_btree_keys = 0,
    BCH_JSET_ENTRY_btree_root = 1,
    BCH_JSET_ENTRY_prio_ptrs = 2,
    BCH_JSET_ENTRY_blacklist = 3,
    BCH_JSET_ENTRY_blacklist_v2 = 4,
    BCH_JSET_ENTRY_usage = 5,
    BCH_JSET_ENTRY_data_usage = 6,
    BCH_JSET_ENTRY_clock = 7,
    BCH_JSET_ENTRY_dev_usage = 8,
    BCH_JSET_ENTRY_log = 9,
    BCH_JSET_ENTRY_overwrite = 10,
    BCH_JSET_ENTRY_write_buffer_keys = 11,
    BCH_JSET_ENTRY_datetime = 12,
    BCH_JSET_ENTRY_log_bkey = 13,
    BCH_JSET_ENTRY_rewind_limit = 14,
    BCH_JSET_ENTRY_rewind = 15,
    BCH_JSET_ENTRY_NR = 16,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_fs_usage_type {
    BCH_FS_USAGE_reserved = 0,
    BCH_FS_USAGE_inodes = 1,
    BCH_FS_USAGE_key_version = 2,
    BCH_FS_USAGE_NR = 3,
}
#[repr(C, align(8))]
pub struct jset {
    pub csum: bch_csum,
    pub magic: __le64,
    pub seq: __le64,
    pub version: __le32,
    pub flags: __le32,
    pub u64s: __le32,
    pub encrypted_start: __IncompleteArrayField<__u8>,
    pub _read_clock: __le16,
    pub _write_clock: __le16,
    pub last_seq: __le64,
    pub start: __IncompleteArrayField<jset_entry>,
    pub _data: __IncompleteArrayField<__u64>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of jset"][::std::mem::size_of::<jset>() - 56usize];
    ["Alignment of jset"][::std::mem::align_of::<jset>() - 8usize];
    ["Offset of field: jset::csum"][::std::mem::offset_of!(jset, csum) - 0usize];
    ["Offset of field: jset::magic"][::std::mem::offset_of!(jset, magic) - 16usize];
    ["Offset of field: jset::seq"][::std::mem::offset_of!(jset, seq) - 24usize];
    ["Offset of field: jset::version"][::std::mem::offset_of!(jset, version) - 32usize];
    ["Offset of field: jset::flags"][::std::mem::offset_of!(jset, flags) - 36usize];
    ["Offset of field: jset::u64s"][::std::mem::offset_of!(jset, u64s) - 40usize];
    [
        "Offset of field: jset::encrypted_start",
    ][::std::mem::offset_of!(jset, encrypted_start) - 44usize];
    [
        "Offset of field: jset::_read_clock",
    ][::std::mem::offset_of!(jset, _read_clock) - 44usize];
    [
        "Offset of field: jset::_write_clock",
    ][::std::mem::offset_of!(jset, _write_clock) - 46usize];
    [
        "Offset of field: jset::last_seq",
    ][::std::mem::offset_of!(jset, last_seq) - 48usize];
    ["Offset of field: jset::start"][::std::mem::offset_of!(jset, start) - 56usize];
    ["Offset of field: jset::_data"][::std::mem::offset_of!(jset, _data) - 56usize];
};
impl Default for jset {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub const BTREE_MAX_DEPTH: _bindgen_ty_18 = _bindgen_ty_18::BTREE_MAX_DEPTH;
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_18 {
    BTREE_MAX_DEPTH = 4,
}
#[repr(C, packed(8))]
pub struct bset {
    pub seq: __le64,
    pub journal_seq: __le64,
    pub flags: __le32,
    pub version: __le16,
    pub u64s: __le16,
    pub start: __IncompleteArrayField<bkey_packed>,
    pub _data: __IncompleteArrayField<__u64>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bset"][::std::mem::size_of::<bset>() - 24usize];
    ["Alignment of bset"][::std::mem::align_of::<bset>() - 8usize];
    ["Offset of field: bset::seq"][::std::mem::offset_of!(bset, seq) - 0usize];
    [
        "Offset of field: bset::journal_seq",
    ][::std::mem::offset_of!(bset, journal_seq) - 8usize];
    ["Offset of field: bset::flags"][::std::mem::offset_of!(bset, flags) - 16usize];
    ["Offset of field: bset::version"][::std::mem::offset_of!(bset, version) - 20usize];
    ["Offset of field: bset::u64s"][::std::mem::offset_of!(bset, u64s) - 22usize];
    ["Offset of field: bset::start"][::std::mem::offset_of!(bset, start) - 24usize];
    ["Offset of field: bset::_data"][::std::mem::offset_of!(bset, _data) - 24usize];
};
impl Default for bset {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C, align(8))]
pub struct btree_node {
    pub csum: bch_csum,
    pub magic: __le64,
    pub flags: __le64,
    pub min_key: bpos,
    pub max_key: bpos,
    pub _ptr: bch_extent_ptr,
    pub format: bkey_format,
    pub __bindgen_anon_1: btree_node__bindgen_ty_1,
}
#[repr(C)]
pub struct btree_node__bindgen_ty_1 {
    pub keys: __BindgenUnionField<bset>,
    pub __bindgen_anon_1: __BindgenUnionField<btree_node__bindgen_ty_1__bindgen_ty_1>,
    pub bindgen_union_field: [u64; 3usize],
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct btree_node__bindgen_ty_1__bindgen_ty_1 {
    pub pad: [__u8; 22usize],
    pub u64s: __le16,
    pub _data: __IncompleteArrayField<__u64>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of btree_node__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<btree_node__bindgen_ty_1__bindgen_ty_1>() - 24usize];
    [
        "Alignment of btree_node__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<btree_node__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: btree_node__bindgen_ty_1__bindgen_ty_1::pad",
    ][::std::mem::offset_of!(btree_node__bindgen_ty_1__bindgen_ty_1, pad) - 0usize];
    [
        "Offset of field: btree_node__bindgen_ty_1__bindgen_ty_1::u64s",
    ][::std::mem::offset_of!(btree_node__bindgen_ty_1__bindgen_ty_1, u64s) - 22usize];
    [
        "Offset of field: btree_node__bindgen_ty_1__bindgen_ty_1::_data",
    ][::std::mem::offset_of!(btree_node__bindgen_ty_1__bindgen_ty_1, _data) - 24usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of btree_node__bindgen_ty_1",
    ][::std::mem::size_of::<btree_node__bindgen_ty_1>() - 24usize];
    [
        "Alignment of btree_node__bindgen_ty_1",
    ][::std::mem::align_of::<btree_node__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: btree_node__bindgen_ty_1::keys",
    ][::std::mem::offset_of!(btree_node__bindgen_ty_1, keys) - 0usize];
};
impl Default for btree_node__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of btree_node"][::std::mem::size_of::<btree_node>() - 160usize];
    ["Alignment of btree_node"][::std::mem::align_of::<btree_node>() - 8usize];
    [
        "Offset of field: btree_node::csum",
    ][::std::mem::offset_of!(btree_node, csum) - 0usize];
    [
        "Offset of field: btree_node::magic",
    ][::std::mem::offset_of!(btree_node, magic) - 16usize];
    [
        "Offset of field: btree_node::flags",
    ][::std::mem::offset_of!(btree_node, flags) - 24usize];
    [
        "Offset of field: btree_node::min_key",
    ][::std::mem::offset_of!(btree_node, min_key) - 32usize];
    [
        "Offset of field: btree_node::max_key",
    ][::std::mem::offset_of!(btree_node, max_key) - 52usize];
    [
        "Offset of field: btree_node::_ptr",
    ][::std::mem::offset_of!(btree_node, _ptr) - 72usize];
    [
        "Offset of field: btree_node::format",
    ][::std::mem::offset_of!(btree_node, format) - 80usize];
};
impl Default for btree_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C, align(8))]
pub struct btree_node_entry {
    pub csum: bch_csum,
    pub __bindgen_anon_1: btree_node_entry__bindgen_ty_1,
}
#[repr(C)]
pub struct btree_node_entry__bindgen_ty_1 {
    pub keys: __BindgenUnionField<bset>,
    pub __bindgen_anon_1: __BindgenUnionField<
        btree_node_entry__bindgen_ty_1__bindgen_ty_1,
    >,
    pub bindgen_union_field: [u64; 3usize],
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct btree_node_entry__bindgen_ty_1__bindgen_ty_1 {
    pub pad: [__u8; 22usize],
    pub u64s: __le16,
    pub _data: __IncompleteArrayField<__u64>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of btree_node_entry__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<btree_node_entry__bindgen_ty_1__bindgen_ty_1>() - 24usize];
    [
        "Alignment of btree_node_entry__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<btree_node_entry__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: btree_node_entry__bindgen_ty_1__bindgen_ty_1::pad",
    ][::std::mem::offset_of!(btree_node_entry__bindgen_ty_1__bindgen_ty_1, pad)
        - 0usize];
    [
        "Offset of field: btree_node_entry__bindgen_ty_1__bindgen_ty_1::u64s",
    ][::std::mem::offset_of!(btree_node_entry__bindgen_ty_1__bindgen_ty_1, u64s)
        - 22usize];
    [
        "Offset of field: btree_node_entry__bindgen_ty_1__bindgen_ty_1::_data",
    ][::std::mem::offset_of!(btree_node_entry__bindgen_ty_1__bindgen_ty_1, _data)
        - 24usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of btree_node_entry__bindgen_ty_1",
    ][::std::mem::size_of::<btree_node_entry__bindgen_ty_1>() - 24usize];
    [
        "Alignment of btree_node_entry__bindgen_ty_1",
    ][::std::mem::align_of::<btree_node_entry__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: btree_node_entry__bindgen_ty_1::keys",
    ][::std::mem::offset_of!(btree_node_entry__bindgen_ty_1, keys) - 0usize];
};
impl Default for btree_node_entry__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of btree_node_entry"][::std::mem::size_of::<btree_node_entry>() - 40usize];
    [
        "Alignment of btree_node_entry",
    ][::std::mem::align_of::<btree_node_entry>() - 8usize];
    [
        "Offset of field: btree_node_entry::csum",
    ][::std::mem::offset_of!(btree_node_entry, csum) - 0usize];
};
impl Default for btree_node_entry {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_errcode {
    BCH_ERR_START = 2048,
    BCH_ERR_blockdev_io_error = 2049,
    BCH_ERR_BLK_STS_NOTSUPP = 2050,
    BCH_ERR_BLK_STS_TIMEOUT = 2051,
    BCH_ERR_BLK_STS_NOSPC = 2052,
    BCH_ERR_BLK_STS_TRANSPORT = 2053,
    BCH_ERR_BLK_STS_TARGET = 2054,
    BCH_ERR_BLK_STS_RESV_CONFLICT = 2055,
    BCH_ERR_BLK_STS_MEDIUM = 2056,
    BCH_ERR_BLK_STS_PROTECTION = 2057,
    BCH_ERR_BLK_STS_RESOURCE = 2058,
    BCH_ERR_BLK_STS_IOERR = 2059,
    BCH_ERR_BLK_STS_DM_REQUEUE = 2060,
    BCH_ERR_BLK_STS_AGAIN = 2061,
    BCH_ERR_BLK_STS_DEV_RESOURCE = 2062,
    BCH_ERR_BLK_STS_ZONE_OPEN_RESOURCE = 2063,
    BCH_ERR_BLK_STS_ZONE_ACTIVE_RESOURCE = 2064,
    BCH_ERR_BLK_STS_OFFLINE = 2065,
    BCH_ERR_BLK_STS_DURATION_LIMIT = 2066,
    BCH_ERR_BLK_STS_INVAL = 2067,
    BCH_ERR_BLK_STS_REMOVED = 2068,
    BCH_ERR_BLK_STS_UNKNOWN = 2069,
    BCH_ERR_zstd_error = 2070,
    BCH_ERR_ZSTD_error_GENERIC = 2071,
    BCH_ERR_ZSTD_error_prefix_unknown = 2072,
    BCH_ERR_ZSTD_error_version_unsupported = 2073,
    BCH_ERR_ZSTD_error_frameParameter_unsupported = 2074,
    BCH_ERR_ZSTD_error_frameParameter_windowTooLarge = 2075,
    BCH_ERR_ZSTD_error_corruption_detected = 2076,
    BCH_ERR_ZSTD_error_checksum_wrong = 2077,
    BCH_ERR_ZSTD_error_dictionary_corrupted = 2078,
    BCH_ERR_ZSTD_error_dictionary_wrong = 2079,
    BCH_ERR_ZSTD_error_dictionaryCreation_failed = 2080,
    BCH_ERR_ZSTD_error_parameter_unsupported = 2081,
    BCH_ERR_ZSTD_error_parameter_outOfBound = 2082,
    BCH_ERR_ZSTD_error_tableLog_tooLarge = 2083,
    BCH_ERR_ZSTD_error_maxSymbolValue_tooLarge = 2084,
    BCH_ERR_ZSTD_error_maxSymbolValue_tooSmall = 2085,
    BCH_ERR_ZSTD_error_stage_wrong = 2086,
    BCH_ERR_ZSTD_error_init_missing = 2087,
    BCH_ERR_ZSTD_error_memory_allocation = 2088,
    BCH_ERR_ZSTD_error_workSpace_tooSmall = 2089,
    BCH_ERR_ZSTD_error_dstSize_tooSmall = 2090,
    BCH_ERR_ZSTD_error_srcSize_wrong = 2091,
    BCH_ERR_ZSTD_error_dstBuffer_null = 2092,
    BCH_ERR_ZSTD_error_frameIndex_tooLarge = 2093,
    BCH_ERR_ZSTD_error_seekableIO = 2094,
    BCH_ERR_ZSTD_error_dstBuffer_wrong = 2095,
    BCH_ERR_ZSTD_error_srcBuffer_wrong = 2096,
    BCH_ERR_ZSTD_error_unknown = 2097,
    BCH_ERR_ERANGE_option_too_small = 2098,
    BCH_ERR_ERANGE_option_too_big = 2099,
    BCH_ERR_projid_too_big = 2100,
    BCH_ERR_injected = 2101,
    BCH_ERR_injected_fs_start = 2102,
    BCH_ERR_mount_option = 2103,
    BCH_ERR_option_name = 2104,
    BCH_ERR_option_value = 2105,
    BCH_ERR_option_not_bool = 2106,
    BCH_ERR_ENOMEM_stripe_buf = 2107,
    BCH_ERR_ENOMEM_replicas_table = 2108,
    BCH_ERR_ENOMEM_cpu_replicas = 2109,
    BCH_ERR_ENOMEM_replicas_gc = 2110,
    BCH_ERR_ENOMEM_disk_groups_validate = 2111,
    BCH_ERR_ENOMEM_disk_groups_to_cpu = 2112,
    BCH_ERR_ENOMEM_mark_snapshot = 2113,
    BCH_ERR_ENOMEM_mark_stripe = 2114,
    BCH_ERR_ENOMEM_mark_stripe_ptr = 2115,
    BCH_ERR_ENOMEM_btree_key_cache_create = 2116,
    BCH_ERR_ENOMEM_btree_key_cache_fill = 2117,
    BCH_ERR_ENOMEM_btree_key_cache_insert = 2118,
    BCH_ERR_ENOMEM_trans_kmalloc = 2119,
    BCH_ERR_ENOMEM_trans_log_msg = 2120,
    BCH_ERR_ENOMEM_do_encrypt = 2121,
    BCH_ERR_ENOMEM_ec_read_extent = 2122,
    BCH_ERR_ENOMEM_ec_stripe_mem_alloc = 2123,
    BCH_ERR_ENOMEM_ec_new_stripe_alloc = 2124,
    BCH_ERR_ENOMEM_fs_btree_cache_init = 2125,
    BCH_ERR_ENOMEM_fs_btree_key_cache_init = 2126,
    BCH_ERR_ENOMEM_fs_counters_init = 2127,
    BCH_ERR_ENOMEM_fs_btree_write_buffer_init = 2128,
    BCH_ERR_ENOMEM_io_clock_init = 2129,
    BCH_ERR_ENOMEM_blacklist_table_init = 2130,
    BCH_ERR_ENOMEM_sb_realloc_injected = 2131,
    BCH_ERR_ENOMEM_sb_bio_realloc = 2132,
    BCH_ERR_ENOMEM_sb_buf_realloc = 2133,
    BCH_ERR_ENOMEM_sb_journal_validate = 2134,
    BCH_ERR_ENOMEM_sb_journal_v2_validate = 2135,
    BCH_ERR_ENOMEM_journal_entry_add = 2136,
    BCH_ERR_ENOMEM_journal_read_buf_realloc = 2137,
    BCH_ERR_ENOMEM_btree_interior_update_worker_init = 2138,
    BCH_ERR_ENOMEM_btree_interior_update_pool_init = 2139,
    BCH_ERR_ENOMEM_bio_read_init = 2140,
    BCH_ERR_ENOMEM_bio_read_split_init = 2141,
    BCH_ERR_ENOMEM_bio_write_init = 2142,
    BCH_ERR_ENOMEM_promote_limit_init = 2143,
    BCH_ERR_ENOMEM_bio_bounce_pages_init = 2144,
    BCH_ERR_ENOMEM_writepage_bioset_init = 2145,
    BCH_ERR_ENOMEM_writepage_buf_pool_init = 2146,
    BCH_ERR_ENOMEM_dio_read_bioset_init = 2147,
    BCH_ERR_ENOMEM_dio_write_bioset_init = 2148,
    BCH_ERR_ENOMEM_nocow_flush_bioset_init = 2149,
    BCH_ERR_ENOMEM_promote_table_init = 2150,
    BCH_ERR_ENOMEM_async_obj_init = 2151,
    BCH_ERR_ENOMEM_compression_bounce_read_init = 2152,
    BCH_ERR_ENOMEM_compression_bounce_write_init = 2153,
    BCH_ERR_ENOMEM_compression_workspace_init = 2154,
    BCH_ERR_ENOMEM_backpointer_mismatches_bitmap = 2155,
    BCH_ERR_compression_workspace_not_initialized = 2156,
    BCH_ERR_ENOMEM_bucket_gens = 2157,
    BCH_ERR_ENOMEM_buckets_nouse = 2158,
    BCH_ERR_ENOMEM_usage_init = 2159,
    BCH_ERR_ENOMEM_btree_node_read_all_replicas = 2160,
    BCH_ERR_ENOMEM_btree_node_reclaim = 2161,
    BCH_ERR_ENOMEM_btree_node_mem_alloc = 2162,
    BCH_ERR_ENOMEM_btree_cache_cannibalize_lock = 2163,
    BCH_ERR_ENOMEM_set_nr_journal_buckets = 2164,
    BCH_ERR_ENOMEM_dev_journal_init = 2165,
    BCH_ERR_ENOMEM_journal_pin_fifo = 2166,
    BCH_ERR_ENOMEM_journal_buf = 2167,
    BCH_ERR_ENOMEM_gc_start = 2168,
    BCH_ERR_ENOMEM_gc_alloc_start = 2169,
    BCH_ERR_ENOMEM_gc_reflink_start = 2170,
    BCH_ERR_ENOMEM_gc_gens = 2171,
    BCH_ERR_ENOMEM_gc_repair_key = 2172,
    BCH_ERR_ENOMEM_fsck_extent_ends_at = 2173,
    BCH_ERR_ENOMEM_fsck_add_nlink = 2174,
    BCH_ERR_ENOMEM_journal_key_insert = 2175,
    BCH_ERR_ENOMEM_journal_keys_sort = 2176,
    BCH_ERR_ENOMEM_read_superblock_clean = 2177,
    BCH_ERR_ENOMEM_fs_alloc = 2178,
    BCH_ERR_ENOMEM_fs_name_alloc = 2179,
    BCH_ERR_ENOMEM_fs_other_alloc = 2180,
    BCH_ERR_ENOMEM_dev_alloc = 2181,
    BCH_ERR_ENOMEM_disk_accounting = 2182,
    BCH_ERR_ENOMEM_stripe_head_alloc = 2183,
    BCH_ERR_ENOMEM_journal_read_bucket = 2184,
    BCH_ERR_ENOMEM_acl = 2185,
    BCH_ERR_ENOMEM_move_extent = 2186,
    BCH_ERR_ENOMEM_reconcile_scan_in_flight = 2187,
    BCH_ERR_ENOSPC_disk_reservation = 2188,
    BCH_ERR_ENOSPC_bucket_alloc = 2189,
    BCH_ERR_ENOSPC_disk_label_add = 2190,
    BCH_ERR_ENOSPC_stripe_create = 2191,
    BCH_ERR_ENOSPC_inode_create = 2192,
    BCH_ERR_ENOSPC_str_hash_create = 2193,
    BCH_ERR_ENOSPC_snapshot_create = 2194,
    BCH_ERR_ENOSPC_subvolume_create = 2195,
    BCH_ERR_ENOSPC_sb = 2196,
    BCH_ERR_ENOSPC_sb_journal = 2197,
    BCH_ERR_ENOSPC_sb_journal_seq_blacklist = 2198,
    BCH_ERR_ENOSPC_sb_quota = 2199,
    BCH_ERR_ENOSPC_sb_replicas = 2200,
    BCH_ERR_ENOSPC_sb_members = 2201,
    BCH_ERR_ENOSPC_sb_members_v2 = 2202,
    BCH_ERR_ENOSPC_sb_extent_type_u64s = 2203,
    BCH_ERR_ENOSPC_sb_crypt = 2204,
    BCH_ERR_ENOSPC_sb_downgrade = 2205,
    BCH_ERR_ENOSPC_btree_slot = 2206,
    BCH_ERR_ENOSPC_snapshot_tree = 2207,
    BCH_ERR_ENOENT_bkey_type_mismatch = 2208,
    BCH_ERR_ENOENT_str_hash_lookup = 2209,
    BCH_ERR_ENOENT_str_hash_set_must_replace = 2210,
    BCH_ERR_ENOENT_inode = 2211,
    BCH_ERR_ENOENT_not_subvol = 2212,
    BCH_ERR_ENOENT_not_directory = 2213,
    BCH_ERR_ENOENT_directory_dead = 2214,
    BCH_ERR_ENOENT_subvolume = 2215,
    BCH_ERR_ENOENT_snapshot = 2216,
    BCH_ERR_ENOENT_snapshot_tree = 2217,
    BCH_ERR_ENOENT_dirent_doesnt_match_inode = 2218,
    BCH_ERR_ENOENT_dev_not_found = 2219,
    BCH_ERR_ENOENT_dev_bucket_not_found = 2220,
    BCH_ERR_ENOENT_dev_idx_not_found = 2221,
    BCH_ERR_ENOENT_inode_no_backpointer = 2222,
    BCH_ERR_ENOENT_no_snapshot_tree_subvol = 2223,
    BCH_ERR_btree_node_dying = 2224,
    BCH_ERR_ENOTEMPTY_dir_not_empty = 2225,
    BCH_ERR_ENOTEMPTY_subvol_not_empty = 2226,
    BCH_ERR_EEXIST_str_hash_set = 2227,
    BCH_ERR_EEXIST_discard_in_flight_add = 2228,
    BCH_ERR_EEXIST_subvolume_create = 2229,
    BCH_ERR_open_buckets_empty = 2230,
    BCH_ERR_freelist_empty = 2231,
    BCH_ERR_stripe_needs_block_evacuate = 2232,
    BCH_ERR_stripe_insufficient_devices = 2233,
    BCH_ERR_max_discards_in_flight = 2234,
    BCH_ERR_ec_alloc_failed = 2235,
    BCH_ERR_no_buckets_found = 2236,
    BCH_ERR_bucket_alloc_no_progress = 2237,
    BCH_ERR_transaction_restart = 2238,
    BCH_ERR_transaction_restart_fault_inject = 2239,
    BCH_ERR_transaction_restart_relock = 2240,
    BCH_ERR_transaction_restart_relock_path = 2241,
    BCH_ERR_transaction_restart_relock_path_intent = 2242,
    BCH_ERR_transaction_restart_too_many_iters = 2243,
    BCH_ERR_transaction_restart_lock_node_reused = 2244,
    BCH_ERR_transaction_restart_fill_relock = 2245,
    BCH_ERR_transaction_restart_fill_mem_alloc_fail = 2246,
    BCH_ERR_transaction_restart_lock_waitlist_alloc = 2247,
    BCH_ERR_transaction_restart_mem_realloced = 2248,
    BCH_ERR_transaction_restart_in_traverse_all = 2249,
    BCH_ERR_transaction_restart_would_deadlock = 2250,
    BCH_ERR_transaction_restart_would_deadlock_write = 2251,
    BCH_ERR_transaction_restart_deadlock_recursion_limit = 2252,
    BCH_ERR_transaction_restart_deadlock_waitlist_alloc = 2253,
    BCH_ERR_transaction_restart_upgrade = 2254,
    BCH_ERR_transaction_restart_key_cache_fill = 2255,
    BCH_ERR_transaction_restart_key_cache_raced = 2256,
    BCH_ERR_transaction_restart_lock_root_race = 2257,
    BCH_ERR_transaction_restart_split_race = 2258,
    BCH_ERR_transaction_restart_split_with_interior_updates = 2259,
    BCH_ERR_transaction_restart_write_buffer_flush = 2260,
    BCH_ERR_transaction_restart_nested = 2261,
    BCH_ERR_transaction_restart_commit = 2262,
    BCH_ERR_transaction_restart_journal_overwrites_changed = 2263,
    BCH_ERR_no_btree_node = 2264,
    BCH_ERR_no_btree_node_relock = 2265,
    BCH_ERR_no_btree_node_upgrade = 2266,
    BCH_ERR_no_btree_node_drop = 2267,
    BCH_ERR_no_btree_node_lock_root = 2268,
    BCH_ERR_no_btree_node_up = 2269,
    BCH_ERR_no_btree_node_down = 2270,
    BCH_ERR_no_btree_node_init = 2271,
    BCH_ERR_no_btree_node_cached = 2272,
    BCH_ERR_no_btree_node_srcu_reset = 2273,
    BCH_ERR_no_btree_node_nofill = 2274,
    BCH_ERR_no_btree_node_reused = 2275,
    BCH_ERR_btree_insert_fail = 2276,
    BCH_ERR_btree_insert_btree_node_full = 2277,
    BCH_ERR_btree_insert_need_mark_replicas = 2278,
    BCH_ERR_btree_insert_need_journal_res = 2279,
    BCH_ERR_btree_insert_need_journal_reclaim = 2280,
    BCH_ERR_backpointer_to_overwritten_btree_node = 2281,
    BCH_ERR_journal_reclaim_would_deadlock = 2282,
    BCH_ERR_journal_rewind_no_overwrites = 2283,
    BCH_ERR_fsck = 2284,
    BCH_ERR_fsck_ask = 2285,
    BCH_ERR_fsck_fix = 2286,
    BCH_ERR_fsck_delete_bkey = 2287,
    BCH_ERR_fsck_ignore = 2288,
    BCH_ERR_fsck_errors_not_fixed = 2289,
    BCH_ERR_fsck_repair_unimplemented = 2290,
    BCH_ERR_fsck_repair_impossible = 2291,
    BCH_ERR_recovery_will_run = 2292,
    BCH_ERR_restart_recovery = 2293,
    BCH_ERR_cannot_rewind_recovery = 2294,
    BCH_ERR_recovery_pass_will_run = 2295,
    BCH_ERR_bkey_was_deleted = 2296,
    BCH_ERR_bucket_not_moveable = 2297,
    BCH_ERR_bucket_not_moveable_dev_not_rw = 2298,
    BCH_ERR_bucket_not_moveable_bucket_open = 2299,
    BCH_ERR_bucket_not_moveable_bp_mismatch = 2300,
    BCH_ERR_bucket_not_moveable_lru_race = 2301,
    BCH_ERR_data_update_done = 2302,
    BCH_ERR_data_update_done_unwritten = 2303,
    BCH_ERR_data_update_done_no_writes_needed = 2304,
    BCH_ERR_data_update_fail = 2305,
    BCH_ERR_data_update_fail_would_block = 2306,
    BCH_ERR_data_update_fail_in_flight = 2307,
    BCH_ERR_data_update_fail_no_snapshot = 2308,
    BCH_ERR_data_update_fail_no_rw_devs = 2309,
    BCH_ERR_data_update_fail_need_copygc = 2310,
    BCH_ERR_reflink_p_may_update_options_unset = 2311,
    BCH_ERR_EPERM_non_admin = 2312,
    BCH_ERR_EPERM_non_admin_or_owner = 2313,
    BCH_ERR_device_state_not_allowed = 2314,
    BCH_ERR_member_info_missing = 2315,
    BCH_ERR_mismatched_block_size = 2316,
    BCH_ERR_block_size_too_small = 2317,
    BCH_ERR_bucket_size_too_small = 2318,
    BCH_ERR_device_size_too_small = 2319,
    BCH_ERR_device_size_too_big = 2320,
    BCH_ERR_device_not_a_member_of_filesystem = 2321,
    BCH_ERR_device_has_been_removed = 2322,
    BCH_ERR_device_splitbrain = 2323,
    BCH_ERR_device_already_online = 2324,
    BCH_ERR_filesystem_uuid_already_open = 2325,
    BCH_ERR_insufficient_devices_to_start = 2326,
    BCH_ERR_chardev_init_error = 2327,
    BCH_ERR_sysfs_init_error = 2328,
    BCH_ERR_invalid = 2329,
    BCH_ERR_internal_fsck_err = 2330,
    BCH_ERR_opt_parse_error = 2331,
    BCH_ERR_remove_with_metadata_missing_unimplemented = 2332,
    BCH_ERR_remove_would_lose_data = 2333,
    BCH_ERR_remove_by_backpointer_did_not_terminate = 2334,
    BCH_ERR_no_resize_with_buckets_nouse = 2335,
    BCH_ERR_inode_unpack_error = 2336,
    BCH_ERR_inode_not_unlinked = 2337,
    BCH_ERR_inode_has_child_snapshot = 2338,
    BCH_ERR_varint_decode_error = 2339,
    BCH_ERR_erasure_coding_found_btree_node = 2340,
    BCH_ERR_erasure_coding_stripe_update_err = 2341,
    BCH_ERR_option_negative = 2342,
    BCH_ERR_topology_repair = 2343,
    BCH_ERR_EINVAL_unaligned_io = 2344,
    BCH_ERR_EINVAL_rename_bad_flags = 2345,
    BCH_ERR_EINVAL_setattr_bad_file_type = 2346,
    BCH_ERR_EINVAL_get_name_not_dir = 2347,
    BCH_ERR_EINVAL_reconfigure_read_write = 2348,
    BCH_ERR_EINVAL_fcollapse_finsert_unaligned = 2349,
    BCH_ERR_EINVAL_finsert_past_eof = 2350,
    BCH_ERR_EINVAL_fcollapse_past_eof = 2351,
    BCH_ERR_EINVAL_remap_bad_flags = 2352,
    BCH_ERR_EINVAL_remap_unaligned = 2353,
    BCH_ERR_EINVAL_remap_overlapping = 2354,
    BCH_ERR_EINVAL_setlabel_too_long = 2355,
    BCH_ERR_EINVAL_goingdown_bad_flags = 2356,
    BCH_ERR_EINVAL_subvol_create_bad_flags = 2357,
    BCH_ERR_EINVAL_subvol_create_flags_mismatch = 2358,
    BCH_ERR_EINVAL_subvol_destroy_bad_flags = 2359,
    BCH_ERR_EINVAL_subvol_readdir_pad = 2360,
    BCH_ERR_EINVAL_subvol_to_path_no_buf = 2361,
    BCH_ERR_EINVAL_snapshot_tree_query_pad = 2362,
    BCH_ERR_EINVAL_fiemap_overflow = 2363,
    BCH_ERR_EINVAL_snapshot_not_subvol_root = 2364,
    BCH_ERR_EINVAL_quota_enable_acct = 2365,
    BCH_ERR_EINVAL_quota_enable_usrquota = 2366,
    BCH_ERR_EINVAL_quota_enable_grpquota = 2367,
    BCH_ERR_EINVAL_quota_enable_prjquota = 2368,
    BCH_ERR_EINVAL_quota_remove_usrquota = 2369,
    BCH_ERR_EINVAL_quota_remove_grpquota = 2370,
    BCH_ERR_EINVAL_quota_remove_prjquota = 2371,
    BCH_ERR_EINVAL_quota_set_info_bad_type = 2372,
    BCH_ERR_EINVAL_quota_set_info_bad_field = 2373,
    BCH_ERR_EINVAL_xattr_get_bad_opt = 2374,
    BCH_ERR_EINVAL_xattr_get_not_inode_opt = 2375,
    BCH_ERR_EINVAL_xattr_set_bad_opt = 2376,
    BCH_ERR_EINVAL_xattr_set_not_inode_opt = 2377,
    BCH_ERR_EINVAL_fsck_offline_bad_flags = 2378,
    BCH_ERR_EINVAL_fsck_online_bad_passes = 2379,
    BCH_ERR_EINVAL_fsck_online_bad_flags = 2380,
    BCH_ERR_EINVAL_journal_replay_key_bad_btree_depth = 2381,
    BCH_ERR_EINVAL_dev_resize_shrink = 2382,
    BCH_ERR_EINVAL_missing_new_extent_overwrite = 2383,
    BCH_ERR_EINVAL_version_min_too_old = 2384,
    BCH_ERR_EINVAL_block_size_needs_thp = 2385,
    BCH_ERR_EINVAL_utf8_load_failed = 2386,
    BCH_ERR_EINVAL_casefolding_no_unicode = 2387,
    BCH_ERR_EINVAL_no_version_check_start = 2388,
    BCH_ERR_EINVAL_ioctl_disk_add_bad_flags = 2389,
    BCH_ERR_EINVAL_ioctl_disk_add_v2_bad_flags = 2390,
    BCH_ERR_EINVAL_ioctl_disk_remove_bad_flags = 2391,
    BCH_ERR_EINVAL_ioctl_disk_remove_v2_bad_flags = 2392,
    BCH_ERR_EINVAL_ioctl_disk_online_bad_flags = 2393,
    BCH_ERR_EINVAL_ioctl_disk_online_v2_bad_flags = 2394,
    BCH_ERR_EINVAL_ioctl_disk_offline_bad_flags = 2395,
    BCH_ERR_EINVAL_ioctl_disk_offline_v2_bad_flags = 2396,
    BCH_ERR_EINVAL_ioctl_disk_set_state_bad_args = 2397,
    BCH_ERR_EINVAL_ioctl_disk_set_state_v2_bad_args = 2398,
    BCH_ERR_EINVAL_ioctl_data_read_short_buf = 2399,
    BCH_ERR_EINVAL_ioctl_data_bad_op = 2400,
    BCH_ERR_EINVAL_ioctl_fs_usage_not_started = 2401,
    BCH_ERR_EINVAL_ioctl_query_accounting_not_started = 2402,
    BCH_ERR_EINVAL_ioctl_dev_usage_not_started = 2403,
    BCH_ERR_EINVAL_ioctl_dev_usage_bad_flags = 2404,
    BCH_ERR_EINVAL_ioctl_dev_usage_v2_not_started = 2405,
    BCH_ERR_EINVAL_ioctl_dev_usage_v2_bad_flags = 2406,
    BCH_ERR_EINVAL_ioctl_read_super_bad_flags = 2407,
    BCH_ERR_EINVAL_ioctl_disk_get_idx_bad_dev = 2408,
    BCH_ERR_EINVAL_ioctl_disk_resize_bad_flags = 2409,
    BCH_ERR_EINVAL_ioctl_disk_resize_v2_bad_flags = 2410,
    BCH_ERR_EINVAL_ioctl_disk_resize_journal_bad_flags = 2411,
    BCH_ERR_EINVAL_ioctl_disk_resize_journal_too_big = 2412,
    BCH_ERR_EINVAL_ioctl_disk_resize_journal_v2_bad_flags = 2413,
    BCH_ERR_EINVAL_ioctl_disk_resize_journal_v2_too_big = 2414,
    BCH_ERR_EINVAL_ioctl_not_started = 2415,
    BCH_ERR_EINVAL_journal_write_overran_available_space = 2416,
    BCH_ERR_EINVAL_journal_bucket_not_found = 2417,
    BCH_ERR_EINVAL_journal_seq_overflow = 2418,
    BCH_ERR_EINVAL_journal_entry_version_incompatible = 2419,
    BCH_ERR_EINVAL_journal_validate_version_incompatible = 2420,
    BCH_ERR_EINVAL_journal_rewind_before_discard = 2421,
    BCH_ERR_EINVAL_opt_target_parse_not_found = 2422,
    BCH_ERR_EINVAL_disable_encryption_no_crypt = 2423,
    BCH_ERR_EINVAL_reflink_gc_table_mismatch = 2424,
    BCH_ERR_EINVAL_ec_stripe_create_existing_key = 2425,
    BCH_ERR_EINVAL_finsert_offset_past_eof = 2426,
    BCH_ERR_EINVAL_data_job_bad_op = 2427,
    BCH_ERR_EINVAL_snapshot_parent_already_has_children = 2428,
    BCH_ERR_EINVAL_snapshot_delete_has_two_children = 2429,
    BCH_ERR_EINVAL_snapshot_delete_interior_at_runtime = 2430,
    BCH_ERR_EINVAL_snapshot_parent_missing_child_ptr = 2431,
    BCH_ERR_EINVAL_snapshot_child_bad_parent = 2432,
    BCH_ERR_EINVAL_snapshot_bad_subvol_flag = 2433,
    BCH_ERR_EINVAL_opt_parse_uint_required = 2434,
    BCH_ERR_EINVAL_opt_parse_str_required = 2435,
    BCH_ERR_EINVAL_test_zero_nr_or_threads = 2436,
    BCH_ERR_EINVAL_test_unknown_test = 2437,
    BCH_ERR_EINVAL_sysfs_opt_not_found = 2438,
    BCH_ERR_EINVAL_ioctl_query_counters_bad_flags = 2439,
    BCH_ERR_EINVAL_node_scan_no_nodes = 2440,
    BCH_ERR_EINVAL_node_scan_too_many_replicas = 2441,
    BCH_ERR_topology_repair_drop_this_node = 2442,
    BCH_ERR_topology_repair_drop_prev_node = 2443,
    BCH_ERR_topology_repair_did_fill_from_scan = 2444,
    BCH_ERR_too_many_links = 2445,
    BCH_ERR_may_not_use_incompat_feature = 2446,
    BCH_ERR_no_casefolding_without_utf8 = 2447,
    BCH_ERR_casefolding_disabled = 2448,
    BCH_ERR_casefold_opt_is_dir_only = 2449,
    BCH_ERR_casefolding_in_use = 2450,
    BCH_ERR_casefold_dir_but_disabled = 2451,
    BCH_ERR_unsupported_fsx_flag = 2452,
    BCH_ERR_unsupported_fa_flag = 2453,
    BCH_ERR_unsupported_fallocate_mode = 2454,
    BCH_ERR_erofs_trans_commit = 2455,
    BCH_ERR_erofs_no_writes = 2456,
    BCH_ERR_erofs_journal_err = 2457,
    BCH_ERR_erofs_sb_err = 2458,
    BCH_ERR_erofs_unfixed_errors = 2459,
    BCH_ERR_erofs_norecovery = 2460,
    BCH_ERR_erofs_nochanges = 2461,
    BCH_ERR_erofs_no_alloc_info = 2462,
    BCH_ERR_erofs_filesystem_full = 2463,
    BCH_ERR_erofs_sb_not_migrated = 2464,
    BCH_ERR_insufficient_devices = 2465,
    BCH_ERR_erofs_recovery_cancelled = 2466,
    BCH_ERR_emergency_ro = 2467,
    BCH_ERR_btree_not_started = 2468,
    BCH_ERR_operation_blocked = 2469,
    BCH_ERR_btree_cache_cannibalize_lock_blocked = 2470,
    BCH_ERR_journal_res_blocked = 2471,
    BCH_ERR_bucket_alloc_blocked = 2472,
    BCH_ERR_open_bucket_alloc_blocked = 2473,
    BCH_ERR_stripe_alloc_blocked = 2474,
    BCH_ERR_stripe_buf_mem_blocked = 2475,
    BCH_ERR_stripe_buf_mem_limit = 2476,
    BCH_ERR_journal_blocked = 2477,
    BCH_ERR_journal_max_in_flight = 2478,
    BCH_ERR_journal_max_open = 2479,
    BCH_ERR_journal_full = 2480,
    BCH_ERR_journal_pin_full = 2481,
    BCH_ERR_journal_buf_enomem = 2482,
    BCH_ERR_journal_stuck = 2483,
    BCH_ERR_journal_retry_open = 2484,
    BCH_ERR_invalid_sb = 2485,
    BCH_ERR_invalid_sb_magic = 2486,
    BCH_ERR_invalid_sb_version = 2487,
    BCH_ERR_invalid_sb_features = 2488,
    BCH_ERR_invalid_sb_too_big = 2489,
    BCH_ERR_invalid_sb_csum_type = 2490,
    BCH_ERR_invalid_sb_csum = 2491,
    BCH_ERR_invalid_sb_block_size = 2492,
    BCH_ERR_invalid_sb_uuid = 2493,
    BCH_ERR_invalid_sb_offset = 2494,
    BCH_ERR_invalid_sb_too_many_members = 2495,
    BCH_ERR_invalid_sb_dev_idx = 2496,
    BCH_ERR_invalid_sb_time_precision = 2497,
    BCH_ERR_invalid_sb_field_size = 2498,
    BCH_ERR_invalid_sb_layout = 2499,
    BCH_ERR_invalid_sb_layout_type = 2500,
    BCH_ERR_invalid_sb_layout_nr_superblocks = 2501,
    BCH_ERR_invalid_sb_layout_superblocks_overlap = 2502,
    BCH_ERR_invalid_sb_layout_sb_max_size_bits = 2503,
    BCH_ERR_invalid_sb_members_missing = 2504,
    BCH_ERR_invalid_sb_members = 2505,
    BCH_ERR_invalid_sb_disk_groups = 2506,
    BCH_ERR_invalid_sb_replicas = 2507,
    BCH_ERR_invalid_replicas_entry = 2508,
    BCH_ERR_invalid_sb_journal = 2509,
    BCH_ERR_invalid_sb_journal_seq_blacklist = 2510,
    BCH_ERR_invalid_sb_crypt = 2511,
    BCH_ERR_invalid_sb_clean = 2512,
    BCH_ERR_invalid_sb_quota = 2513,
    BCH_ERR_invalid_sb_errors = 2514,
    BCH_ERR_invalid_sb_opt_compression = 2515,
    BCH_ERR_invalid_sb_ext = 2516,
    BCH_ERR_invalid_sb_downgrade = 2517,
    BCH_ERR_invalid_sb_extent_type_u64s = 2518,
    BCH_ERR_invalid_bkey = 2519,
    BCH_ERR_nocow_lock_blocked = 2520,
    BCH_ERR_journal_shutdown = 2521,
    BCH_ERR_journal_flush_err = 2522,
    BCH_ERR_journal_write_err = 2523,
    BCH_ERR_btree_node_read_err = 2524,
    BCH_ERR_btree_node_validate_err = 2525,
    BCH_ERR_btree_node_read_err_cached = 2526,
    BCH_ERR_sb_not_downgraded = 2527,
    BCH_ERR_btree_node_write_all_failed = 2528,
    BCH_ERR_btree_node_read_error = 2529,
    BCH_ERR_btree_need_topology_repair = 2530,
    BCH_ERR_bucket_ref_update = 2531,
    BCH_ERR_trigger_alloc = 2532,
    BCH_ERR_trigger_pointer = 2533,
    BCH_ERR_trigger_stripe_pointer = 2534,
    BCH_ERR_metadata_bucket_inconsistency = 2535,
    BCH_ERR_mark_stripe = 2536,
    BCH_ERR_stripe_read = 2537,
    BCH_ERR_stripe_read_device_offline = 2538,
    BCH_ERR_stripe_read_ptr_stale = 2539,
    BCH_ERR_stripe_read_csum_err = 2540,
    BCH_ERR_stripe_reconstruct = 2541,
    BCH_ERR_stripe_reconstruct_enomem = 2542,
    BCH_ERR_stripe_reconstruct_insufficient_blocks = 2543,
    BCH_ERR_stripe_reconstruct_stale_race = 2544,
    BCH_ERR_key_type_error = 2545,
    BCH_ERR_extent_poisoned = 2546,
    BCH_ERR_missing_indirect_extent = 2547,
    BCH_ERR_invalidate_stripe_to_dev = 2548,
    BCH_ERR_no_encryption_key = 2549,
    BCH_ERR_insufficient_journal_devices = 2550,
    BCH_ERR_device_offline = 2551,
    BCH_ERR_stripe_create_device_offline = 2552,
    BCH_ERR_EIO_fault_injected = 2553,
    BCH_ERR_ec_block_read = 2554,
    BCH_ERR_ec_block_write = 2555,
    BCH_ERR_recompute_checksum = 2556,
    BCH_ERR_decompress = 2557,
    BCH_ERR_decompress_exceeded_max_encoded_extent = 2558,
    BCH_ERR_decompress_lz4 = 2559,
    BCH_ERR_decompress_gzip = 2560,
    BCH_ERR_decompress_zstd_src_len_bad = 2561,
    BCH_ERR_decompress_zstd_size_mismatch = 2562,
    BCH_ERR_data_write = 2563,
    BCH_ERR_data_write_io = 2564,
    BCH_ERR_data_write_csum = 2565,
    BCH_ERR_data_write_invalid_ptr = 2566,
    BCH_ERR_data_write_misaligned = 2567,
    BCH_ERR_data_read = 2568,
    BCH_ERR_no_device_to_read_from = 2569,
    BCH_ERR_no_devices_valid = 2570,
    BCH_ERR_data_read_io_err = 2571,
    BCH_ERR_data_read_csum_err = 2572,
    BCH_ERR_data_read_retry = 2573,
    BCH_ERR_data_read_retry_avoid = 2574,
    BCH_ERR_data_read_retry_device_offline = 2575,
    BCH_ERR_data_read_retry_io_err = 2576,
    BCH_ERR_data_read_retry_ec_reconstruct_err = 2577,
    BCH_ERR_data_read_retry_csum_err = 2578,
    BCH_ERR_data_read_retry_csum_err_maybe_userspace = 2579,
    BCH_ERR_data_read_decompress_err = 2580,
    BCH_ERR_data_read_decrypt_err = 2581,
    BCH_ERR_data_read_ptr_stale_race = 2582,
    BCH_ERR_data_read_ptr_stale_retry = 2583,
    BCH_ERR_data_read_ptr_stale_dirty = 2584,
    BCH_ERR_data_read_no_encryption_key = 2585,
    BCH_ERR_data_read_buffer_too_small = 2586,
    BCH_ERR_data_read_key_overwritten = 2587,
    BCH_ERR_rbio_narrow_crcs_fail = 2588,
    BCH_ERR_nopromote = 2589,
    BCH_ERR_nopromote_no_rewrites = 2590,
    BCH_ERR_nopromote_already_promoted = 2591,
    BCH_ERR_nopromote_unwritten = 2592,
    BCH_ERR_nopromote_congested = 2593,
    BCH_ERR_nopromote_ratelimited = 2594,
    BCH_ERR_nopromote_no_writes = 2595,
    BCH_ERR_nopromote_enomem = 2596,
    BCH_ERR_invalid_snapshot_node = 2597,
    BCH_ERR_option_needs_open_fs = 2598,
    BCH_ERR_remove_disk_accounting_entry = 2599,
    BCH_ERR_nocow_trylock_fail = 2600,
    BCH_ERR_nocow_trylock_contended = 2601,
    BCH_ERR_nocow_trylock_bucket_full = 2602,
    BCH_ERR_recovery_cancelled = 2603,
    BCH_ERR_shutdown_with_errors = 2604,
    BCH_ERR_shutdown_with_errors_fixed = 2605,
    BCH_ERR_shutdown_with_errors_unfixed = 2606,
    BCH_ERR_shutdown_with_emergency_ro = 2607,
    BCH_ERR_MAX = 2608,
}
unsafe extern "C" {
    pub fn bch2_err_str(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char;
}
unsafe extern "C" {
    pub fn __bch2_err_matches(
        arg1: ::std::os::raw::c_int,
        arg2: ::std::os::raw::c_int,
    ) -> bool;
}
unsafe extern "C" {
    #[link_name = "_bch2_err_matches__extern"]
    pub fn _bch2_err_matches(
        err: ::std::os::raw::c_int,
        class: ::std::os::raw::c_int,
    ) -> bool;
}
unsafe extern "C" {
    pub fn __bch2_err_class(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_err_class__extern"]
    pub fn bch2_err_class(err: ::std::os::raw::c_long) -> ::std::os::raw::c_long;
}
unsafe extern "C" {
    pub fn bch2_blk_status_to_str(arg1: blk_status_t) -> *const ::std::os::raw::c_char;
}
unsafe extern "C" {
    pub static bch2_error_actions: [*const ::std::os::raw::c_char; 0usize];
}
unsafe extern "C" {
    pub static bch2_degraded_actions: [*const ::std::os::raw::c_char; 0usize];
}
unsafe extern "C" {
    pub static bch2_fsck_fix_opts: [*const ::std::os::raw::c_char; 0usize];
}
unsafe extern "C" {
    pub static bch2_version_upgrade_opts: [*const ::std::os::raw::c_char; 0usize];
}
unsafe extern "C" {
    pub static bch2_sb_features: [*const ::std::os::raw::c_char; 0usize];
}
unsafe extern "C" {
    pub static bch2_sb_compat: [*const ::std::os::raw::c_char; 0usize];
}
unsafe extern "C" {
    pub static __bch2_btree_ids: [*const ::std::os::raw::c_char; 0usize];
}
unsafe extern "C" {
    pub static __bch2_csum_types: [*const ::std::os::raw::c_char; 0usize];
}
unsafe extern "C" {
    pub static __bch2_csum_opts: [*const ::std::os::raw::c_char; 0usize];
}
unsafe extern "C" {
    pub static __bch2_compression_types: [*const ::std::os::raw::c_char; 0usize];
}
unsafe extern "C" {
    pub static bch2_compression_opts: [*const ::std::os::raw::c_char; 0usize];
}
unsafe extern "C" {
    pub static __bch2_str_hash_types: [*const ::std::os::raw::c_char; 0usize];
}
unsafe extern "C" {
    pub static bch2_str_hash_opts: [*const ::std::os::raw::c_char; 0usize];
}
unsafe extern "C" {
    pub static __bch2_data_types: [*const ::std::os::raw::c_char; 0usize];
}
unsafe extern "C" {
    pub static bch2_member_states: [*const ::std::os::raw::c_char; 0usize];
}
unsafe extern "C" {
    pub static __bch2_reconcile_accounting_types: [*const ::std::os::raw::c_char; 0usize];
}
unsafe extern "C" {
    pub static bch2_d_types: [*const ::std::os::raw::c_char; 0usize];
}
unsafe extern "C" {
    pub static bch2_scrub_journal_opts: [*const ::std::os::raw::c_char; 0usize];
}
unsafe extern "C" {
    pub fn bch2_prt_jset_entry_type(arg1: *mut printbuf, arg2: bch_jset_entry_type);
}
unsafe extern "C" {
    pub fn bch2_prt_fs_usage_type(arg1: *mut printbuf, arg2: bch_fs_usage_type);
}
unsafe extern "C" {
    pub fn bch2_prt_data_type(arg1: *mut printbuf, arg2: bch_data_type);
}
unsafe extern "C" {
    pub fn bch2_prt_csum_opt(arg1: *mut printbuf, arg2: bch_csum_opt);
}
unsafe extern "C" {
    pub fn bch2_prt_csum_type(arg1: *mut printbuf, arg2: bch_csum_type);
}
unsafe extern "C" {
    pub fn bch2_prt_compression_type(arg1: *mut printbuf, arg2: bch_compression_type);
}
unsafe extern "C" {
    pub fn bch2_prt_str_hash_type(arg1: *mut printbuf, arg2: bch_str_hash_type);
}
unsafe extern "C" {
    pub fn bch2_prt_reconcile_accounting_type(
        arg1: *mut printbuf,
        arg2: bch_reconcile_accounting_type,
    );
}
unsafe extern "C" {
    pub fn bch2_prt_key_type_error_reason(
        arg1: *mut printbuf,
        arg2: bch_key_type_errors,
    );
}
unsafe extern "C" {
    #[link_name = "bch2_d_type_str__extern"]
    pub fn bch2_d_type_str(
        d_type: ::std::os::raw::c_uint,
    ) -> *const ::std::os::raw::c_char;
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum opt_flags {
    OPT_FS = 1,
    OPT_DEVICE = 2,
    OPT_INODE = 4,
    OPT_FORMAT = 8,
    OPT_MOUNT = 16,
    OPT_RUNTIME = 32,
    OPT_HUMAN_READABLE = 64,
    OPT_MUST_BE_POW_2 = 128,
    OPT_SB_FIELD_SECTORS = 256,
    OPT_SB_FIELD_ILOG2 = 512,
    OPT_SB_FIELD_ONE_BIAS = 1024,
    OPT_HIDDEN = 2048,
    OPT_MOUNT_OLD = 4096,
    OPT_NODOC = 8192,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum opt_type {
    BCH_OPT_BOOL = 0,
    BCH_OPT_UINT = 1,
    BCH_OPT_STR = 2,
    BCH_OPT_BITFIELD = 3,
    BCH_OPT_FN = 4,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_opt_fn {
    pub parse: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut bch_fs,
            arg2: *const ::std::os::raw::c_char,
            arg3: *mut u64_,
            arg4: *mut printbuf,
        ) -> ::std::os::raw::c_int,
    >,
    pub to_text: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut printbuf,
            arg2: *mut bch_fs,
            arg3: *mut bch_sb,
            arg4: u64_,
        ),
    >,
    pub validate: ::std::option::Option<
        unsafe extern "C" fn(arg1: u64_, arg2: *mut printbuf) -> ::std::os::raw::c_int,
    >,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_opt_fn"][::std::mem::size_of::<bch_opt_fn>() - 24usize];
    ["Alignment of bch_opt_fn"][::std::mem::align_of::<bch_opt_fn>() - 8usize];
    [
        "Offset of field: bch_opt_fn::parse",
    ][::std::mem::offset_of!(bch_opt_fn, parse) - 0usize];
    [
        "Offset of field: bch_opt_fn::to_text",
    ][::std::mem::offset_of!(bch_opt_fn, to_text) - 8usize];
    [
        "Offset of field: bch_opt_fn::validate",
    ][::std::mem::offset_of!(bch_opt_fn, validate) - 16usize];
};
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum fsck_err_opts {
    FSCK_FIX_exit = 0,
    FSCK_FIX_yes = 1,
    FSCK_FIX_no = 2,
    FSCK_FIX_ask = 3,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_opt_id {
    Opt_block_size = 0,
    Opt_btree_node_size = 1,
    Opt_errors = 2,
    Opt_write_error_timeout = 3,
    Opt_metadata_replicas = 4,
    Opt_data_replicas = 5,
    Opt_encoded_extent_max = 6,
    Opt_metadata_checksum = 7,
    Opt_data_checksum = 8,
    Opt_checksum_err_retry_nr = 9,
    Opt_compression = 10,
    Opt_background_compression = 11,
    Opt_str_hash = 12,
    Opt_metadata_target = 13,
    Opt_foreground_target = 14,
    Opt_background_target = 15,
    Opt_promote_target = 16,
    Opt_erasure_code = 17,
    Opt_ec_max_data_blocks = 18,
    Opt_casefold = 19,
    Opt_casefold_disabled = 20,
    Opt_inodes_32bit = 21,
    Opt_shard_inode_numbers_bits = 22,
    Opt_btree_node_mem_ptr_optimization = 23,
    Opt_gc_reserve_percent = 24,
    Opt_gc_reserve_bytes = 25,
    Opt_root_reserve_percent = 26,
    Opt_wide_macs = 27,
    Opt_inline_data = 28,
    Opt_promote_whole_extents = 29,
    Opt_acl = 30,
    Opt_usrquota = 31,
    Opt_grpquota = 32,
    Opt_prjquota = 33,
    Opt_degraded = 34,
    Opt_mount_trusts_udev = 35,
    Opt_no_splitbrain_check = 36,
    Opt_no_version_check = 37,
    Opt_verbose = 38,
    Opt_journal_flush_delay = 39,
    Opt_journal_flush_disabled = 40,
    Opt_journal_reclaim_delay = 41,
    Opt_writeback_timeout = 42,
    Opt_move_bytes_in_flight = 43,
    Opt_move_ios_in_flight = 44,
    Opt_fsck = 45,
    Opt_fsck_memory_usage_percent = 46,
    Opt_fix_errors = 47,
    Opt_ratelimit_errors = 48,
    Opt_nochanges = 49,
    Opt_norecovery = 50,
    Opt_journal_rewind = 51,
    Opt_journal_rewind_discard_buffer_percent = 52,
    Opt_scrub_recent_journal_entries = 53,
    Opt_scrub_journal_max_rewind_secs = 54,
    Opt_recovery_passes = 55,
    Opt_recovery_passes_exclude = 56,
    Opt_recovery_pass_last = 57,
    Opt_retain_recovery_info = 58,
    Opt_read_entire_journal = 59,
    Opt_read_journal_only = 60,
    Opt_journal_transaction_names = 61,
    Opt_allocator_stuck_timeout = 62,
    Opt_noexcl = 63,
    Opt_direct_io = 64,
    Opt_sb = 65,
    Opt_read_only = 66,
    Opt_nostart = 67,
    Opt_dangerously_reconstruct_alloc = 68,
    Opt_version_upgrade = 69,
    Opt_stdio = 70,
    Opt_project = 71,
    Opt_nocow = 72,
    Opt_nocow_enabled = 73,
    Opt_copygc_enabled = 74,
    Opt_reconcile_enabled = 75,
    Opt_reconcile_on_ac_only = 76,
    Opt_auto_snapshot_deletion = 77,
    Opt_no_data_io = 78,
    Opt_state = 79,
    Opt_bucket_size = 80,
    Opt_durability = 81,
    Opt_data_allowed = 82,
    Opt_discard = 83,
    Opt_rotational = 84,
    Opt_btree_node_prefetch = 85,
    Opt_dev_readahead = 86,
    Opt_ec_stripe_buf_limit = 87,
    bch2_opts_nr = 88,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_opts_mask {
    pub d: [::std::os::raw::c_ulong; 2usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_opts_mask"][::std::mem::size_of::<bch_opts_mask>() - 16usize];
    ["Alignment of bch_opts_mask"][::std::mem::align_of::<bch_opts_mask>() - 8usize];
    [
        "Offset of field: bch_opts_mask::d",
    ][::std::mem::offset_of!(bch_opts_mask, d) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_opts {
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 11usize]>,
    pub block_size: u16_,
    pub btree_node_size: u32_,
    pub errors: u8_,
    pub write_error_timeout: u16_,
    pub metadata_replicas: u8_,
    pub data_replicas: u8_,
    pub encoded_extent_max: u32_,
    pub metadata_checksum: u8_,
    pub data_checksum: u8_,
    pub checksum_err_retry_nr: u8_,
    pub compression: u8_,
    pub background_compression: u8_,
    pub str_hash: u8_,
    pub metadata_target: u16_,
    pub foreground_target: u16_,
    pub background_target: u16_,
    pub promote_target: u16_,
    pub erasure_code: u16_,
    pub ec_max_data_blocks: u8_,
    pub casefold: u8_,
    pub casefold_disabled: u8_,
    pub inodes_32bit: u8_,
    pub shard_inode_numbers_bits: u8_,
    pub btree_node_mem_ptr_optimization: u8_,
    pub gc_reserve_percent: u8_,
    pub gc_reserve_bytes: u64_,
    pub root_reserve_percent: u8_,
    pub wide_macs: u8_,
    pub inline_data: u8_,
    pub promote_whole_extents: u8_,
    pub acl: u8_,
    pub usrquota: u8_,
    pub grpquota: u8_,
    pub prjquota: u8_,
    pub degraded: u8_,
    pub mount_trusts_udev: u8_,
    pub no_splitbrain_check: u8_,
    pub no_version_check: u8_,
    pub verbose: u8_,
    pub journal_flush_delay: u32_,
    pub journal_flush_disabled: u8_,
    pub journal_reclaim_delay: u32_,
    pub writeback_timeout: u16_,
    pub move_bytes_in_flight: u32_,
    pub move_ios_in_flight: u32_,
    pub fsck: u8_,
    pub fsck_memory_usage_percent: u8_,
    pub fix_errors: u8_,
    pub ratelimit_errors: u8_,
    pub nochanges: u8_,
    pub norecovery: u8_,
    pub journal_rewind: u64_,
    pub journal_rewind_discard_buffer_percent: u8_,
    pub scrub_recent_journal_entries: u8_,
    pub scrub_journal_max_rewind_secs: u32_,
    pub recovery_passes: u64_,
    pub recovery_passes_exclude: u64_,
    pub recovery_pass_last: u8_,
    pub retain_recovery_info: u8_,
    pub read_entire_journal: u8_,
    pub read_journal_only: u8_,
    pub journal_transaction_names: u8_,
    pub allocator_stuck_timeout: u16_,
    pub noexcl: u8_,
    pub direct_io: u8_,
    pub sb: u64_,
    pub read_only: u8_,
    pub nostart: u8_,
    pub dangerously_reconstruct_alloc: u8_,
    pub version_upgrade: u8_,
    pub stdio: u64_,
    pub project: u8_,
    pub nocow: u8_,
    pub nocow_enabled: u8_,
    pub copygc_enabled: u8_,
    pub reconcile_enabled: u8_,
    pub reconcile_on_ac_only: u8_,
    pub auto_snapshot_deletion: u8_,
    pub no_data_io: u8_,
    pub state: u64_,
    pub bucket_size: u32_,
    pub durability: u8_,
    pub data_allowed: u8_,
    pub discard: u8_,
    pub rotational: u8_,
    pub btree_node_prefetch: u8_,
    pub dev_readahead: u64_,
    pub ec_stripe_buf_limit: u8_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_opts"][::std::mem::size_of::<bch_opts>() - 232usize];
    ["Alignment of bch_opts"][::std::mem::align_of::<bch_opts>() - 8usize];
    [
        "Offset of field: bch_opts::block_size",
    ][::std::mem::offset_of!(bch_opts, block_size) - 12usize];
    [
        "Offset of field: bch_opts::btree_node_size",
    ][::std::mem::offset_of!(bch_opts, btree_node_size) - 16usize];
    [
        "Offset of field: bch_opts::errors",
    ][::std::mem::offset_of!(bch_opts, errors) - 20usize];
    [
        "Offset of field: bch_opts::write_error_timeout",
    ][::std::mem::offset_of!(bch_opts, write_error_timeout) - 22usize];
    [
        "Offset of field: bch_opts::metadata_replicas",
    ][::std::mem::offset_of!(bch_opts, metadata_replicas) - 24usize];
    [
        "Offset of field: bch_opts::data_replicas",
    ][::std::mem::offset_of!(bch_opts, data_replicas) - 25usize];
    [
        "Offset of field: bch_opts::encoded_extent_max",
    ][::std::mem::offset_of!(bch_opts, encoded_extent_max) - 28usize];
    [
        "Offset of field: bch_opts::metadata_checksum",
    ][::std::mem::offset_of!(bch_opts, metadata_checksum) - 32usize];
    [
        "Offset of field: bch_opts::data_checksum",
    ][::std::mem::offset_of!(bch_opts, data_checksum) - 33usize];
    [
        "Offset of field: bch_opts::checksum_err_retry_nr",
    ][::std::mem::offset_of!(bch_opts, checksum_err_retry_nr) - 34usize];
    [
        "Offset of field: bch_opts::compression",
    ][::std::mem::offset_of!(bch_opts, compression) - 35usize];
    [
        "Offset of field: bch_opts::background_compression",
    ][::std::mem::offset_of!(bch_opts, background_compression) - 36usize];
    [
        "Offset of field: bch_opts::str_hash",
    ][::std::mem::offset_of!(bch_opts, str_hash) - 37usize];
    [
        "Offset of field: bch_opts::metadata_target",
    ][::std::mem::offset_of!(bch_opts, metadata_target) - 38usize];
    [
        "Offset of field: bch_opts::foreground_target",
    ][::std::mem::offset_of!(bch_opts, foreground_target) - 40usize];
    [
        "Offset of field: bch_opts::background_target",
    ][::std::mem::offset_of!(bch_opts, background_target) - 42usize];
    [
        "Offset of field: bch_opts::promote_target",
    ][::std::mem::offset_of!(bch_opts, promote_target) - 44usize];
    [
        "Offset of field: bch_opts::erasure_code",
    ][::std::mem::offset_of!(bch_opts, erasure_code) - 46usize];
    [
        "Offset of field: bch_opts::ec_max_data_blocks",
    ][::std::mem::offset_of!(bch_opts, ec_max_data_blocks) - 48usize];
    [
        "Offset of field: bch_opts::casefold",
    ][::std::mem::offset_of!(bch_opts, casefold) - 49usize];
    [
        "Offset of field: bch_opts::casefold_disabled",
    ][::std::mem::offset_of!(bch_opts, casefold_disabled) - 50usize];
    [
        "Offset of field: bch_opts::inodes_32bit",
    ][::std::mem::offset_of!(bch_opts, inodes_32bit) - 51usize];
    [
        "Offset of field: bch_opts::shard_inode_numbers_bits",
    ][::std::mem::offset_of!(bch_opts, shard_inode_numbers_bits) - 52usize];
    [
        "Offset of field: bch_opts::btree_node_mem_ptr_optimization",
    ][::std::mem::offset_of!(bch_opts, btree_node_mem_ptr_optimization) - 53usize];
    [
        "Offset of field: bch_opts::gc_reserve_percent",
    ][::std::mem::offset_of!(bch_opts, gc_reserve_percent) - 54usize];
    [
        "Offset of field: bch_opts::gc_reserve_bytes",
    ][::std::mem::offset_of!(bch_opts, gc_reserve_bytes) - 56usize];
    [
        "Offset of field: bch_opts::root_reserve_percent",
    ][::std::mem::offset_of!(bch_opts, root_reserve_percent) - 64usize];
    [
        "Offset of field: bch_opts::wide_macs",
    ][::std::mem::offset_of!(bch_opts, wide_macs) - 65usize];
    [
        "Offset of field: bch_opts::inline_data",
    ][::std::mem::offset_of!(bch_opts, inline_data) - 66usize];
    [
        "Offset of field: bch_opts::promote_whole_extents",
    ][::std::mem::offset_of!(bch_opts, promote_whole_extents) - 67usize];
    ["Offset of field: bch_opts::acl"][::std::mem::offset_of!(bch_opts, acl) - 68usize];
    [
        "Offset of field: bch_opts::usrquota",
    ][::std::mem::offset_of!(bch_opts, usrquota) - 69usize];
    [
        "Offset of field: bch_opts::grpquota",
    ][::std::mem::offset_of!(bch_opts, grpquota) - 70usize];
    [
        "Offset of field: bch_opts::prjquota",
    ][::std::mem::offset_of!(bch_opts, prjquota) - 71usize];
    [
        "Offset of field: bch_opts::degraded",
    ][::std::mem::offset_of!(bch_opts, degraded) - 72usize];
    [
        "Offset of field: bch_opts::mount_trusts_udev",
    ][::std::mem::offset_of!(bch_opts, mount_trusts_udev) - 73usize];
    [
        "Offset of field: bch_opts::no_splitbrain_check",
    ][::std::mem::offset_of!(bch_opts, no_splitbrain_check) - 74usize];
    [
        "Offset of field: bch_opts::no_version_check",
    ][::std::mem::offset_of!(bch_opts, no_version_check) - 75usize];
    [
        "Offset of field: bch_opts::verbose",
    ][::std::mem::offset_of!(bch_opts, verbose) - 76usize];
    [
        "Offset of field: bch_opts::journal_flush_delay",
    ][::std::mem::offset_of!(bch_opts, journal_flush_delay) - 80usize];
    [
        "Offset of field: bch_opts::journal_flush_disabled",
    ][::std::mem::offset_of!(bch_opts, journal_flush_disabled) - 84usize];
    [
        "Offset of field: bch_opts::journal_reclaim_delay",
    ][::std::mem::offset_of!(bch_opts, journal_reclaim_delay) - 88usize];
    [
        "Offset of field: bch_opts::writeback_timeout",
    ][::std::mem::offset_of!(bch_opts, writeback_timeout) - 92usize];
    [
        "Offset of field: bch_opts::move_bytes_in_flight",
    ][::std::mem::offset_of!(bch_opts, move_bytes_in_flight) - 96usize];
    [
        "Offset of field: bch_opts::move_ios_in_flight",
    ][::std::mem::offset_of!(bch_opts, move_ios_in_flight) - 100usize];
    [
        "Offset of field: bch_opts::fsck",
    ][::std::mem::offset_of!(bch_opts, fsck) - 104usize];
    [
        "Offset of field: bch_opts::fsck_memory_usage_percent",
    ][::std::mem::offset_of!(bch_opts, fsck_memory_usage_percent) - 105usize];
    [
        "Offset of field: bch_opts::fix_errors",
    ][::std::mem::offset_of!(bch_opts, fix_errors) - 106usize];
    [
        "Offset of field: bch_opts::ratelimit_errors",
    ][::std::mem::offset_of!(bch_opts, ratelimit_errors) - 107usize];
    [
        "Offset of field: bch_opts::nochanges",
    ][::std::mem::offset_of!(bch_opts, nochanges) - 108usize];
    [
        "Offset of field: bch_opts::norecovery",
    ][::std::mem::offset_of!(bch_opts, norecovery) - 109usize];
    [
        "Offset of field: bch_opts::journal_rewind",
    ][::std::mem::offset_of!(bch_opts, journal_rewind) - 112usize];
    [
        "Offset of field: bch_opts::journal_rewind_discard_buffer_percent",
    ][::std::mem::offset_of!(bch_opts, journal_rewind_discard_buffer_percent)
        - 120usize];
    [
        "Offset of field: bch_opts::scrub_recent_journal_entries",
    ][::std::mem::offset_of!(bch_opts, scrub_recent_journal_entries) - 121usize];
    [
        "Offset of field: bch_opts::scrub_journal_max_rewind_secs",
    ][::std::mem::offset_of!(bch_opts, scrub_journal_max_rewind_secs) - 124usize];
    [
        "Offset of field: bch_opts::recovery_passes",
    ][::std::mem::offset_of!(bch_opts, recovery_passes) - 128usize];
    [
        "Offset of field: bch_opts::recovery_passes_exclude",
    ][::std::mem::offset_of!(bch_opts, recovery_passes_exclude) - 136usize];
    [
        "Offset of field: bch_opts::recovery_pass_last",
    ][::std::mem::offset_of!(bch_opts, recovery_pass_last) - 144usize];
    [
        "Offset of field: bch_opts::retain_recovery_info",
    ][::std::mem::offset_of!(bch_opts, retain_recovery_info) - 145usize];
    [
        "Offset of field: bch_opts::read_entire_journal",
    ][::std::mem::offset_of!(bch_opts, read_entire_journal) - 146usize];
    [
        "Offset of field: bch_opts::read_journal_only",
    ][::std::mem::offset_of!(bch_opts, read_journal_only) - 147usize];
    [
        "Offset of field: bch_opts::journal_transaction_names",
    ][::std::mem::offset_of!(bch_opts, journal_transaction_names) - 148usize];
    [
        "Offset of field: bch_opts::allocator_stuck_timeout",
    ][::std::mem::offset_of!(bch_opts, allocator_stuck_timeout) - 150usize];
    [
        "Offset of field: bch_opts::noexcl",
    ][::std::mem::offset_of!(bch_opts, noexcl) - 152usize];
    [
        "Offset of field: bch_opts::direct_io",
    ][::std::mem::offset_of!(bch_opts, direct_io) - 153usize];
    ["Offset of field: bch_opts::sb"][::std::mem::offset_of!(bch_opts, sb) - 160usize];
    [
        "Offset of field: bch_opts::read_only",
    ][::std::mem::offset_of!(bch_opts, read_only) - 168usize];
    [
        "Offset of field: bch_opts::nostart",
    ][::std::mem::offset_of!(bch_opts, nostart) - 169usize];
    [
        "Offset of field: bch_opts::dangerously_reconstruct_alloc",
    ][::std::mem::offset_of!(bch_opts, dangerously_reconstruct_alloc) - 170usize];
    [
        "Offset of field: bch_opts::version_upgrade",
    ][::std::mem::offset_of!(bch_opts, version_upgrade) - 171usize];
    [
        "Offset of field: bch_opts::stdio",
    ][::std::mem::offset_of!(bch_opts, stdio) - 176usize];
    [
        "Offset of field: bch_opts::project",
    ][::std::mem::offset_of!(bch_opts, project) - 184usize];
    [
        "Offset of field: bch_opts::nocow",
    ][::std::mem::offset_of!(bch_opts, nocow) - 185usize];
    [
        "Offset of field: bch_opts::nocow_enabled",
    ][::std::mem::offset_of!(bch_opts, nocow_enabled) - 186usize];
    [
        "Offset of field: bch_opts::copygc_enabled",
    ][::std::mem::offset_of!(bch_opts, copygc_enabled) - 187usize];
    [
        "Offset of field: bch_opts::reconcile_enabled",
    ][::std::mem::offset_of!(bch_opts, reconcile_enabled) - 188usize];
    [
        "Offset of field: bch_opts::reconcile_on_ac_only",
    ][::std::mem::offset_of!(bch_opts, reconcile_on_ac_only) - 189usize];
    [
        "Offset of field: bch_opts::auto_snapshot_deletion",
    ][::std::mem::offset_of!(bch_opts, auto_snapshot_deletion) - 190usize];
    [
        "Offset of field: bch_opts::no_data_io",
    ][::std::mem::offset_of!(bch_opts, no_data_io) - 191usize];
    [
        "Offset of field: bch_opts::state",
    ][::std::mem::offset_of!(bch_opts, state) - 192usize];
    [
        "Offset of field: bch_opts::bucket_size",
    ][::std::mem::offset_of!(bch_opts, bucket_size) - 200usize];
    [
        "Offset of field: bch_opts::durability",
    ][::std::mem::offset_of!(bch_opts, durability) - 204usize];
    [
        "Offset of field: bch_opts::data_allowed",
    ][::std::mem::offset_of!(bch_opts, data_allowed) - 205usize];
    [
        "Offset of field: bch_opts::discard",
    ][::std::mem::offset_of!(bch_opts, discard) - 206usize];
    [
        "Offset of field: bch_opts::rotational",
    ][::std::mem::offset_of!(bch_opts, rotational) - 207usize];
    [
        "Offset of field: bch_opts::btree_node_prefetch",
    ][::std::mem::offset_of!(bch_opts, btree_node_prefetch) - 208usize];
    [
        "Offset of field: bch_opts::dev_readahead",
    ][::std::mem::offset_of!(bch_opts, dev_readahead) - 216usize];
    [
        "Offset of field: bch_opts::ec_stripe_buf_limit",
    ][::std::mem::offset_of!(bch_opts, ec_stripe_buf_limit) - 224usize];
};
impl bch_opts {
    #[inline]
    pub fn block_size_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_block_size_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn block_size_defined_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_block_size_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn btree_node_size_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_btree_node_size_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(1usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn btree_node_size_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 1usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_btree_node_size_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                1usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn errors_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_errors_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(2usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn errors_defined_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 2usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_errors_defined_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                2usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn write_error_timeout_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_write_error_timeout_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(3usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn write_error_timeout_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 3usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_write_error_timeout_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                3usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn metadata_replicas_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_metadata_replicas_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(4usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn metadata_replicas_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 4usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_metadata_replicas_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                4usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn data_replicas_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_data_replicas_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(5usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn data_replicas_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 5usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_data_replicas_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                5usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn encoded_extent_max_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_encoded_extent_max_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(6usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn encoded_extent_max_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 6usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_encoded_extent_max_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                6usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn metadata_checksum_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_metadata_checksum_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(7usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn metadata_checksum_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 7usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_metadata_checksum_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                7usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn data_checksum_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_data_checksum_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(8usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn data_checksum_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 8usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_data_checksum_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                8usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn checksum_err_retry_nr_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_checksum_err_retry_nr_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(9usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn checksum_err_retry_nr_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 9usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_checksum_err_retry_nr_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                9usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn compression_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_compression_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(10usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn compression_defined_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 10usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_compression_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                10usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn background_compression_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_background_compression_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(11usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn background_compression_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 11usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_background_compression_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                11usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn str_hash_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_str_hash_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(12usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn str_hash_defined_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 12usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_str_hash_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                12usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn metadata_target_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_metadata_target_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(13usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn metadata_target_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 13usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_metadata_target_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                13usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn foreground_target_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_foreground_target_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(14usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn foreground_target_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 14usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_foreground_target_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                14usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn background_target_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_background_target_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(15usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn background_target_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 15usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_background_target_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                15usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn promote_target_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_promote_target_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(16usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn promote_target_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 16usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_promote_target_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                16usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn erasure_code_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_erasure_code_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(17usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn erasure_code_defined_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 17usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_erasure_code_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                17usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn ec_max_data_blocks_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_ec_max_data_blocks_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(18usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn ec_max_data_blocks_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 18usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_ec_max_data_blocks_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                18usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn casefold_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_casefold_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(19usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn casefold_defined_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 19usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_casefold_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                19usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn casefold_disabled_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_casefold_disabled_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(20usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn casefold_disabled_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 20usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_casefold_disabled_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                20usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn inodes_32bit_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_inodes_32bit_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(21usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn inodes_32bit_defined_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 21usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_inodes_32bit_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                21usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn shard_inode_numbers_bits_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_shard_inode_numbers_bits_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(22usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn shard_inode_numbers_bits_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 22usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_shard_inode_numbers_bits_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                22usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn btree_node_mem_ptr_optimization_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_btree_node_mem_ptr_optimization_defined(
        &mut self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(23usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn btree_node_mem_ptr_optimization_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 23usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_btree_node_mem_ptr_optimization_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                23usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn gc_reserve_percent_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_gc_reserve_percent_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(24usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn gc_reserve_percent_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 24usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_gc_reserve_percent_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                24usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn gc_reserve_bytes_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_gc_reserve_bytes_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(25usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn gc_reserve_bytes_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 25usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_gc_reserve_bytes_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                25usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn root_reserve_percent_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_root_reserve_percent_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(26usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn root_reserve_percent_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 26usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_root_reserve_percent_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                26usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn wide_macs_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_wide_macs_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(27usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn wide_macs_defined_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 27usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_wide_macs_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                27usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn inline_data_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_inline_data_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(28usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn inline_data_defined_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 28usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_inline_data_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                28usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn promote_whole_extents_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_promote_whole_extents_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(29usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn promote_whole_extents_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 29usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_promote_whole_extents_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                29usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn acl_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_acl_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(30usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn acl_defined_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 30usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_acl_defined_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                30usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn usrquota_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_usrquota_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(31usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn usrquota_defined_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 31usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_usrquota_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                31usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn grpquota_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_grpquota_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(32usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn grpquota_defined_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 32usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_grpquota_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                32usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn prjquota_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(33usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_prjquota_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(33usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn prjquota_defined_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 33usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_prjquota_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                33usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn degraded_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(34usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_degraded_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(34usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn degraded_defined_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 34usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_degraded_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                34usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn mount_trusts_udev_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(35usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_mount_trusts_udev_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(35usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn mount_trusts_udev_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 35usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_mount_trusts_udev_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                35usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn no_splitbrain_check_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(36usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_no_splitbrain_check_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(36usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn no_splitbrain_check_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 36usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_no_splitbrain_check_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                36usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn no_version_check_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(37usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_no_version_check_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(37usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn no_version_check_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 37usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_no_version_check_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                37usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn verbose_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(38usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_verbose_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(38usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn verbose_defined_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 38usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_verbose_defined_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                38usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn journal_flush_delay_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(39usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_journal_flush_delay_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(39usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn journal_flush_delay_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 39usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_journal_flush_delay_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                39usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn journal_flush_disabled_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(40usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_journal_flush_disabled_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(40usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn journal_flush_disabled_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 40usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_journal_flush_disabled_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                40usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn journal_reclaim_delay_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(41usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_journal_reclaim_delay_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(41usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn journal_reclaim_delay_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 41usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_journal_reclaim_delay_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                41usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn writeback_timeout_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(42usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_writeback_timeout_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(42usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn writeback_timeout_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 42usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_writeback_timeout_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                42usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn move_bytes_in_flight_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(43usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_move_bytes_in_flight_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(43usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn move_bytes_in_flight_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 43usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_move_bytes_in_flight_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                43usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn move_ios_in_flight_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(44usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_move_ios_in_flight_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(44usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn move_ios_in_flight_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 44usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_move_ios_in_flight_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                44usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn fsck_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(45usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_fsck_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(45usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn fsck_defined_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 45usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_fsck_defined_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                45usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn fsck_memory_usage_percent_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(46usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_fsck_memory_usage_percent_defined(
        &mut self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(46usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn fsck_memory_usage_percent_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 46usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_fsck_memory_usage_percent_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                46usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn fix_errors_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(47usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_fix_errors_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(47usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn fix_errors_defined_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 47usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_fix_errors_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                47usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn ratelimit_errors_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_ratelimit_errors_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(48usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn ratelimit_errors_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 48usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_ratelimit_errors_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                48usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn nochanges_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(49usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_nochanges_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(49usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn nochanges_defined_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 49usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_nochanges_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                49usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn norecovery_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(50usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_norecovery_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(50usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn norecovery_defined_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 50usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_norecovery_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                50usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn journal_rewind_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(51usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_journal_rewind_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(51usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn journal_rewind_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 51usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_journal_rewind_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                51usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn journal_rewind_discard_buffer_percent_defined(
        &self,
    ) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(52usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_journal_rewind_discard_buffer_percent_defined(
        &mut self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(52usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn journal_rewind_discard_buffer_percent_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 52usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_journal_rewind_discard_buffer_percent_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                52usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn scrub_recent_journal_entries_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(53usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_scrub_recent_journal_entries_defined(
        &mut self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(53usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn scrub_recent_journal_entries_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 53usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_scrub_recent_journal_entries_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                53usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn scrub_journal_max_rewind_secs_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(54usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_scrub_journal_max_rewind_secs_defined(
        &mut self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(54usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn scrub_journal_max_rewind_secs_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 54usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_scrub_journal_max_rewind_secs_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                54usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn recovery_passes_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(55usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_recovery_passes_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(55usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn recovery_passes_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 55usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_recovery_passes_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                55usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn recovery_passes_exclude_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(56usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_recovery_passes_exclude_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(56usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn recovery_passes_exclude_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 56usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_recovery_passes_exclude_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                56usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn recovery_pass_last_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(57usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_recovery_pass_last_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(57usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn recovery_pass_last_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 57usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_recovery_pass_last_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                57usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn retain_recovery_info_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(58usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_retain_recovery_info_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(58usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn retain_recovery_info_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 58usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_retain_recovery_info_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                58usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn read_entire_journal_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(59usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_read_entire_journal_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(59usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn read_entire_journal_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 59usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_read_entire_journal_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                59usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn read_journal_only_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(60usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_read_journal_only_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(60usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn read_journal_only_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 60usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_read_journal_only_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                60usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn journal_transaction_names_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(61usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_journal_transaction_names_defined(
        &mut self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(61usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn journal_transaction_names_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 61usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_journal_transaction_names_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                61usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn allocator_stuck_timeout_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(62usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_allocator_stuck_timeout_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(62usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn allocator_stuck_timeout_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 62usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_allocator_stuck_timeout_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                62usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn noexcl_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(63usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_noexcl_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(63usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn noexcl_defined_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 63usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_noexcl_defined_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                63usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn direct_io_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_direct_io_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(64usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn direct_io_defined_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 64usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_direct_io_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                64usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn sb_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(65usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_sb_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(65usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn sb_defined_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 65usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_sb_defined_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                65usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn read_only_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(66usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_read_only_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(66usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn read_only_defined_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 66usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_read_only_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                66usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn nostart_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(67usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_nostart_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(67usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn nostart_defined_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 67usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_nostart_defined_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                67usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn dangerously_reconstruct_alloc_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(68usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_dangerously_reconstruct_alloc_defined(
        &mut self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(68usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn dangerously_reconstruct_alloc_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 68usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_dangerously_reconstruct_alloc_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                68usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn version_upgrade_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(69usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_version_upgrade_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(69usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn version_upgrade_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 69usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_version_upgrade_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                69usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn stdio_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(70usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_stdio_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(70usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn stdio_defined_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 70usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_stdio_defined_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                70usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn project_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(71usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_project_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(71usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn project_defined_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 71usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_project_defined_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                71usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn nocow_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(72usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_nocow_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(72usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn nocow_defined_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 72usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_nocow_defined_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                72usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn nocow_enabled_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(73usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_nocow_enabled_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(73usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn nocow_enabled_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 73usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_nocow_enabled_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                73usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn copygc_enabled_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(74usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_copygc_enabled_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(74usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn copygc_enabled_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 74usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_copygc_enabled_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                74usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn reconcile_enabled_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(75usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_reconcile_enabled_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(75usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn reconcile_enabled_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 75usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_reconcile_enabled_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                75usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn reconcile_on_ac_only_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(76usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_reconcile_on_ac_only_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(76usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn reconcile_on_ac_only_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 76usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_reconcile_on_ac_only_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                76usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn auto_snapshot_deletion_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(77usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_auto_snapshot_deletion_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(77usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn auto_snapshot_deletion_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 77usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_auto_snapshot_deletion_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                77usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn no_data_io_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(78usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_no_data_io_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(78usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn no_data_io_defined_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 78usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_no_data_io_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                78usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn state_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(79usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_state_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(79usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn state_defined_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 79usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_state_defined_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                79usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn bucket_size_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(80usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_bucket_size_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(80usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn bucket_size_defined_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 80usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_bucket_size_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                80usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn durability_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(81usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_durability_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(81usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn durability_defined_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 81usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_durability_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                81usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn data_allowed_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(82usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_data_allowed_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(82usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn data_allowed_defined_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 82usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_data_allowed_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                82usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn discard_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(83usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_discard_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(83usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn discard_defined_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 83usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_discard_defined_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                83usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn rotational_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(84usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_rotational_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(84usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn rotational_defined_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 84usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_rotational_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                84usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn btree_node_prefetch_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(85usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_btree_node_prefetch_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(85usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn btree_node_prefetch_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 85usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_btree_node_prefetch_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                85usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn dev_readahead_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(86usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_dev_readahead_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(86usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn dev_readahead_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 86usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_dev_readahead_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                86usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn ec_stripe_buf_limit_defined(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(87usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_ec_stripe_buf_limit_defined(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(87usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn ec_stripe_buf_limit_defined_raw(
        this: *const Self,
    ) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 11usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 87usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_ec_stripe_buf_limit_defined_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 11usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                87usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        block_size_defined: ::std::os::raw::c_uint,
        btree_node_size_defined: ::std::os::raw::c_uint,
        errors_defined: ::std::os::raw::c_uint,
        write_error_timeout_defined: ::std::os::raw::c_uint,
        metadata_replicas_defined: ::std::os::raw::c_uint,
        data_replicas_defined: ::std::os::raw::c_uint,
        encoded_extent_max_defined: ::std::os::raw::c_uint,
        metadata_checksum_defined: ::std::os::raw::c_uint,
        data_checksum_defined: ::std::os::raw::c_uint,
        checksum_err_retry_nr_defined: ::std::os::raw::c_uint,
        compression_defined: ::std::os::raw::c_uint,
        background_compression_defined: ::std::os::raw::c_uint,
        str_hash_defined: ::std::os::raw::c_uint,
        metadata_target_defined: ::std::os::raw::c_uint,
        foreground_target_defined: ::std::os::raw::c_uint,
        background_target_defined: ::std::os::raw::c_uint,
        promote_target_defined: ::std::os::raw::c_uint,
        erasure_code_defined: ::std::os::raw::c_uint,
        ec_max_data_blocks_defined: ::std::os::raw::c_uint,
        casefold_defined: ::std::os::raw::c_uint,
        casefold_disabled_defined: ::std::os::raw::c_uint,
        inodes_32bit_defined: ::std::os::raw::c_uint,
        shard_inode_numbers_bits_defined: ::std::os::raw::c_uint,
        btree_node_mem_ptr_optimization_defined: ::std::os::raw::c_uint,
        gc_reserve_percent_defined: ::std::os::raw::c_uint,
        gc_reserve_bytes_defined: ::std::os::raw::c_uint,
        root_reserve_percent_defined: ::std::os::raw::c_uint,
        wide_macs_defined: ::std::os::raw::c_uint,
        inline_data_defined: ::std::os::raw::c_uint,
        promote_whole_extents_defined: ::std::os::raw::c_uint,
        acl_defined: ::std::os::raw::c_uint,
        usrquota_defined: ::std::os::raw::c_uint,
        grpquota_defined: ::std::os::raw::c_uint,
        prjquota_defined: ::std::os::raw::c_uint,
        degraded_defined: ::std::os::raw::c_uint,
        mount_trusts_udev_defined: ::std::os::raw::c_uint,
        no_splitbrain_check_defined: ::std::os::raw::c_uint,
        no_version_check_defined: ::std::os::raw::c_uint,
        verbose_defined: ::std::os::raw::c_uint,
        journal_flush_delay_defined: ::std::os::raw::c_uint,
        journal_flush_disabled_defined: ::std::os::raw::c_uint,
        journal_reclaim_delay_defined: ::std::os::raw::c_uint,
        writeback_timeout_defined: ::std::os::raw::c_uint,
        move_bytes_in_flight_defined: ::std::os::raw::c_uint,
        move_ios_in_flight_defined: ::std::os::raw::c_uint,
        fsck_defined: ::std::os::raw::c_uint,
        fsck_memory_usage_percent_defined: ::std::os::raw::c_uint,
        fix_errors_defined: ::std::os::raw::c_uint,
        ratelimit_errors_defined: ::std::os::raw::c_uint,
        nochanges_defined: ::std::os::raw::c_uint,
        norecovery_defined: ::std::os::raw::c_uint,
        journal_rewind_defined: ::std::os::raw::c_uint,
        journal_rewind_discard_buffer_percent_defined: ::std::os::raw::c_uint,
        scrub_recent_journal_entries_defined: ::std::os::raw::c_uint,
        scrub_journal_max_rewind_secs_defined: ::std::os::raw::c_uint,
        recovery_passes_defined: ::std::os::raw::c_uint,
        recovery_passes_exclude_defined: ::std::os::raw::c_uint,
        recovery_pass_last_defined: ::std::os::raw::c_uint,
        retain_recovery_info_defined: ::std::os::raw::c_uint,
        read_entire_journal_defined: ::std::os::raw::c_uint,
        read_journal_only_defined: ::std::os::raw::c_uint,
        journal_transaction_names_defined: ::std::os::raw::c_uint,
        allocator_stuck_timeout_defined: ::std::os::raw::c_uint,
        noexcl_defined: ::std::os::raw::c_uint,
        direct_io_defined: ::std::os::raw::c_uint,
        sb_defined: ::std::os::raw::c_uint,
        read_only_defined: ::std::os::raw::c_uint,
        nostart_defined: ::std::os::raw::c_uint,
        dangerously_reconstruct_alloc_defined: ::std::os::raw::c_uint,
        version_upgrade_defined: ::std::os::raw::c_uint,
        stdio_defined: ::std::os::raw::c_uint,
        project_defined: ::std::os::raw::c_uint,
        nocow_defined: ::std::os::raw::c_uint,
        nocow_enabled_defined: ::std::os::raw::c_uint,
        copygc_enabled_defined: ::std::os::raw::c_uint,
        reconcile_enabled_defined: ::std::os::raw::c_uint,
        reconcile_on_ac_only_defined: ::std::os::raw::c_uint,
        auto_snapshot_deletion_defined: ::std::os::raw::c_uint,
        no_data_io_defined: ::std::os::raw::c_uint,
        state_defined: ::std::os::raw::c_uint,
        bucket_size_defined: ::std::os::raw::c_uint,
        durability_defined: ::std::os::raw::c_uint,
        data_allowed_defined: ::std::os::raw::c_uint,
        discard_defined: ::std::os::raw::c_uint,
        rotational_defined: ::std::os::raw::c_uint,
        btree_node_prefetch_defined: ::std::os::raw::c_uint,
        dev_readahead_defined: ::std::os::raw::c_uint,
        ec_stripe_buf_limit_defined: ::std::os::raw::c_uint,
    ) -> __BindgenBitfieldUnit<[u8; 11usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 11usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                1u8,
                {
                    let block_size_defined: u32 = unsafe {
                        ::std::mem::transmute(block_size_defined)
                    };
                    block_size_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                1usize,
                1u8,
                {
                    let btree_node_size_defined: u32 = unsafe {
                        ::std::mem::transmute(btree_node_size_defined)
                    };
                    btree_node_size_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                2usize,
                1u8,
                {
                    let errors_defined: u32 = unsafe {
                        ::std::mem::transmute(errors_defined)
                    };
                    errors_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                3usize,
                1u8,
                {
                    let write_error_timeout_defined: u32 = unsafe {
                        ::std::mem::transmute(write_error_timeout_defined)
                    };
                    write_error_timeout_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                4usize,
                1u8,
                {
                    let metadata_replicas_defined: u32 = unsafe {
                        ::std::mem::transmute(metadata_replicas_defined)
                    };
                    metadata_replicas_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                5usize,
                1u8,
                {
                    let data_replicas_defined: u32 = unsafe {
                        ::std::mem::transmute(data_replicas_defined)
                    };
                    data_replicas_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                6usize,
                1u8,
                {
                    let encoded_extent_max_defined: u32 = unsafe {
                        ::std::mem::transmute(encoded_extent_max_defined)
                    };
                    encoded_extent_max_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                7usize,
                1u8,
                {
                    let metadata_checksum_defined: u32 = unsafe {
                        ::std::mem::transmute(metadata_checksum_defined)
                    };
                    metadata_checksum_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                8usize,
                1u8,
                {
                    let data_checksum_defined: u32 = unsafe {
                        ::std::mem::transmute(data_checksum_defined)
                    };
                    data_checksum_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                9usize,
                1u8,
                {
                    let checksum_err_retry_nr_defined: u32 = unsafe {
                        ::std::mem::transmute(checksum_err_retry_nr_defined)
                    };
                    checksum_err_retry_nr_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                10usize,
                1u8,
                {
                    let compression_defined: u32 = unsafe {
                        ::std::mem::transmute(compression_defined)
                    };
                    compression_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                11usize,
                1u8,
                {
                    let background_compression_defined: u32 = unsafe {
                        ::std::mem::transmute(background_compression_defined)
                    };
                    background_compression_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                12usize,
                1u8,
                {
                    let str_hash_defined: u32 = unsafe {
                        ::std::mem::transmute(str_hash_defined)
                    };
                    str_hash_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                13usize,
                1u8,
                {
                    let metadata_target_defined: u32 = unsafe {
                        ::std::mem::transmute(metadata_target_defined)
                    };
                    metadata_target_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                14usize,
                1u8,
                {
                    let foreground_target_defined: u32 = unsafe {
                        ::std::mem::transmute(foreground_target_defined)
                    };
                    foreground_target_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                15usize,
                1u8,
                {
                    let background_target_defined: u32 = unsafe {
                        ::std::mem::transmute(background_target_defined)
                    };
                    background_target_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                16usize,
                1u8,
                {
                    let promote_target_defined: u32 = unsafe {
                        ::std::mem::transmute(promote_target_defined)
                    };
                    promote_target_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                17usize,
                1u8,
                {
                    let erasure_code_defined: u32 = unsafe {
                        ::std::mem::transmute(erasure_code_defined)
                    };
                    erasure_code_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                18usize,
                1u8,
                {
                    let ec_max_data_blocks_defined: u32 = unsafe {
                        ::std::mem::transmute(ec_max_data_blocks_defined)
                    };
                    ec_max_data_blocks_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                19usize,
                1u8,
                {
                    let casefold_defined: u32 = unsafe {
                        ::std::mem::transmute(casefold_defined)
                    };
                    casefold_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                20usize,
                1u8,
                {
                    let casefold_disabled_defined: u32 = unsafe {
                        ::std::mem::transmute(casefold_disabled_defined)
                    };
                    casefold_disabled_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                21usize,
                1u8,
                {
                    let inodes_32bit_defined: u32 = unsafe {
                        ::std::mem::transmute(inodes_32bit_defined)
                    };
                    inodes_32bit_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                22usize,
                1u8,
                {
                    let shard_inode_numbers_bits_defined: u32 = unsafe {
                        ::std::mem::transmute(shard_inode_numbers_bits_defined)
                    };
                    shard_inode_numbers_bits_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                23usize,
                1u8,
                {
                    let btree_node_mem_ptr_optimization_defined: u32 = unsafe {
                        ::std::mem::transmute(btree_node_mem_ptr_optimization_defined)
                    };
                    btree_node_mem_ptr_optimization_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                24usize,
                1u8,
                {
                    let gc_reserve_percent_defined: u32 = unsafe {
                        ::std::mem::transmute(gc_reserve_percent_defined)
                    };
                    gc_reserve_percent_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                25usize,
                1u8,
                {
                    let gc_reserve_bytes_defined: u32 = unsafe {
                        ::std::mem::transmute(gc_reserve_bytes_defined)
                    };
                    gc_reserve_bytes_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                26usize,
                1u8,
                {
                    let root_reserve_percent_defined: u32 = unsafe {
                        ::std::mem::transmute(root_reserve_percent_defined)
                    };
                    root_reserve_percent_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                27usize,
                1u8,
                {
                    let wide_macs_defined: u32 = unsafe {
                        ::std::mem::transmute(wide_macs_defined)
                    };
                    wide_macs_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                28usize,
                1u8,
                {
                    let inline_data_defined: u32 = unsafe {
                        ::std::mem::transmute(inline_data_defined)
                    };
                    inline_data_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                29usize,
                1u8,
                {
                    let promote_whole_extents_defined: u32 = unsafe {
                        ::std::mem::transmute(promote_whole_extents_defined)
                    };
                    promote_whole_extents_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                30usize,
                1u8,
                {
                    let acl_defined: u32 = unsafe { ::std::mem::transmute(acl_defined) };
                    acl_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                31usize,
                1u8,
                {
                    let usrquota_defined: u32 = unsafe {
                        ::std::mem::transmute(usrquota_defined)
                    };
                    usrquota_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                32usize,
                1u8,
                {
                    let grpquota_defined: u32 = unsafe {
                        ::std::mem::transmute(grpquota_defined)
                    };
                    grpquota_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                33usize,
                1u8,
                {
                    let prjquota_defined: u32 = unsafe {
                        ::std::mem::transmute(prjquota_defined)
                    };
                    prjquota_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                34usize,
                1u8,
                {
                    let degraded_defined: u32 = unsafe {
                        ::std::mem::transmute(degraded_defined)
                    };
                    degraded_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                35usize,
                1u8,
                {
                    let mount_trusts_udev_defined: u32 = unsafe {
                        ::std::mem::transmute(mount_trusts_udev_defined)
                    };
                    mount_trusts_udev_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                36usize,
                1u8,
                {
                    let no_splitbrain_check_defined: u32 = unsafe {
                        ::std::mem::transmute(no_splitbrain_check_defined)
                    };
                    no_splitbrain_check_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                37usize,
                1u8,
                {
                    let no_version_check_defined: u32 = unsafe {
                        ::std::mem::transmute(no_version_check_defined)
                    };
                    no_version_check_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                38usize,
                1u8,
                {
                    let verbose_defined: u32 = unsafe {
                        ::std::mem::transmute(verbose_defined)
                    };
                    verbose_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                39usize,
                1u8,
                {
                    let journal_flush_delay_defined: u32 = unsafe {
                        ::std::mem::transmute(journal_flush_delay_defined)
                    };
                    journal_flush_delay_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                40usize,
                1u8,
                {
                    let journal_flush_disabled_defined: u32 = unsafe {
                        ::std::mem::transmute(journal_flush_disabled_defined)
                    };
                    journal_flush_disabled_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                41usize,
                1u8,
                {
                    let journal_reclaim_delay_defined: u32 = unsafe {
                        ::std::mem::transmute(journal_reclaim_delay_defined)
                    };
                    journal_reclaim_delay_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                42usize,
                1u8,
                {
                    let writeback_timeout_defined: u32 = unsafe {
                        ::std::mem::transmute(writeback_timeout_defined)
                    };
                    writeback_timeout_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                43usize,
                1u8,
                {
                    let move_bytes_in_flight_defined: u32 = unsafe {
                        ::std::mem::transmute(move_bytes_in_flight_defined)
                    };
                    move_bytes_in_flight_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                44usize,
                1u8,
                {
                    let move_ios_in_flight_defined: u32 = unsafe {
                        ::std::mem::transmute(move_ios_in_flight_defined)
                    };
                    move_ios_in_flight_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                45usize,
                1u8,
                {
                    let fsck_defined: u32 = unsafe {
                        ::std::mem::transmute(fsck_defined)
                    };
                    fsck_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                46usize,
                1u8,
                {
                    let fsck_memory_usage_percent_defined: u32 = unsafe {
                        ::std::mem::transmute(fsck_memory_usage_percent_defined)
                    };
                    fsck_memory_usage_percent_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                47usize,
                1u8,
                {
                    let fix_errors_defined: u32 = unsafe {
                        ::std::mem::transmute(fix_errors_defined)
                    };
                    fix_errors_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                48usize,
                1u8,
                {
                    let ratelimit_errors_defined: u32 = unsafe {
                        ::std::mem::transmute(ratelimit_errors_defined)
                    };
                    ratelimit_errors_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                49usize,
                1u8,
                {
                    let nochanges_defined: u32 = unsafe {
                        ::std::mem::transmute(nochanges_defined)
                    };
                    nochanges_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                50usize,
                1u8,
                {
                    let norecovery_defined: u32 = unsafe {
                        ::std::mem::transmute(norecovery_defined)
                    };
                    norecovery_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                51usize,
                1u8,
                {
                    let journal_rewind_defined: u32 = unsafe {
                        ::std::mem::transmute(journal_rewind_defined)
                    };
                    journal_rewind_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                52usize,
                1u8,
                {
                    let journal_rewind_discard_buffer_percent_defined: u32 = unsafe {
                        ::std::mem::transmute(
                            journal_rewind_discard_buffer_percent_defined,
                        )
                    };
                    journal_rewind_discard_buffer_percent_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                53usize,
                1u8,
                {
                    let scrub_recent_journal_entries_defined: u32 = unsafe {
                        ::std::mem::transmute(scrub_recent_journal_entries_defined)
                    };
                    scrub_recent_journal_entries_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                54usize,
                1u8,
                {
                    let scrub_journal_max_rewind_secs_defined: u32 = unsafe {
                        ::std::mem::transmute(scrub_journal_max_rewind_secs_defined)
                    };
                    scrub_journal_max_rewind_secs_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                55usize,
                1u8,
                {
                    let recovery_passes_defined: u32 = unsafe {
                        ::std::mem::transmute(recovery_passes_defined)
                    };
                    recovery_passes_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                56usize,
                1u8,
                {
                    let recovery_passes_exclude_defined: u32 = unsafe {
                        ::std::mem::transmute(recovery_passes_exclude_defined)
                    };
                    recovery_passes_exclude_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                57usize,
                1u8,
                {
                    let recovery_pass_last_defined: u32 = unsafe {
                        ::std::mem::transmute(recovery_pass_last_defined)
                    };
                    recovery_pass_last_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                58usize,
                1u8,
                {
                    let retain_recovery_info_defined: u32 = unsafe {
                        ::std::mem::transmute(retain_recovery_info_defined)
                    };
                    retain_recovery_info_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                59usize,
                1u8,
                {
                    let read_entire_journal_defined: u32 = unsafe {
                        ::std::mem::transmute(read_entire_journal_defined)
                    };
                    read_entire_journal_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                60usize,
                1u8,
                {
                    let read_journal_only_defined: u32 = unsafe {
                        ::std::mem::transmute(read_journal_only_defined)
                    };
                    read_journal_only_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                61usize,
                1u8,
                {
                    let journal_transaction_names_defined: u32 = unsafe {
                        ::std::mem::transmute(journal_transaction_names_defined)
                    };
                    journal_transaction_names_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                62usize,
                1u8,
                {
                    let allocator_stuck_timeout_defined: u32 = unsafe {
                        ::std::mem::transmute(allocator_stuck_timeout_defined)
                    };
                    allocator_stuck_timeout_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                63usize,
                1u8,
                {
                    let noexcl_defined: u32 = unsafe {
                        ::std::mem::transmute(noexcl_defined)
                    };
                    noexcl_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                64usize,
                1u8,
                {
                    let direct_io_defined: u32 = unsafe {
                        ::std::mem::transmute(direct_io_defined)
                    };
                    direct_io_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                65usize,
                1u8,
                {
                    let sb_defined: u32 = unsafe { ::std::mem::transmute(sb_defined) };
                    sb_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                66usize,
                1u8,
                {
                    let read_only_defined: u32 = unsafe {
                        ::std::mem::transmute(read_only_defined)
                    };
                    read_only_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                67usize,
                1u8,
                {
                    let nostart_defined: u32 = unsafe {
                        ::std::mem::transmute(nostart_defined)
                    };
                    nostart_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                68usize,
                1u8,
                {
                    let dangerously_reconstruct_alloc_defined: u32 = unsafe {
                        ::std::mem::transmute(dangerously_reconstruct_alloc_defined)
                    };
                    dangerously_reconstruct_alloc_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                69usize,
                1u8,
                {
                    let version_upgrade_defined: u32 = unsafe {
                        ::std::mem::transmute(version_upgrade_defined)
                    };
                    version_upgrade_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                70usize,
                1u8,
                {
                    let stdio_defined: u32 = unsafe {
                        ::std::mem::transmute(stdio_defined)
                    };
                    stdio_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                71usize,
                1u8,
                {
                    let project_defined: u32 = unsafe {
                        ::std::mem::transmute(project_defined)
                    };
                    project_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                72usize,
                1u8,
                {
                    let nocow_defined: u32 = unsafe {
                        ::std::mem::transmute(nocow_defined)
                    };
                    nocow_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                73usize,
                1u8,
                {
                    let nocow_enabled_defined: u32 = unsafe {
                        ::std::mem::transmute(nocow_enabled_defined)
                    };
                    nocow_enabled_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                74usize,
                1u8,
                {
                    let copygc_enabled_defined: u32 = unsafe {
                        ::std::mem::transmute(copygc_enabled_defined)
                    };
                    copygc_enabled_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                75usize,
                1u8,
                {
                    let reconcile_enabled_defined: u32 = unsafe {
                        ::std::mem::transmute(reconcile_enabled_defined)
                    };
                    reconcile_enabled_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                76usize,
                1u8,
                {
                    let reconcile_on_ac_only_defined: u32 = unsafe {
                        ::std::mem::transmute(reconcile_on_ac_only_defined)
                    };
                    reconcile_on_ac_only_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                77usize,
                1u8,
                {
                    let auto_snapshot_deletion_defined: u32 = unsafe {
                        ::std::mem::transmute(auto_snapshot_deletion_defined)
                    };
                    auto_snapshot_deletion_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                78usize,
                1u8,
                {
                    let no_data_io_defined: u32 = unsafe {
                        ::std::mem::transmute(no_data_io_defined)
                    };
                    no_data_io_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                79usize,
                1u8,
                {
                    let state_defined: u32 = unsafe {
                        ::std::mem::transmute(state_defined)
                    };
                    state_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                80usize,
                1u8,
                {
                    let bucket_size_defined: u32 = unsafe {
                        ::std::mem::transmute(bucket_size_defined)
                    };
                    bucket_size_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                81usize,
                1u8,
                {
                    let durability_defined: u32 = unsafe {
                        ::std::mem::transmute(durability_defined)
                    };
                    durability_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                82usize,
                1u8,
                {
                    let data_allowed_defined: u32 = unsafe {
                        ::std::mem::transmute(data_allowed_defined)
                    };
                    data_allowed_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                83usize,
                1u8,
                {
                    let discard_defined: u32 = unsafe {
                        ::std::mem::transmute(discard_defined)
                    };
                    discard_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                84usize,
                1u8,
                {
                    let rotational_defined: u32 = unsafe {
                        ::std::mem::transmute(rotational_defined)
                    };
                    rotational_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                85usize,
                1u8,
                {
                    let btree_node_prefetch_defined: u32 = unsafe {
                        ::std::mem::transmute(btree_node_prefetch_defined)
                    };
                    btree_node_prefetch_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                86usize,
                1u8,
                {
                    let dev_readahead_defined: u32 = unsafe {
                        ::std::mem::transmute(dev_readahead_defined)
                    };
                    dev_readahead_defined as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                87usize,
                1u8,
                {
                    let ec_stripe_buf_limit_defined: u32 = unsafe {
                        ::std::mem::transmute(ec_stripe_buf_limit_defined)
                    };
                    ec_stripe_buf_limit_defined as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
unsafe extern "C" {
    pub static bch2_opts_default: bch_opts;
}
unsafe extern "C" {
    #[link_name = "bch2_opts_empty__extern"]
    pub fn bch2_opts_empty() -> bch_opts;
}
unsafe extern "C" {
    pub fn bch2_opts_apply(arg1: *mut bch_opts, arg2: bch_opts);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bch_option {
    pub attr: attribute,
    pub type_: opt_type,
    pub flags: opt_flags,
    pub min: u64_,
    pub max: u64_,
    pub choices: *const *const ::std::os::raw::c_char,
    pub fn_: bch_opt_fn,
    pub hint: *const ::std::os::raw::c_char,
    pub help: *const ::std::os::raw::c_char,
    pub get_sb: ::std::option::Option<unsafe extern "C" fn(arg1: *const bch_sb) -> u64_>,
    pub set_sb: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut bch_sb, arg2: u64_),
    >,
    pub get_member: ::std::option::Option<
        unsafe extern "C" fn(arg1: *const bch_member) -> u64_,
    >,
    pub set_member: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut bch_member, arg2: u64_),
    >,
    pub get_ext: ::std::option::Option<
        unsafe extern "C" fn(arg1: *const bch_sb_field_ext) -> u64_,
    >,
    pub set_ext: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut bch_sb_field_ext, arg2: u64_),
    >,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_option"][::std::mem::size_of::<bch_option>() - 136usize];
    ["Alignment of bch_option"][::std::mem::align_of::<bch_option>() - 8usize];
    [
        "Offset of field: bch_option::attr",
    ][::std::mem::offset_of!(bch_option, attr) - 0usize];
    [
        "Offset of field: bch_option::type_",
    ][::std::mem::offset_of!(bch_option, type_) - 16usize];
    [
        "Offset of field: bch_option::flags",
    ][::std::mem::offset_of!(bch_option, flags) - 20usize];
    [
        "Offset of field: bch_option::min",
    ][::std::mem::offset_of!(bch_option, min) - 24usize];
    [
        "Offset of field: bch_option::max",
    ][::std::mem::offset_of!(bch_option, max) - 32usize];
    [
        "Offset of field: bch_option::choices",
    ][::std::mem::offset_of!(bch_option, choices) - 40usize];
    [
        "Offset of field: bch_option::fn_",
    ][::std::mem::offset_of!(bch_option, fn_) - 48usize];
    [
        "Offset of field: bch_option::hint",
    ][::std::mem::offset_of!(bch_option, hint) - 72usize];
    [
        "Offset of field: bch_option::help",
    ][::std::mem::offset_of!(bch_option, help) - 80usize];
    [
        "Offset of field: bch_option::get_sb",
    ][::std::mem::offset_of!(bch_option, get_sb) - 88usize];
    [
        "Offset of field: bch_option::set_sb",
    ][::std::mem::offset_of!(bch_option, set_sb) - 96usize];
    [
        "Offset of field: bch_option::get_member",
    ][::std::mem::offset_of!(bch_option, get_member) - 104usize];
    [
        "Offset of field: bch_option::set_member",
    ][::std::mem::offset_of!(bch_option, set_member) - 112usize];
    [
        "Offset of field: bch_option::get_ext",
    ][::std::mem::offset_of!(bch_option, get_ext) - 120usize];
    [
        "Offset of field: bch_option::set_ext",
    ][::std::mem::offset_of!(bch_option, set_ext) - 128usize];
};
impl Default for bch_option {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C" {
    pub static bch2_opt_table: [bch_option; 0usize];
}
unsafe extern "C" {
    pub fn bch2_opt_defined_by_id(arg1: *const bch_opts, arg2: bch_opt_id) -> bool;
}
unsafe extern "C" {
    pub fn bch2_opt_get_by_id(arg1: *const bch_opts, arg2: bch_opt_id) -> u64_;
}
unsafe extern "C" {
    pub fn bch2_opt_set_by_id(arg1: *mut bch_opts, arg2: bch_opt_id, arg3: u64_);
}
unsafe extern "C" {
    pub fn bch2_opt_from_sb(
        arg1: *mut bch_sb,
        arg2: bch_opt_id,
        arg3: ::std::os::raw::c_int,
    ) -> u64_;
}
unsafe extern "C" {
    pub fn bch2_opts_from_sb(
        arg1: *mut bch_opts,
        arg2: *mut bch_sb,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn __bch2_opt_set_sb(
        arg1: *mut bch_sb,
        arg2: ::std::os::raw::c_int,
        arg3: *const bch_option,
        arg4: u64_,
    ) -> bool;
}
unsafe extern "C" {
    pub fn bch2_opt_set_sb(
        arg1: *mut bch_fs,
        arg2: *mut bch_dev,
        arg3: *const bch_option,
        arg4: u64_,
    ) -> bool;
}
unsafe extern "C" {
    pub fn bch2_opt_lookup(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_opt_validate(
        arg1: *const bch_option,
        arg2: u64_,
        arg3: *mut printbuf,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_opt_parse(
        arg1: *mut bch_fs,
        arg2: *const bch_option,
        arg3: *const ::std::os::raw::c_char,
        arg4: *mut u64_,
        arg5: *mut printbuf,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_opt_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: *mut bch_sb,
        arg4: *const bch_option,
        arg5: u64_,
        arg6: ::std::os::raw::c_uint,
    );
}
unsafe extern "C" {
    pub fn bch2_opts_to_text(
        arg1: *mut printbuf,
        arg2: bch_opts,
        arg3: *mut bch_fs,
        arg4: *mut bch_sb,
        arg5: *mut bch_opts_mask,
        arg6: ::std::os::raw::c_uint,
        arg7: ::std::os::raw::c_uint,
        arg8: ::std::os::raw::c_uint,
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct opt_change_scope {
    _unused: [u8; 0],
}
unsafe extern "C" {
    pub fn bch2_opt_hook_pre_set(
        arg1: *mut bch_fs,
        arg2: *mut bch_dev,
        arg3: u64_,
        arg4: bch_opt_id,
        arg5: u64_,
        arg6: bool,
        arg7: *mut opt_change_scope,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_opts_hooks_pre_set(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_opt_hook_post_set(
        arg1: *mut bch_fs,
        arg2: *mut bch_dev,
        arg3: u64_,
        arg4: bch_opt_id,
        arg5: u64_,
    );
}
unsafe extern "C" {
    pub fn bch2_parse_one_mount_opt(
        arg1: *mut bch_fs,
        arg2: *mut bch_opts,
        arg3: *mut printbuf,
        arg4: *const ::std::os::raw::c_char,
        arg5: *const ::std::os::raw::c_char,
        arg6: *mut printbuf,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_parse_mount_opts(
        arg1: *mut bch_fs,
        arg2: *mut bch_opts,
        arg3: *mut printbuf,
        arg4: *mut ::std::os::raw::c_char,
        arg5: bool,
    ) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[repr(align(8))]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_inode_opts {
    pub data_checksum: u8_,
    pub compression: u8_,
    pub project: u32_,
    pub background_compression: u8_,
    pub data_replicas: u8_,
    pub promote_target: u16_,
    pub foreground_target: u16_,
    pub background_target: u16_,
    pub erasure_code: u16_,
    pub nocow: u8_,
    pub inodes_32bit: u8_,
    pub casefold: u8_,
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
    pub change_cookie: u32_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_inode_opts"][::std::mem::size_of::<bch_inode_opts>() - 32usize];
    ["Alignment of bch_inode_opts"][::std::mem::align_of::<bch_inode_opts>() - 8usize];
    [
        "Offset of field: bch_inode_opts::data_checksum",
    ][::std::mem::offset_of!(bch_inode_opts, data_checksum) - 0usize];
    [
        "Offset of field: bch_inode_opts::compression",
    ][::std::mem::offset_of!(bch_inode_opts, compression) - 1usize];
    [
        "Offset of field: bch_inode_opts::project",
    ][::std::mem::offset_of!(bch_inode_opts, project) - 4usize];
    [
        "Offset of field: bch_inode_opts::background_compression",
    ][::std::mem::offset_of!(bch_inode_opts, background_compression) - 8usize];
    [
        "Offset of field: bch_inode_opts::data_replicas",
    ][::std::mem::offset_of!(bch_inode_opts, data_replicas) - 9usize];
    [
        "Offset of field: bch_inode_opts::promote_target",
    ][::std::mem::offset_of!(bch_inode_opts, promote_target) - 10usize];
    [
        "Offset of field: bch_inode_opts::foreground_target",
    ][::std::mem::offset_of!(bch_inode_opts, foreground_target) - 12usize];
    [
        "Offset of field: bch_inode_opts::background_target",
    ][::std::mem::offset_of!(bch_inode_opts, background_target) - 14usize];
    [
        "Offset of field: bch_inode_opts::erasure_code",
    ][::std::mem::offset_of!(bch_inode_opts, erasure_code) - 16usize];
    [
        "Offset of field: bch_inode_opts::nocow",
    ][::std::mem::offset_of!(bch_inode_opts, nocow) - 18usize];
    [
        "Offset of field: bch_inode_opts::inodes_32bit",
    ][::std::mem::offset_of!(bch_inode_opts, inodes_32bit) - 19usize];
    [
        "Offset of field: bch_inode_opts::casefold",
    ][::std::mem::offset_of!(bch_inode_opts, casefold) - 20usize];
    [
        "Offset of field: bch_inode_opts::change_cookie",
    ][::std::mem::offset_of!(bch_inode_opts, change_cookie) - 24usize];
};
impl bch_inode_opts {
    #[inline]
    pub fn data_checksum_from_inode(&self) -> u64_ {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
    }
    #[inline]
    pub fn set_data_checksum_from_inode(&mut self, val: u64_) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn data_checksum_from_inode_raw(this: *const Self) -> u64_ {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_data_checksum_from_inode_raw(this: *mut Self, val: u64_) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn compression_from_inode(&self) -> u64_ {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
    }
    #[inline]
    pub fn set_compression_from_inode(&mut self, val: u64_) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(1usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn compression_from_inode_raw(this: *const Self) -> u64_ {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 1usize, 1u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_compression_from_inode_raw(this: *mut Self, val: u64_) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                1usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn project_from_inode(&self) -> u64_ {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
    }
    #[inline]
    pub fn set_project_from_inode(&mut self, val: u64_) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(2usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn project_from_inode_raw(this: *const Self) -> u64_ {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 2usize, 1u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_project_from_inode_raw(this: *mut Self, val: u64_) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                2usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn background_compression_from_inode(&self) -> u64_ {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
    }
    #[inline]
    pub fn set_background_compression_from_inode(&mut self, val: u64_) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(3usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn background_compression_from_inode_raw(this: *const Self) -> u64_ {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 3usize, 1u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_background_compression_from_inode_raw(this: *mut Self, val: u64_) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                3usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn data_replicas_from_inode(&self) -> u64_ {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u64) }
    }
    #[inline]
    pub fn set_data_replicas_from_inode(&mut self, val: u64_) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(4usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn data_replicas_from_inode_raw(this: *const Self) -> u64_ {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 4usize, 1u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_data_replicas_from_inode_raw(this: *mut Self, val: u64_) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                4usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn promote_target_from_inode(&self) -> u64_ {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u64) }
    }
    #[inline]
    pub fn set_promote_target_from_inode(&mut self, val: u64_) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(5usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn promote_target_from_inode_raw(this: *const Self) -> u64_ {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 5usize, 1u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_promote_target_from_inode_raw(this: *mut Self, val: u64_) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                5usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn foreground_target_from_inode(&self) -> u64_ {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u64) }
    }
    #[inline]
    pub fn set_foreground_target_from_inode(&mut self, val: u64_) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(6usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn foreground_target_from_inode_raw(this: *const Self) -> u64_ {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 6usize, 1u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_foreground_target_from_inode_raw(this: *mut Self, val: u64_) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                6usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn background_target_from_inode(&self) -> u64_ {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u64) }
    }
    #[inline]
    pub fn set_background_target_from_inode(&mut self, val: u64_) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(7usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn background_target_from_inode_raw(this: *const Self) -> u64_ {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 7usize, 1u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_background_target_from_inode_raw(this: *mut Self, val: u64_) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                7usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn erasure_code_from_inode(&self) -> u64_ {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u64) }
    }
    #[inline]
    pub fn set_erasure_code_from_inode(&mut self, val: u64_) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(8usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn erasure_code_from_inode_raw(this: *const Self) -> u64_ {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 8usize, 1u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_erasure_code_from_inode_raw(this: *mut Self, val: u64_) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                8usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn nocow_from_inode(&self) -> u64_ {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u64) }
    }
    #[inline]
    pub fn set_nocow_from_inode(&mut self, val: u64_) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(9usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn nocow_from_inode_raw(this: *const Self) -> u64_ {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 9usize, 1u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_nocow_from_inode_raw(this: *mut Self, val: u64_) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                9usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn inodes_32bit_from_inode(&self) -> u64_ {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u64) }
    }
    #[inline]
    pub fn set_inodes_32bit_from_inode(&mut self, val: u64_) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(10usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn inodes_32bit_from_inode_raw(this: *const Self) -> u64_ {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 10usize, 1u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_inodes_32bit_from_inode_raw(this: *mut Self, val: u64_) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                10usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn casefold_from_inode(&self) -> u64_ {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u64) }
    }
    #[inline]
    pub fn set_casefold_from_inode(&mut self, val: u64_) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(11usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn casefold_from_inode_raw(this: *const Self) -> u64_ {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 11usize, 1u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_casefold_from_inode_raw(this: *mut Self, val: u64_) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                11usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        data_checksum_from_inode: u64_,
        compression_from_inode: u64_,
        project_from_inode: u64_,
        background_compression_from_inode: u64_,
        data_replicas_from_inode: u64_,
        promote_target_from_inode: u64_,
        foreground_target_from_inode: u64_,
        background_target_from_inode: u64_,
        erasure_code_from_inode: u64_,
        nocow_from_inode: u64_,
        inodes_32bit_from_inode: u64_,
        casefold_from_inode: u64_,
    ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                1u8,
                {
                    let data_checksum_from_inode: u64 = unsafe {
                        ::std::mem::transmute(data_checksum_from_inode)
                    };
                    data_checksum_from_inode as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                1usize,
                1u8,
                {
                    let compression_from_inode: u64 = unsafe {
                        ::std::mem::transmute(compression_from_inode)
                    };
                    compression_from_inode as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                2usize,
                1u8,
                {
                    let project_from_inode: u64 = unsafe {
                        ::std::mem::transmute(project_from_inode)
                    };
                    project_from_inode as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                3usize,
                1u8,
                {
                    let background_compression_from_inode: u64 = unsafe {
                        ::std::mem::transmute(background_compression_from_inode)
                    };
                    background_compression_from_inode as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                4usize,
                1u8,
                {
                    let data_replicas_from_inode: u64 = unsafe {
                        ::std::mem::transmute(data_replicas_from_inode)
                    };
                    data_replicas_from_inode as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                5usize,
                1u8,
                {
                    let promote_target_from_inode: u64 = unsafe {
                        ::std::mem::transmute(promote_target_from_inode)
                    };
                    promote_target_from_inode as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                6usize,
                1u8,
                {
                    let foreground_target_from_inode: u64 = unsafe {
                        ::std::mem::transmute(foreground_target_from_inode)
                    };
                    foreground_target_from_inode as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                7usize,
                1u8,
                {
                    let background_target_from_inode: u64 = unsafe {
                        ::std::mem::transmute(background_target_from_inode)
                    };
                    background_target_from_inode as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                8usize,
                1u8,
                {
                    let erasure_code_from_inode: u64 = unsafe {
                        ::std::mem::transmute(erasure_code_from_inode)
                    };
                    erasure_code_from_inode as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                9usize,
                1u8,
                {
                    let nocow_from_inode: u64 = unsafe {
                        ::std::mem::transmute(nocow_from_inode)
                    };
                    nocow_from_inode as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                10usize,
                1u8,
                {
                    let inodes_32bit_from_inode: u64 = unsafe {
                        ::std::mem::transmute(inodes_32bit_from_inode)
                    };
                    inodes_32bit_from_inode as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                11usize,
                1u8,
                {
                    let casefold_from_inode: u64 = unsafe {
                        ::std::mem::transmute(casefold_from_inode)
                    };
                    casefold_from_inode as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
unsafe extern "C" {
    #[link_name = "bch2_io_opts_fixups__extern"]
    pub fn bch2_io_opts_fixups(opts: *mut bch_inode_opts);
}
unsafe extern "C" {
    pub fn bch2_inode_opts_get(arg1: *mut bch_fs, arg2: *mut bch_inode_opts, arg3: bool);
}
unsafe extern "C" {
    pub fn bch2_opt_is_inode_opt(arg1: bch_opt_id) -> bool;
}
unsafe extern "C" {
    pub fn bch2_inode_opts_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: bch_inode_opts,
    );
}
unsafe extern "C" {
    pub fn bch2_opt_change_unlock(arg1: *mut bch_fs);
}
unsafe extern "C" {
    pub fn bch2_opt_change_lock(arg1: *mut bch_fs);
}
pub type percpu_ref_func_t = ::std::option::Option<
    unsafe extern "C" fn(arg1: *mut percpu_ref),
>;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct percpu_ref {
    pub count: atomic_long_t,
    pub release: percpu_ref_func_t,
    pub confirm_switch: percpu_ref_func_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of percpu_ref"][::std::mem::size_of::<percpu_ref>() - 24usize];
    ["Alignment of percpu_ref"][::std::mem::align_of::<percpu_ref>() - 8usize];
    [
        "Offset of field: percpu_ref::count",
    ][::std::mem::offset_of!(percpu_ref, count) - 0usize];
    [
        "Offset of field: percpu_ref::release",
    ][::std::mem::offset_of!(percpu_ref, release) - 8usize];
    [
        "Offset of field: percpu_ref::confirm_switch",
    ][::std::mem::offset_of!(percpu_ref, confirm_switch) - 16usize];
};
#[repr(C)]
#[derive(Copy, Clone)]
pub struct percpu_rw_semaphore {
    pub lock: pthread_mutex_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of percpu_rw_semaphore",
    ][::std::mem::size_of::<percpu_rw_semaphore>() - 40usize];
    [
        "Alignment of percpu_rw_semaphore",
    ][::std::mem::align_of::<percpu_rw_semaphore>() - 8usize];
    [
        "Offset of field: percpu_rw_semaphore::lock",
    ][::std::mem::offset_of!(percpu_rw_semaphore, lock) - 0usize];
};
impl Default for percpu_rw_semaphore {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
/** typedef refcount_t - variant of atomic_t specialized for reference counts
 @refs: atomic_t counter field

 The counter saturates at REFCOUNT_SATURATED and will not move once
 there. This avoids wrapping the counter and causing 'spurious'
 use-after-free bugs.*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct refcount_struct {
    pub refs: atomic_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of refcount_struct"][::std::mem::size_of::<refcount_struct>() - 4usize];
    ["Alignment of refcount_struct"][::std::mem::align_of::<refcount_struct>() - 4usize];
    [
        "Offset of field: refcount_struct::refs",
    ][::std::mem::offset_of!(refcount_struct, refs) - 0usize];
};
/** typedef refcount_t - variant of atomic_t specialized for reference counts
 @refs: atomic_t counter field

 The counter saturates at REFCOUNT_SATURATED and will not move once
 there. This avoids wrapping the counter and causing 'spurious'
 use-after-free bugs.*/
pub type refcount_t = refcount_struct;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cds_wfcq_node {
    pub next: *mut cds_wfcq_node,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of cds_wfcq_node"][::std::mem::size_of::<cds_wfcq_node>() - 8usize];
    ["Alignment of cds_wfcq_node"][::std::mem::align_of::<cds_wfcq_node>() - 8usize];
    [
        "Offset of field: cds_wfcq_node::next",
    ][::std::mem::offset_of!(cds_wfcq_node, next) - 0usize];
};
impl Default for cds_wfcq_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rcu_head {
    pub next: cds_wfcq_node,
    pub func: ::std::option::Option<unsafe extern "C" fn(head: *mut rcu_head)>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of rcu_head"][::std::mem::size_of::<rcu_head>() - 16usize];
    ["Alignment of rcu_head"][::std::mem::align_of::<rcu_head>() - 8usize];
    ["Offset of field: rcu_head::next"][::std::mem::offset_of!(rcu_head, next) - 0usize];
    ["Offset of field: rcu_head::func"][::std::mem::offset_of!(rcu_head, func) - 8usize];
};
impl Default for rcu_head {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rhash_head {
    pub next: *mut rhash_head,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of rhash_head"][::std::mem::size_of::<rhash_head>() - 8usize];
    ["Alignment of rhash_head"][::std::mem::align_of::<rhash_head>() - 8usize];
    [
        "Offset of field: rhash_head::next",
    ][::std::mem::offset_of!(rhash_head, next) - 0usize];
};
impl Default for rhash_head {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rhlist_head {
    pub rhead: rhash_head,
    pub next: *mut rhlist_head,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of rhlist_head"][::std::mem::size_of::<rhlist_head>() - 16usize];
    ["Alignment of rhlist_head"][::std::mem::align_of::<rhlist_head>() - 8usize];
    [
        "Offset of field: rhlist_head::rhead",
    ][::std::mem::offset_of!(rhlist_head, rhead) - 0usize];
    [
        "Offset of field: rhlist_head::next",
    ][::std::mem::offset_of!(rhlist_head, next) - 8usize];
};
impl Default for rhlist_head {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
/** struct rhashtable_compare_arg - Key for the function rhashtable_compare
 @ht: Hash table
 @key: Key to compare against*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rhashtable_compare_arg {
    pub ht: *mut rhashtable,
    pub key: *const ::std::os::raw::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of rhashtable_compare_arg",
    ][::std::mem::size_of::<rhashtable_compare_arg>() - 16usize];
    [
        "Alignment of rhashtable_compare_arg",
    ][::std::mem::align_of::<rhashtable_compare_arg>() - 8usize];
    [
        "Offset of field: rhashtable_compare_arg::ht",
    ][::std::mem::offset_of!(rhashtable_compare_arg, ht) - 0usize];
    [
        "Offset of field: rhashtable_compare_arg::key",
    ][::std::mem::offset_of!(rhashtable_compare_arg, key) - 8usize];
};
impl Default for rhashtable_compare_arg {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type rht_hashfn_t = ::std::option::Option<
    unsafe extern "C" fn(
        data: *const ::std::os::raw::c_void,
        len: u32_,
        seed: u32_,
    ) -> u32_,
>;
pub type rht_obj_hashfn_t = ::std::option::Option<
    unsafe extern "C" fn(
        data: *const ::std::os::raw::c_void,
        len: u32_,
        seed: u32_,
    ) -> u32_,
>;
pub type rht_obj_cmpfn_t = ::std::option::Option<
    unsafe extern "C" fn(
        arg: *mut rhashtable_compare_arg,
        obj: *const ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int,
>;
/** struct rhashtable_params - Hash table construction parameters
 @nelem_hint: Hint on number of elements, should be 75% of desired size
 @key_len: Length of key
 @key_offset: Offset of key in struct to be hashed
 @head_offset: Offset of rhash_head in struct to be hashed
 @max_size: Maximum size while expanding
 @min_size: Minimum size while shrinking
 @automatic_shrinking: Enable automatic shrinking of tables
 @hashfn: Hash function (default: jhash2 if !(key_len % 4), or jhash)
 @obj_hashfn: Function to hash object
 @obj_cmpfn: Function to compare key with object*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct rhashtable_params {
    pub nelem_hint: u16_,
    pub key_len: u16_,
    pub key_offset: u16_,
    pub head_offset: u16_,
    pub max_size: ::std::os::raw::c_uint,
    pub min_size: u16_,
    pub automatic_shrinking: bool,
    pub hashfn: rht_hashfn_t,
    pub obj_hashfn: rht_obj_hashfn_t,
    pub obj_cmpfn: rht_obj_cmpfn_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of rhashtable_params"][::std::mem::size_of::<rhashtable_params>() - 40usize];
    [
        "Alignment of rhashtable_params",
    ][::std::mem::align_of::<rhashtable_params>() - 8usize];
    [
        "Offset of field: rhashtable_params::nelem_hint",
    ][::std::mem::offset_of!(rhashtable_params, nelem_hint) - 0usize];
    [
        "Offset of field: rhashtable_params::key_len",
    ][::std::mem::offset_of!(rhashtable_params, key_len) - 2usize];
    [
        "Offset of field: rhashtable_params::key_offset",
    ][::std::mem::offset_of!(rhashtable_params, key_offset) - 4usize];
    [
        "Offset of field: rhashtable_params::head_offset",
    ][::std::mem::offset_of!(rhashtable_params, head_offset) - 6usize];
    [
        "Offset of field: rhashtable_params::max_size",
    ][::std::mem::offset_of!(rhashtable_params, max_size) - 8usize];
    [
        "Offset of field: rhashtable_params::min_size",
    ][::std::mem::offset_of!(rhashtable_params, min_size) - 12usize];
    [
        "Offset of field: rhashtable_params::automatic_shrinking",
    ][::std::mem::offset_of!(rhashtable_params, automatic_shrinking) - 14usize];
    [
        "Offset of field: rhashtable_params::hashfn",
    ][::std::mem::offset_of!(rhashtable_params, hashfn) - 16usize];
    [
        "Offset of field: rhashtable_params::obj_hashfn",
    ][::std::mem::offset_of!(rhashtable_params, obj_hashfn) - 24usize];
    [
        "Offset of field: rhashtable_params::obj_cmpfn",
    ][::std::mem::offset_of!(rhashtable_params, obj_cmpfn) - 32usize];
};
/** struct rhashtable - Hash table handle
 @tbl: Bucket table
 @key_len: Key length for hashfn
 @max_elems: Maximum number of elements in table
 @p: Configuration parameters
 @rhlist: True if this is an rhltable
 @run_work: Deferred worker to expand/shrink asynchronously
 @mutex: Mutex to protect current/future table swapping
 @lock: Spin lock to protect walker list
 @nelems: Number of elements in table*/
#[repr(C)]
#[derive(Copy, Clone)]
pub struct rhashtable {
    pub tbl: *mut bucket_table,
    pub key_len: ::std::os::raw::c_uint,
    pub max_elems: ::std::os::raw::c_uint,
    pub p: rhashtable_params,
    pub rhlist: bool,
    pub run_work: work_struct,
    pub mutex: mutex,
    pub lock: spinlock_t,
    pub nelems: atomic_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of rhashtable"][::std::mem::size_of::<rhashtable>() - 184usize];
    ["Alignment of rhashtable"][::std::mem::align_of::<rhashtable>() - 8usize];
    [
        "Offset of field: rhashtable::tbl",
    ][::std::mem::offset_of!(rhashtable, tbl) - 0usize];
    [
        "Offset of field: rhashtable::key_len",
    ][::std::mem::offset_of!(rhashtable, key_len) - 8usize];
    [
        "Offset of field: rhashtable::max_elems",
    ][::std::mem::offset_of!(rhashtable, max_elems) - 12usize];
    ["Offset of field: rhashtable::p"][::std::mem::offset_of!(rhashtable, p) - 16usize];
    [
        "Offset of field: rhashtable::rhlist",
    ][::std::mem::offset_of!(rhashtable, rhlist) - 56usize];
    [
        "Offset of field: rhashtable::run_work",
    ][::std::mem::offset_of!(rhashtable, run_work) - 64usize];
    [
        "Offset of field: rhashtable::mutex",
    ][::std::mem::offset_of!(rhashtable, mutex) - 96usize];
    [
        "Offset of field: rhashtable::lock",
    ][::std::mem::offset_of!(rhashtable, lock) - 136usize];
    [
        "Offset of field: rhashtable::nelems",
    ][::std::mem::offset_of!(rhashtable, nelems) - 176usize];
};
impl Default for rhashtable {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
/** struct rhltable - Hash table with duplicate objects in a list
 @ht: Underlying rhtable*/
#[repr(C)]
#[derive(Copy, Clone)]
pub struct rhltable {
    pub ht: rhashtable,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of rhltable"][::std::mem::size_of::<rhltable>() - 184usize];
    ["Alignment of rhltable"][::std::mem::align_of::<rhltable>() - 8usize];
    ["Offset of field: rhltable::ht"][::std::mem::offset_of!(rhltable, ht) - 0usize];
};
impl Default for rhltable {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
/** struct bucket_table - Table of hash buckets
 @size: Number of hash buckets
 @nest: Number of bits of first-level nested table.
 @rehash: Current bucket being rehashed
 @hash_rnd: Random seed to fold into hash
 @walkers: List of active walkers
 @rcu: RCU structure for freeing the table
 @future_tbl: Table under construction during rehashing
 @ntbl: Nested table used when out of memory.
 @buckets: size * hash buckets*/
#[repr(C)]
#[repr(align(64))]
#[derive(Debug)]
pub struct bucket_table {
    pub size: ::std::os::raw::c_uint,
    pub nest: ::std::os::raw::c_uint,
    pub hash_rnd: u32_,
    pub walkers: cds_list_head,
    pub rcu: rcu_head,
    pub future_tbl: *mut bucket_table,
    pub __bindgen_padding_0: u64,
    pub buckets: __IncompleteArrayField<*mut rhash_lock_head>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bucket_table"][::std::mem::size_of::<bucket_table>() - 64usize];
    ["Alignment of bucket_table"][::std::mem::align_of::<bucket_table>() - 64usize];
    [
        "Offset of field: bucket_table::size",
    ][::std::mem::offset_of!(bucket_table, size) - 0usize];
    [
        "Offset of field: bucket_table::nest",
    ][::std::mem::offset_of!(bucket_table, nest) - 4usize];
    [
        "Offset of field: bucket_table::hash_rnd",
    ][::std::mem::offset_of!(bucket_table, hash_rnd) - 8usize];
    [
        "Offset of field: bucket_table::walkers",
    ][::std::mem::offset_of!(bucket_table, walkers) - 16usize];
    [
        "Offset of field: bucket_table::rcu",
    ][::std::mem::offset_of!(bucket_table, rcu) - 32usize];
    [
        "Offset of field: bucket_table::future_tbl",
    ][::std::mem::offset_of!(bucket_table, future_tbl) - 48usize];
    [
        "Offset of field: bucket_table::buckets",
    ][::std::mem::offset_of!(bucket_table, buckets) - 64usize];
};
impl Default for bucket_table {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct semaphore {
    pub lock: raw_spinlock_t,
    pub count: ::std::os::raw::c_uint,
    pub wait_list: cds_list_head,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of semaphore"][::std::mem::size_of::<semaphore>() - 64usize];
    ["Alignment of semaphore"][::std::mem::align_of::<semaphore>() - 8usize];
    [
        "Offset of field: semaphore::lock",
    ][::std::mem::offset_of!(semaphore, lock) - 0usize];
    [
        "Offset of field: semaphore::count",
    ][::std::mem::offset_of!(semaphore, count) - 40usize];
    [
        "Offset of field: semaphore::wait_list",
    ][::std::mem::offset_of!(semaphore, wait_list) - 48usize];
};
impl Default for semaphore {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct seqcount {
    pub sequence: ::std::os::raw::c_uint,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of seqcount"][::std::mem::size_of::<seqcount>() - 4usize];
    ["Alignment of seqcount"][::std::mem::align_of::<seqcount>() - 4usize];
    [
        "Offset of field: seqcount::sequence",
    ][::std::mem::offset_of!(seqcount, sequence) - 0usize];
};
pub type seqcount_t = seqcount;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct utf8data {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct utf8data_table {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct unicode_map {
    pub version: ::std::os::raw::c_uint,
    pub ntab: [*const utf8data; 2usize],
    pub tables: *const utf8data_table,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of unicode_map"][::std::mem::size_of::<unicode_map>() - 32usize];
    ["Alignment of unicode_map"][::std::mem::align_of::<unicode_map>() - 8usize];
    [
        "Offset of field: unicode_map::version",
    ][::std::mem::offset_of!(unicode_map, version) - 0usize];
    [
        "Offset of field: unicode_map::ntab",
    ][::std::mem::offset_of!(unicode_map, ntab) - 8usize];
    [
        "Offset of field: unicode_map::tables",
    ][::std::mem::offset_of!(unicode_map, tables) - 24usize];
};
impl Default for unicode_map {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug)]
pub struct min_heap_char {
    pub nr: usize,
    pub size: usize,
    pub data: *mut ::std::os::raw::c_char,
    pub preallocated: __IncompleteArrayField<::std::os::raw::c_char>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of min_heap_char"][::std::mem::size_of::<min_heap_char>() - 24usize];
    ["Alignment of min_heap_char"][::std::mem::align_of::<min_heap_char>() - 8usize];
    [
        "Offset of field: min_heap_char::nr",
    ][::std::mem::offset_of!(min_heap_char, nr) - 0usize];
    [
        "Offset of field: min_heap_char::size",
    ][::std::mem::offset_of!(min_heap_char, size) - 8usize];
    [
        "Offset of field: min_heap_char::data",
    ][::std::mem::offset_of!(min_heap_char, data) - 16usize];
    [
        "Offset of field: min_heap_char::preallocated",
    ][::std::mem::offset_of!(min_heap_char, preallocated) - 24usize];
};
impl Default for min_heap_char {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
/** struct min_heap_callbacks - Data/functions to customise the min_heap.
 @less: Partial order function for this heap.
 @swp: Swap elements function.*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct min_heap_callbacks {
    pub less: ::std::option::Option<
        unsafe extern "C" fn(
            lhs: *const ::std::os::raw::c_void,
            rhs: *const ::std::os::raw::c_void,
            args: *mut ::std::os::raw::c_void,
        ) -> bool,
    >,
    pub swp: ::std::option::Option<
        unsafe extern "C" fn(
            lhs: *mut ::std::os::raw::c_void,
            rhs: *mut ::std::os::raw::c_void,
            args: *mut ::std::os::raw::c_void,
        ),
    >,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of min_heap_callbacks",
    ][::std::mem::size_of::<min_heap_callbacks>() - 16usize];
    [
        "Alignment of min_heap_callbacks",
    ][::std::mem::align_of::<min_heap_callbacks>() - 8usize];
    [
        "Offset of field: min_heap_callbacks::less",
    ][::std::mem::offset_of!(min_heap_callbacks, less) - 0usize];
    [
        "Offset of field: min_heap_callbacks::swp",
    ][::std::mem::offset_of!(min_heap_callbacks, swp) - 8usize];
};
unsafe extern "C" {
    pub fn __bch2_min_heap_init(
        heap: *mut min_heap_char,
        data: *mut ::std::os::raw::c_void,
        size: usize,
    );
}
unsafe extern "C" {
    pub fn __bch2_min_heap_peek(heap: *mut min_heap_char) -> *mut ::std::os::raw::c_void;
}
unsafe extern "C" {
    pub fn __bch2_min_heap_full(heap: *mut min_heap_char) -> bool;
}
unsafe extern "C" {
    pub fn __bch2_min_heap_sift_down(
        heap: *mut min_heap_char,
        pos: usize,
        elem_size: usize,
        func: *const min_heap_callbacks,
        args: *mut ::std::os::raw::c_void,
    );
}
unsafe extern "C" {
    pub fn __bch2_min_heap_sift_up(
        heap: *mut min_heap_char,
        elem_size: usize,
        idx: usize,
        func: *const min_heap_callbacks,
        args: *mut ::std::os::raw::c_void,
    );
}
unsafe extern "C" {
    pub fn __bch2_min_heapify_all(
        heap: *mut min_heap_char,
        elem_size: usize,
        func: *const min_heap_callbacks,
        args: *mut ::std::os::raw::c_void,
    );
}
unsafe extern "C" {
    pub fn __bch2_min_heap_pop(
        heap: *mut min_heap_char,
        elem_size: usize,
        func: *const min_heap_callbacks,
        args: *mut ::std::os::raw::c_void,
    ) -> bool;
}
unsafe extern "C" {
    pub fn __bch2_min_heap_pop_push(
        heap: *mut min_heap_char,
        element: *const ::std::os::raw::c_void,
        elem_size: usize,
        func: *const min_heap_callbacks,
        args: *mut ::std::os::raw::c_void,
    );
}
unsafe extern "C" {
    pub fn __bch2_min_heap_push(
        heap: *mut min_heap_char,
        element: *const ::std::os::raw::c_void,
        elem_size: usize,
        func: *const min_heap_callbacks,
        args: *mut ::std::os::raw::c_void,
    ) -> bool;
}
unsafe extern "C" {
    pub fn __bch2_min_heap_del(
        heap: *mut min_heap_char,
        elem_size: usize,
        idx: usize,
        func: *const min_heap_callbacks,
        args: *mut ::std::os::raw::c_void,
    ) -> bool;
}
pub type io_timer_fn = ::std::option::Option<unsafe extern "C" fn(arg1: *mut io_timer)>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct io_timer {
    pub fn_: io_timer_fn,
    pub fn2: *mut ::std::os::raw::c_void,
    pub expire: u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of io_timer"][::std::mem::size_of::<io_timer>() - 24usize];
    ["Alignment of io_timer"][::std::mem::align_of::<io_timer>() - 8usize];
    ["Offset of field: io_timer::fn_"][::std::mem::offset_of!(io_timer, fn_) - 0usize];
    ["Offset of field: io_timer::fn2"][::std::mem::offset_of!(io_timer, fn2) - 8usize];
    [
        "Offset of field: io_timer::expire",
    ][::std::mem::offset_of!(io_timer, expire) - 16usize];
};
impl Default for io_timer {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug)]
pub struct io_timer_heap {
    pub nr: usize,
    pub size: usize,
    pub data: *mut *mut io_timer,
    pub preallocated: __IncompleteArrayField<*mut io_timer>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of io_timer_heap"][::std::mem::size_of::<io_timer_heap>() - 24usize];
    ["Alignment of io_timer_heap"][::std::mem::align_of::<io_timer_heap>() - 8usize];
    [
        "Offset of field: io_timer_heap::nr",
    ][::std::mem::offset_of!(io_timer_heap, nr) - 0usize];
    [
        "Offset of field: io_timer_heap::size",
    ][::std::mem::offset_of!(io_timer_heap, size) - 8usize];
    [
        "Offset of field: io_timer_heap::data",
    ][::std::mem::offset_of!(io_timer_heap, data) - 16usize];
    [
        "Offset of field: io_timer_heap::preallocated",
    ][::std::mem::offset_of!(io_timer_heap, preallocated) - 24usize];
};
impl Default for io_timer_heap {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct io_clock {
    pub now: atomic64_t,
    pub pcpu_buf: *mut u16_,
    pub max_slop: ::std::os::raw::c_uint,
    pub timer_lock: spinlock_t,
    pub timers: io_timer_heap,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of io_clock"][::std::mem::size_of::<io_clock>() - 88usize];
    ["Alignment of io_clock"][::std::mem::align_of::<io_clock>() - 8usize];
    ["Offset of field: io_clock::now"][::std::mem::offset_of!(io_clock, now) - 0usize];
    [
        "Offset of field: io_clock::pcpu_buf",
    ][::std::mem::offset_of!(io_clock, pcpu_buf) - 8usize];
    [
        "Offset of field: io_clock::max_slop",
    ][::std::mem::offset_of!(io_clock, max_slop) - 16usize];
    [
        "Offset of field: io_clock::timer_lock",
    ][::std::mem::offset_of!(io_clock, timer_lock) - 24usize];
    [
        "Offset of field: io_clock::timers",
    ][::std::mem::offset_of!(io_clock, timers) - 64usize];
};
impl Default for io_clock {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct enumerated_ref {
    pub ref_: percpu_ref,
    pub stop_fn: ::std::option::Option<unsafe extern "C" fn(arg1: *mut enumerated_ref)>,
    pub stop_complete: completion,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of enumerated_ref"][::std::mem::size_of::<enumerated_ref>() - 96usize];
    ["Alignment of enumerated_ref"][::std::mem::align_of::<enumerated_ref>() - 8usize];
    [
        "Offset of field: enumerated_ref::ref_",
    ][::std::mem::offset_of!(enumerated_ref, ref_) - 0usize];
    [
        "Offset of field: enumerated_ref::stop_fn",
    ][::std::mem::offset_of!(enumerated_ref, stop_fn) - 24usize];
    [
        "Offset of field: enumerated_ref::stop_complete",
    ][::std::mem::offset_of!(enumerated_ref, stop_complete) - 32usize];
};
impl Default for enumerated_ref {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct genradix_root {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __genradix {
    pub root: *mut genradix_root,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of __genradix"][::std::mem::size_of::<__genradix>() - 8usize];
    ["Alignment of __genradix"][::std::mem::align_of::<__genradix>() - 8usize];
    [
        "Offset of field: __genradix::root",
    ][::std::mem::offset_of!(__genradix, root) - 0usize];
};
impl Default for __genradix {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ida {
    pub lock: mutex,
    pub depth: ::std::os::raw::c_uint,
    pub nodes: *mut ::std::os::raw::c_ulong,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of ida"][::std::mem::size_of::<ida>() - 56usize];
    ["Alignment of ida"][::std::mem::align_of::<ida>() - 8usize];
    ["Offset of field: ida::lock"][::std::mem::offset_of!(ida, lock) - 0usize];
    ["Offset of field: ida::depth"][::std::mem::offset_of!(ida, depth) - 40usize];
    ["Offset of field: ida::nodes"][::std::mem::offset_of!(ida, nodes) - 48usize];
};
impl Default for ida {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct fast_list_pcpu {
    _unused: [u8; 0],
}
#[repr(C)]
pub struct fast_list {
    pub items: fast_list__bindgen_ty_1,
    pub slots_allocated: ida,
    pub buffer: *mut fast_list_pcpu,
}
#[repr(C)]
#[derive(Debug)]
pub struct fast_list__bindgen_ty_1 {
    pub tree: __genradix,
    pub type_: __IncompleteArrayField<*mut ::std::os::raw::c_void>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of fast_list__bindgen_ty_1",
    ][::std::mem::size_of::<fast_list__bindgen_ty_1>() - 8usize];
    [
        "Alignment of fast_list__bindgen_ty_1",
    ][::std::mem::align_of::<fast_list__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: fast_list__bindgen_ty_1::tree",
    ][::std::mem::offset_of!(fast_list__bindgen_ty_1, tree) - 0usize];
    [
        "Offset of field: fast_list__bindgen_ty_1::type_",
    ][::std::mem::offset_of!(fast_list__bindgen_ty_1, type_) - 8usize];
};
impl Default for fast_list__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of fast_list"][::std::mem::size_of::<fast_list>() - 72usize];
    ["Alignment of fast_list"][::std::mem::align_of::<fast_list>() - 8usize];
    [
        "Offset of field: fast_list::items",
    ][::std::mem::offset_of!(fast_list, items) - 0usize];
    [
        "Offset of field: fast_list::slots_allocated",
    ][::std::mem::offset_of!(fast_list, slots_allocated) - 8usize];
    [
        "Offset of field: fast_list::buffer",
    ][::std::mem::offset_of!(fast_list, buffer) - 64usize];
};
impl Default for fast_list {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct seqmutex {
    pub lock: mutex,
    pub seq: u32_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of seqmutex"][::std::mem::size_of::<seqmutex>() - 48usize];
    ["Alignment of seqmutex"][::std::mem::align_of::<seqmutex>() - 8usize];
    ["Offset of field: seqmutex::lock"][::std::mem::offset_of!(seqmutex, lock) - 0usize];
    ["Offset of field: seqmutex::seq"][::std::mem::offset_of!(seqmutex, seq) - 40usize];
};
impl Default for seqmutex {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct stdio_buf {
    pub lock: spinlock_t,
    pub wait: wait_queue_head_t,
    pub buf: darray_char,
    pub waiting_for_line: bool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of stdio_buf"][::std::mem::size_of::<stdio_buf>() - 128usize];
    ["Alignment of stdio_buf"][::std::mem::align_of::<stdio_buf>() - 8usize];
    [
        "Offset of field: stdio_buf::lock",
    ][::std::mem::offset_of!(stdio_buf, lock) - 0usize];
    [
        "Offset of field: stdio_buf::wait",
    ][::std::mem::offset_of!(stdio_buf, wait) - 40usize];
    [
        "Offset of field: stdio_buf::buf",
    ][::std::mem::offset_of!(stdio_buf, buf) - 96usize];
    [
        "Offset of field: stdio_buf::waiting_for_line",
    ][::std::mem::offset_of!(stdio_buf, waiting_for_line) - 120usize];
};
impl Default for stdio_buf {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct stdio_redirect {
    pub input: stdio_buf,
    pub output: stdio_buf,
    pub done: bool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of stdio_redirect"][::std::mem::size_of::<stdio_redirect>() - 264usize];
    ["Alignment of stdio_redirect"][::std::mem::align_of::<stdio_redirect>() - 8usize];
    [
        "Offset of field: stdio_redirect::input",
    ][::std::mem::offset_of!(stdio_redirect, input) - 0usize];
    [
        "Offset of field: stdio_redirect::output",
    ][::std::mem::offset_of!(stdio_redirect, output) - 128usize];
    [
        "Offset of field: stdio_redirect::done",
    ][::std::mem::offset_of!(stdio_redirect, done) - 256usize];
};
impl Default for stdio_redirect {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct accounting_mem_entry {
    pub pos: bpos,
    pub bversion: bversion,
    pub nr_counters: ::std::os::raw::c_uint,
    pub v: [*mut u64_; 2usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of accounting_mem_entry",
    ][::std::mem::size_of::<accounting_mem_entry>() - 56usize];
    [
        "Alignment of accounting_mem_entry",
    ][::std::mem::align_of::<accounting_mem_entry>() - 8usize];
    [
        "Offset of field: accounting_mem_entry::pos",
    ][::std::mem::offset_of!(accounting_mem_entry, pos) - 0usize];
    [
        "Offset of field: accounting_mem_entry::bversion",
    ][::std::mem::offset_of!(accounting_mem_entry, bversion) - 20usize];
    [
        "Offset of field: accounting_mem_entry::nr_counters",
    ][::std::mem::offset_of!(accounting_mem_entry, nr_counters) - 32usize];
    [
        "Offset of field: accounting_mem_entry::v",
    ][::std::mem::offset_of!(accounting_mem_entry, v) - 40usize];
};
impl Default for accounting_mem_entry {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug)]
pub struct bch_accounting_mem {
    pub k: bch_accounting_mem__bindgen_ty_1,
    pub gc_running: bool,
}
#[repr(C)]
#[derive(Debug)]
pub struct bch_accounting_mem__bindgen_ty_1 {
    pub nr: usize,
    pub size: usize,
    pub data: *mut accounting_mem_entry,
    pub preallocated: __IncompleteArrayField<accounting_mem_entry>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_accounting_mem__bindgen_ty_1",
    ][::std::mem::size_of::<bch_accounting_mem__bindgen_ty_1>() - 24usize];
    [
        "Alignment of bch_accounting_mem__bindgen_ty_1",
    ][::std::mem::align_of::<bch_accounting_mem__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bch_accounting_mem__bindgen_ty_1::nr",
    ][::std::mem::offset_of!(bch_accounting_mem__bindgen_ty_1, nr) - 0usize];
    [
        "Offset of field: bch_accounting_mem__bindgen_ty_1::size",
    ][::std::mem::offset_of!(bch_accounting_mem__bindgen_ty_1, size) - 8usize];
    [
        "Offset of field: bch_accounting_mem__bindgen_ty_1::data",
    ][::std::mem::offset_of!(bch_accounting_mem__bindgen_ty_1, data) - 16usize];
    [
        "Offset of field: bch_accounting_mem__bindgen_ty_1::preallocated",
    ][::std::mem::offset_of!(bch_accounting_mem__bindgen_ty_1, preallocated) - 24usize];
};
impl Default for bch_accounting_mem__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_accounting_mem",
    ][::std::mem::size_of::<bch_accounting_mem>() - 32usize];
    [
        "Alignment of bch_accounting_mem",
    ][::std::mem::align_of::<bch_accounting_mem>() - 8usize];
    [
        "Offset of field: bch_accounting_mem::k",
    ][::std::mem::offset_of!(bch_accounting_mem, k) - 0usize];
    [
        "Offset of field: bch_accounting_mem::gc_running",
    ][::std::mem::offset_of!(bch_accounting_mem, gc_running) - 24usize];
};
impl Default for bch_accounting_mem {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[repr(align(8))]
#[derive(Debug, Default, Copy, Clone)]
pub struct bucket {
    pub lock: u8_,
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
    pub gen_: u8_,
    pub dirty_sectors: u32_,
    pub cached_sectors: u32_,
    pub stripe_sectors: u32_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bucket"][::std::mem::size_of::<bucket>() - 16usize];
    ["Alignment of bucket"][::std::mem::align_of::<bucket>() - 8usize];
    ["Offset of field: bucket::lock"][::std::mem::offset_of!(bucket, lock) - 0usize];
    ["Offset of field: bucket::gen_"][::std::mem::offset_of!(bucket, gen_) - 2usize];
    [
        "Offset of field: bucket::dirty_sectors",
    ][::std::mem::offset_of!(bucket, dirty_sectors) - 4usize];
    [
        "Offset of field: bucket::cached_sectors",
    ][::std::mem::offset_of!(bucket, cached_sectors) - 8usize];
    [
        "Offset of field: bucket::stripe_sectors",
    ][::std::mem::offset_of!(bucket, stripe_sectors) - 12usize];
};
impl bucket {
    #[inline]
    pub fn gen_valid(&self) -> u8_ {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_gen_valid(&mut self, val: u8_) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn gen_valid_raw(this: *const Self) -> u8_ {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_gen_valid_raw(this: *mut Self, val: u8_) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn data_type(&self) -> u8_ {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 7u8) as u8) }
    }
    #[inline]
    pub fn set_data_type(&mut self, val: u8_) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(1usize, 7u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn data_type_raw(this: *const Self) -> u8_ {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 1usize, 7u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_data_type_raw(this: *mut Self, val: u8_) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                1usize,
                7u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        gen_valid: u8_,
        data_type: u8_,
    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                1u8,
                {
                    let gen_valid: u8 = unsafe { ::std::mem::transmute(gen_valid) };
                    gen_valid as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                1usize,
                7u8,
                {
                    let data_type: u8 = unsafe { ::std::mem::transmute(data_type) };
                    data_type as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Debug)]
pub struct bucket_gens {
    pub rcu: rcu_head,
    pub first_bucket: u16_,
    pub nbuckets: usize,
    pub nbuckets_minus_first: usize,
    pub b: __IncompleteArrayField<u8_>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bucket_gens"][::std::mem::size_of::<bucket_gens>() - 40usize];
    ["Alignment of bucket_gens"][::std::mem::align_of::<bucket_gens>() - 8usize];
    [
        "Offset of field: bucket_gens::rcu",
    ][::std::mem::offset_of!(bucket_gens, rcu) - 0usize];
    [
        "Offset of field: bucket_gens::first_bucket",
    ][::std::mem::offset_of!(bucket_gens, first_bucket) - 16usize];
    [
        "Offset of field: bucket_gens::nbuckets",
    ][::std::mem::offset_of!(bucket_gens, nbuckets) - 24usize];
    [
        "Offset of field: bucket_gens::nbuckets_minus_first",
    ][::std::mem::offset_of!(bucket_gens, nbuckets_minus_first) - 32usize];
    [
        "Offset of field: bucket_gens::b",
    ][::std::mem::offset_of!(bucket_gens, b) - 40usize];
};
impl Default for bucket_gens {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_dev_usage {
    pub buckets: [u64_; 11usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_dev_usage"][::std::mem::size_of::<bch_dev_usage>() - 88usize];
    ["Alignment of bch_dev_usage"][::std::mem::align_of::<bch_dev_usage>() - 8usize];
    [
        "Offset of field: bch_dev_usage::buckets",
    ][::std::mem::offset_of!(bch_dev_usage, buckets) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_dev_usage_full {
    pub d: [bch_dev_usage_full_bch_dev_usage_type; 11usize],
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_dev_usage_full_bch_dev_usage_type {
    pub buckets: u64_,
    pub sectors: u64_,
    pub fragmented: u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_dev_usage_full_bch_dev_usage_type",
    ][::std::mem::size_of::<bch_dev_usage_full_bch_dev_usage_type>() - 24usize];
    [
        "Alignment of bch_dev_usage_full_bch_dev_usage_type",
    ][::std::mem::align_of::<bch_dev_usage_full_bch_dev_usage_type>() - 8usize];
    [
        "Offset of field: bch_dev_usage_full_bch_dev_usage_type::buckets",
    ][::std::mem::offset_of!(bch_dev_usage_full_bch_dev_usage_type, buckets) - 0usize];
    [
        "Offset of field: bch_dev_usage_full_bch_dev_usage_type::sectors",
    ][::std::mem::offset_of!(bch_dev_usage_full_bch_dev_usage_type, sectors) - 8usize];
    [
        "Offset of field: bch_dev_usage_full_bch_dev_usage_type::fragmented",
    ][::std::mem::offset_of!(bch_dev_usage_full_bch_dev_usage_type, fragmented)
        - 16usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_dev_usage_full",
    ][::std::mem::size_of::<bch_dev_usage_full>() - 264usize];
    [
        "Alignment of bch_dev_usage_full",
    ][::std::mem::align_of::<bch_dev_usage_full>() - 8usize];
    [
        "Offset of field: bch_dev_usage_full::d",
    ][::std::mem::offset_of!(bch_dev_usage_full, d) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_fs_usage_base {
    pub hidden: u64_,
    pub btree: u64_,
    pub data: u64_,
    pub cached: u64_,
    pub reserved: u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_fs_usage_base"][::std::mem::size_of::<bch_fs_usage_base>() - 40usize];
    [
        "Alignment of bch_fs_usage_base",
    ][::std::mem::align_of::<bch_fs_usage_base>() - 8usize];
    [
        "Offset of field: bch_fs_usage_base::hidden",
    ][::std::mem::offset_of!(bch_fs_usage_base, hidden) - 0usize];
    [
        "Offset of field: bch_fs_usage_base::btree",
    ][::std::mem::offset_of!(bch_fs_usage_base, btree) - 8usize];
    [
        "Offset of field: bch_fs_usage_base::data",
    ][::std::mem::offset_of!(bch_fs_usage_base, data) - 16usize];
    [
        "Offset of field: bch_fs_usage_base::cached",
    ][::std::mem::offset_of!(bch_fs_usage_base, cached) - 24usize];
    [
        "Offset of field: bch_fs_usage_base::reserved",
    ][::std::mem::offset_of!(bch_fs_usage_base, reserved) - 32usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_fs_usage_short {
    pub capacity: u64_,
    pub used: u64_,
    pub free: u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_fs_usage_short",
    ][::std::mem::size_of::<bch_fs_usage_short>() - 24usize];
    [
        "Alignment of bch_fs_usage_short",
    ][::std::mem::align_of::<bch_fs_usage_short>() - 8usize];
    [
        "Offset of field: bch_fs_usage_short::capacity",
    ][::std::mem::offset_of!(bch_fs_usage_short, capacity) - 0usize];
    [
        "Offset of field: bch_fs_usage_short::used",
    ][::std::mem::offset_of!(bch_fs_usage_short, used) - 8usize];
    [
        "Offset of field: bch_fs_usage_short::free",
    ][::std::mem::offset_of!(bch_fs_usage_short, free) - 16usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct disk_reservation {
    pub sectors: u64_,
    pub gen_: u32_,
    pub nr_replicas: ::std::os::raw::c_uint,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of disk_reservation"][::std::mem::size_of::<disk_reservation>() - 16usize];
    [
        "Alignment of disk_reservation",
    ][::std::mem::align_of::<disk_reservation>() - 8usize];
    [
        "Offset of field: disk_reservation::sectors",
    ][::std::mem::offset_of!(disk_reservation, sectors) - 0usize];
    [
        "Offset of field: disk_reservation::gen_",
    ][::std::mem::offset_of!(disk_reservation, gen_) - 8usize];
    [
        "Offset of field: disk_reservation::nr_replicas",
    ][::std::mem::offset_of!(disk_reservation, nr_replicas) - 12usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bch_sb_handle_holder {
    pub c: *mut bch_fs,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_sb_handle_holder",
    ][::std::mem::size_of::<bch_sb_handle_holder>() - 8usize];
    [
        "Alignment of bch_sb_handle_holder",
    ][::std::mem::align_of::<bch_sb_handle_holder>() - 8usize];
    [
        "Offset of field: bch_sb_handle_holder::c",
    ][::std::mem::offset_of!(bch_sb_handle_holder, c) - 0usize];
};
impl Default for bch_sb_handle_holder {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug)]
pub struct bch_sb_handle {
    pub sb: *mut bch_sb,
    pub s_bdev_file: *mut file,
    pub bdev: *mut block_device,
    pub sb_name: *mut ::std::os::raw::c_char,
    pub bio: *mut bio,
    pub holder: *mut bch_sb_handle_holder,
    pub buffer_size: usize,
    pub mode: blk_mode_t,
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
    pub seq: u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_sb_handle"][::std::mem::size_of::<bch_sb_handle>() - 72usize];
    ["Alignment of bch_sb_handle"][::std::mem::align_of::<bch_sb_handle>() - 8usize];
    [
        "Offset of field: bch_sb_handle::sb",
    ][::std::mem::offset_of!(bch_sb_handle, sb) - 0usize];
    [
        "Offset of field: bch_sb_handle::s_bdev_file",
    ][::std::mem::offset_of!(bch_sb_handle, s_bdev_file) - 8usize];
    [
        "Offset of field: bch_sb_handle::bdev",
    ][::std::mem::offset_of!(bch_sb_handle, bdev) - 16usize];
    [
        "Offset of field: bch_sb_handle::sb_name",
    ][::std::mem::offset_of!(bch_sb_handle, sb_name) - 24usize];
    [
        "Offset of field: bch_sb_handle::bio",
    ][::std::mem::offset_of!(bch_sb_handle, bio) - 32usize];
    [
        "Offset of field: bch_sb_handle::holder",
    ][::std::mem::offset_of!(bch_sb_handle, holder) - 40usize];
    [
        "Offset of field: bch_sb_handle::buffer_size",
    ][::std::mem::offset_of!(bch_sb_handle, buffer_size) - 48usize];
    [
        "Offset of field: bch_sb_handle::mode",
    ][::std::mem::offset_of!(bch_sb_handle, mode) - 56usize];
    [
        "Offset of field: bch_sb_handle::seq",
    ][::std::mem::offset_of!(bch_sb_handle, seq) - 64usize];
};
impl Default for bch_sb_handle {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl bch_sb_handle {
    #[inline]
    pub fn have_layout(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_have_layout(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn have_layout_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_have_layout_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn have_bio(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_have_bio(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(1usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn have_bio_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 1usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_have_bio_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                1usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn fs_sb(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_fs_sb(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(2usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn fs_sb_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 2usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_fs_sb_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                2usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        have_layout: ::std::os::raw::c_uint,
        have_bio: ::std::os::raw::c_uint,
        fs_sb: ::std::os::raw::c_uint,
    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                1u8,
                {
                    let have_layout: u32 = unsafe { ::std::mem::transmute(have_layout) };
                    have_layout as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                1usize,
                1u8,
                {
                    let have_bio: u32 = unsafe { ::std::mem::transmute(have_bio) };
                    have_bio as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                2usize,
                1u8,
                {
                    let fs_sb: u32 = unsafe { ::std::mem::transmute(fs_sb) };
                    fs_sb as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_devs_mask {
    pub d: [::std::os::raw::c_ulong; 1usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_devs_mask"][::std::mem::size_of::<bch_devs_mask>() - 8usize];
    ["Alignment of bch_devs_mask"][::std::mem::align_of::<bch_devs_mask>() - 8usize];
    [
        "Offset of field: bch_devs_mask::d",
    ][::std::mem::offset_of!(bch_devs_mask, d) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_devs_list {
    pub nr: u8_,
    pub data: [u8_; 16usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_devs_list"][::std::mem::size_of::<bch_devs_list>() - 17usize];
    ["Alignment of bch_devs_list"][::std::mem::align_of::<bch_devs_list>() - 1usize];
    [
        "Offset of field: bch_devs_list::nr",
    ][::std::mem::offset_of!(bch_devs_list, nr) - 0usize];
    [
        "Offset of field: bch_devs_list::data",
    ][::std::mem::offset_of!(bch_devs_list, data) - 1usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_disk_group_cpu {
    pub deleted: bool,
    pub parent: u16_,
    pub label: [u8_; 32usize],
    pub devs: bch_devs_mask,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_disk_group_cpu",
    ][::std::mem::size_of::<bch_disk_group_cpu>() - 48usize];
    [
        "Alignment of bch_disk_group_cpu",
    ][::std::mem::align_of::<bch_disk_group_cpu>() - 8usize];
    [
        "Offset of field: bch_disk_group_cpu::deleted",
    ][::std::mem::offset_of!(bch_disk_group_cpu, deleted) - 0usize];
    [
        "Offset of field: bch_disk_group_cpu::parent",
    ][::std::mem::offset_of!(bch_disk_group_cpu, parent) - 2usize];
    [
        "Offset of field: bch_disk_group_cpu::label",
    ][::std::mem::offset_of!(bch_disk_group_cpu, label) - 4usize];
    [
        "Offset of field: bch_disk_group_cpu::devs",
    ][::std::mem::offset_of!(bch_disk_group_cpu, devs) - 40usize];
};
#[repr(C)]
#[derive(Debug)]
pub struct bch_disk_groups_cpu {
    pub rcu: rcu_head,
    pub nr: ::std::os::raw::c_uint,
    pub entries: __IncompleteArrayField<bch_disk_group_cpu>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_disk_groups_cpu",
    ][::std::mem::size_of::<bch_disk_groups_cpu>() - 24usize];
    [
        "Alignment of bch_disk_groups_cpu",
    ][::std::mem::align_of::<bch_disk_groups_cpu>() - 8usize];
    [
        "Offset of field: bch_disk_groups_cpu::rcu",
    ][::std::mem::offset_of!(bch_disk_groups_cpu, rcu) - 0usize];
    [
        "Offset of field: bch_disk_groups_cpu::nr",
    ][::std::mem::offset_of!(bch_disk_groups_cpu, nr) - 16usize];
    [
        "Offset of field: bch_disk_groups_cpu::entries",
    ][::std::mem::offset_of!(bch_disk_groups_cpu, entries) - 24usize];
};
impl Default for bch_disk_groups_cpu {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Default)]
pub struct bch_replicas_entry_cpu {
    pub ref_: atomic_t,
    pub e: bch_replicas_entry_v1,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_replicas_entry_cpu",
    ][::std::mem::size_of::<bch_replicas_entry_cpu>() - 8usize];
    [
        "Alignment of bch_replicas_entry_cpu",
    ][::std::mem::align_of::<bch_replicas_entry_cpu>() - 4usize];
    [
        "Offset of field: bch_replicas_entry_cpu::ref_",
    ][::std::mem::offset_of!(bch_replicas_entry_cpu, ref_) - 0usize];
    [
        "Offset of field: bch_replicas_entry_cpu::e",
    ][::std::mem::offset_of!(bch_replicas_entry_cpu, e) - 4usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bch_replicas_cpu {
    pub nr: ::std::os::raw::c_uint,
    pub entry_size: ::std::os::raw::c_uint,
    pub entries: *mut bch_replicas_entry_cpu,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_replicas_cpu"][::std::mem::size_of::<bch_replicas_cpu>() - 16usize];
    [
        "Alignment of bch_replicas_cpu",
    ][::std::mem::align_of::<bch_replicas_cpu>() - 8usize];
    [
        "Offset of field: bch_replicas_cpu::nr",
    ][::std::mem::offset_of!(bch_replicas_cpu, nr) - 0usize];
    [
        "Offset of field: bch_replicas_cpu::entry_size",
    ][::std::mem::offset_of!(bch_replicas_cpu, entry_size) - 4usize];
    [
        "Offset of field: bch_replicas_cpu::entries",
    ][::std::mem::offset_of!(bch_replicas_cpu, entries) - 8usize];
};
impl Default for bch_replicas_cpu {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[repr(align(1))]
#[derive(Copy, Clone)]
pub struct bch_replicas_padded {
    pub _bindgen_opaque_blob: [u8; 19usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_replicas_padded",
    ][::std::mem::size_of::<bch_replicas_padded>() - 19usize];
    [
        "Alignment of bch_replicas_padded",
    ][::std::mem::align_of::<bch_replicas_padded>() - 1usize];
};
impl Default for bch_replicas_padded {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_watermark {
    BCH_WATERMARK_stripe = 0,
    BCH_WATERMARK_normal = 1,
    BCH_WATERMARK_copygc = 2,
    BCH_WATERMARK_btree = 3,
    BCH_WATERMARK_btree_copygc = 4,
    BCH_WATERMARK_reclaim = 5,
    BCH_WATERMARK_interior_updates = 6,
    BCH_WATERMARK_NR = 7,
}
pub type open_bucket_idx_t = u16;
#[repr(C)]
#[repr(align(8))]
#[derive(Debug, Default, Copy, Clone)]
pub struct open_bucket {
    pub _bindgen_opaque_blob: [u64; 9usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of open_bucket"][::std::mem::size_of::<open_bucket>() - 72usize];
    ["Alignment of open_bucket"][::std::mem::align_of::<open_bucket>() - 8usize];
};
#[repr(C)]
#[repr(align(2))]
#[derive(Debug, Default, Copy, Clone)]
pub struct open_buckets {
    pub _bindgen_opaque_blob: [u16; 17usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of open_buckets"][::std::mem::size_of::<open_buckets>() - 34usize];
    ["Alignment of open_buckets"][::std::mem::align_of::<open_buckets>() - 2usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dev_stripe_state {
    pub next_alloc: [u64_; 64usize],
    pub cached_devs: bch_devs_mask,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of dev_stripe_state"][::std::mem::size_of::<dev_stripe_state>() - 520usize];
    [
        "Alignment of dev_stripe_state",
    ][::std::mem::align_of::<dev_stripe_state>() - 8usize];
    [
        "Offset of field: dev_stripe_state::next_alloc",
    ][::std::mem::offset_of!(dev_stripe_state, next_alloc) - 0usize];
    [
        "Offset of field: dev_stripe_state::cached_devs",
    ][::std::mem::offset_of!(dev_stripe_state, cached_devs) - 512usize];
};
impl Default for dev_stripe_state {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum write_point_state {
    WRITE_POINT_stopped = 0,
    WRITE_POINT_waiting_io = 1,
    WRITE_POINT_waiting_work = 2,
    WRITE_POINT_runnable = 3,
    WRITE_POINT_running = 4,
    WRITE_POINT_STATE_NR = 5,
}
#[repr(C)]
#[repr(align(64))]
#[derive(Copy, Clone)]
pub struct write_point {
    pub __bindgen_anon_1: write_point__bindgen_ty_1,
    pub __bindgen_anon_2: write_point__bindgen_ty_2,
}
#[repr(C)]
#[repr(align(64))]
#[derive(Copy, Clone)]
pub struct write_point__bindgen_ty_1 {
    pub node: cds_hlist_node,
    pub lock: mutex,
    pub last_used: u64_,
    pub write_point: ::std::os::raw::c_ulong,
    pub data_type: bch_data_type,
    pub sectors_free: ::std::os::raw::c_uint,
    pub prev_sectors_free: ::std::os::raw::c_uint,
    pub ptrs: open_buckets,
    pub stripe: dev_stripe_state,
    pub sectors_allocated: u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of write_point__bindgen_ty_1",
    ][::std::mem::size_of::<write_point__bindgen_ty_1>() - 704usize];
    [
        "Alignment of write_point__bindgen_ty_1",
    ][::std::mem::align_of::<write_point__bindgen_ty_1>() - 64usize];
    [
        "Offset of field: write_point__bindgen_ty_1::node",
    ][::std::mem::offset_of!(write_point__bindgen_ty_1, node) - 0usize];
    [
        "Offset of field: write_point__bindgen_ty_1::lock",
    ][::std::mem::offset_of!(write_point__bindgen_ty_1, lock) - 16usize];
    [
        "Offset of field: write_point__bindgen_ty_1::last_used",
    ][::std::mem::offset_of!(write_point__bindgen_ty_1, last_used) - 56usize];
    [
        "Offset of field: write_point__bindgen_ty_1::write_point",
    ][::std::mem::offset_of!(write_point__bindgen_ty_1, write_point) - 64usize];
    [
        "Offset of field: write_point__bindgen_ty_1::data_type",
    ][::std::mem::offset_of!(write_point__bindgen_ty_1, data_type) - 72usize];
    [
        "Offset of field: write_point__bindgen_ty_1::sectors_free",
    ][::std::mem::offset_of!(write_point__bindgen_ty_1, sectors_free) - 76usize];
    [
        "Offset of field: write_point__bindgen_ty_1::prev_sectors_free",
    ][::std::mem::offset_of!(write_point__bindgen_ty_1, prev_sectors_free) - 80usize];
    [
        "Offset of field: write_point__bindgen_ty_1::ptrs",
    ][::std::mem::offset_of!(write_point__bindgen_ty_1, ptrs) - 84usize];
    [
        "Offset of field: write_point__bindgen_ty_1::stripe",
    ][::std::mem::offset_of!(write_point__bindgen_ty_1, stripe) - 120usize];
    [
        "Offset of field: write_point__bindgen_ty_1::sectors_allocated",
    ][::std::mem::offset_of!(write_point__bindgen_ty_1, sectors_allocated) - 640usize];
};
impl Default for write_point__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[repr(align(64))]
#[derive(Copy, Clone)]
pub struct write_point__bindgen_ty_2 {
    pub index_update_work: work_struct,
    pub writes: cds_list_head,
    pub writes_lock: spinlock_t,
    pub state: write_point_state,
    pub last_state_change: u64_,
    pub time: [u64_; 5usize],
    pub last_runtime: u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of write_point__bindgen_ty_2",
    ][::std::mem::size_of::<write_point__bindgen_ty_2>() - 192usize];
    [
        "Alignment of write_point__bindgen_ty_2",
    ][::std::mem::align_of::<write_point__bindgen_ty_2>() - 64usize];
    [
        "Offset of field: write_point__bindgen_ty_2::index_update_work",
    ][::std::mem::offset_of!(write_point__bindgen_ty_2, index_update_work) - 0usize];
    [
        "Offset of field: write_point__bindgen_ty_2::writes",
    ][::std::mem::offset_of!(write_point__bindgen_ty_2, writes) - 32usize];
    [
        "Offset of field: write_point__bindgen_ty_2::writes_lock",
    ][::std::mem::offset_of!(write_point__bindgen_ty_2, writes_lock) - 48usize];
    [
        "Offset of field: write_point__bindgen_ty_2::state",
    ][::std::mem::offset_of!(write_point__bindgen_ty_2, state) - 88usize];
    [
        "Offset of field: write_point__bindgen_ty_2::last_state_change",
    ][::std::mem::offset_of!(write_point__bindgen_ty_2, last_state_change) - 96usize];
    [
        "Offset of field: write_point__bindgen_ty_2::time",
    ][::std::mem::offset_of!(write_point__bindgen_ty_2, time) - 104usize];
    [
        "Offset of field: write_point__bindgen_ty_2::last_runtime",
    ][::std::mem::offset_of!(write_point__bindgen_ty_2, last_runtime) - 144usize];
};
impl Default for write_point__bindgen_ty_2 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of write_point"][::std::mem::size_of::<write_point>() - 896usize];
    ["Alignment of write_point"][::std::mem::align_of::<write_point>() - 64usize];
};
impl Default for write_point {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct write_point_specifier {
    pub v: ::std::os::raw::c_ulong,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of write_point_specifier",
    ][::std::mem::size_of::<write_point_specifier>() - 8usize];
    [
        "Alignment of write_point_specifier",
    ][::std::mem::align_of::<write_point_specifier>() - 8usize];
    [
        "Offset of field: write_point_specifier::v",
    ][::std::mem::offset_of!(write_point_specifier, v) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_fs_capacity_pcpu {
    pub sectors_available: u64_,
    pub online_reserved: u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_fs_capacity_pcpu",
    ][::std::mem::size_of::<bch_fs_capacity_pcpu>() - 16usize];
    [
        "Alignment of bch_fs_capacity_pcpu",
    ][::std::mem::align_of::<bch_fs_capacity_pcpu>() - 8usize];
    [
        "Offset of field: bch_fs_capacity_pcpu::sectors_available",
    ][::std::mem::offset_of!(bch_fs_capacity_pcpu, sectors_available) - 0usize];
    [
        "Offset of field: bch_fs_capacity_pcpu::online_reserved",
    ][::std::mem::offset_of!(bch_fs_capacity_pcpu, online_reserved) - 8usize];
};
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bch_fs_capacity {
    pub capacity: u64_,
    pub reserved: u64_,
    pub capacity_gen: u32_,
    pub bucket_size_max: ::std::os::raw::c_uint,
    pub sectors_available: atomic64_t,
    pub sectors_available_lock: spinlock_t,
    pub pcpu: *mut bch_fs_capacity_pcpu,
    pub mark_lock: percpu_rw_semaphore,
    pub usage_lock: seqcount_t,
    pub usage: *mut bch_fs_usage_base,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_fs_capacity"][::std::mem::size_of::<bch_fs_capacity>() - 136usize];
    ["Alignment of bch_fs_capacity"][::std::mem::align_of::<bch_fs_capacity>() - 8usize];
    [
        "Offset of field: bch_fs_capacity::capacity",
    ][::std::mem::offset_of!(bch_fs_capacity, capacity) - 0usize];
    [
        "Offset of field: bch_fs_capacity::reserved",
    ][::std::mem::offset_of!(bch_fs_capacity, reserved) - 8usize];
    [
        "Offset of field: bch_fs_capacity::capacity_gen",
    ][::std::mem::offset_of!(bch_fs_capacity, capacity_gen) - 16usize];
    [
        "Offset of field: bch_fs_capacity::bucket_size_max",
    ][::std::mem::offset_of!(bch_fs_capacity, bucket_size_max) - 20usize];
    [
        "Offset of field: bch_fs_capacity::sectors_available",
    ][::std::mem::offset_of!(bch_fs_capacity, sectors_available) - 24usize];
    [
        "Offset of field: bch_fs_capacity::sectors_available_lock",
    ][::std::mem::offset_of!(bch_fs_capacity, sectors_available_lock) - 32usize];
    [
        "Offset of field: bch_fs_capacity::pcpu",
    ][::std::mem::offset_of!(bch_fs_capacity, pcpu) - 72usize];
    [
        "Offset of field: bch_fs_capacity::mark_lock",
    ][::std::mem::offset_of!(bch_fs_capacity, mark_lock) - 80usize];
    [
        "Offset of field: bch_fs_capacity::usage_lock",
    ][::std::mem::offset_of!(bch_fs_capacity, usage_lock) - 120usize];
    [
        "Offset of field: bch_fs_capacity::usage",
    ][::std::mem::offset_of!(bch_fs_capacity, usage) - 128usize];
};
impl Default for bch_fs_capacity {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[repr(align(64))]
#[derive(Copy, Clone)]
pub struct bch_fs_allocator {
    pub rw_devs: [bch_devs_mask; 11usize],
    pub rw_devs_change_count: ::std::os::raw::c_ulong,
    pub freelist_lock: spinlock_t,
    pub freelist_wait: closure_waitlist,
    pub last_stuck: ::std::os::raw::c_ulong,
    pub open_buckets_freelist: open_bucket_idx_t,
    pub open_buckets_nr_free: open_bucket_idx_t,
    pub open_buckets_wait: closure_waitlist,
    pub open_buckets: [open_bucket; 4096usize],
    pub open_buckets_hash: [open_bucket_idx_t; 4096usize],
    pub open_buckets_partial: [open_bucket_idx_t; 4096usize],
    pub open_buckets_partial_nr: open_bucket_idx_t,
    pub __bindgen_padding_0: [u64; 2usize],
    pub write_points: [write_point; 32usize],
    pub write_points_hash: [cds_hlist_head; 32usize],
    pub write_points_hash_lock: mutex,
    pub write_points_nr: ::std::os::raw::c_uint,
    pub __bindgen_padding_1: [u64; 2usize],
    pub btree_write_point: write_point,
    pub reconcile_write_point: write_point,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_fs_allocator",
    ][::std::mem::size_of::<bch_fs_allocator>() - 342272usize];
    [
        "Alignment of bch_fs_allocator",
    ][::std::mem::align_of::<bch_fs_allocator>() - 64usize];
    [
        "Offset of field: bch_fs_allocator::rw_devs",
    ][::std::mem::offset_of!(bch_fs_allocator, rw_devs) - 0usize];
    [
        "Offset of field: bch_fs_allocator::rw_devs_change_count",
    ][::std::mem::offset_of!(bch_fs_allocator, rw_devs_change_count) - 88usize];
    [
        "Offset of field: bch_fs_allocator::freelist_lock",
    ][::std::mem::offset_of!(bch_fs_allocator, freelist_lock) - 96usize];
    [
        "Offset of field: bch_fs_allocator::freelist_wait",
    ][::std::mem::offset_of!(bch_fs_allocator, freelist_wait) - 136usize];
    [
        "Offset of field: bch_fs_allocator::last_stuck",
    ][::std::mem::offset_of!(bch_fs_allocator, last_stuck) - 144usize];
    [
        "Offset of field: bch_fs_allocator::open_buckets_freelist",
    ][::std::mem::offset_of!(bch_fs_allocator, open_buckets_freelist) - 152usize];
    [
        "Offset of field: bch_fs_allocator::open_buckets_nr_free",
    ][::std::mem::offset_of!(bch_fs_allocator, open_buckets_nr_free) - 154usize];
    [
        "Offset of field: bch_fs_allocator::open_buckets_wait",
    ][::std::mem::offset_of!(bch_fs_allocator, open_buckets_wait) - 160usize];
    [
        "Offset of field: bch_fs_allocator::open_buckets",
    ][::std::mem::offset_of!(bch_fs_allocator, open_buckets) - 168usize];
    [
        "Offset of field: bch_fs_allocator::open_buckets_hash",
    ][::std::mem::offset_of!(bch_fs_allocator, open_buckets_hash) - 295080usize];
    [
        "Offset of field: bch_fs_allocator::open_buckets_partial",
    ][::std::mem::offset_of!(bch_fs_allocator, open_buckets_partial) - 303272usize];
    [
        "Offset of field: bch_fs_allocator::open_buckets_partial_nr",
    ][::std::mem::offset_of!(bch_fs_allocator, open_buckets_partial_nr) - 311464usize];
    [
        "Offset of field: bch_fs_allocator::write_points",
    ][::std::mem::offset_of!(bch_fs_allocator, write_points) - 311488usize];
    [
        "Offset of field: bch_fs_allocator::write_points_hash",
    ][::std::mem::offset_of!(bch_fs_allocator, write_points_hash) - 340160usize];
    [
        "Offset of field: bch_fs_allocator::write_points_hash_lock",
    ][::std::mem::offset_of!(bch_fs_allocator, write_points_hash_lock) - 340416usize];
    [
        "Offset of field: bch_fs_allocator::write_points_nr",
    ][::std::mem::offset_of!(bch_fs_allocator, write_points_nr) - 340456usize];
    [
        "Offset of field: bch_fs_allocator::btree_write_point",
    ][::std::mem::offset_of!(bch_fs_allocator, btree_write_point) - 340480usize];
    [
        "Offset of field: bch_fs_allocator::reconcile_write_point",
    ][::std::mem::offset_of!(bch_fs_allocator, reconcile_write_point) - 341376usize];
};
impl Default for bch_fs_allocator {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct discard_in_flight {
    pub dev_bucket: u64_,
    pub ca: *mut bch_dev,
    pub complete: bool,
    pub marking_free: bool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of discard_in_flight"][::std::mem::size_of::<discard_in_flight>() - 24usize];
    [
        "Alignment of discard_in_flight",
    ][::std::mem::align_of::<discard_in_flight>() - 8usize];
    [
        "Offset of field: discard_in_flight::dev_bucket",
    ][::std::mem::offset_of!(discard_in_flight, dev_bucket) - 0usize];
    [
        "Offset of field: discard_in_flight::ca",
    ][::std::mem::offset_of!(discard_in_flight, ca) - 8usize];
    [
        "Offset of field: discard_in_flight::complete",
    ][::std::mem::offset_of!(discard_in_flight, complete) - 16usize];
    [
        "Offset of field: discard_in_flight::marking_free",
    ][::std::mem::offset_of!(discard_in_flight, marking_free) - 17usize];
};
impl Default for discard_in_flight {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct discard_release {
    pub buffer: u64_,
    pub pending_need_flush: u64_,
    pub pending_need_rewind_advance: u64_,
    pub pending_total: u64_,
    pub free: u64_,
    pub reserve: u64_,
    pub buffer_clamped: u64_,
    pub release: s64,
    pub new_rewind_seq: u64_,
    pub flush_journal: bool,
    pub flush_wb: bool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of discard_release"][::std::mem::size_of::<discard_release>() - 80usize];
    ["Alignment of discard_release"][::std::mem::align_of::<discard_release>() - 8usize];
    [
        "Offset of field: discard_release::buffer",
    ][::std::mem::offset_of!(discard_release, buffer) - 0usize];
    [
        "Offset of field: discard_release::pending_need_flush",
    ][::std::mem::offset_of!(discard_release, pending_need_flush) - 8usize];
    [
        "Offset of field: discard_release::pending_need_rewind_advance",
    ][::std::mem::offset_of!(discard_release, pending_need_rewind_advance) - 16usize];
    [
        "Offset of field: discard_release::pending_total",
    ][::std::mem::offset_of!(discard_release, pending_total) - 24usize];
    [
        "Offset of field: discard_release::free",
    ][::std::mem::offset_of!(discard_release, free) - 32usize];
    [
        "Offset of field: discard_release::reserve",
    ][::std::mem::offset_of!(discard_release, reserve) - 40usize];
    [
        "Offset of field: discard_release::buffer_clamped",
    ][::std::mem::offset_of!(discard_release, buffer_clamped) - 48usize];
    [
        "Offset of field: discard_release::release",
    ][::std::mem::offset_of!(discard_release, release) - 56usize];
    [
        "Offset of field: discard_release::new_rewind_seq",
    ][::std::mem::offset_of!(discard_release, new_rewind_seq) - 64usize];
    [
        "Offset of field: discard_release::flush_journal",
    ][::std::mem::offset_of!(discard_release, flush_journal) - 72usize];
    [
        "Offset of field: discard_release::flush_wb",
    ][::std::mem::offset_of!(discard_release, flush_wb) - 73usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct discard_state {
    pub seen: u64_,
    pub not_rw: u64_,
    pub eexist: u64_,
    pub eagain: u64_,
    pub open: u64_,
    pub need_journal_commit: u64_,
    pub need_rewind_advance: u64_,
    pub bad_data_type: u64_,
    pub discarded: u64_,
    pub committed: u64_,
    pub pos: bpos,
    pub r: discard_release,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of discard_state"][::std::mem::size_of::<discard_state>() - 184usize];
    ["Alignment of discard_state"][::std::mem::align_of::<discard_state>() - 8usize];
    [
        "Offset of field: discard_state::seen",
    ][::std::mem::offset_of!(discard_state, seen) - 0usize];
    [
        "Offset of field: discard_state::not_rw",
    ][::std::mem::offset_of!(discard_state, not_rw) - 8usize];
    [
        "Offset of field: discard_state::eexist",
    ][::std::mem::offset_of!(discard_state, eexist) - 16usize];
    [
        "Offset of field: discard_state::eagain",
    ][::std::mem::offset_of!(discard_state, eagain) - 24usize];
    [
        "Offset of field: discard_state::open",
    ][::std::mem::offset_of!(discard_state, open) - 32usize];
    [
        "Offset of field: discard_state::need_journal_commit",
    ][::std::mem::offset_of!(discard_state, need_journal_commit) - 40usize];
    [
        "Offset of field: discard_state::need_rewind_advance",
    ][::std::mem::offset_of!(discard_state, need_rewind_advance) - 48usize];
    [
        "Offset of field: discard_state::bad_data_type",
    ][::std::mem::offset_of!(discard_state, bad_data_type) - 56usize];
    [
        "Offset of field: discard_state::discarded",
    ][::std::mem::offset_of!(discard_state, discarded) - 64usize];
    [
        "Offset of field: discard_state::committed",
    ][::std::mem::offset_of!(discard_state, committed) - 72usize];
    [
        "Offset of field: discard_state::pos",
    ][::std::mem::offset_of!(discard_state, pos) - 80usize];
    [
        "Offset of field: discard_state::r",
    ][::std::mem::offset_of!(discard_state, r) - 104usize];
};
#[repr(C)]
pub struct bch_fs_discards {
    pub work: work_struct,
    pub bioset: bio_set,
    pub in_flight: bch_fs_discards__bindgen_ty_1,
    pub lock: spinlock_t,
    pub ref_: u32_,
    pub refs: [u8_; 64usize],
    pub wait: closure_waitlist,
    pub s: discard_state,
}
#[repr(C)]
#[derive(Debug)]
pub struct bch_fs_discards__bindgen_ty_1 {
    pub nr: usize,
    pub size: usize,
    pub data: *mut discard_in_flight,
    pub preallocated: __IncompleteArrayField<discard_in_flight>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_fs_discards__bindgen_ty_1",
    ][::std::mem::size_of::<bch_fs_discards__bindgen_ty_1>() - 24usize];
    [
        "Alignment of bch_fs_discards__bindgen_ty_1",
    ][::std::mem::align_of::<bch_fs_discards__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bch_fs_discards__bindgen_ty_1::nr",
    ][::std::mem::offset_of!(bch_fs_discards__bindgen_ty_1, nr) - 0usize];
    [
        "Offset of field: bch_fs_discards__bindgen_ty_1::size",
    ][::std::mem::offset_of!(bch_fs_discards__bindgen_ty_1, size) - 8usize];
    [
        "Offset of field: bch_fs_discards__bindgen_ty_1::data",
    ][::std::mem::offset_of!(bch_fs_discards__bindgen_ty_1, data) - 16usize];
    [
        "Offset of field: bch_fs_discards__bindgen_ty_1::preallocated",
    ][::std::mem::offset_of!(bch_fs_discards__bindgen_ty_1, preallocated) - 24usize];
};
impl Default for bch_fs_discards__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_fs_discards"][::std::mem::size_of::<bch_fs_discards>() - 640usize];
    ["Alignment of bch_fs_discards"][::std::mem::align_of::<bch_fs_discards>() - 8usize];
    [
        "Offset of field: bch_fs_discards::work",
    ][::std::mem::offset_of!(bch_fs_discards, work) - 0usize];
    [
        "Offset of field: bch_fs_discards::bioset",
    ][::std::mem::offset_of!(bch_fs_discards, bioset) - 32usize];
    [
        "Offset of field: bch_fs_discards::in_flight",
    ][::std::mem::offset_of!(bch_fs_discards, in_flight) - 312usize];
    [
        "Offset of field: bch_fs_discards::lock",
    ][::std::mem::offset_of!(bch_fs_discards, lock) - 336usize];
    [
        "Offset of field: bch_fs_discards::ref_",
    ][::std::mem::offset_of!(bch_fs_discards, ref_) - 376usize];
    [
        "Offset of field: bch_fs_discards::refs",
    ][::std::mem::offset_of!(bch_fs_discards, refs) - 380usize];
    [
        "Offset of field: bch_fs_discards::wait",
    ][::std::mem::offset_of!(bch_fs_discards, wait) - 448usize];
    [
        "Offset of field: bch_fs_discards::s",
    ][::std::mem::offset_of!(bch_fs_discards, s) - 456usize];
};
impl Default for bch_fs_discards {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bbpos {
    pub btree: btree_id,
    pub pos: bpos,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bbpos"][::std::mem::size_of::<bbpos>() - 24usize];
    ["Alignment of bbpos"][::std::mem::align_of::<bbpos>() - 4usize];
    ["Offset of field: bbpos::btree"][::std::mem::offset_of!(bbpos, btree) - 0usize];
    ["Offset of field: bbpos::pos"][::std::mem::offset_of!(bbpos, pos) - 4usize];
};
impl Default for bbpos {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum gc_phase {
    GC_PHASE_not_running = 0,
    GC_PHASE_start = 1,
    GC_PHASE_sb = 2,
    GC_PHASE_btree = 3,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct gc_pos {
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
    pub level: u16_,
    pub pos: bpos,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of gc_pos"][::std::mem::size_of::<gc_pos>() - 24usize];
    ["Alignment of gc_pos"][::std::mem::align_of::<gc_pos>() - 4usize];
    ["Offset of field: gc_pos::level"][::std::mem::offset_of!(gc_pos, level) - 2usize];
    ["Offset of field: gc_pos::pos"][::std::mem::offset_of!(gc_pos, pos) - 4usize];
};
impl Default for gc_pos {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl gc_pos {
    #[inline]
    pub fn phase(&self) -> gc_phase {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
    }
    #[inline]
    pub fn set_phase(&mut self, val: gc_phase) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 8u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn phase_raw(this: *const Self) -> gc_phase {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 8u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_phase_raw(this: *mut Self, val: gc_phase) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                8u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn btree(&self) -> btree_id {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 8u8) as u32) }
    }
    #[inline]
    pub fn set_btree(&mut self, val: btree_id) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(8usize, 8u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn btree_raw(this: *const Self) -> btree_id {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 8usize, 8u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_btree_raw(this: *mut Self, val: btree_id) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                8usize,
                8u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        phase: gc_phase,
        btree: btree_id,
    ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                8u8,
                {
                    let phase: u32 = unsafe { ::std::mem::transmute(phase) };
                    phase as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                8usize,
                8u8,
                {
                    let btree: u32 = unsafe { ::std::mem::transmute(btree) };
                    btree as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct reflink_gc {
    pub offset: u64_,
    pub size: u32_,
    pub refcount: u32_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of reflink_gc"][::std::mem::size_of::<reflink_gc>() - 16usize];
    ["Alignment of reflink_gc"][::std::mem::align_of::<reflink_gc>() - 8usize];
    [
        "Offset of field: reflink_gc::offset",
    ][::std::mem::offset_of!(reflink_gc, offset) - 0usize];
    [
        "Offset of field: reflink_gc::size",
    ][::std::mem::offset_of!(reflink_gc, size) - 8usize];
    [
        "Offset of field: reflink_gc::refcount",
    ][::std::mem::offset_of!(reflink_gc, refcount) - 12usize];
};
#[repr(C)]
#[derive(Debug)]
pub struct reflink_gc_table {
    pub tree: __genradix,
    pub type_: __IncompleteArrayField<reflink_gc>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of reflink_gc_table"][::std::mem::size_of::<reflink_gc_table>() - 8usize];
    [
        "Alignment of reflink_gc_table",
    ][::std::mem::align_of::<reflink_gc_table>() - 8usize];
    [
        "Offset of field: reflink_gc_table::tree",
    ][::std::mem::offset_of!(reflink_gc_table, tree) - 0usize];
    [
        "Offset of field: reflink_gc_table::type_",
    ][::std::mem::offset_of!(reflink_gc_table, type_) - 8usize];
};
impl Default for reflink_gc_table {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bch_fs_gc {
    pub pos_lock: seqcount_t,
    pub pos: gc_pos,
    pub lock: rw_semaphore,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_fs_gc"][::std::mem::size_of::<bch_fs_gc>() - 88usize];
    ["Alignment of bch_fs_gc"][::std::mem::align_of::<bch_fs_gc>() - 8usize];
    [
        "Offset of field: bch_fs_gc::pos_lock",
    ][::std::mem::offset_of!(bch_fs_gc, pos_lock) - 0usize];
    ["Offset of field: bch_fs_gc::pos"][::std::mem::offset_of!(bch_fs_gc, pos) - 4usize];
    [
        "Offset of field: bch_fs_gc::lock",
    ][::std::mem::offset_of!(bch_fs_gc, lock) - 32usize];
};
impl Default for bch_fs_gc {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bch_fs_gc_gens {
    pub pos: bbpos,
    pub work: work_struct,
    pub lock: mutex,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_fs_gc_gens"][::std::mem::size_of::<bch_fs_gc_gens>() - 96usize];
    ["Alignment of bch_fs_gc_gens"][::std::mem::align_of::<bch_fs_gc_gens>() - 8usize];
    [
        "Offset of field: bch_fs_gc_gens::pos",
    ][::std::mem::offset_of!(bch_fs_gc_gens, pos) - 0usize];
    [
        "Offset of field: bch_fs_gc_gens::work",
    ][::std::mem::offset_of!(bch_fs_gc_gens, work) - 24usize];
    [
        "Offset of field: bch_fs_gc_gens::lock",
    ][::std::mem::offset_of!(bch_fs_gc_gens, lock) - 56usize];
};
impl Default for bch_fs_gc_gens {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct journal_ptr {
    pub csum_good: bool,
    pub csum: bch_csum,
    pub dev: u8_,
    pub bucket: u32_,
    pub bucket_offset: u32_,
    pub sector: u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of journal_ptr"][::std::mem::size_of::<journal_ptr>() - 48usize];
    ["Alignment of journal_ptr"][::std::mem::align_of::<journal_ptr>() - 8usize];
    [
        "Offset of field: journal_ptr::csum_good",
    ][::std::mem::offset_of!(journal_ptr, csum_good) - 0usize];
    [
        "Offset of field: journal_ptr::csum",
    ][::std::mem::offset_of!(journal_ptr, csum) - 8usize];
    [
        "Offset of field: journal_ptr::dev",
    ][::std::mem::offset_of!(journal_ptr, dev) - 24usize];
    [
        "Offset of field: journal_ptr::bucket",
    ][::std::mem::offset_of!(journal_ptr, bucket) - 28usize];
    [
        "Offset of field: journal_ptr::bucket_offset",
    ][::std::mem::offset_of!(journal_ptr, bucket_offset) - 32usize];
    [
        "Offset of field: journal_ptr::sector",
    ][::std::mem::offset_of!(journal_ptr, sector) - 40usize];
};
#[repr(C)]
pub struct journal_replay {
    pub ptrs: journal_replay__bindgen_ty_1,
    pub csum_good: bool,
    pub ignore_blacklisted: bool,
    pub ignore_not_dirty: bool,
    pub j: jset,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct journal_replay__bindgen_ty_1 {
    pub nr: usize,
    pub size: usize,
    pub data: *mut journal_ptr,
    pub preallocated: [journal_ptr; 8usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of journal_replay__bindgen_ty_1",
    ][::std::mem::size_of::<journal_replay__bindgen_ty_1>() - 408usize];
    [
        "Alignment of journal_replay__bindgen_ty_1",
    ][::std::mem::align_of::<journal_replay__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: journal_replay__bindgen_ty_1::nr",
    ][::std::mem::offset_of!(journal_replay__bindgen_ty_1, nr) - 0usize];
    [
        "Offset of field: journal_replay__bindgen_ty_1::size",
    ][::std::mem::offset_of!(journal_replay__bindgen_ty_1, size) - 8usize];
    [
        "Offset of field: journal_replay__bindgen_ty_1::data",
    ][::std::mem::offset_of!(journal_replay__bindgen_ty_1, data) - 16usize];
    [
        "Offset of field: journal_replay__bindgen_ty_1::preallocated",
    ][::std::mem::offset_of!(journal_replay__bindgen_ty_1, preallocated) - 24usize];
};
impl Default for journal_replay__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of journal_replay"][::std::mem::size_of::<journal_replay>() - 472usize];
    ["Alignment of journal_replay"][::std::mem::align_of::<journal_replay>() - 8usize];
    [
        "Offset of field: journal_replay::ptrs",
    ][::std::mem::offset_of!(journal_replay, ptrs) - 0usize];
    [
        "Offset of field: journal_replay::csum_good",
    ][::std::mem::offset_of!(journal_replay, csum_good) - 408usize];
    [
        "Offset of field: journal_replay::ignore_blacklisted",
    ][::std::mem::offset_of!(journal_replay, ignore_blacklisted) - 409usize];
    [
        "Offset of field: journal_replay::ignore_not_dirty",
    ][::std::mem::offset_of!(journal_replay, ignore_not_dirty) - 410usize];
    [
        "Offset of field: journal_replay::j",
    ][::std::mem::offset_of!(journal_replay, j) - 416usize];
};
impl Default for journal_replay {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct journal_key_range_overwritten {
    pub start: usize,
    pub end: usize,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of journal_key_range_overwritten",
    ][::std::mem::size_of::<journal_key_range_overwritten>() - 16usize];
    [
        "Alignment of journal_key_range_overwritten",
    ][::std::mem::align_of::<journal_key_range_overwritten>() - 8usize];
    [
        "Offset of field: journal_key_range_overwritten::start",
    ][::std::mem::offset_of!(journal_key_range_overwritten, start) - 0usize];
    [
        "Offset of field: journal_key_range_overwritten::end",
    ][::std::mem::offset_of!(journal_key_range_overwritten, end) - 8usize];
};
#[repr(C)]
#[derive(Copy, Clone)]
pub struct journal_key {
    pub __bindgen_anon_1: journal_key__bindgen_ty_1,
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
    pub overwritten_range: u32_,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union journal_key__bindgen_ty_1 {
    pub __bindgen_anon_1: journal_key__bindgen_ty_1__bindgen_ty_1,
    pub allocated_k: *mut bkey_i,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct journal_key__bindgen_ty_1__bindgen_ty_1 {
    pub journal_seq_offset: u32_,
    pub journal_offset: u32_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of journal_key__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<journal_key__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Alignment of journal_key__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<journal_key__bindgen_ty_1__bindgen_ty_1>() - 4usize];
    [
        "Offset of field: journal_key__bindgen_ty_1__bindgen_ty_1::journal_seq_offset",
    ][::std::mem::offset_of!(journal_key__bindgen_ty_1__bindgen_ty_1, journal_seq_offset)
        - 0usize];
    [
        "Offset of field: journal_key__bindgen_ty_1__bindgen_ty_1::journal_offset",
    ][::std::mem::offset_of!(journal_key__bindgen_ty_1__bindgen_ty_1, journal_offset)
        - 4usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of journal_key__bindgen_ty_1",
    ][::std::mem::size_of::<journal_key__bindgen_ty_1>() - 8usize];
    [
        "Alignment of journal_key__bindgen_ty_1",
    ][::std::mem::align_of::<journal_key__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: journal_key__bindgen_ty_1::allocated_k",
    ][::std::mem::offset_of!(journal_key__bindgen_ty_1, allocated_k) - 0usize];
};
impl Default for journal_key__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of journal_key"][::std::mem::size_of::<journal_key>() - 16usize];
    ["Alignment of journal_key"][::std::mem::align_of::<journal_key>() - 8usize];
    [
        "Offset of field: journal_key::overwritten_range",
    ][::std::mem::offset_of!(journal_key, overwritten_range) - 12usize];
};
impl Default for journal_key {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl journal_key {
    #[inline]
    pub fn btree_id(&self) -> btree_id {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
    }
    #[inline]
    pub fn set_btree_id(&mut self, val: btree_id) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 8u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn btree_id_raw(this: *const Self) -> btree_id {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 3usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 8u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_btree_id_raw(this: *mut Self, val: btree_id) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 3usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                8u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn level(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 8u8) as u32) }
    }
    #[inline]
    pub fn set_level(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(8usize, 8u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn level_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 3usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 8usize, 8u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_level_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 3usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                8usize,
                8u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn allocated(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_allocated(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(16usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn allocated_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 3usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 16usize, 1u8)
                    as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_allocated_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 3usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                16usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn overwritten(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_overwritten(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(17usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn overwritten_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 3usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 17usize, 1u8)
                    as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_overwritten_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 3usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                17usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn rewind(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_rewind(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(18usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn rewind_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 3usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 18usize, 1u8)
                    as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_rewind_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 3usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                18usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        btree_id: btree_id,
        level: ::std::os::raw::c_uint,
        allocated: bool,
        overwritten: bool,
        rewind: bool,
    ) -> __BindgenBitfieldUnit<[u8; 3usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                8u8,
                {
                    let btree_id: u32 = unsafe { ::std::mem::transmute(btree_id) };
                    btree_id as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                8usize,
                8u8,
                {
                    let level: u32 = unsafe { ::std::mem::transmute(level) };
                    level as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                16usize,
                1u8,
                {
                    let allocated: u8 = unsafe { ::std::mem::transmute(allocated) };
                    allocated as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                17usize,
                1u8,
                {
                    let overwritten: u8 = unsafe { ::std::mem::transmute(overwritten) };
                    overwritten as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                18usize,
                1u8,
                {
                    let rewind: u8 = unsafe { ::std::mem::transmute(rewind) };
                    rewind as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
pub struct journal_keys {
    pub nr: usize,
    pub size: usize,
    pub data: *mut journal_key,
    pub preallocated: __IncompleteArrayField<journal_key>,
    pub gap: usize,
    pub ref_: atomic_t,
    pub initial_ref_held: bool,
    pub pre_sort: journal_keys__bindgen_ty_1,
    pub overwrite_lock: mutex,
    pub overwrites: journal_keys__bindgen_ty_2,
}
#[repr(C)]
pub struct journal_keys__bindgen_ty_1 {
    pub nr: usize,
    pub size: usize,
    pub data: *mut journal_key,
    pub preallocated: __IncompleteArrayField<journal_key>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of journal_keys__bindgen_ty_1",
    ][::std::mem::size_of::<journal_keys__bindgen_ty_1>() - 24usize];
    [
        "Alignment of journal_keys__bindgen_ty_1",
    ][::std::mem::align_of::<journal_keys__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: journal_keys__bindgen_ty_1::nr",
    ][::std::mem::offset_of!(journal_keys__bindgen_ty_1, nr) - 0usize];
    [
        "Offset of field: journal_keys__bindgen_ty_1::size",
    ][::std::mem::offset_of!(journal_keys__bindgen_ty_1, size) - 8usize];
    [
        "Offset of field: journal_keys__bindgen_ty_1::data",
    ][::std::mem::offset_of!(journal_keys__bindgen_ty_1, data) - 16usize];
    [
        "Offset of field: journal_keys__bindgen_ty_1::preallocated",
    ][::std::mem::offset_of!(journal_keys__bindgen_ty_1, preallocated) - 24usize];
};
impl Default for journal_keys__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug)]
pub struct journal_keys__bindgen_ty_2 {
    pub nr: usize,
    pub size: usize,
    pub data: *mut journal_key_range_overwritten,
    pub preallocated: __IncompleteArrayField<journal_key_range_overwritten>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of journal_keys__bindgen_ty_2",
    ][::std::mem::size_of::<journal_keys__bindgen_ty_2>() - 24usize];
    [
        "Alignment of journal_keys__bindgen_ty_2",
    ][::std::mem::align_of::<journal_keys__bindgen_ty_2>() - 8usize];
    [
        "Offset of field: journal_keys__bindgen_ty_2::nr",
    ][::std::mem::offset_of!(journal_keys__bindgen_ty_2, nr) - 0usize];
    [
        "Offset of field: journal_keys__bindgen_ty_2::size",
    ][::std::mem::offset_of!(journal_keys__bindgen_ty_2, size) - 8usize];
    [
        "Offset of field: journal_keys__bindgen_ty_2::data",
    ][::std::mem::offset_of!(journal_keys__bindgen_ty_2, data) - 16usize];
    [
        "Offset of field: journal_keys__bindgen_ty_2::preallocated",
    ][::std::mem::offset_of!(journal_keys__bindgen_ty_2, preallocated) - 24usize];
};
impl Default for journal_keys__bindgen_ty_2 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of journal_keys"][::std::mem::size_of::<journal_keys>() - 128usize];
    ["Alignment of journal_keys"][::std::mem::align_of::<journal_keys>() - 8usize];
    [
        "Offset of field: journal_keys::nr",
    ][::std::mem::offset_of!(journal_keys, nr) - 0usize];
    [
        "Offset of field: journal_keys::size",
    ][::std::mem::offset_of!(journal_keys, size) - 8usize];
    [
        "Offset of field: journal_keys::data",
    ][::std::mem::offset_of!(journal_keys, data) - 16usize];
    [
        "Offset of field: journal_keys::preallocated",
    ][::std::mem::offset_of!(journal_keys, preallocated) - 24usize];
    [
        "Offset of field: journal_keys::gap",
    ][::std::mem::offset_of!(journal_keys, gap) - 24usize];
    [
        "Offset of field: journal_keys::ref_",
    ][::std::mem::offset_of!(journal_keys, ref_) - 32usize];
    [
        "Offset of field: journal_keys::initial_ref_held",
    ][::std::mem::offset_of!(journal_keys, initial_ref_held) - 36usize];
    [
        "Offset of field: journal_keys::pre_sort",
    ][::std::mem::offset_of!(journal_keys, pre_sort) - 40usize];
    [
        "Offset of field: journal_keys::overwrite_lock",
    ][::std::mem::offset_of!(journal_keys, overwrite_lock) - 64usize];
    [
        "Offset of field: journal_keys::overwrites",
    ][::std::mem::offset_of!(journal_keys, overwrites) - 104usize];
};
impl Default for journal_keys {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_c {
    pub k: *const bkey,
    pub v: *const bch_val,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_c"][::std::mem::size_of::<bkey_s_c>() - 16usize];
    ["Alignment of bkey_s_c"][::std::mem::align_of::<bkey_s_c>() - 8usize];
    ["Offset of field: bkey_s_c::k"][::std::mem::offset_of!(bkey_s_c, k) - 0usize];
    ["Offset of field: bkey_s_c::v"][::std::mem::offset_of!(bkey_s_c, v) - 8usize];
};
impl Default for bkey_s_c {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s {
    pub __bindgen_anon_1: bkey_s__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s__bindgen_ty_1__bindgen_ty_1,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s__bindgen_ty_1__bindgen_ty_1 {
    pub k: *mut bkey,
    pub v: *mut bch_val,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s"][::std::mem::size_of::<bkey_s>() - 16usize];
    ["Alignment of bkey_s"][::std::mem::align_of::<bkey_s>() - 8usize];
};
impl Default for bkey_s {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bkey_i_deleted {
    pub __bindgen_anon_1: bkey_i_deleted__bindgen_ty_1,
    pub v: bch_deleted,
}
#[repr(C)]
pub struct bkey_i_deleted__bindgen_ty_1 {
    pub k: __BindgenUnionField<bkey>,
    pub k_i: __BindgenUnionField<bkey_i>,
    pub bindgen_union_field: [u64; 5usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_deleted__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_i_deleted__bindgen_ty_1>() - 40usize];
    [
        "Alignment of bkey_i_deleted__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_i_deleted__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_i_deleted__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_i_deleted__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_i_deleted__bindgen_ty_1::k_i",
    ][::std::mem::offset_of!(bkey_i_deleted__bindgen_ty_1, k_i) - 0usize];
};
impl Default for bkey_i_deleted__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_i_deleted"][::std::mem::size_of::<bkey_i_deleted>() - 40usize];
    ["Alignment of bkey_i_deleted"][::std::mem::align_of::<bkey_i_deleted>() - 8usize];
    [
        "Offset of field: bkey_i_deleted::v",
    ][::std::mem::offset_of!(bkey_i_deleted, v) - 40usize];
};
impl Default for bkey_i_deleted {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_c_deleted {
    pub __bindgen_anon_1: bkey_s_c_deleted__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_c_deleted__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_c_deleted__bindgen_ty_1__bindgen_ty_1,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_c_deleted__bindgen_ty_1__bindgen_ty_1 {
    pub k: *const bkey,
    pub v: *const bch_deleted,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_deleted__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_deleted__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_deleted__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_deleted__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_deleted__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_c_deleted__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_c_deleted__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_c_deleted__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_c_deleted__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_deleted__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_deleted__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_deleted__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_deleted__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_deleted__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_c_deleted__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_c_deleted__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_c_deleted"][::std::mem::size_of::<bkey_s_c_deleted>() - 16usize];
    [
        "Alignment of bkey_s_c_deleted",
    ][::std::mem::align_of::<bkey_s_c_deleted>() - 8usize];
};
impl Default for bkey_s_c_deleted {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_deleted {
    pub __bindgen_anon_1: bkey_s_deleted__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_deleted__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_deleted__bindgen_ty_1__bindgen_ty_1,
    pub c: bkey_s_c_deleted,
    pub s: bkey_s,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_deleted__bindgen_ty_1__bindgen_ty_1 {
    pub k: *mut bkey,
    pub v: *mut bch_deleted,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_deleted__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_deleted__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_deleted__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_deleted__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_deleted__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_deleted__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_deleted__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_deleted__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_deleted__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_deleted__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_deleted__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_deleted__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_deleted__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_deleted__bindgen_ty_1::c",
    ][::std::mem::offset_of!(bkey_s_deleted__bindgen_ty_1, c) - 0usize];
    [
        "Offset of field: bkey_s_deleted__bindgen_ty_1::s",
    ][::std::mem::offset_of!(bkey_s_deleted__bindgen_ty_1, s) - 0usize];
    [
        "Offset of field: bkey_s_deleted__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_deleted__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_deleted__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_deleted"][::std::mem::size_of::<bkey_s_deleted>() - 16usize];
    ["Alignment of bkey_s_deleted"][::std::mem::align_of::<bkey_s_deleted>() - 8usize];
};
impl Default for bkey_s_deleted {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bkey_i_whiteout {
    pub __bindgen_anon_1: bkey_i_whiteout__bindgen_ty_1,
    pub v: bch_whiteout,
}
#[repr(C)]
pub struct bkey_i_whiteout__bindgen_ty_1 {
    pub k: __BindgenUnionField<bkey>,
    pub k_i: __BindgenUnionField<bkey_i>,
    pub bindgen_union_field: [u64; 5usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_whiteout__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_i_whiteout__bindgen_ty_1>() - 40usize];
    [
        "Alignment of bkey_i_whiteout__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_i_whiteout__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_i_whiteout__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_i_whiteout__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_i_whiteout__bindgen_ty_1::k_i",
    ][::std::mem::offset_of!(bkey_i_whiteout__bindgen_ty_1, k_i) - 0usize];
};
impl Default for bkey_i_whiteout__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_i_whiteout"][::std::mem::size_of::<bkey_i_whiteout>() - 40usize];
    ["Alignment of bkey_i_whiteout"][::std::mem::align_of::<bkey_i_whiteout>() - 8usize];
    [
        "Offset of field: bkey_i_whiteout::v",
    ][::std::mem::offset_of!(bkey_i_whiteout, v) - 40usize];
};
impl Default for bkey_i_whiteout {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_c_whiteout {
    pub __bindgen_anon_1: bkey_s_c_whiteout__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_c_whiteout__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_c_whiteout__bindgen_ty_1__bindgen_ty_1,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_c_whiteout__bindgen_ty_1__bindgen_ty_1 {
    pub k: *const bkey,
    pub v: *const bch_whiteout,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_whiteout__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_whiteout__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_whiteout__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_whiteout__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_whiteout__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_c_whiteout__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_c_whiteout__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_c_whiteout__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_c_whiteout__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_whiteout__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_whiteout__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_whiteout__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_whiteout__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_whiteout__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_c_whiteout__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_c_whiteout__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_c_whiteout"][::std::mem::size_of::<bkey_s_c_whiteout>() - 16usize];
    [
        "Alignment of bkey_s_c_whiteout",
    ][::std::mem::align_of::<bkey_s_c_whiteout>() - 8usize];
};
impl Default for bkey_s_c_whiteout {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_whiteout {
    pub __bindgen_anon_1: bkey_s_whiteout__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_whiteout__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_whiteout__bindgen_ty_1__bindgen_ty_1,
    pub c: bkey_s_c_whiteout,
    pub s: bkey_s,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_whiteout__bindgen_ty_1__bindgen_ty_1 {
    pub k: *mut bkey,
    pub v: *mut bch_whiteout,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_whiteout__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_whiteout__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_whiteout__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_whiteout__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_whiteout__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_whiteout__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_whiteout__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_whiteout__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_whiteout__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_whiteout__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_whiteout__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_whiteout__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_whiteout__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_whiteout__bindgen_ty_1::c",
    ][::std::mem::offset_of!(bkey_s_whiteout__bindgen_ty_1, c) - 0usize];
    [
        "Offset of field: bkey_s_whiteout__bindgen_ty_1::s",
    ][::std::mem::offset_of!(bkey_s_whiteout__bindgen_ty_1, s) - 0usize];
    [
        "Offset of field: bkey_s_whiteout__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_whiteout__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_whiteout__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_whiteout"][::std::mem::size_of::<bkey_s_whiteout>() - 16usize];
    ["Alignment of bkey_s_whiteout"][::std::mem::align_of::<bkey_s_whiteout>() - 8usize];
};
impl Default for bkey_s_whiteout {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bkey_i_error {
    pub __bindgen_anon_1: bkey_i_error__bindgen_ty_1,
    pub v: bch_error,
}
#[repr(C)]
pub struct bkey_i_error__bindgen_ty_1 {
    pub k: __BindgenUnionField<bkey>,
    pub k_i: __BindgenUnionField<bkey_i>,
    pub bindgen_union_field: [u64; 5usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_error__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_i_error__bindgen_ty_1>() - 40usize];
    [
        "Alignment of bkey_i_error__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_i_error__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_i_error__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_i_error__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_i_error__bindgen_ty_1::k_i",
    ][::std::mem::offset_of!(bkey_i_error__bindgen_ty_1, k_i) - 0usize];
};
impl Default for bkey_i_error__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_i_error"][::std::mem::size_of::<bkey_i_error>() - 48usize];
    ["Alignment of bkey_i_error"][::std::mem::align_of::<bkey_i_error>() - 8usize];
    [
        "Offset of field: bkey_i_error::v",
    ][::std::mem::offset_of!(bkey_i_error, v) - 40usize];
};
impl Default for bkey_i_error {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_c_error {
    pub __bindgen_anon_1: bkey_s_c_error__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_c_error__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_c_error__bindgen_ty_1__bindgen_ty_1,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_c_error__bindgen_ty_1__bindgen_ty_1 {
    pub k: *const bkey,
    pub v: *const bch_error,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_error__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_error__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_error__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_error__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_error__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_c_error__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_c_error__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_c_error__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_c_error__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_error__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_error__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_error__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_error__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_error__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_c_error__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_c_error__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_c_error"][::std::mem::size_of::<bkey_s_c_error>() - 16usize];
    ["Alignment of bkey_s_c_error"][::std::mem::align_of::<bkey_s_c_error>() - 8usize];
};
impl Default for bkey_s_c_error {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_error {
    pub __bindgen_anon_1: bkey_s_error__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_error__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_error__bindgen_ty_1__bindgen_ty_1,
    pub c: bkey_s_c_error,
    pub s: bkey_s,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_error__bindgen_ty_1__bindgen_ty_1 {
    pub k: *mut bkey,
    pub v: *mut bch_error,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_error__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_error__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_error__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_error__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_error__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_error__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_error__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_error__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_error__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_error__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_error__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_error__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_error__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_error__bindgen_ty_1::c",
    ][::std::mem::offset_of!(bkey_s_error__bindgen_ty_1, c) - 0usize];
    [
        "Offset of field: bkey_s_error__bindgen_ty_1::s",
    ][::std::mem::offset_of!(bkey_s_error__bindgen_ty_1, s) - 0usize];
    [
        "Offset of field: bkey_s_error__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_error__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_error__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_error"][::std::mem::size_of::<bkey_s_error>() - 16usize];
    ["Alignment of bkey_s_error"][::std::mem::align_of::<bkey_s_error>() - 8usize];
};
impl Default for bkey_s_error {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bkey_i_cookie {
    pub __bindgen_anon_1: bkey_i_cookie__bindgen_ty_1,
    pub v: bch_cookie,
}
#[repr(C)]
pub struct bkey_i_cookie__bindgen_ty_1 {
    pub k: __BindgenUnionField<bkey>,
    pub k_i: __BindgenUnionField<bkey_i>,
    pub bindgen_union_field: [u64; 5usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_cookie__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_i_cookie__bindgen_ty_1>() - 40usize];
    [
        "Alignment of bkey_i_cookie__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_i_cookie__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_i_cookie__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_i_cookie__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_i_cookie__bindgen_ty_1::k_i",
    ][::std::mem::offset_of!(bkey_i_cookie__bindgen_ty_1, k_i) - 0usize];
};
impl Default for bkey_i_cookie__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_i_cookie"][::std::mem::size_of::<bkey_i_cookie>() - 48usize];
    ["Alignment of bkey_i_cookie"][::std::mem::align_of::<bkey_i_cookie>() - 8usize];
    [
        "Offset of field: bkey_i_cookie::v",
    ][::std::mem::offset_of!(bkey_i_cookie, v) - 40usize];
};
impl Default for bkey_i_cookie {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_c_cookie {
    pub __bindgen_anon_1: bkey_s_c_cookie__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_c_cookie__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_c_cookie__bindgen_ty_1__bindgen_ty_1,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_c_cookie__bindgen_ty_1__bindgen_ty_1 {
    pub k: *const bkey,
    pub v: *const bch_cookie,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_cookie__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_cookie__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_cookie__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_cookie__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_cookie__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_c_cookie__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_c_cookie__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_c_cookie__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_c_cookie__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_cookie__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_cookie__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_cookie__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_cookie__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_cookie__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_c_cookie__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_c_cookie__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_c_cookie"][::std::mem::size_of::<bkey_s_c_cookie>() - 16usize];
    ["Alignment of bkey_s_c_cookie"][::std::mem::align_of::<bkey_s_c_cookie>() - 8usize];
};
impl Default for bkey_s_c_cookie {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_cookie {
    pub __bindgen_anon_1: bkey_s_cookie__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_cookie__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_cookie__bindgen_ty_1__bindgen_ty_1,
    pub c: bkey_s_c_cookie,
    pub s: bkey_s,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_cookie__bindgen_ty_1__bindgen_ty_1 {
    pub k: *mut bkey,
    pub v: *mut bch_cookie,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_cookie__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_cookie__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_cookie__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_cookie__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_cookie__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_cookie__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_cookie__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_cookie__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_cookie__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_cookie__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_cookie__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_cookie__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_cookie__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_cookie__bindgen_ty_1::c",
    ][::std::mem::offset_of!(bkey_s_cookie__bindgen_ty_1, c) - 0usize];
    [
        "Offset of field: bkey_s_cookie__bindgen_ty_1::s",
    ][::std::mem::offset_of!(bkey_s_cookie__bindgen_ty_1, s) - 0usize];
    [
        "Offset of field: bkey_s_cookie__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_cookie__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_cookie__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_cookie"][::std::mem::size_of::<bkey_s_cookie>() - 16usize];
    ["Alignment of bkey_s_cookie"][::std::mem::align_of::<bkey_s_cookie>() - 8usize];
};
impl Default for bkey_s_cookie {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bkey_i_hash_whiteout {
    pub __bindgen_anon_1: bkey_i_hash_whiteout__bindgen_ty_1,
    pub v: bch_hash_whiteout,
}
#[repr(C)]
pub struct bkey_i_hash_whiteout__bindgen_ty_1 {
    pub k: __BindgenUnionField<bkey>,
    pub k_i: __BindgenUnionField<bkey_i>,
    pub bindgen_union_field: [u64; 5usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_hash_whiteout__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_i_hash_whiteout__bindgen_ty_1>() - 40usize];
    [
        "Alignment of bkey_i_hash_whiteout__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_i_hash_whiteout__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_i_hash_whiteout__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_i_hash_whiteout__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_i_hash_whiteout__bindgen_ty_1::k_i",
    ][::std::mem::offset_of!(bkey_i_hash_whiteout__bindgen_ty_1, k_i) - 0usize];
};
impl Default for bkey_i_hash_whiteout__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_hash_whiteout",
    ][::std::mem::size_of::<bkey_i_hash_whiteout>() - 40usize];
    [
        "Alignment of bkey_i_hash_whiteout",
    ][::std::mem::align_of::<bkey_i_hash_whiteout>() - 8usize];
    [
        "Offset of field: bkey_i_hash_whiteout::v",
    ][::std::mem::offset_of!(bkey_i_hash_whiteout, v) - 40usize];
};
impl Default for bkey_i_hash_whiteout {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_c_hash_whiteout {
    pub __bindgen_anon_1: bkey_s_c_hash_whiteout__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_c_hash_whiteout__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_c_hash_whiteout__bindgen_ty_1__bindgen_ty_1,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_c_hash_whiteout__bindgen_ty_1__bindgen_ty_1 {
    pub k: *const bkey,
    pub v: *const bch_hash_whiteout,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_hash_whiteout__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_hash_whiteout__bindgen_ty_1__bindgen_ty_1>()
        - 16usize];
    [
        "Alignment of bkey_s_c_hash_whiteout__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_hash_whiteout__bindgen_ty_1__bindgen_ty_1>()
        - 8usize];
    [
        "Offset of field: bkey_s_c_hash_whiteout__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_c_hash_whiteout__bindgen_ty_1__bindgen_ty_1, k)
        - 0usize];
    [
        "Offset of field: bkey_s_c_hash_whiteout__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_c_hash_whiteout__bindgen_ty_1__bindgen_ty_1, v)
        - 8usize];
};
impl Default for bkey_s_c_hash_whiteout__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_hash_whiteout__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_hash_whiteout__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_hash_whiteout__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_hash_whiteout__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_hash_whiteout__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_c_hash_whiteout__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_c_hash_whiteout__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_hash_whiteout",
    ][::std::mem::size_of::<bkey_s_c_hash_whiteout>() - 16usize];
    [
        "Alignment of bkey_s_c_hash_whiteout",
    ][::std::mem::align_of::<bkey_s_c_hash_whiteout>() - 8usize];
};
impl Default for bkey_s_c_hash_whiteout {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_hash_whiteout {
    pub __bindgen_anon_1: bkey_s_hash_whiteout__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_hash_whiteout__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_hash_whiteout__bindgen_ty_1__bindgen_ty_1,
    pub c: bkey_s_c_hash_whiteout,
    pub s: bkey_s,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_hash_whiteout__bindgen_ty_1__bindgen_ty_1 {
    pub k: *mut bkey,
    pub v: *mut bch_hash_whiteout,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_hash_whiteout__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_hash_whiteout__bindgen_ty_1__bindgen_ty_1>()
        - 16usize];
    [
        "Alignment of bkey_s_hash_whiteout__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_hash_whiteout__bindgen_ty_1__bindgen_ty_1>()
        - 8usize];
    [
        "Offset of field: bkey_s_hash_whiteout__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_hash_whiteout__bindgen_ty_1__bindgen_ty_1, k)
        - 0usize];
    [
        "Offset of field: bkey_s_hash_whiteout__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_hash_whiteout__bindgen_ty_1__bindgen_ty_1, v)
        - 8usize];
};
impl Default for bkey_s_hash_whiteout__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_hash_whiteout__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_hash_whiteout__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_hash_whiteout__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_hash_whiteout__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_hash_whiteout__bindgen_ty_1::c",
    ][::std::mem::offset_of!(bkey_s_hash_whiteout__bindgen_ty_1, c) - 0usize];
    [
        "Offset of field: bkey_s_hash_whiteout__bindgen_ty_1::s",
    ][::std::mem::offset_of!(bkey_s_hash_whiteout__bindgen_ty_1, s) - 0usize];
    [
        "Offset of field: bkey_s_hash_whiteout__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_hash_whiteout__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_hash_whiteout__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_hash_whiteout",
    ][::std::mem::size_of::<bkey_s_hash_whiteout>() - 16usize];
    [
        "Alignment of bkey_s_hash_whiteout",
    ][::std::mem::align_of::<bkey_s_hash_whiteout>() - 8usize];
};
impl Default for bkey_s_hash_whiteout {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bkey_i_btree_ptr {
    pub __bindgen_anon_1: bkey_i_btree_ptr__bindgen_ty_1,
    pub v: bch_btree_ptr,
}
#[repr(C)]
pub struct bkey_i_btree_ptr__bindgen_ty_1 {
    pub k: __BindgenUnionField<bkey>,
    pub k_i: __BindgenUnionField<bkey_i>,
    pub bindgen_union_field: [u64; 5usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_btree_ptr__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_i_btree_ptr__bindgen_ty_1>() - 40usize];
    [
        "Alignment of bkey_i_btree_ptr__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_i_btree_ptr__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_i_btree_ptr__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_i_btree_ptr__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_i_btree_ptr__bindgen_ty_1::k_i",
    ][::std::mem::offset_of!(bkey_i_btree_ptr__bindgen_ty_1, k_i) - 0usize];
};
impl Default for bkey_i_btree_ptr__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_i_btree_ptr"][::std::mem::size_of::<bkey_i_btree_ptr>() - 40usize];
    [
        "Alignment of bkey_i_btree_ptr",
    ][::std::mem::align_of::<bkey_i_btree_ptr>() - 8usize];
    [
        "Offset of field: bkey_i_btree_ptr::v",
    ][::std::mem::offset_of!(bkey_i_btree_ptr, v) - 40usize];
};
impl Default for bkey_i_btree_ptr {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_c_btree_ptr {
    pub __bindgen_anon_1: bkey_s_c_btree_ptr__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_c_btree_ptr__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_c_btree_ptr__bindgen_ty_1__bindgen_ty_1,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_c_btree_ptr__bindgen_ty_1__bindgen_ty_1 {
    pub k: *const bkey,
    pub v: *const bch_btree_ptr,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_btree_ptr__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_btree_ptr__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_btree_ptr__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_btree_ptr__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_btree_ptr__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_c_btree_ptr__bindgen_ty_1__bindgen_ty_1, k)
        - 0usize];
    [
        "Offset of field: bkey_s_c_btree_ptr__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_c_btree_ptr__bindgen_ty_1__bindgen_ty_1, v)
        - 8usize];
};
impl Default for bkey_s_c_btree_ptr__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_btree_ptr__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_btree_ptr__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_btree_ptr__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_btree_ptr__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_btree_ptr__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_c_btree_ptr__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_c_btree_ptr__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_btree_ptr",
    ][::std::mem::size_of::<bkey_s_c_btree_ptr>() - 16usize];
    [
        "Alignment of bkey_s_c_btree_ptr",
    ][::std::mem::align_of::<bkey_s_c_btree_ptr>() - 8usize];
};
impl Default for bkey_s_c_btree_ptr {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_btree_ptr {
    pub __bindgen_anon_1: bkey_s_btree_ptr__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_btree_ptr__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_btree_ptr__bindgen_ty_1__bindgen_ty_1,
    pub c: bkey_s_c_btree_ptr,
    pub s: bkey_s,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_btree_ptr__bindgen_ty_1__bindgen_ty_1 {
    pub k: *mut bkey,
    pub v: *mut bch_btree_ptr,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_btree_ptr__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_btree_ptr__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_btree_ptr__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_btree_ptr__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_btree_ptr__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_btree_ptr__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_btree_ptr__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_btree_ptr__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_btree_ptr__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_btree_ptr__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_btree_ptr__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_btree_ptr__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_btree_ptr__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_btree_ptr__bindgen_ty_1::c",
    ][::std::mem::offset_of!(bkey_s_btree_ptr__bindgen_ty_1, c) - 0usize];
    [
        "Offset of field: bkey_s_btree_ptr__bindgen_ty_1::s",
    ][::std::mem::offset_of!(bkey_s_btree_ptr__bindgen_ty_1, s) - 0usize];
    [
        "Offset of field: bkey_s_btree_ptr__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_btree_ptr__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_btree_ptr__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_btree_ptr"][::std::mem::size_of::<bkey_s_btree_ptr>() - 16usize];
    [
        "Alignment of bkey_s_btree_ptr",
    ][::std::mem::align_of::<bkey_s_btree_ptr>() - 8usize];
};
impl Default for bkey_s_btree_ptr {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bkey_i_extent {
    pub __bindgen_anon_1: bkey_i_extent__bindgen_ty_1,
    pub v: bch_extent,
}
#[repr(C)]
pub struct bkey_i_extent__bindgen_ty_1 {
    pub k: __BindgenUnionField<bkey>,
    pub k_i: __BindgenUnionField<bkey_i>,
    pub bindgen_union_field: [u64; 5usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_extent__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_i_extent__bindgen_ty_1>() - 40usize];
    [
        "Alignment of bkey_i_extent__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_i_extent__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_i_extent__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_i_extent__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_i_extent__bindgen_ty_1::k_i",
    ][::std::mem::offset_of!(bkey_i_extent__bindgen_ty_1, k_i) - 0usize];
};
impl Default for bkey_i_extent__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_i_extent"][::std::mem::size_of::<bkey_i_extent>() - 40usize];
    ["Alignment of bkey_i_extent"][::std::mem::align_of::<bkey_i_extent>() - 8usize];
    [
        "Offset of field: bkey_i_extent::v",
    ][::std::mem::offset_of!(bkey_i_extent, v) - 40usize];
};
impl Default for bkey_i_extent {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_c_extent {
    pub __bindgen_anon_1: bkey_s_c_extent__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_c_extent__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_c_extent__bindgen_ty_1__bindgen_ty_1,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_c_extent__bindgen_ty_1__bindgen_ty_1 {
    pub k: *const bkey,
    pub v: *const bch_extent,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_extent__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_extent__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_extent__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_extent__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_extent__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_c_extent__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_c_extent__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_c_extent__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_c_extent__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_extent__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_extent__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_extent__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_extent__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_extent__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_c_extent__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_c_extent__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_c_extent"][::std::mem::size_of::<bkey_s_c_extent>() - 16usize];
    ["Alignment of bkey_s_c_extent"][::std::mem::align_of::<bkey_s_c_extent>() - 8usize];
};
impl Default for bkey_s_c_extent {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_extent {
    pub __bindgen_anon_1: bkey_s_extent__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_extent__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_extent__bindgen_ty_1__bindgen_ty_1,
    pub c: bkey_s_c_extent,
    pub s: bkey_s,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_extent__bindgen_ty_1__bindgen_ty_1 {
    pub k: *mut bkey,
    pub v: *mut bch_extent,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_extent__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_extent__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_extent__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_extent__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_extent__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_extent__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_extent__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_extent__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_extent__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_extent__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_extent__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_extent__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_extent__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_extent__bindgen_ty_1::c",
    ][::std::mem::offset_of!(bkey_s_extent__bindgen_ty_1, c) - 0usize];
    [
        "Offset of field: bkey_s_extent__bindgen_ty_1::s",
    ][::std::mem::offset_of!(bkey_s_extent__bindgen_ty_1, s) - 0usize];
    [
        "Offset of field: bkey_s_extent__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_extent__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_extent__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_extent"][::std::mem::size_of::<bkey_s_extent>() - 16usize];
    ["Alignment of bkey_s_extent"][::std::mem::align_of::<bkey_s_extent>() - 8usize];
};
impl Default for bkey_s_extent {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bkey_i_reservation {
    pub __bindgen_anon_1: bkey_i_reservation__bindgen_ty_1,
    pub v: bch_reservation,
}
#[repr(C)]
pub struct bkey_i_reservation__bindgen_ty_1 {
    pub k: __BindgenUnionField<bkey>,
    pub k_i: __BindgenUnionField<bkey_i>,
    pub bindgen_union_field: [u64; 5usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_reservation__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_i_reservation__bindgen_ty_1>() - 40usize];
    [
        "Alignment of bkey_i_reservation__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_i_reservation__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_i_reservation__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_i_reservation__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_i_reservation__bindgen_ty_1::k_i",
    ][::std::mem::offset_of!(bkey_i_reservation__bindgen_ty_1, k_i) - 0usize];
};
impl Default for bkey_i_reservation__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_reservation",
    ][::std::mem::size_of::<bkey_i_reservation>() - 48usize];
    [
        "Alignment of bkey_i_reservation",
    ][::std::mem::align_of::<bkey_i_reservation>() - 8usize];
    [
        "Offset of field: bkey_i_reservation::v",
    ][::std::mem::offset_of!(bkey_i_reservation, v) - 40usize];
};
impl Default for bkey_i_reservation {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_c_reservation {
    pub __bindgen_anon_1: bkey_s_c_reservation__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_c_reservation__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_c_reservation__bindgen_ty_1__bindgen_ty_1,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_c_reservation__bindgen_ty_1__bindgen_ty_1 {
    pub k: *const bkey,
    pub v: *const bch_reservation,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_reservation__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_reservation__bindgen_ty_1__bindgen_ty_1>()
        - 16usize];
    [
        "Alignment of bkey_s_c_reservation__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_reservation__bindgen_ty_1__bindgen_ty_1>()
        - 8usize];
    [
        "Offset of field: bkey_s_c_reservation__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_c_reservation__bindgen_ty_1__bindgen_ty_1, k)
        - 0usize];
    [
        "Offset of field: bkey_s_c_reservation__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_c_reservation__bindgen_ty_1__bindgen_ty_1, v)
        - 8usize];
};
impl Default for bkey_s_c_reservation__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_reservation__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_reservation__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_reservation__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_reservation__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_reservation__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_c_reservation__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_c_reservation__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_reservation",
    ][::std::mem::size_of::<bkey_s_c_reservation>() - 16usize];
    [
        "Alignment of bkey_s_c_reservation",
    ][::std::mem::align_of::<bkey_s_c_reservation>() - 8usize];
};
impl Default for bkey_s_c_reservation {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_reservation {
    pub __bindgen_anon_1: bkey_s_reservation__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_reservation__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_reservation__bindgen_ty_1__bindgen_ty_1,
    pub c: bkey_s_c_reservation,
    pub s: bkey_s,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_reservation__bindgen_ty_1__bindgen_ty_1 {
    pub k: *mut bkey,
    pub v: *mut bch_reservation,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_reservation__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_reservation__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_reservation__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_reservation__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_reservation__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_reservation__bindgen_ty_1__bindgen_ty_1, k)
        - 0usize];
    [
        "Offset of field: bkey_s_reservation__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_reservation__bindgen_ty_1__bindgen_ty_1, v)
        - 8usize];
};
impl Default for bkey_s_reservation__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_reservation__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_reservation__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_reservation__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_reservation__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_reservation__bindgen_ty_1::c",
    ][::std::mem::offset_of!(bkey_s_reservation__bindgen_ty_1, c) - 0usize];
    [
        "Offset of field: bkey_s_reservation__bindgen_ty_1::s",
    ][::std::mem::offset_of!(bkey_s_reservation__bindgen_ty_1, s) - 0usize];
    [
        "Offset of field: bkey_s_reservation__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_reservation__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_reservation__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_reservation",
    ][::std::mem::size_of::<bkey_s_reservation>() - 16usize];
    [
        "Alignment of bkey_s_reservation",
    ][::std::mem::align_of::<bkey_s_reservation>() - 8usize];
};
impl Default for bkey_s_reservation {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bkey_i_inode {
    pub __bindgen_anon_1: bkey_i_inode__bindgen_ty_1,
    pub v: bch_inode,
}
#[repr(C)]
pub struct bkey_i_inode__bindgen_ty_1 {
    pub k: __BindgenUnionField<bkey>,
    pub k_i: __BindgenUnionField<bkey_i>,
    pub bindgen_union_field: [u64; 5usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_inode__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_i_inode__bindgen_ty_1>() - 40usize];
    [
        "Alignment of bkey_i_inode__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_i_inode__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_i_inode__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_i_inode__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_i_inode__bindgen_ty_1::k_i",
    ][::std::mem::offset_of!(bkey_i_inode__bindgen_ty_1, k_i) - 0usize];
};
impl Default for bkey_i_inode__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_i_inode"][::std::mem::size_of::<bkey_i_inode>() - 56usize];
    ["Alignment of bkey_i_inode"][::std::mem::align_of::<bkey_i_inode>() - 8usize];
    [
        "Offset of field: bkey_i_inode::v",
    ][::std::mem::offset_of!(bkey_i_inode, v) - 40usize];
};
impl Default for bkey_i_inode {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_c_inode {
    pub __bindgen_anon_1: bkey_s_c_inode__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_c_inode__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_c_inode__bindgen_ty_1__bindgen_ty_1,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_c_inode__bindgen_ty_1__bindgen_ty_1 {
    pub k: *const bkey,
    pub v: *const bch_inode,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_inode__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_inode__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_inode__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_inode__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_inode__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_c_inode__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_c_inode__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_c_inode__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_c_inode__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_inode__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_inode__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_inode__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_inode__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_inode__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_c_inode__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_c_inode__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_c_inode"][::std::mem::size_of::<bkey_s_c_inode>() - 16usize];
    ["Alignment of bkey_s_c_inode"][::std::mem::align_of::<bkey_s_c_inode>() - 8usize];
};
impl Default for bkey_s_c_inode {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_inode {
    pub __bindgen_anon_1: bkey_s_inode__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_inode__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_inode__bindgen_ty_1__bindgen_ty_1,
    pub c: bkey_s_c_inode,
    pub s: bkey_s,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_inode__bindgen_ty_1__bindgen_ty_1 {
    pub k: *mut bkey,
    pub v: *mut bch_inode,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_inode__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_inode__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_inode__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_inode__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_inode__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_inode__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_inode__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_inode__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_inode__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_inode__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_inode__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_inode__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_inode__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_inode__bindgen_ty_1::c",
    ][::std::mem::offset_of!(bkey_s_inode__bindgen_ty_1, c) - 0usize];
    [
        "Offset of field: bkey_s_inode__bindgen_ty_1::s",
    ][::std::mem::offset_of!(bkey_s_inode__bindgen_ty_1, s) - 0usize];
    [
        "Offset of field: bkey_s_inode__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_inode__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_inode__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_inode"][::std::mem::size_of::<bkey_s_inode>() - 16usize];
    ["Alignment of bkey_s_inode"][::std::mem::align_of::<bkey_s_inode>() - 8usize];
};
impl Default for bkey_s_inode {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bkey_i_inode_generation {
    pub __bindgen_anon_1: bkey_i_inode_generation__bindgen_ty_1,
    pub v: bch_inode_generation,
}
#[repr(C)]
pub struct bkey_i_inode_generation__bindgen_ty_1 {
    pub k: __BindgenUnionField<bkey>,
    pub k_i: __BindgenUnionField<bkey_i>,
    pub bindgen_union_field: [u64; 5usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_inode_generation__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_i_inode_generation__bindgen_ty_1>() - 40usize];
    [
        "Alignment of bkey_i_inode_generation__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_i_inode_generation__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_i_inode_generation__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_i_inode_generation__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_i_inode_generation__bindgen_ty_1::k_i",
    ][::std::mem::offset_of!(bkey_i_inode_generation__bindgen_ty_1, k_i) - 0usize];
};
impl Default for bkey_i_inode_generation__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_inode_generation",
    ][::std::mem::size_of::<bkey_i_inode_generation>() - 48usize];
    [
        "Alignment of bkey_i_inode_generation",
    ][::std::mem::align_of::<bkey_i_inode_generation>() - 8usize];
    [
        "Offset of field: bkey_i_inode_generation::v",
    ][::std::mem::offset_of!(bkey_i_inode_generation, v) - 40usize];
};
impl Default for bkey_i_inode_generation {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_c_inode_generation {
    pub __bindgen_anon_1: bkey_s_c_inode_generation__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_c_inode_generation__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_c_inode_generation__bindgen_ty_1__bindgen_ty_1,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_c_inode_generation__bindgen_ty_1__bindgen_ty_1 {
    pub k: *const bkey,
    pub v: *const bch_inode_generation,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_inode_generation__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_inode_generation__bindgen_ty_1__bindgen_ty_1>()
        - 16usize];
    [
        "Alignment of bkey_s_c_inode_generation__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_inode_generation__bindgen_ty_1__bindgen_ty_1>()
        - 8usize];
    [
        "Offset of field: bkey_s_c_inode_generation__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_c_inode_generation__bindgen_ty_1__bindgen_ty_1, k)
        - 0usize];
    [
        "Offset of field: bkey_s_c_inode_generation__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_c_inode_generation__bindgen_ty_1__bindgen_ty_1, v)
        - 8usize];
};
impl Default for bkey_s_c_inode_generation__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_inode_generation__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_inode_generation__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_inode_generation__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_inode_generation__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_inode_generation__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_c_inode_generation__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_c_inode_generation__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_inode_generation",
    ][::std::mem::size_of::<bkey_s_c_inode_generation>() - 16usize];
    [
        "Alignment of bkey_s_c_inode_generation",
    ][::std::mem::align_of::<bkey_s_c_inode_generation>() - 8usize];
};
impl Default for bkey_s_c_inode_generation {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_inode_generation {
    pub __bindgen_anon_1: bkey_s_inode_generation__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_inode_generation__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_inode_generation__bindgen_ty_1__bindgen_ty_1,
    pub c: bkey_s_c_inode_generation,
    pub s: bkey_s,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_inode_generation__bindgen_ty_1__bindgen_ty_1 {
    pub k: *mut bkey,
    pub v: *mut bch_inode_generation,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_inode_generation__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_inode_generation__bindgen_ty_1__bindgen_ty_1>()
        - 16usize];
    [
        "Alignment of bkey_s_inode_generation__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_inode_generation__bindgen_ty_1__bindgen_ty_1>()
        - 8usize];
    [
        "Offset of field: bkey_s_inode_generation__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_inode_generation__bindgen_ty_1__bindgen_ty_1, k)
        - 0usize];
    [
        "Offset of field: bkey_s_inode_generation__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_inode_generation__bindgen_ty_1__bindgen_ty_1, v)
        - 8usize];
};
impl Default for bkey_s_inode_generation__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_inode_generation__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_inode_generation__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_inode_generation__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_inode_generation__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_inode_generation__bindgen_ty_1::c",
    ][::std::mem::offset_of!(bkey_s_inode_generation__bindgen_ty_1, c) - 0usize];
    [
        "Offset of field: bkey_s_inode_generation__bindgen_ty_1::s",
    ][::std::mem::offset_of!(bkey_s_inode_generation__bindgen_ty_1, s) - 0usize];
    [
        "Offset of field: bkey_s_inode_generation__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_inode_generation__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_inode_generation__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_inode_generation",
    ][::std::mem::size_of::<bkey_s_inode_generation>() - 16usize];
    [
        "Alignment of bkey_s_inode_generation",
    ][::std::mem::align_of::<bkey_s_inode_generation>() - 8usize];
};
impl Default for bkey_s_inode_generation {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bkey_i_dirent {
    pub __bindgen_anon_1: bkey_i_dirent__bindgen_ty_1,
    pub v: bch_dirent,
}
#[repr(C)]
pub struct bkey_i_dirent__bindgen_ty_1 {
    pub k: __BindgenUnionField<bkey>,
    pub k_i: __BindgenUnionField<bkey_i>,
    pub bindgen_union_field: [u64; 5usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_dirent__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_i_dirent__bindgen_ty_1>() - 40usize];
    [
        "Alignment of bkey_i_dirent__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_i_dirent__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_i_dirent__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_i_dirent__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_i_dirent__bindgen_ty_1::k_i",
    ][::std::mem::offset_of!(bkey_i_dirent__bindgen_ty_1, k_i) - 0usize];
};
impl Default for bkey_i_dirent__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_i_dirent"][::std::mem::size_of::<bkey_i_dirent>() - 56usize];
    ["Alignment of bkey_i_dirent"][::std::mem::align_of::<bkey_i_dirent>() - 8usize];
    [
        "Offset of field: bkey_i_dirent::v",
    ][::std::mem::offset_of!(bkey_i_dirent, v) - 40usize];
};
impl Default for bkey_i_dirent {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_c_dirent {
    pub __bindgen_anon_1: bkey_s_c_dirent__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_c_dirent__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_c_dirent__bindgen_ty_1__bindgen_ty_1,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_c_dirent__bindgen_ty_1__bindgen_ty_1 {
    pub k: *const bkey,
    pub v: *const bch_dirent,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_dirent__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_dirent__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_dirent__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_dirent__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_dirent__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_c_dirent__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_c_dirent__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_c_dirent__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_c_dirent__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_dirent__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_dirent__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_dirent__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_dirent__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_dirent__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_c_dirent__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_c_dirent__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_c_dirent"][::std::mem::size_of::<bkey_s_c_dirent>() - 16usize];
    ["Alignment of bkey_s_c_dirent"][::std::mem::align_of::<bkey_s_c_dirent>() - 8usize];
};
impl Default for bkey_s_c_dirent {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_dirent {
    pub __bindgen_anon_1: bkey_s_dirent__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_dirent__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_dirent__bindgen_ty_1__bindgen_ty_1,
    pub c: bkey_s_c_dirent,
    pub s: bkey_s,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_dirent__bindgen_ty_1__bindgen_ty_1 {
    pub k: *mut bkey,
    pub v: *mut bch_dirent,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_dirent__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_dirent__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_dirent__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_dirent__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_dirent__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_dirent__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_dirent__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_dirent__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_dirent__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_dirent__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_dirent__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_dirent__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_dirent__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_dirent__bindgen_ty_1::c",
    ][::std::mem::offset_of!(bkey_s_dirent__bindgen_ty_1, c) - 0usize];
    [
        "Offset of field: bkey_s_dirent__bindgen_ty_1::s",
    ][::std::mem::offset_of!(bkey_s_dirent__bindgen_ty_1, s) - 0usize];
    [
        "Offset of field: bkey_s_dirent__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_dirent__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_dirent__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_dirent"][::std::mem::size_of::<bkey_s_dirent>() - 16usize];
    ["Alignment of bkey_s_dirent"][::std::mem::align_of::<bkey_s_dirent>() - 8usize];
};
impl Default for bkey_s_dirent {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bkey_i_xattr {
    pub __bindgen_anon_1: bkey_i_xattr__bindgen_ty_1,
    pub v: bch_xattr,
}
#[repr(C)]
pub struct bkey_i_xattr__bindgen_ty_1 {
    pub k: __BindgenUnionField<bkey>,
    pub k_i: __BindgenUnionField<bkey_i>,
    pub bindgen_union_field: [u64; 5usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_xattr__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_i_xattr__bindgen_ty_1>() - 40usize];
    [
        "Alignment of bkey_i_xattr__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_i_xattr__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_i_xattr__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_i_xattr__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_i_xattr__bindgen_ty_1::k_i",
    ][::std::mem::offset_of!(bkey_i_xattr__bindgen_ty_1, k_i) - 0usize];
};
impl Default for bkey_i_xattr__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_i_xattr"][::std::mem::size_of::<bkey_i_xattr>() - 48usize];
    ["Alignment of bkey_i_xattr"][::std::mem::align_of::<bkey_i_xattr>() - 8usize];
    [
        "Offset of field: bkey_i_xattr::v",
    ][::std::mem::offset_of!(bkey_i_xattr, v) - 40usize];
};
impl Default for bkey_i_xattr {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_c_xattr {
    pub __bindgen_anon_1: bkey_s_c_xattr__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_c_xattr__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_c_xattr__bindgen_ty_1__bindgen_ty_1,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_c_xattr__bindgen_ty_1__bindgen_ty_1 {
    pub k: *const bkey,
    pub v: *const bch_xattr,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_xattr__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_xattr__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_xattr__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_xattr__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_xattr__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_c_xattr__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_c_xattr__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_c_xattr__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_c_xattr__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_xattr__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_xattr__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_xattr__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_xattr__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_xattr__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_c_xattr__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_c_xattr__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_c_xattr"][::std::mem::size_of::<bkey_s_c_xattr>() - 16usize];
    ["Alignment of bkey_s_c_xattr"][::std::mem::align_of::<bkey_s_c_xattr>() - 8usize];
};
impl Default for bkey_s_c_xattr {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_xattr {
    pub __bindgen_anon_1: bkey_s_xattr__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_xattr__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_xattr__bindgen_ty_1__bindgen_ty_1,
    pub c: bkey_s_c_xattr,
    pub s: bkey_s,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_xattr__bindgen_ty_1__bindgen_ty_1 {
    pub k: *mut bkey,
    pub v: *mut bch_xattr,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_xattr__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_xattr__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_xattr__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_xattr__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_xattr__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_xattr__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_xattr__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_xattr__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_xattr__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_xattr__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_xattr__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_xattr__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_xattr__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_xattr__bindgen_ty_1::c",
    ][::std::mem::offset_of!(bkey_s_xattr__bindgen_ty_1, c) - 0usize];
    [
        "Offset of field: bkey_s_xattr__bindgen_ty_1::s",
    ][::std::mem::offset_of!(bkey_s_xattr__bindgen_ty_1, s) - 0usize];
    [
        "Offset of field: bkey_s_xattr__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_xattr__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_xattr__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_xattr"][::std::mem::size_of::<bkey_s_xattr>() - 16usize];
    ["Alignment of bkey_s_xattr"][::std::mem::align_of::<bkey_s_xattr>() - 8usize];
};
impl Default for bkey_s_xattr {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bkey_i_alloc {
    pub __bindgen_anon_1: bkey_i_alloc__bindgen_ty_1,
    pub v: bch_alloc,
}
#[repr(C)]
pub struct bkey_i_alloc__bindgen_ty_1 {
    pub k: __BindgenUnionField<bkey>,
    pub k_i: __BindgenUnionField<bkey_i>,
    pub bindgen_union_field: [u64; 5usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_alloc__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_i_alloc__bindgen_ty_1>() - 40usize];
    [
        "Alignment of bkey_i_alloc__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_i_alloc__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_i_alloc__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_i_alloc__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_i_alloc__bindgen_ty_1::k_i",
    ][::std::mem::offset_of!(bkey_i_alloc__bindgen_ty_1, k_i) - 0usize];
};
impl Default for bkey_i_alloc__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_i_alloc"][::std::mem::size_of::<bkey_i_alloc>() - 48usize];
    ["Alignment of bkey_i_alloc"][::std::mem::align_of::<bkey_i_alloc>() - 8usize];
    [
        "Offset of field: bkey_i_alloc::v",
    ][::std::mem::offset_of!(bkey_i_alloc, v) - 40usize];
};
impl Default for bkey_i_alloc {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_c_alloc {
    pub __bindgen_anon_1: bkey_s_c_alloc__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_c_alloc__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_c_alloc__bindgen_ty_1__bindgen_ty_1,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_c_alloc__bindgen_ty_1__bindgen_ty_1 {
    pub k: *const bkey,
    pub v: *const bch_alloc,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_alloc__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_alloc__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_alloc__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_alloc__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_alloc__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_c_alloc__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_c_alloc__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_c_alloc__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_c_alloc__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_alloc__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_alloc__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_alloc__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_alloc__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_alloc__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_c_alloc__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_c_alloc__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_c_alloc"][::std::mem::size_of::<bkey_s_c_alloc>() - 16usize];
    ["Alignment of bkey_s_c_alloc"][::std::mem::align_of::<bkey_s_c_alloc>() - 8usize];
};
impl Default for bkey_s_c_alloc {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_alloc {
    pub __bindgen_anon_1: bkey_s_alloc__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_alloc__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_alloc__bindgen_ty_1__bindgen_ty_1,
    pub c: bkey_s_c_alloc,
    pub s: bkey_s,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_alloc__bindgen_ty_1__bindgen_ty_1 {
    pub k: *mut bkey,
    pub v: *mut bch_alloc,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_alloc__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_alloc__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_alloc__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_alloc__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_alloc__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_alloc__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_alloc__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_alloc__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_alloc__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_alloc__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_alloc__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_alloc__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_alloc__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_alloc__bindgen_ty_1::c",
    ][::std::mem::offset_of!(bkey_s_alloc__bindgen_ty_1, c) - 0usize];
    [
        "Offset of field: bkey_s_alloc__bindgen_ty_1::s",
    ][::std::mem::offset_of!(bkey_s_alloc__bindgen_ty_1, s) - 0usize];
    [
        "Offset of field: bkey_s_alloc__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_alloc__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_alloc__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_alloc"][::std::mem::size_of::<bkey_s_alloc>() - 16usize];
    ["Alignment of bkey_s_alloc"][::std::mem::align_of::<bkey_s_alloc>() - 8usize];
};
impl Default for bkey_s_alloc {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bkey_i_quota {
    pub __bindgen_anon_1: bkey_i_quota__bindgen_ty_1,
    pub v: bch_quota,
}
#[repr(C)]
pub struct bkey_i_quota__bindgen_ty_1 {
    pub k: __BindgenUnionField<bkey>,
    pub k_i: __BindgenUnionField<bkey_i>,
    pub bindgen_union_field: [u64; 5usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_quota__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_i_quota__bindgen_ty_1>() - 40usize];
    [
        "Alignment of bkey_i_quota__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_i_quota__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_i_quota__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_i_quota__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_i_quota__bindgen_ty_1::k_i",
    ][::std::mem::offset_of!(bkey_i_quota__bindgen_ty_1, k_i) - 0usize];
};
impl Default for bkey_i_quota__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_i_quota"][::std::mem::size_of::<bkey_i_quota>() - 72usize];
    ["Alignment of bkey_i_quota"][::std::mem::align_of::<bkey_i_quota>() - 8usize];
    [
        "Offset of field: bkey_i_quota::v",
    ][::std::mem::offset_of!(bkey_i_quota, v) - 40usize];
};
impl Default for bkey_i_quota {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_c_quota {
    pub __bindgen_anon_1: bkey_s_c_quota__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_c_quota__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_c_quota__bindgen_ty_1__bindgen_ty_1,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_c_quota__bindgen_ty_1__bindgen_ty_1 {
    pub k: *const bkey,
    pub v: *const bch_quota,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_quota__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_quota__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_quota__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_quota__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_quota__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_c_quota__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_c_quota__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_c_quota__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_c_quota__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_quota__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_quota__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_quota__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_quota__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_quota__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_c_quota__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_c_quota__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_c_quota"][::std::mem::size_of::<bkey_s_c_quota>() - 16usize];
    ["Alignment of bkey_s_c_quota"][::std::mem::align_of::<bkey_s_c_quota>() - 8usize];
};
impl Default for bkey_s_c_quota {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_quota {
    pub __bindgen_anon_1: bkey_s_quota__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_quota__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_quota__bindgen_ty_1__bindgen_ty_1,
    pub c: bkey_s_c_quota,
    pub s: bkey_s,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_quota__bindgen_ty_1__bindgen_ty_1 {
    pub k: *mut bkey,
    pub v: *mut bch_quota,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_quota__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_quota__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_quota__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_quota__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_quota__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_quota__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_quota__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_quota__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_quota__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_quota__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_quota__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_quota__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_quota__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_quota__bindgen_ty_1::c",
    ][::std::mem::offset_of!(bkey_s_quota__bindgen_ty_1, c) - 0usize];
    [
        "Offset of field: bkey_s_quota__bindgen_ty_1::s",
    ][::std::mem::offset_of!(bkey_s_quota__bindgen_ty_1, s) - 0usize];
    [
        "Offset of field: bkey_s_quota__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_quota__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_quota__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_quota"][::std::mem::size_of::<bkey_s_quota>() - 16usize];
    ["Alignment of bkey_s_quota"][::std::mem::align_of::<bkey_s_quota>() - 8usize];
};
impl Default for bkey_s_quota {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bkey_i_stripe {
    pub __bindgen_anon_1: bkey_i_stripe__bindgen_ty_1,
    pub v: bch_stripe,
}
#[repr(C)]
pub struct bkey_i_stripe__bindgen_ty_1 {
    pub k: __BindgenUnionField<bkey>,
    pub k_i: __BindgenUnionField<bkey_i>,
    pub bindgen_union_field: [u64; 5usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_stripe__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_i_stripe__bindgen_ty_1>() - 40usize];
    [
        "Alignment of bkey_i_stripe__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_i_stripe__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_i_stripe__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_i_stripe__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_i_stripe__bindgen_ty_1::k_i",
    ][::std::mem::offset_of!(bkey_i_stripe__bindgen_ty_1, k_i) - 0usize];
};
impl Default for bkey_i_stripe__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_i_stripe"][::std::mem::size_of::<bkey_i_stripe>() - 48usize];
    ["Alignment of bkey_i_stripe"][::std::mem::align_of::<bkey_i_stripe>() - 8usize];
    [
        "Offset of field: bkey_i_stripe::v",
    ][::std::mem::offset_of!(bkey_i_stripe, v) - 40usize];
};
impl Default for bkey_i_stripe {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_c_stripe {
    pub __bindgen_anon_1: bkey_s_c_stripe__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_c_stripe__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_c_stripe__bindgen_ty_1__bindgen_ty_1,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_c_stripe__bindgen_ty_1__bindgen_ty_1 {
    pub k: *const bkey,
    pub v: *const bch_stripe,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_stripe__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_stripe__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_stripe__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_stripe__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_stripe__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_c_stripe__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_c_stripe__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_c_stripe__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_c_stripe__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_stripe__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_stripe__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_stripe__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_stripe__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_stripe__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_c_stripe__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_c_stripe__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_c_stripe"][::std::mem::size_of::<bkey_s_c_stripe>() - 16usize];
    ["Alignment of bkey_s_c_stripe"][::std::mem::align_of::<bkey_s_c_stripe>() - 8usize];
};
impl Default for bkey_s_c_stripe {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_stripe {
    pub __bindgen_anon_1: bkey_s_stripe__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_stripe__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_stripe__bindgen_ty_1__bindgen_ty_1,
    pub c: bkey_s_c_stripe,
    pub s: bkey_s,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_stripe__bindgen_ty_1__bindgen_ty_1 {
    pub k: *mut bkey,
    pub v: *mut bch_stripe,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_stripe__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_stripe__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_stripe__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_stripe__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_stripe__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_stripe__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_stripe__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_stripe__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_stripe__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_stripe__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_stripe__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_stripe__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_stripe__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_stripe__bindgen_ty_1::c",
    ][::std::mem::offset_of!(bkey_s_stripe__bindgen_ty_1, c) - 0usize];
    [
        "Offset of field: bkey_s_stripe__bindgen_ty_1::s",
    ][::std::mem::offset_of!(bkey_s_stripe__bindgen_ty_1, s) - 0usize];
    [
        "Offset of field: bkey_s_stripe__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_stripe__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_stripe__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_stripe"][::std::mem::size_of::<bkey_s_stripe>() - 16usize];
    ["Alignment of bkey_s_stripe"][::std::mem::align_of::<bkey_s_stripe>() - 8usize];
};
impl Default for bkey_s_stripe {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bkey_i_reflink_p {
    pub __bindgen_anon_1: bkey_i_reflink_p__bindgen_ty_1,
    pub v: bch_reflink_p,
}
#[repr(C)]
pub struct bkey_i_reflink_p__bindgen_ty_1 {
    pub k: __BindgenUnionField<bkey>,
    pub k_i: __BindgenUnionField<bkey_i>,
    pub bindgen_union_field: [u64; 5usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_reflink_p__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_i_reflink_p__bindgen_ty_1>() - 40usize];
    [
        "Alignment of bkey_i_reflink_p__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_i_reflink_p__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_i_reflink_p__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_i_reflink_p__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_i_reflink_p__bindgen_ty_1::k_i",
    ][::std::mem::offset_of!(bkey_i_reflink_p__bindgen_ty_1, k_i) - 0usize];
};
impl Default for bkey_i_reflink_p__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_i_reflink_p"][::std::mem::size_of::<bkey_i_reflink_p>() - 56usize];
    [
        "Alignment of bkey_i_reflink_p",
    ][::std::mem::align_of::<bkey_i_reflink_p>() - 8usize];
    [
        "Offset of field: bkey_i_reflink_p::v",
    ][::std::mem::offset_of!(bkey_i_reflink_p, v) - 40usize];
};
impl Default for bkey_i_reflink_p {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_c_reflink_p {
    pub __bindgen_anon_1: bkey_s_c_reflink_p__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_c_reflink_p__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_c_reflink_p__bindgen_ty_1__bindgen_ty_1,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_c_reflink_p__bindgen_ty_1__bindgen_ty_1 {
    pub k: *const bkey,
    pub v: *const bch_reflink_p,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_reflink_p__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_reflink_p__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_reflink_p__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_reflink_p__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_reflink_p__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_c_reflink_p__bindgen_ty_1__bindgen_ty_1, k)
        - 0usize];
    [
        "Offset of field: bkey_s_c_reflink_p__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_c_reflink_p__bindgen_ty_1__bindgen_ty_1, v)
        - 8usize];
};
impl Default for bkey_s_c_reflink_p__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_reflink_p__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_reflink_p__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_reflink_p__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_reflink_p__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_reflink_p__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_c_reflink_p__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_c_reflink_p__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_reflink_p",
    ][::std::mem::size_of::<bkey_s_c_reflink_p>() - 16usize];
    [
        "Alignment of bkey_s_c_reflink_p",
    ][::std::mem::align_of::<bkey_s_c_reflink_p>() - 8usize];
};
impl Default for bkey_s_c_reflink_p {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_reflink_p {
    pub __bindgen_anon_1: bkey_s_reflink_p__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_reflink_p__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_reflink_p__bindgen_ty_1__bindgen_ty_1,
    pub c: bkey_s_c_reflink_p,
    pub s: bkey_s,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_reflink_p__bindgen_ty_1__bindgen_ty_1 {
    pub k: *mut bkey,
    pub v: *mut bch_reflink_p,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_reflink_p__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_reflink_p__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_reflink_p__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_reflink_p__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_reflink_p__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_reflink_p__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_reflink_p__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_reflink_p__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_reflink_p__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_reflink_p__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_reflink_p__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_reflink_p__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_reflink_p__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_reflink_p__bindgen_ty_1::c",
    ][::std::mem::offset_of!(bkey_s_reflink_p__bindgen_ty_1, c) - 0usize];
    [
        "Offset of field: bkey_s_reflink_p__bindgen_ty_1::s",
    ][::std::mem::offset_of!(bkey_s_reflink_p__bindgen_ty_1, s) - 0usize];
    [
        "Offset of field: bkey_s_reflink_p__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_reflink_p__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_reflink_p__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_reflink_p"][::std::mem::size_of::<bkey_s_reflink_p>() - 16usize];
    [
        "Alignment of bkey_s_reflink_p",
    ][::std::mem::align_of::<bkey_s_reflink_p>() - 8usize];
};
impl Default for bkey_s_reflink_p {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bkey_i_reflink_v {
    pub __bindgen_anon_1: bkey_i_reflink_v__bindgen_ty_1,
    pub v: bch_reflink_v,
}
#[repr(C)]
pub struct bkey_i_reflink_v__bindgen_ty_1 {
    pub k: __BindgenUnionField<bkey>,
    pub k_i: __BindgenUnionField<bkey_i>,
    pub bindgen_union_field: [u64; 5usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_reflink_v__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_i_reflink_v__bindgen_ty_1>() - 40usize];
    [
        "Alignment of bkey_i_reflink_v__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_i_reflink_v__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_i_reflink_v__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_i_reflink_v__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_i_reflink_v__bindgen_ty_1::k_i",
    ][::std::mem::offset_of!(bkey_i_reflink_v__bindgen_ty_1, k_i) - 0usize];
};
impl Default for bkey_i_reflink_v__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_i_reflink_v"][::std::mem::size_of::<bkey_i_reflink_v>() - 48usize];
    [
        "Alignment of bkey_i_reflink_v",
    ][::std::mem::align_of::<bkey_i_reflink_v>() - 8usize];
    [
        "Offset of field: bkey_i_reflink_v::v",
    ][::std::mem::offset_of!(bkey_i_reflink_v, v) - 40usize];
};
impl Default for bkey_i_reflink_v {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_c_reflink_v {
    pub __bindgen_anon_1: bkey_s_c_reflink_v__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_c_reflink_v__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_c_reflink_v__bindgen_ty_1__bindgen_ty_1,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_c_reflink_v__bindgen_ty_1__bindgen_ty_1 {
    pub k: *const bkey,
    pub v: *const bch_reflink_v,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_reflink_v__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_reflink_v__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_reflink_v__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_reflink_v__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_reflink_v__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_c_reflink_v__bindgen_ty_1__bindgen_ty_1, k)
        - 0usize];
    [
        "Offset of field: bkey_s_c_reflink_v__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_c_reflink_v__bindgen_ty_1__bindgen_ty_1, v)
        - 8usize];
};
impl Default for bkey_s_c_reflink_v__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_reflink_v__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_reflink_v__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_reflink_v__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_reflink_v__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_reflink_v__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_c_reflink_v__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_c_reflink_v__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_reflink_v",
    ][::std::mem::size_of::<bkey_s_c_reflink_v>() - 16usize];
    [
        "Alignment of bkey_s_c_reflink_v",
    ][::std::mem::align_of::<bkey_s_c_reflink_v>() - 8usize];
};
impl Default for bkey_s_c_reflink_v {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_reflink_v {
    pub __bindgen_anon_1: bkey_s_reflink_v__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_reflink_v__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_reflink_v__bindgen_ty_1__bindgen_ty_1,
    pub c: bkey_s_c_reflink_v,
    pub s: bkey_s,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_reflink_v__bindgen_ty_1__bindgen_ty_1 {
    pub k: *mut bkey,
    pub v: *mut bch_reflink_v,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_reflink_v__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_reflink_v__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_reflink_v__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_reflink_v__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_reflink_v__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_reflink_v__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_reflink_v__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_reflink_v__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_reflink_v__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_reflink_v__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_reflink_v__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_reflink_v__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_reflink_v__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_reflink_v__bindgen_ty_1::c",
    ][::std::mem::offset_of!(bkey_s_reflink_v__bindgen_ty_1, c) - 0usize];
    [
        "Offset of field: bkey_s_reflink_v__bindgen_ty_1::s",
    ][::std::mem::offset_of!(bkey_s_reflink_v__bindgen_ty_1, s) - 0usize];
    [
        "Offset of field: bkey_s_reflink_v__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_reflink_v__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_reflink_v__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_reflink_v"][::std::mem::size_of::<bkey_s_reflink_v>() - 16usize];
    [
        "Alignment of bkey_s_reflink_v",
    ][::std::mem::align_of::<bkey_s_reflink_v>() - 8usize];
};
impl Default for bkey_s_reflink_v {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bkey_i_inline_data {
    pub __bindgen_anon_1: bkey_i_inline_data__bindgen_ty_1,
    pub v: bch_inline_data,
}
#[repr(C)]
pub struct bkey_i_inline_data__bindgen_ty_1 {
    pub k: __BindgenUnionField<bkey>,
    pub k_i: __BindgenUnionField<bkey_i>,
    pub bindgen_union_field: [u64; 5usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_inline_data__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_i_inline_data__bindgen_ty_1>() - 40usize];
    [
        "Alignment of bkey_i_inline_data__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_i_inline_data__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_i_inline_data__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_i_inline_data__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_i_inline_data__bindgen_ty_1::k_i",
    ][::std::mem::offset_of!(bkey_i_inline_data__bindgen_ty_1, k_i) - 0usize];
};
impl Default for bkey_i_inline_data__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_inline_data",
    ][::std::mem::size_of::<bkey_i_inline_data>() - 40usize];
    [
        "Alignment of bkey_i_inline_data",
    ][::std::mem::align_of::<bkey_i_inline_data>() - 8usize];
    [
        "Offset of field: bkey_i_inline_data::v",
    ][::std::mem::offset_of!(bkey_i_inline_data, v) - 40usize];
};
impl Default for bkey_i_inline_data {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_c_inline_data {
    pub __bindgen_anon_1: bkey_s_c_inline_data__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_c_inline_data__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_c_inline_data__bindgen_ty_1__bindgen_ty_1,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_c_inline_data__bindgen_ty_1__bindgen_ty_1 {
    pub k: *const bkey,
    pub v: *const bch_inline_data,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_inline_data__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_inline_data__bindgen_ty_1__bindgen_ty_1>()
        - 16usize];
    [
        "Alignment of bkey_s_c_inline_data__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_inline_data__bindgen_ty_1__bindgen_ty_1>()
        - 8usize];
    [
        "Offset of field: bkey_s_c_inline_data__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_c_inline_data__bindgen_ty_1__bindgen_ty_1, k)
        - 0usize];
    [
        "Offset of field: bkey_s_c_inline_data__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_c_inline_data__bindgen_ty_1__bindgen_ty_1, v)
        - 8usize];
};
impl Default for bkey_s_c_inline_data__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_inline_data__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_inline_data__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_inline_data__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_inline_data__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_inline_data__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_c_inline_data__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_c_inline_data__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_inline_data",
    ][::std::mem::size_of::<bkey_s_c_inline_data>() - 16usize];
    [
        "Alignment of bkey_s_c_inline_data",
    ][::std::mem::align_of::<bkey_s_c_inline_data>() - 8usize];
};
impl Default for bkey_s_c_inline_data {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_inline_data {
    pub __bindgen_anon_1: bkey_s_inline_data__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_inline_data__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_inline_data__bindgen_ty_1__bindgen_ty_1,
    pub c: bkey_s_c_inline_data,
    pub s: bkey_s,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_inline_data__bindgen_ty_1__bindgen_ty_1 {
    pub k: *mut bkey,
    pub v: *mut bch_inline_data,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_inline_data__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_inline_data__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_inline_data__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_inline_data__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_inline_data__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_inline_data__bindgen_ty_1__bindgen_ty_1, k)
        - 0usize];
    [
        "Offset of field: bkey_s_inline_data__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_inline_data__bindgen_ty_1__bindgen_ty_1, v)
        - 8usize];
};
impl Default for bkey_s_inline_data__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_inline_data__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_inline_data__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_inline_data__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_inline_data__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_inline_data__bindgen_ty_1::c",
    ][::std::mem::offset_of!(bkey_s_inline_data__bindgen_ty_1, c) - 0usize];
    [
        "Offset of field: bkey_s_inline_data__bindgen_ty_1::s",
    ][::std::mem::offset_of!(bkey_s_inline_data__bindgen_ty_1, s) - 0usize];
    [
        "Offset of field: bkey_s_inline_data__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_inline_data__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_inline_data__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_inline_data",
    ][::std::mem::size_of::<bkey_s_inline_data>() - 16usize];
    [
        "Alignment of bkey_s_inline_data",
    ][::std::mem::align_of::<bkey_s_inline_data>() - 8usize];
};
impl Default for bkey_s_inline_data {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bkey_i_btree_ptr_v2 {
    pub __bindgen_anon_1: bkey_i_btree_ptr_v2__bindgen_ty_1,
    pub v: bch_btree_ptr_v2,
}
#[repr(C)]
pub struct bkey_i_btree_ptr_v2__bindgen_ty_1 {
    pub k: __BindgenUnionField<bkey>,
    pub k_i: __BindgenUnionField<bkey_i>,
    pub bindgen_union_field: [u64; 5usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_btree_ptr_v2__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_i_btree_ptr_v2__bindgen_ty_1>() - 40usize];
    [
        "Alignment of bkey_i_btree_ptr_v2__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_i_btree_ptr_v2__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_i_btree_ptr_v2__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_i_btree_ptr_v2__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_i_btree_ptr_v2__bindgen_ty_1::k_i",
    ][::std::mem::offset_of!(bkey_i_btree_ptr_v2__bindgen_ty_1, k_i) - 0usize];
};
impl Default for bkey_i_btree_ptr_v2__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_btree_ptr_v2",
    ][::std::mem::size_of::<bkey_i_btree_ptr_v2>() - 80usize];
    [
        "Alignment of bkey_i_btree_ptr_v2",
    ][::std::mem::align_of::<bkey_i_btree_ptr_v2>() - 8usize];
    [
        "Offset of field: bkey_i_btree_ptr_v2::v",
    ][::std::mem::offset_of!(bkey_i_btree_ptr_v2, v) - 40usize];
};
impl Default for bkey_i_btree_ptr_v2 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_c_btree_ptr_v2 {
    pub __bindgen_anon_1: bkey_s_c_btree_ptr_v2__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_c_btree_ptr_v2__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_c_btree_ptr_v2__bindgen_ty_1__bindgen_ty_1,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_c_btree_ptr_v2__bindgen_ty_1__bindgen_ty_1 {
    pub k: *const bkey,
    pub v: *const bch_btree_ptr_v2,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_btree_ptr_v2__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_btree_ptr_v2__bindgen_ty_1__bindgen_ty_1>()
        - 16usize];
    [
        "Alignment of bkey_s_c_btree_ptr_v2__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_btree_ptr_v2__bindgen_ty_1__bindgen_ty_1>()
        - 8usize];
    [
        "Offset of field: bkey_s_c_btree_ptr_v2__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_c_btree_ptr_v2__bindgen_ty_1__bindgen_ty_1, k)
        - 0usize];
    [
        "Offset of field: bkey_s_c_btree_ptr_v2__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_c_btree_ptr_v2__bindgen_ty_1__bindgen_ty_1, v)
        - 8usize];
};
impl Default for bkey_s_c_btree_ptr_v2__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_btree_ptr_v2__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_btree_ptr_v2__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_btree_ptr_v2__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_btree_ptr_v2__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_btree_ptr_v2__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_c_btree_ptr_v2__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_c_btree_ptr_v2__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_btree_ptr_v2",
    ][::std::mem::size_of::<bkey_s_c_btree_ptr_v2>() - 16usize];
    [
        "Alignment of bkey_s_c_btree_ptr_v2",
    ][::std::mem::align_of::<bkey_s_c_btree_ptr_v2>() - 8usize];
};
impl Default for bkey_s_c_btree_ptr_v2 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_btree_ptr_v2 {
    pub __bindgen_anon_1: bkey_s_btree_ptr_v2__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_btree_ptr_v2__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_btree_ptr_v2__bindgen_ty_1__bindgen_ty_1,
    pub c: bkey_s_c_btree_ptr_v2,
    pub s: bkey_s,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_btree_ptr_v2__bindgen_ty_1__bindgen_ty_1 {
    pub k: *mut bkey,
    pub v: *mut bch_btree_ptr_v2,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_btree_ptr_v2__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_btree_ptr_v2__bindgen_ty_1__bindgen_ty_1>()
        - 16usize];
    [
        "Alignment of bkey_s_btree_ptr_v2__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_btree_ptr_v2__bindgen_ty_1__bindgen_ty_1>()
        - 8usize];
    [
        "Offset of field: bkey_s_btree_ptr_v2__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_btree_ptr_v2__bindgen_ty_1__bindgen_ty_1, k)
        - 0usize];
    [
        "Offset of field: bkey_s_btree_ptr_v2__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_btree_ptr_v2__bindgen_ty_1__bindgen_ty_1, v)
        - 8usize];
};
impl Default for bkey_s_btree_ptr_v2__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_btree_ptr_v2__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_btree_ptr_v2__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_btree_ptr_v2__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_btree_ptr_v2__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_btree_ptr_v2__bindgen_ty_1::c",
    ][::std::mem::offset_of!(bkey_s_btree_ptr_v2__bindgen_ty_1, c) - 0usize];
    [
        "Offset of field: bkey_s_btree_ptr_v2__bindgen_ty_1::s",
    ][::std::mem::offset_of!(bkey_s_btree_ptr_v2__bindgen_ty_1, s) - 0usize];
    [
        "Offset of field: bkey_s_btree_ptr_v2__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_btree_ptr_v2__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_btree_ptr_v2__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_btree_ptr_v2",
    ][::std::mem::size_of::<bkey_s_btree_ptr_v2>() - 16usize];
    [
        "Alignment of bkey_s_btree_ptr_v2",
    ][::std::mem::align_of::<bkey_s_btree_ptr_v2>() - 8usize];
};
impl Default for bkey_s_btree_ptr_v2 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bkey_i_indirect_inline_data {
    pub __bindgen_anon_1: bkey_i_indirect_inline_data__bindgen_ty_1,
    pub v: bch_indirect_inline_data,
}
#[repr(C)]
pub struct bkey_i_indirect_inline_data__bindgen_ty_1 {
    pub k: __BindgenUnionField<bkey>,
    pub k_i: __BindgenUnionField<bkey_i>,
    pub bindgen_union_field: [u64; 5usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_indirect_inline_data__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_i_indirect_inline_data__bindgen_ty_1>() - 40usize];
    [
        "Alignment of bkey_i_indirect_inline_data__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_i_indirect_inline_data__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_i_indirect_inline_data__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_i_indirect_inline_data__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_i_indirect_inline_data__bindgen_ty_1::k_i",
    ][::std::mem::offset_of!(bkey_i_indirect_inline_data__bindgen_ty_1, k_i) - 0usize];
};
impl Default for bkey_i_indirect_inline_data__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_indirect_inline_data",
    ][::std::mem::size_of::<bkey_i_indirect_inline_data>() - 48usize];
    [
        "Alignment of bkey_i_indirect_inline_data",
    ][::std::mem::align_of::<bkey_i_indirect_inline_data>() - 8usize];
    [
        "Offset of field: bkey_i_indirect_inline_data::v",
    ][::std::mem::offset_of!(bkey_i_indirect_inline_data, v) - 40usize];
};
impl Default for bkey_i_indirect_inline_data {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_c_indirect_inline_data {
    pub __bindgen_anon_1: bkey_s_c_indirect_inline_data__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_c_indirect_inline_data__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_c_indirect_inline_data__bindgen_ty_1__bindgen_ty_1,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_c_indirect_inline_data__bindgen_ty_1__bindgen_ty_1 {
    pub k: *const bkey,
    pub v: *const bch_indirect_inline_data,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_indirect_inline_data__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_indirect_inline_data__bindgen_ty_1__bindgen_ty_1>()
        - 16usize];
    [
        "Alignment of bkey_s_c_indirect_inline_data__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_indirect_inline_data__bindgen_ty_1__bindgen_ty_1>()
        - 8usize];
    [
        "Offset of field: bkey_s_c_indirect_inline_data__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(
        bkey_s_c_indirect_inline_data__bindgen_ty_1__bindgen_ty_1, k
    ) - 0usize];
    [
        "Offset of field: bkey_s_c_indirect_inline_data__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(
        bkey_s_c_indirect_inline_data__bindgen_ty_1__bindgen_ty_1, v
    ) - 8usize];
};
impl Default for bkey_s_c_indirect_inline_data__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_indirect_inline_data__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_indirect_inline_data__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_indirect_inline_data__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_indirect_inline_data__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_indirect_inline_data__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_c_indirect_inline_data__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_c_indirect_inline_data__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_indirect_inline_data",
    ][::std::mem::size_of::<bkey_s_c_indirect_inline_data>() - 16usize];
    [
        "Alignment of bkey_s_c_indirect_inline_data",
    ][::std::mem::align_of::<bkey_s_c_indirect_inline_data>() - 8usize];
};
impl Default for bkey_s_c_indirect_inline_data {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_indirect_inline_data {
    pub __bindgen_anon_1: bkey_s_indirect_inline_data__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_indirect_inline_data__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_indirect_inline_data__bindgen_ty_1__bindgen_ty_1,
    pub c: bkey_s_c_indirect_inline_data,
    pub s: bkey_s,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_indirect_inline_data__bindgen_ty_1__bindgen_ty_1 {
    pub k: *mut bkey,
    pub v: *mut bch_indirect_inline_data,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_indirect_inline_data__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_indirect_inline_data__bindgen_ty_1__bindgen_ty_1>()
        - 16usize];
    [
        "Alignment of bkey_s_indirect_inline_data__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_indirect_inline_data__bindgen_ty_1__bindgen_ty_1>()
        - 8usize];
    [
        "Offset of field: bkey_s_indirect_inline_data__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_indirect_inline_data__bindgen_ty_1__bindgen_ty_1, k)
        - 0usize];
    [
        "Offset of field: bkey_s_indirect_inline_data__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_indirect_inline_data__bindgen_ty_1__bindgen_ty_1, v)
        - 8usize];
};
impl Default for bkey_s_indirect_inline_data__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_indirect_inline_data__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_indirect_inline_data__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_indirect_inline_data__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_indirect_inline_data__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_indirect_inline_data__bindgen_ty_1::c",
    ][::std::mem::offset_of!(bkey_s_indirect_inline_data__bindgen_ty_1, c) - 0usize];
    [
        "Offset of field: bkey_s_indirect_inline_data__bindgen_ty_1::s",
    ][::std::mem::offset_of!(bkey_s_indirect_inline_data__bindgen_ty_1, s) - 0usize];
    [
        "Offset of field: bkey_s_indirect_inline_data__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_indirect_inline_data__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_indirect_inline_data__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_indirect_inline_data",
    ][::std::mem::size_of::<bkey_s_indirect_inline_data>() - 16usize];
    [
        "Alignment of bkey_s_indirect_inline_data",
    ][::std::mem::align_of::<bkey_s_indirect_inline_data>() - 8usize];
};
impl Default for bkey_s_indirect_inline_data {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bkey_i_alloc_v2 {
    pub __bindgen_anon_1: bkey_i_alloc_v2__bindgen_ty_1,
    pub v: bch_alloc_v2,
}
#[repr(C)]
pub struct bkey_i_alloc_v2__bindgen_ty_1 {
    pub k: __BindgenUnionField<bkey>,
    pub k_i: __BindgenUnionField<bkey_i>,
    pub bindgen_union_field: [u64; 5usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_alloc_v2__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_i_alloc_v2__bindgen_ty_1>() - 40usize];
    [
        "Alignment of bkey_i_alloc_v2__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_i_alloc_v2__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_i_alloc_v2__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_i_alloc_v2__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_i_alloc_v2__bindgen_ty_1::k_i",
    ][::std::mem::offset_of!(bkey_i_alloc_v2__bindgen_ty_1, k_i) - 0usize];
};
impl Default for bkey_i_alloc_v2__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_i_alloc_v2"][::std::mem::size_of::<bkey_i_alloc_v2>() - 48usize];
    ["Alignment of bkey_i_alloc_v2"][::std::mem::align_of::<bkey_i_alloc_v2>() - 8usize];
    [
        "Offset of field: bkey_i_alloc_v2::v",
    ][::std::mem::offset_of!(bkey_i_alloc_v2, v) - 40usize];
};
impl Default for bkey_i_alloc_v2 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_c_alloc_v2 {
    pub __bindgen_anon_1: bkey_s_c_alloc_v2__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_c_alloc_v2__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_c_alloc_v2__bindgen_ty_1__bindgen_ty_1,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_c_alloc_v2__bindgen_ty_1__bindgen_ty_1 {
    pub k: *const bkey,
    pub v: *const bch_alloc_v2,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_alloc_v2__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_alloc_v2__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_alloc_v2__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_alloc_v2__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_alloc_v2__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_c_alloc_v2__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_c_alloc_v2__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_c_alloc_v2__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_c_alloc_v2__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_alloc_v2__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_alloc_v2__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_alloc_v2__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_alloc_v2__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_alloc_v2__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_c_alloc_v2__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_c_alloc_v2__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_c_alloc_v2"][::std::mem::size_of::<bkey_s_c_alloc_v2>() - 16usize];
    [
        "Alignment of bkey_s_c_alloc_v2",
    ][::std::mem::align_of::<bkey_s_c_alloc_v2>() - 8usize];
};
impl Default for bkey_s_c_alloc_v2 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_alloc_v2 {
    pub __bindgen_anon_1: bkey_s_alloc_v2__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_alloc_v2__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_alloc_v2__bindgen_ty_1__bindgen_ty_1,
    pub c: bkey_s_c_alloc_v2,
    pub s: bkey_s,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_alloc_v2__bindgen_ty_1__bindgen_ty_1 {
    pub k: *mut bkey,
    pub v: *mut bch_alloc_v2,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_alloc_v2__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_alloc_v2__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_alloc_v2__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_alloc_v2__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_alloc_v2__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_alloc_v2__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_alloc_v2__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_alloc_v2__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_alloc_v2__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_alloc_v2__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_alloc_v2__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_alloc_v2__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_alloc_v2__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_alloc_v2__bindgen_ty_1::c",
    ][::std::mem::offset_of!(bkey_s_alloc_v2__bindgen_ty_1, c) - 0usize];
    [
        "Offset of field: bkey_s_alloc_v2__bindgen_ty_1::s",
    ][::std::mem::offset_of!(bkey_s_alloc_v2__bindgen_ty_1, s) - 0usize];
    [
        "Offset of field: bkey_s_alloc_v2__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_alloc_v2__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_alloc_v2__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_alloc_v2"][::std::mem::size_of::<bkey_s_alloc_v2>() - 16usize];
    ["Alignment of bkey_s_alloc_v2"][::std::mem::align_of::<bkey_s_alloc_v2>() - 8usize];
};
impl Default for bkey_s_alloc_v2 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bkey_i_subvolume {
    pub __bindgen_anon_1: bkey_i_subvolume__bindgen_ty_1,
    pub v: bch_subvolume,
}
#[repr(C)]
pub struct bkey_i_subvolume__bindgen_ty_1 {
    pub k: __BindgenUnionField<bkey>,
    pub k_i: __BindgenUnionField<bkey_i>,
    pub bindgen_union_field: [u64; 5usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_subvolume__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_i_subvolume__bindgen_ty_1>() - 40usize];
    [
        "Alignment of bkey_i_subvolume__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_i_subvolume__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_i_subvolume__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_i_subvolume__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_i_subvolume__bindgen_ty_1::k_i",
    ][::std::mem::offset_of!(bkey_i_subvolume__bindgen_ty_1, k_i) - 0usize];
};
impl Default for bkey_i_subvolume__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_i_subvolume"][::std::mem::size_of::<bkey_i_subvolume>() - 80usize];
    [
        "Alignment of bkey_i_subvolume",
    ][::std::mem::align_of::<bkey_i_subvolume>() - 8usize];
    [
        "Offset of field: bkey_i_subvolume::v",
    ][::std::mem::offset_of!(bkey_i_subvolume, v) - 40usize];
};
impl Default for bkey_i_subvolume {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_c_subvolume {
    pub __bindgen_anon_1: bkey_s_c_subvolume__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_c_subvolume__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_c_subvolume__bindgen_ty_1__bindgen_ty_1,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_c_subvolume__bindgen_ty_1__bindgen_ty_1 {
    pub k: *const bkey,
    pub v: *const bch_subvolume,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_subvolume__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_subvolume__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_subvolume__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_subvolume__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_subvolume__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_c_subvolume__bindgen_ty_1__bindgen_ty_1, k)
        - 0usize];
    [
        "Offset of field: bkey_s_c_subvolume__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_c_subvolume__bindgen_ty_1__bindgen_ty_1, v)
        - 8usize];
};
impl Default for bkey_s_c_subvolume__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_subvolume__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_subvolume__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_subvolume__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_subvolume__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_subvolume__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_c_subvolume__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_c_subvolume__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_subvolume",
    ][::std::mem::size_of::<bkey_s_c_subvolume>() - 16usize];
    [
        "Alignment of bkey_s_c_subvolume",
    ][::std::mem::align_of::<bkey_s_c_subvolume>() - 8usize];
};
impl Default for bkey_s_c_subvolume {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_subvolume {
    pub __bindgen_anon_1: bkey_s_subvolume__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_subvolume__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_subvolume__bindgen_ty_1__bindgen_ty_1,
    pub c: bkey_s_c_subvolume,
    pub s: bkey_s,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_subvolume__bindgen_ty_1__bindgen_ty_1 {
    pub k: *mut bkey,
    pub v: *mut bch_subvolume,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_subvolume__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_subvolume__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_subvolume__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_subvolume__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_subvolume__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_subvolume__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_subvolume__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_subvolume__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_subvolume__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_subvolume__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_subvolume__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_subvolume__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_subvolume__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_subvolume__bindgen_ty_1::c",
    ][::std::mem::offset_of!(bkey_s_subvolume__bindgen_ty_1, c) - 0usize];
    [
        "Offset of field: bkey_s_subvolume__bindgen_ty_1::s",
    ][::std::mem::offset_of!(bkey_s_subvolume__bindgen_ty_1, s) - 0usize];
    [
        "Offset of field: bkey_s_subvolume__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_subvolume__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_subvolume__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_subvolume"][::std::mem::size_of::<bkey_s_subvolume>() - 16usize];
    [
        "Alignment of bkey_s_subvolume",
    ][::std::mem::align_of::<bkey_s_subvolume>() - 8usize];
};
impl Default for bkey_s_subvolume {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bkey_i_snapshot {
    pub __bindgen_anon_1: bkey_i_snapshot__bindgen_ty_1,
    pub v: bch_snapshot,
}
#[repr(C)]
pub struct bkey_i_snapshot__bindgen_ty_1 {
    pub k: __BindgenUnionField<bkey>,
    pub k_i: __BindgenUnionField<bkey_i>,
    pub bindgen_union_field: [u64; 5usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_snapshot__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_i_snapshot__bindgen_ty_1>() - 40usize];
    [
        "Alignment of bkey_i_snapshot__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_i_snapshot__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_i_snapshot__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_i_snapshot__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_i_snapshot__bindgen_ty_1::k_i",
    ][::std::mem::offset_of!(bkey_i_snapshot__bindgen_ty_1, k_i) - 0usize];
};
impl Default for bkey_i_snapshot__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_i_snapshot"][::std::mem::size_of::<bkey_i_snapshot>() - 96usize];
    ["Alignment of bkey_i_snapshot"][::std::mem::align_of::<bkey_i_snapshot>() - 8usize];
    [
        "Offset of field: bkey_i_snapshot::v",
    ][::std::mem::offset_of!(bkey_i_snapshot, v) - 40usize];
};
impl Default for bkey_i_snapshot {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_c_snapshot {
    pub __bindgen_anon_1: bkey_s_c_snapshot__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_c_snapshot__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_c_snapshot__bindgen_ty_1__bindgen_ty_1,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_c_snapshot__bindgen_ty_1__bindgen_ty_1 {
    pub k: *const bkey,
    pub v: *const bch_snapshot,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_snapshot__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_snapshot__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_snapshot__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_snapshot__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_snapshot__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_c_snapshot__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_c_snapshot__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_c_snapshot__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_c_snapshot__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_snapshot__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_snapshot__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_snapshot__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_snapshot__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_snapshot__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_c_snapshot__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_c_snapshot__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_c_snapshot"][::std::mem::size_of::<bkey_s_c_snapshot>() - 16usize];
    [
        "Alignment of bkey_s_c_snapshot",
    ][::std::mem::align_of::<bkey_s_c_snapshot>() - 8usize];
};
impl Default for bkey_s_c_snapshot {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_snapshot {
    pub __bindgen_anon_1: bkey_s_snapshot__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_snapshot__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_snapshot__bindgen_ty_1__bindgen_ty_1,
    pub c: bkey_s_c_snapshot,
    pub s: bkey_s,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_snapshot__bindgen_ty_1__bindgen_ty_1 {
    pub k: *mut bkey,
    pub v: *mut bch_snapshot,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_snapshot__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_snapshot__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_snapshot__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_snapshot__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_snapshot__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_snapshot__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_snapshot__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_snapshot__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_snapshot__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_snapshot__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_snapshot__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_snapshot__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_snapshot__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_snapshot__bindgen_ty_1::c",
    ][::std::mem::offset_of!(bkey_s_snapshot__bindgen_ty_1, c) - 0usize];
    [
        "Offset of field: bkey_s_snapshot__bindgen_ty_1::s",
    ][::std::mem::offset_of!(bkey_s_snapshot__bindgen_ty_1, s) - 0usize];
    [
        "Offset of field: bkey_s_snapshot__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_snapshot__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_snapshot__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_snapshot"][::std::mem::size_of::<bkey_s_snapshot>() - 16usize];
    ["Alignment of bkey_s_snapshot"][::std::mem::align_of::<bkey_s_snapshot>() - 8usize];
};
impl Default for bkey_s_snapshot {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bkey_i_inode_v2 {
    pub __bindgen_anon_1: bkey_i_inode_v2__bindgen_ty_1,
    pub v: bch_inode_v2,
}
#[repr(C)]
pub struct bkey_i_inode_v2__bindgen_ty_1 {
    pub k: __BindgenUnionField<bkey>,
    pub k_i: __BindgenUnionField<bkey_i>,
    pub bindgen_union_field: [u64; 5usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_inode_v2__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_i_inode_v2__bindgen_ty_1>() - 40usize];
    [
        "Alignment of bkey_i_inode_v2__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_i_inode_v2__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_i_inode_v2__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_i_inode_v2__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_i_inode_v2__bindgen_ty_1::k_i",
    ][::std::mem::offset_of!(bkey_i_inode_v2__bindgen_ty_1, k_i) - 0usize];
};
impl Default for bkey_i_inode_v2__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_i_inode_v2"][::std::mem::size_of::<bkey_i_inode_v2>() - 72usize];
    ["Alignment of bkey_i_inode_v2"][::std::mem::align_of::<bkey_i_inode_v2>() - 8usize];
    [
        "Offset of field: bkey_i_inode_v2::v",
    ][::std::mem::offset_of!(bkey_i_inode_v2, v) - 40usize];
};
impl Default for bkey_i_inode_v2 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_c_inode_v2 {
    pub __bindgen_anon_1: bkey_s_c_inode_v2__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_c_inode_v2__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_c_inode_v2__bindgen_ty_1__bindgen_ty_1,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_c_inode_v2__bindgen_ty_1__bindgen_ty_1 {
    pub k: *const bkey,
    pub v: *const bch_inode_v2,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_inode_v2__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_inode_v2__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_inode_v2__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_inode_v2__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_inode_v2__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_c_inode_v2__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_c_inode_v2__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_c_inode_v2__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_c_inode_v2__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_inode_v2__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_inode_v2__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_inode_v2__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_inode_v2__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_inode_v2__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_c_inode_v2__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_c_inode_v2__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_c_inode_v2"][::std::mem::size_of::<bkey_s_c_inode_v2>() - 16usize];
    [
        "Alignment of bkey_s_c_inode_v2",
    ][::std::mem::align_of::<bkey_s_c_inode_v2>() - 8usize];
};
impl Default for bkey_s_c_inode_v2 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_inode_v2 {
    pub __bindgen_anon_1: bkey_s_inode_v2__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_inode_v2__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_inode_v2__bindgen_ty_1__bindgen_ty_1,
    pub c: bkey_s_c_inode_v2,
    pub s: bkey_s,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_inode_v2__bindgen_ty_1__bindgen_ty_1 {
    pub k: *mut bkey,
    pub v: *mut bch_inode_v2,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_inode_v2__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_inode_v2__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_inode_v2__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_inode_v2__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_inode_v2__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_inode_v2__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_inode_v2__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_inode_v2__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_inode_v2__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_inode_v2__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_inode_v2__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_inode_v2__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_inode_v2__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_inode_v2__bindgen_ty_1::c",
    ][::std::mem::offset_of!(bkey_s_inode_v2__bindgen_ty_1, c) - 0usize];
    [
        "Offset of field: bkey_s_inode_v2__bindgen_ty_1::s",
    ][::std::mem::offset_of!(bkey_s_inode_v2__bindgen_ty_1, s) - 0usize];
    [
        "Offset of field: bkey_s_inode_v2__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_inode_v2__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_inode_v2__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_inode_v2"][::std::mem::size_of::<bkey_s_inode_v2>() - 16usize];
    ["Alignment of bkey_s_inode_v2"][::std::mem::align_of::<bkey_s_inode_v2>() - 8usize];
};
impl Default for bkey_s_inode_v2 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bkey_i_alloc_v3 {
    pub __bindgen_anon_1: bkey_i_alloc_v3__bindgen_ty_1,
    pub v: bch_alloc_v3,
}
#[repr(C)]
pub struct bkey_i_alloc_v3__bindgen_ty_1 {
    pub k: __BindgenUnionField<bkey>,
    pub k_i: __BindgenUnionField<bkey_i>,
    pub bindgen_union_field: [u64; 5usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_alloc_v3__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_i_alloc_v3__bindgen_ty_1>() - 40usize];
    [
        "Alignment of bkey_i_alloc_v3__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_i_alloc_v3__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_i_alloc_v3__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_i_alloc_v3__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_i_alloc_v3__bindgen_ty_1::k_i",
    ][::std::mem::offset_of!(bkey_i_alloc_v3__bindgen_ty_1, k_i) - 0usize];
};
impl Default for bkey_i_alloc_v3__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_i_alloc_v3"][::std::mem::size_of::<bkey_i_alloc_v3>() - 56usize];
    ["Alignment of bkey_i_alloc_v3"][::std::mem::align_of::<bkey_i_alloc_v3>() - 8usize];
    [
        "Offset of field: bkey_i_alloc_v3::v",
    ][::std::mem::offset_of!(bkey_i_alloc_v3, v) - 40usize];
};
impl Default for bkey_i_alloc_v3 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_c_alloc_v3 {
    pub __bindgen_anon_1: bkey_s_c_alloc_v3__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_c_alloc_v3__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_c_alloc_v3__bindgen_ty_1__bindgen_ty_1,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_c_alloc_v3__bindgen_ty_1__bindgen_ty_1 {
    pub k: *const bkey,
    pub v: *const bch_alloc_v3,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_alloc_v3__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_alloc_v3__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_alloc_v3__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_alloc_v3__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_alloc_v3__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_c_alloc_v3__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_c_alloc_v3__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_c_alloc_v3__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_c_alloc_v3__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_alloc_v3__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_alloc_v3__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_alloc_v3__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_alloc_v3__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_alloc_v3__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_c_alloc_v3__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_c_alloc_v3__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_c_alloc_v3"][::std::mem::size_of::<bkey_s_c_alloc_v3>() - 16usize];
    [
        "Alignment of bkey_s_c_alloc_v3",
    ][::std::mem::align_of::<bkey_s_c_alloc_v3>() - 8usize];
};
impl Default for bkey_s_c_alloc_v3 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_alloc_v3 {
    pub __bindgen_anon_1: bkey_s_alloc_v3__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_alloc_v3__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_alloc_v3__bindgen_ty_1__bindgen_ty_1,
    pub c: bkey_s_c_alloc_v3,
    pub s: bkey_s,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_alloc_v3__bindgen_ty_1__bindgen_ty_1 {
    pub k: *mut bkey,
    pub v: *mut bch_alloc_v3,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_alloc_v3__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_alloc_v3__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_alloc_v3__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_alloc_v3__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_alloc_v3__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_alloc_v3__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_alloc_v3__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_alloc_v3__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_alloc_v3__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_alloc_v3__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_alloc_v3__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_alloc_v3__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_alloc_v3__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_alloc_v3__bindgen_ty_1::c",
    ][::std::mem::offset_of!(bkey_s_alloc_v3__bindgen_ty_1, c) - 0usize];
    [
        "Offset of field: bkey_s_alloc_v3__bindgen_ty_1::s",
    ][::std::mem::offset_of!(bkey_s_alloc_v3__bindgen_ty_1, s) - 0usize];
    [
        "Offset of field: bkey_s_alloc_v3__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_alloc_v3__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_alloc_v3__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_alloc_v3"][::std::mem::size_of::<bkey_s_alloc_v3>() - 16usize];
    ["Alignment of bkey_s_alloc_v3"][::std::mem::align_of::<bkey_s_alloc_v3>() - 8usize];
};
impl Default for bkey_s_alloc_v3 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bkey_i_set {
    pub __bindgen_anon_1: bkey_i_set__bindgen_ty_1,
    pub v: bch_set,
}
#[repr(C)]
pub struct bkey_i_set__bindgen_ty_1 {
    pub k: __BindgenUnionField<bkey>,
    pub k_i: __BindgenUnionField<bkey_i>,
    pub bindgen_union_field: [u64; 5usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_set__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_i_set__bindgen_ty_1>() - 40usize];
    [
        "Alignment of bkey_i_set__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_i_set__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_i_set__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_i_set__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_i_set__bindgen_ty_1::k_i",
    ][::std::mem::offset_of!(bkey_i_set__bindgen_ty_1, k_i) - 0usize];
};
impl Default for bkey_i_set__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_i_set"][::std::mem::size_of::<bkey_i_set>() - 40usize];
    ["Alignment of bkey_i_set"][::std::mem::align_of::<bkey_i_set>() - 8usize];
    ["Offset of field: bkey_i_set::v"][::std::mem::offset_of!(bkey_i_set, v) - 40usize];
};
impl Default for bkey_i_set {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_c_set {
    pub __bindgen_anon_1: bkey_s_c_set__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_c_set__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_c_set__bindgen_ty_1__bindgen_ty_1,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_c_set__bindgen_ty_1__bindgen_ty_1 {
    pub k: *const bkey,
    pub v: *const bch_set,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_set__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_set__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_set__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_set__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_set__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_c_set__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_c_set__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_c_set__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_c_set__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_set__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_set__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_set__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_set__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_set__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_c_set__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_c_set__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_c_set"][::std::mem::size_of::<bkey_s_c_set>() - 16usize];
    ["Alignment of bkey_s_c_set"][::std::mem::align_of::<bkey_s_c_set>() - 8usize];
};
impl Default for bkey_s_c_set {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_set {
    pub __bindgen_anon_1: bkey_s_set__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_set__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_set__bindgen_ty_1__bindgen_ty_1,
    pub c: bkey_s_c_set,
    pub s: bkey_s,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_set__bindgen_ty_1__bindgen_ty_1 {
    pub k: *mut bkey,
    pub v: *mut bch_set,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_set__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_set__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_set__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_set__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_set__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_set__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_set__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_set__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_set__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_set__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_set__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_set__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_set__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_set__bindgen_ty_1::c",
    ][::std::mem::offset_of!(bkey_s_set__bindgen_ty_1, c) - 0usize];
    [
        "Offset of field: bkey_s_set__bindgen_ty_1::s",
    ][::std::mem::offset_of!(bkey_s_set__bindgen_ty_1, s) - 0usize];
    [
        "Offset of field: bkey_s_set__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_set__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_set__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_set"][::std::mem::size_of::<bkey_s_set>() - 16usize];
    ["Alignment of bkey_s_set"][::std::mem::align_of::<bkey_s_set>() - 8usize];
};
impl Default for bkey_s_set {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bkey_i_lru {
    pub __bindgen_anon_1: bkey_i_lru__bindgen_ty_1,
    pub v: bch_lru,
}
#[repr(C)]
pub struct bkey_i_lru__bindgen_ty_1 {
    pub k: __BindgenUnionField<bkey>,
    pub k_i: __BindgenUnionField<bkey_i>,
    pub bindgen_union_field: [u64; 5usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_lru__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_i_lru__bindgen_ty_1>() - 40usize];
    [
        "Alignment of bkey_i_lru__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_i_lru__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_i_lru__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_i_lru__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_i_lru__bindgen_ty_1::k_i",
    ][::std::mem::offset_of!(bkey_i_lru__bindgen_ty_1, k_i) - 0usize];
};
impl Default for bkey_i_lru__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_i_lru"][::std::mem::size_of::<bkey_i_lru>() - 48usize];
    ["Alignment of bkey_i_lru"][::std::mem::align_of::<bkey_i_lru>() - 8usize];
    ["Offset of field: bkey_i_lru::v"][::std::mem::offset_of!(bkey_i_lru, v) - 40usize];
};
impl Default for bkey_i_lru {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_c_lru {
    pub __bindgen_anon_1: bkey_s_c_lru__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_c_lru__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_c_lru__bindgen_ty_1__bindgen_ty_1,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_c_lru__bindgen_ty_1__bindgen_ty_1 {
    pub k: *const bkey,
    pub v: *const bch_lru,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_lru__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_lru__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_lru__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_lru__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_lru__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_c_lru__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_c_lru__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_c_lru__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_c_lru__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_lru__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_lru__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_lru__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_lru__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_lru__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_c_lru__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_c_lru__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_c_lru"][::std::mem::size_of::<bkey_s_c_lru>() - 16usize];
    ["Alignment of bkey_s_c_lru"][::std::mem::align_of::<bkey_s_c_lru>() - 8usize];
};
impl Default for bkey_s_c_lru {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_lru {
    pub __bindgen_anon_1: bkey_s_lru__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_lru__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_lru__bindgen_ty_1__bindgen_ty_1,
    pub c: bkey_s_c_lru,
    pub s: bkey_s,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_lru__bindgen_ty_1__bindgen_ty_1 {
    pub k: *mut bkey,
    pub v: *mut bch_lru,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_lru__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_lru__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_lru__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_lru__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_lru__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_lru__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_lru__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_lru__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_lru__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_lru__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_lru__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_lru__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_lru__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_lru__bindgen_ty_1::c",
    ][::std::mem::offset_of!(bkey_s_lru__bindgen_ty_1, c) - 0usize];
    [
        "Offset of field: bkey_s_lru__bindgen_ty_1::s",
    ][::std::mem::offset_of!(bkey_s_lru__bindgen_ty_1, s) - 0usize];
    [
        "Offset of field: bkey_s_lru__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_lru__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_lru__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_lru"][::std::mem::size_of::<bkey_s_lru>() - 16usize];
    ["Alignment of bkey_s_lru"][::std::mem::align_of::<bkey_s_lru>() - 8usize];
};
impl Default for bkey_s_lru {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bkey_i_alloc_v4 {
    pub __bindgen_anon_1: bkey_i_alloc_v4__bindgen_ty_1,
    pub v: bch_alloc_v4,
}
#[repr(C)]
pub struct bkey_i_alloc_v4__bindgen_ty_1 {
    pub k: __BindgenUnionField<bkey>,
    pub k_i: __BindgenUnionField<bkey_i>,
    pub bindgen_union_field: [u64; 5usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_alloc_v4__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_i_alloc_v4__bindgen_ty_1>() - 40usize];
    [
        "Alignment of bkey_i_alloc_v4__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_i_alloc_v4__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_i_alloc_v4__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_i_alloc_v4__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_i_alloc_v4__bindgen_ty_1::k_i",
    ][::std::mem::offset_of!(bkey_i_alloc_v4__bindgen_ty_1, k_i) - 0usize];
};
impl Default for bkey_i_alloc_v4__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_i_alloc_v4"][::std::mem::size_of::<bkey_i_alloc_v4>() - 104usize];
    ["Alignment of bkey_i_alloc_v4"][::std::mem::align_of::<bkey_i_alloc_v4>() - 8usize];
    [
        "Offset of field: bkey_i_alloc_v4::v",
    ][::std::mem::offset_of!(bkey_i_alloc_v4, v) - 40usize];
};
impl Default for bkey_i_alloc_v4 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_c_alloc_v4 {
    pub __bindgen_anon_1: bkey_s_c_alloc_v4__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_c_alloc_v4__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_c_alloc_v4__bindgen_ty_1__bindgen_ty_1,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_c_alloc_v4__bindgen_ty_1__bindgen_ty_1 {
    pub k: *const bkey,
    pub v: *const bch_alloc_v4,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_alloc_v4__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_alloc_v4__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_alloc_v4__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_alloc_v4__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_alloc_v4__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_c_alloc_v4__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_c_alloc_v4__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_c_alloc_v4__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_c_alloc_v4__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_alloc_v4__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_alloc_v4__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_alloc_v4__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_alloc_v4__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_alloc_v4__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_c_alloc_v4__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_c_alloc_v4__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_c_alloc_v4"][::std::mem::size_of::<bkey_s_c_alloc_v4>() - 16usize];
    [
        "Alignment of bkey_s_c_alloc_v4",
    ][::std::mem::align_of::<bkey_s_c_alloc_v4>() - 8usize];
};
impl Default for bkey_s_c_alloc_v4 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_alloc_v4 {
    pub __bindgen_anon_1: bkey_s_alloc_v4__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_alloc_v4__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_alloc_v4__bindgen_ty_1__bindgen_ty_1,
    pub c: bkey_s_c_alloc_v4,
    pub s: bkey_s,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_alloc_v4__bindgen_ty_1__bindgen_ty_1 {
    pub k: *mut bkey,
    pub v: *mut bch_alloc_v4,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_alloc_v4__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_alloc_v4__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_alloc_v4__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_alloc_v4__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_alloc_v4__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_alloc_v4__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_alloc_v4__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_alloc_v4__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_alloc_v4__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_alloc_v4__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_alloc_v4__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_alloc_v4__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_alloc_v4__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_alloc_v4__bindgen_ty_1::c",
    ][::std::mem::offset_of!(bkey_s_alloc_v4__bindgen_ty_1, c) - 0usize];
    [
        "Offset of field: bkey_s_alloc_v4__bindgen_ty_1::s",
    ][::std::mem::offset_of!(bkey_s_alloc_v4__bindgen_ty_1, s) - 0usize];
    [
        "Offset of field: bkey_s_alloc_v4__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_alloc_v4__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_alloc_v4__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_alloc_v4"][::std::mem::size_of::<bkey_s_alloc_v4>() - 16usize];
    ["Alignment of bkey_s_alloc_v4"][::std::mem::align_of::<bkey_s_alloc_v4>() - 8usize];
};
impl Default for bkey_s_alloc_v4 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bkey_i_backpointer {
    pub __bindgen_anon_1: bkey_i_backpointer__bindgen_ty_1,
    pub v: bch_backpointer,
}
#[repr(C)]
pub struct bkey_i_backpointer__bindgen_ty_1 {
    pub k: __BindgenUnionField<bkey>,
    pub k_i: __BindgenUnionField<bkey_i>,
    pub bindgen_union_field: [u64; 5usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_backpointer__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_i_backpointer__bindgen_ty_1>() - 40usize];
    [
        "Alignment of bkey_i_backpointer__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_i_backpointer__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_i_backpointer__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_i_backpointer__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_i_backpointer__bindgen_ty_1::k_i",
    ][::std::mem::offset_of!(bkey_i_backpointer__bindgen_ty_1, k_i) - 0usize];
};
impl Default for bkey_i_backpointer__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_backpointer",
    ][::std::mem::size_of::<bkey_i_backpointer>() - 72usize];
    [
        "Alignment of bkey_i_backpointer",
    ][::std::mem::align_of::<bkey_i_backpointer>() - 8usize];
    [
        "Offset of field: bkey_i_backpointer::v",
    ][::std::mem::offset_of!(bkey_i_backpointer, v) - 40usize];
};
impl Default for bkey_i_backpointer {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_c_backpointer {
    pub __bindgen_anon_1: bkey_s_c_backpointer__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_c_backpointer__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_c_backpointer__bindgen_ty_1__bindgen_ty_1,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_c_backpointer__bindgen_ty_1__bindgen_ty_1 {
    pub k: *const bkey,
    pub v: *const bch_backpointer,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_backpointer__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_backpointer__bindgen_ty_1__bindgen_ty_1>()
        - 16usize];
    [
        "Alignment of bkey_s_c_backpointer__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_backpointer__bindgen_ty_1__bindgen_ty_1>()
        - 8usize];
    [
        "Offset of field: bkey_s_c_backpointer__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_c_backpointer__bindgen_ty_1__bindgen_ty_1, k)
        - 0usize];
    [
        "Offset of field: bkey_s_c_backpointer__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_c_backpointer__bindgen_ty_1__bindgen_ty_1, v)
        - 8usize];
};
impl Default for bkey_s_c_backpointer__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_backpointer__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_backpointer__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_backpointer__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_backpointer__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_backpointer__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_c_backpointer__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_c_backpointer__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_backpointer",
    ][::std::mem::size_of::<bkey_s_c_backpointer>() - 16usize];
    [
        "Alignment of bkey_s_c_backpointer",
    ][::std::mem::align_of::<bkey_s_c_backpointer>() - 8usize];
};
impl Default for bkey_s_c_backpointer {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_backpointer {
    pub __bindgen_anon_1: bkey_s_backpointer__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_backpointer__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_backpointer__bindgen_ty_1__bindgen_ty_1,
    pub c: bkey_s_c_backpointer,
    pub s: bkey_s,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_backpointer__bindgen_ty_1__bindgen_ty_1 {
    pub k: *mut bkey,
    pub v: *mut bch_backpointer,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_backpointer__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_backpointer__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_backpointer__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_backpointer__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_backpointer__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_backpointer__bindgen_ty_1__bindgen_ty_1, k)
        - 0usize];
    [
        "Offset of field: bkey_s_backpointer__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_backpointer__bindgen_ty_1__bindgen_ty_1, v)
        - 8usize];
};
impl Default for bkey_s_backpointer__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_backpointer__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_backpointer__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_backpointer__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_backpointer__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_backpointer__bindgen_ty_1::c",
    ][::std::mem::offset_of!(bkey_s_backpointer__bindgen_ty_1, c) - 0usize];
    [
        "Offset of field: bkey_s_backpointer__bindgen_ty_1::s",
    ][::std::mem::offset_of!(bkey_s_backpointer__bindgen_ty_1, s) - 0usize];
    [
        "Offset of field: bkey_s_backpointer__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_backpointer__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_backpointer__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_backpointer",
    ][::std::mem::size_of::<bkey_s_backpointer>() - 16usize];
    [
        "Alignment of bkey_s_backpointer",
    ][::std::mem::align_of::<bkey_s_backpointer>() - 8usize];
};
impl Default for bkey_s_backpointer {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bkey_i_inode_v3 {
    pub __bindgen_anon_1: bkey_i_inode_v3__bindgen_ty_1,
    pub v: bch_inode_v3,
}
#[repr(C)]
pub struct bkey_i_inode_v3__bindgen_ty_1 {
    pub k: __BindgenUnionField<bkey>,
    pub k_i: __BindgenUnionField<bkey_i>,
    pub bindgen_union_field: [u64; 5usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_inode_v3__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_i_inode_v3__bindgen_ty_1>() - 40usize];
    [
        "Alignment of bkey_i_inode_v3__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_i_inode_v3__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_i_inode_v3__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_i_inode_v3__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_i_inode_v3__bindgen_ty_1::k_i",
    ][::std::mem::offset_of!(bkey_i_inode_v3__bindgen_ty_1, k_i) - 0usize];
};
impl Default for bkey_i_inode_v3__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_i_inode_v3"][::std::mem::size_of::<bkey_i_inode_v3>() - 88usize];
    ["Alignment of bkey_i_inode_v3"][::std::mem::align_of::<bkey_i_inode_v3>() - 8usize];
    [
        "Offset of field: bkey_i_inode_v3::v",
    ][::std::mem::offset_of!(bkey_i_inode_v3, v) - 40usize];
};
impl Default for bkey_i_inode_v3 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_c_inode_v3 {
    pub __bindgen_anon_1: bkey_s_c_inode_v3__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_c_inode_v3__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_c_inode_v3__bindgen_ty_1__bindgen_ty_1,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_c_inode_v3__bindgen_ty_1__bindgen_ty_1 {
    pub k: *const bkey,
    pub v: *const bch_inode_v3,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_inode_v3__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_inode_v3__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_inode_v3__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_inode_v3__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_inode_v3__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_c_inode_v3__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_c_inode_v3__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_c_inode_v3__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_c_inode_v3__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_inode_v3__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_inode_v3__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_inode_v3__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_inode_v3__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_inode_v3__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_c_inode_v3__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_c_inode_v3__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_c_inode_v3"][::std::mem::size_of::<bkey_s_c_inode_v3>() - 16usize];
    [
        "Alignment of bkey_s_c_inode_v3",
    ][::std::mem::align_of::<bkey_s_c_inode_v3>() - 8usize];
};
impl Default for bkey_s_c_inode_v3 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_inode_v3 {
    pub __bindgen_anon_1: bkey_s_inode_v3__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_inode_v3__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_inode_v3__bindgen_ty_1__bindgen_ty_1,
    pub c: bkey_s_c_inode_v3,
    pub s: bkey_s,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_inode_v3__bindgen_ty_1__bindgen_ty_1 {
    pub k: *mut bkey,
    pub v: *mut bch_inode_v3,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_inode_v3__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_inode_v3__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_inode_v3__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_inode_v3__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_inode_v3__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_inode_v3__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_inode_v3__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_inode_v3__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_inode_v3__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_inode_v3__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_inode_v3__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_inode_v3__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_inode_v3__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_inode_v3__bindgen_ty_1::c",
    ][::std::mem::offset_of!(bkey_s_inode_v3__bindgen_ty_1, c) - 0usize];
    [
        "Offset of field: bkey_s_inode_v3__bindgen_ty_1::s",
    ][::std::mem::offset_of!(bkey_s_inode_v3__bindgen_ty_1, s) - 0usize];
    [
        "Offset of field: bkey_s_inode_v3__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_inode_v3__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_inode_v3__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_inode_v3"][::std::mem::size_of::<bkey_s_inode_v3>() - 16usize];
    ["Alignment of bkey_s_inode_v3"][::std::mem::align_of::<bkey_s_inode_v3>() - 8usize];
};
impl Default for bkey_s_inode_v3 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bkey_i_bucket_gens {
    pub __bindgen_anon_1: bkey_i_bucket_gens__bindgen_ty_1,
    pub v: bch_bucket_gens,
}
#[repr(C)]
pub struct bkey_i_bucket_gens__bindgen_ty_1 {
    pub k: __BindgenUnionField<bkey>,
    pub k_i: __BindgenUnionField<bkey_i>,
    pub bindgen_union_field: [u64; 5usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_bucket_gens__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_i_bucket_gens__bindgen_ty_1>() - 40usize];
    [
        "Alignment of bkey_i_bucket_gens__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_i_bucket_gens__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_i_bucket_gens__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_i_bucket_gens__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_i_bucket_gens__bindgen_ty_1::k_i",
    ][::std::mem::offset_of!(bkey_i_bucket_gens__bindgen_ty_1, k_i) - 0usize];
};
impl Default for bkey_i_bucket_gens__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_bucket_gens",
    ][::std::mem::size_of::<bkey_i_bucket_gens>() - 296usize];
    [
        "Alignment of bkey_i_bucket_gens",
    ][::std::mem::align_of::<bkey_i_bucket_gens>() - 8usize];
    [
        "Offset of field: bkey_i_bucket_gens::v",
    ][::std::mem::offset_of!(bkey_i_bucket_gens, v) - 40usize];
};
impl Default for bkey_i_bucket_gens {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_c_bucket_gens {
    pub __bindgen_anon_1: bkey_s_c_bucket_gens__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_c_bucket_gens__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_c_bucket_gens__bindgen_ty_1__bindgen_ty_1,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_c_bucket_gens__bindgen_ty_1__bindgen_ty_1 {
    pub k: *const bkey,
    pub v: *const bch_bucket_gens,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_bucket_gens__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_bucket_gens__bindgen_ty_1__bindgen_ty_1>()
        - 16usize];
    [
        "Alignment of bkey_s_c_bucket_gens__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_bucket_gens__bindgen_ty_1__bindgen_ty_1>()
        - 8usize];
    [
        "Offset of field: bkey_s_c_bucket_gens__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_c_bucket_gens__bindgen_ty_1__bindgen_ty_1, k)
        - 0usize];
    [
        "Offset of field: bkey_s_c_bucket_gens__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_c_bucket_gens__bindgen_ty_1__bindgen_ty_1, v)
        - 8usize];
};
impl Default for bkey_s_c_bucket_gens__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_bucket_gens__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_bucket_gens__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_bucket_gens__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_bucket_gens__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_bucket_gens__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_c_bucket_gens__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_c_bucket_gens__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_bucket_gens",
    ][::std::mem::size_of::<bkey_s_c_bucket_gens>() - 16usize];
    [
        "Alignment of bkey_s_c_bucket_gens",
    ][::std::mem::align_of::<bkey_s_c_bucket_gens>() - 8usize];
};
impl Default for bkey_s_c_bucket_gens {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_bucket_gens {
    pub __bindgen_anon_1: bkey_s_bucket_gens__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_bucket_gens__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_bucket_gens__bindgen_ty_1__bindgen_ty_1,
    pub c: bkey_s_c_bucket_gens,
    pub s: bkey_s,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_bucket_gens__bindgen_ty_1__bindgen_ty_1 {
    pub k: *mut bkey,
    pub v: *mut bch_bucket_gens,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_bucket_gens__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_bucket_gens__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_bucket_gens__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_bucket_gens__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_bucket_gens__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_bucket_gens__bindgen_ty_1__bindgen_ty_1, k)
        - 0usize];
    [
        "Offset of field: bkey_s_bucket_gens__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_bucket_gens__bindgen_ty_1__bindgen_ty_1, v)
        - 8usize];
};
impl Default for bkey_s_bucket_gens__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_bucket_gens__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_bucket_gens__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_bucket_gens__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_bucket_gens__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_bucket_gens__bindgen_ty_1::c",
    ][::std::mem::offset_of!(bkey_s_bucket_gens__bindgen_ty_1, c) - 0usize];
    [
        "Offset of field: bkey_s_bucket_gens__bindgen_ty_1::s",
    ][::std::mem::offset_of!(bkey_s_bucket_gens__bindgen_ty_1, s) - 0usize];
    [
        "Offset of field: bkey_s_bucket_gens__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_bucket_gens__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_bucket_gens__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_bucket_gens",
    ][::std::mem::size_of::<bkey_s_bucket_gens>() - 16usize];
    [
        "Alignment of bkey_s_bucket_gens",
    ][::std::mem::align_of::<bkey_s_bucket_gens>() - 8usize];
};
impl Default for bkey_s_bucket_gens {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bkey_i_snapshot_tree {
    pub __bindgen_anon_1: bkey_i_snapshot_tree__bindgen_ty_1,
    pub v: bch_snapshot_tree,
}
#[repr(C)]
pub struct bkey_i_snapshot_tree__bindgen_ty_1 {
    pub k: __BindgenUnionField<bkey>,
    pub k_i: __BindgenUnionField<bkey_i>,
    pub bindgen_union_field: [u64; 5usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_snapshot_tree__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_i_snapshot_tree__bindgen_ty_1>() - 40usize];
    [
        "Alignment of bkey_i_snapshot_tree__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_i_snapshot_tree__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_i_snapshot_tree__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_i_snapshot_tree__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_i_snapshot_tree__bindgen_ty_1::k_i",
    ][::std::mem::offset_of!(bkey_i_snapshot_tree__bindgen_ty_1, k_i) - 0usize];
};
impl Default for bkey_i_snapshot_tree__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_snapshot_tree",
    ][::std::mem::size_of::<bkey_i_snapshot_tree>() - 48usize];
    [
        "Alignment of bkey_i_snapshot_tree",
    ][::std::mem::align_of::<bkey_i_snapshot_tree>() - 8usize];
    [
        "Offset of field: bkey_i_snapshot_tree::v",
    ][::std::mem::offset_of!(bkey_i_snapshot_tree, v) - 40usize];
};
impl Default for bkey_i_snapshot_tree {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_c_snapshot_tree {
    pub __bindgen_anon_1: bkey_s_c_snapshot_tree__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_c_snapshot_tree__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_c_snapshot_tree__bindgen_ty_1__bindgen_ty_1,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_c_snapshot_tree__bindgen_ty_1__bindgen_ty_1 {
    pub k: *const bkey,
    pub v: *const bch_snapshot_tree,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_snapshot_tree__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_snapshot_tree__bindgen_ty_1__bindgen_ty_1>()
        - 16usize];
    [
        "Alignment of bkey_s_c_snapshot_tree__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_snapshot_tree__bindgen_ty_1__bindgen_ty_1>()
        - 8usize];
    [
        "Offset of field: bkey_s_c_snapshot_tree__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_c_snapshot_tree__bindgen_ty_1__bindgen_ty_1, k)
        - 0usize];
    [
        "Offset of field: bkey_s_c_snapshot_tree__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_c_snapshot_tree__bindgen_ty_1__bindgen_ty_1, v)
        - 8usize];
};
impl Default for bkey_s_c_snapshot_tree__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_snapshot_tree__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_snapshot_tree__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_snapshot_tree__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_snapshot_tree__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_snapshot_tree__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_c_snapshot_tree__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_c_snapshot_tree__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_snapshot_tree",
    ][::std::mem::size_of::<bkey_s_c_snapshot_tree>() - 16usize];
    [
        "Alignment of bkey_s_c_snapshot_tree",
    ][::std::mem::align_of::<bkey_s_c_snapshot_tree>() - 8usize];
};
impl Default for bkey_s_c_snapshot_tree {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_snapshot_tree {
    pub __bindgen_anon_1: bkey_s_snapshot_tree__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_snapshot_tree__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_snapshot_tree__bindgen_ty_1__bindgen_ty_1,
    pub c: bkey_s_c_snapshot_tree,
    pub s: bkey_s,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_snapshot_tree__bindgen_ty_1__bindgen_ty_1 {
    pub k: *mut bkey,
    pub v: *mut bch_snapshot_tree,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_snapshot_tree__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_snapshot_tree__bindgen_ty_1__bindgen_ty_1>()
        - 16usize];
    [
        "Alignment of bkey_s_snapshot_tree__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_snapshot_tree__bindgen_ty_1__bindgen_ty_1>()
        - 8usize];
    [
        "Offset of field: bkey_s_snapshot_tree__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_snapshot_tree__bindgen_ty_1__bindgen_ty_1, k)
        - 0usize];
    [
        "Offset of field: bkey_s_snapshot_tree__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_snapshot_tree__bindgen_ty_1__bindgen_ty_1, v)
        - 8usize];
};
impl Default for bkey_s_snapshot_tree__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_snapshot_tree__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_snapshot_tree__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_snapshot_tree__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_snapshot_tree__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_snapshot_tree__bindgen_ty_1::c",
    ][::std::mem::offset_of!(bkey_s_snapshot_tree__bindgen_ty_1, c) - 0usize];
    [
        "Offset of field: bkey_s_snapshot_tree__bindgen_ty_1::s",
    ][::std::mem::offset_of!(bkey_s_snapshot_tree__bindgen_ty_1, s) - 0usize];
    [
        "Offset of field: bkey_s_snapshot_tree__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_snapshot_tree__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_snapshot_tree__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_snapshot_tree",
    ][::std::mem::size_of::<bkey_s_snapshot_tree>() - 16usize];
    [
        "Alignment of bkey_s_snapshot_tree",
    ][::std::mem::align_of::<bkey_s_snapshot_tree>() - 8usize];
};
impl Default for bkey_s_snapshot_tree {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bkey_i_logged_op_truncate {
    pub __bindgen_anon_1: bkey_i_logged_op_truncate__bindgen_ty_1,
    pub v: bch_logged_op_truncate,
}
#[repr(C)]
pub struct bkey_i_logged_op_truncate__bindgen_ty_1 {
    pub k: __BindgenUnionField<bkey>,
    pub k_i: __BindgenUnionField<bkey_i>,
    pub bindgen_union_field: [u64; 5usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_logged_op_truncate__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_i_logged_op_truncate__bindgen_ty_1>() - 40usize];
    [
        "Alignment of bkey_i_logged_op_truncate__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_i_logged_op_truncate__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_i_logged_op_truncate__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_i_logged_op_truncate__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_i_logged_op_truncate__bindgen_ty_1::k_i",
    ][::std::mem::offset_of!(bkey_i_logged_op_truncate__bindgen_ty_1, k_i) - 0usize];
};
impl Default for bkey_i_logged_op_truncate__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_logged_op_truncate",
    ][::std::mem::size_of::<bkey_i_logged_op_truncate>() - 64usize];
    [
        "Alignment of bkey_i_logged_op_truncate",
    ][::std::mem::align_of::<bkey_i_logged_op_truncate>() - 8usize];
    [
        "Offset of field: bkey_i_logged_op_truncate::v",
    ][::std::mem::offset_of!(bkey_i_logged_op_truncate, v) - 40usize];
};
impl Default for bkey_i_logged_op_truncate {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_c_logged_op_truncate {
    pub __bindgen_anon_1: bkey_s_c_logged_op_truncate__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_c_logged_op_truncate__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_c_logged_op_truncate__bindgen_ty_1__bindgen_ty_1,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_c_logged_op_truncate__bindgen_ty_1__bindgen_ty_1 {
    pub k: *const bkey,
    pub v: *const bch_logged_op_truncate,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_logged_op_truncate__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_logged_op_truncate__bindgen_ty_1__bindgen_ty_1>()
        - 16usize];
    [
        "Alignment of bkey_s_c_logged_op_truncate__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_logged_op_truncate__bindgen_ty_1__bindgen_ty_1>()
        - 8usize];
    [
        "Offset of field: bkey_s_c_logged_op_truncate__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_c_logged_op_truncate__bindgen_ty_1__bindgen_ty_1, k)
        - 0usize];
    [
        "Offset of field: bkey_s_c_logged_op_truncate__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_c_logged_op_truncate__bindgen_ty_1__bindgen_ty_1, v)
        - 8usize];
};
impl Default for bkey_s_c_logged_op_truncate__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_logged_op_truncate__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_logged_op_truncate__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_logged_op_truncate__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_logged_op_truncate__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_logged_op_truncate__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_c_logged_op_truncate__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_c_logged_op_truncate__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_logged_op_truncate",
    ][::std::mem::size_of::<bkey_s_c_logged_op_truncate>() - 16usize];
    [
        "Alignment of bkey_s_c_logged_op_truncate",
    ][::std::mem::align_of::<bkey_s_c_logged_op_truncate>() - 8usize];
};
impl Default for bkey_s_c_logged_op_truncate {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_logged_op_truncate {
    pub __bindgen_anon_1: bkey_s_logged_op_truncate__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_logged_op_truncate__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_logged_op_truncate__bindgen_ty_1__bindgen_ty_1,
    pub c: bkey_s_c_logged_op_truncate,
    pub s: bkey_s,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_logged_op_truncate__bindgen_ty_1__bindgen_ty_1 {
    pub k: *mut bkey,
    pub v: *mut bch_logged_op_truncate,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_logged_op_truncate__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_logged_op_truncate__bindgen_ty_1__bindgen_ty_1>()
        - 16usize];
    [
        "Alignment of bkey_s_logged_op_truncate__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_logged_op_truncate__bindgen_ty_1__bindgen_ty_1>()
        - 8usize];
    [
        "Offset of field: bkey_s_logged_op_truncate__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_logged_op_truncate__bindgen_ty_1__bindgen_ty_1, k)
        - 0usize];
    [
        "Offset of field: bkey_s_logged_op_truncate__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_logged_op_truncate__bindgen_ty_1__bindgen_ty_1, v)
        - 8usize];
};
impl Default for bkey_s_logged_op_truncate__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_logged_op_truncate__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_logged_op_truncate__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_logged_op_truncate__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_logged_op_truncate__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_logged_op_truncate__bindgen_ty_1::c",
    ][::std::mem::offset_of!(bkey_s_logged_op_truncate__bindgen_ty_1, c) - 0usize];
    [
        "Offset of field: bkey_s_logged_op_truncate__bindgen_ty_1::s",
    ][::std::mem::offset_of!(bkey_s_logged_op_truncate__bindgen_ty_1, s) - 0usize];
    [
        "Offset of field: bkey_s_logged_op_truncate__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_logged_op_truncate__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_logged_op_truncate__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_logged_op_truncate",
    ][::std::mem::size_of::<bkey_s_logged_op_truncate>() - 16usize];
    [
        "Alignment of bkey_s_logged_op_truncate",
    ][::std::mem::align_of::<bkey_s_logged_op_truncate>() - 8usize];
};
impl Default for bkey_s_logged_op_truncate {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bkey_i_logged_op_finsert {
    pub __bindgen_anon_1: bkey_i_logged_op_finsert__bindgen_ty_1,
    pub v: bch_logged_op_finsert,
}
#[repr(C)]
pub struct bkey_i_logged_op_finsert__bindgen_ty_1 {
    pub k: __BindgenUnionField<bkey>,
    pub k_i: __BindgenUnionField<bkey_i>,
    pub bindgen_union_field: [u64; 5usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_logged_op_finsert__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_i_logged_op_finsert__bindgen_ty_1>() - 40usize];
    [
        "Alignment of bkey_i_logged_op_finsert__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_i_logged_op_finsert__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_i_logged_op_finsert__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_i_logged_op_finsert__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_i_logged_op_finsert__bindgen_ty_1::k_i",
    ][::std::mem::offset_of!(bkey_i_logged_op_finsert__bindgen_ty_1, k_i) - 0usize];
};
impl Default for bkey_i_logged_op_finsert__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_logged_op_finsert",
    ][::std::mem::size_of::<bkey_i_logged_op_finsert>() - 80usize];
    [
        "Alignment of bkey_i_logged_op_finsert",
    ][::std::mem::align_of::<bkey_i_logged_op_finsert>() - 8usize];
    [
        "Offset of field: bkey_i_logged_op_finsert::v",
    ][::std::mem::offset_of!(bkey_i_logged_op_finsert, v) - 40usize];
};
impl Default for bkey_i_logged_op_finsert {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_c_logged_op_finsert {
    pub __bindgen_anon_1: bkey_s_c_logged_op_finsert__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_c_logged_op_finsert__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_c_logged_op_finsert__bindgen_ty_1__bindgen_ty_1,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_c_logged_op_finsert__bindgen_ty_1__bindgen_ty_1 {
    pub k: *const bkey,
    pub v: *const bch_logged_op_finsert,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_logged_op_finsert__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_logged_op_finsert__bindgen_ty_1__bindgen_ty_1>()
        - 16usize];
    [
        "Alignment of bkey_s_c_logged_op_finsert__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_logged_op_finsert__bindgen_ty_1__bindgen_ty_1>()
        - 8usize];
    [
        "Offset of field: bkey_s_c_logged_op_finsert__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_c_logged_op_finsert__bindgen_ty_1__bindgen_ty_1, k)
        - 0usize];
    [
        "Offset of field: bkey_s_c_logged_op_finsert__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_c_logged_op_finsert__bindgen_ty_1__bindgen_ty_1, v)
        - 8usize];
};
impl Default for bkey_s_c_logged_op_finsert__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_logged_op_finsert__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_logged_op_finsert__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_logged_op_finsert__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_logged_op_finsert__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_logged_op_finsert__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_c_logged_op_finsert__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_c_logged_op_finsert__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_logged_op_finsert",
    ][::std::mem::size_of::<bkey_s_c_logged_op_finsert>() - 16usize];
    [
        "Alignment of bkey_s_c_logged_op_finsert",
    ][::std::mem::align_of::<bkey_s_c_logged_op_finsert>() - 8usize];
};
impl Default for bkey_s_c_logged_op_finsert {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_logged_op_finsert {
    pub __bindgen_anon_1: bkey_s_logged_op_finsert__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_logged_op_finsert__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_logged_op_finsert__bindgen_ty_1__bindgen_ty_1,
    pub c: bkey_s_c_logged_op_finsert,
    pub s: bkey_s,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_logged_op_finsert__bindgen_ty_1__bindgen_ty_1 {
    pub k: *mut bkey,
    pub v: *mut bch_logged_op_finsert,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_logged_op_finsert__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_logged_op_finsert__bindgen_ty_1__bindgen_ty_1>()
        - 16usize];
    [
        "Alignment of bkey_s_logged_op_finsert__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_logged_op_finsert__bindgen_ty_1__bindgen_ty_1>()
        - 8usize];
    [
        "Offset of field: bkey_s_logged_op_finsert__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_logged_op_finsert__bindgen_ty_1__bindgen_ty_1, k)
        - 0usize];
    [
        "Offset of field: bkey_s_logged_op_finsert__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_logged_op_finsert__bindgen_ty_1__bindgen_ty_1, v)
        - 8usize];
};
impl Default for bkey_s_logged_op_finsert__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_logged_op_finsert__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_logged_op_finsert__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_logged_op_finsert__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_logged_op_finsert__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_logged_op_finsert__bindgen_ty_1::c",
    ][::std::mem::offset_of!(bkey_s_logged_op_finsert__bindgen_ty_1, c) - 0usize];
    [
        "Offset of field: bkey_s_logged_op_finsert__bindgen_ty_1::s",
    ][::std::mem::offset_of!(bkey_s_logged_op_finsert__bindgen_ty_1, s) - 0usize];
    [
        "Offset of field: bkey_s_logged_op_finsert__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_logged_op_finsert__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_logged_op_finsert__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_logged_op_finsert",
    ][::std::mem::size_of::<bkey_s_logged_op_finsert>() - 16usize];
    [
        "Alignment of bkey_s_logged_op_finsert",
    ][::std::mem::align_of::<bkey_s_logged_op_finsert>() - 8usize];
};
impl Default for bkey_s_logged_op_finsert {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bkey_i_accounting {
    pub __bindgen_anon_1: bkey_i_accounting__bindgen_ty_1,
    pub v: bch_accounting,
}
#[repr(C)]
pub struct bkey_i_accounting__bindgen_ty_1 {
    pub k: __BindgenUnionField<bkey>,
    pub k_i: __BindgenUnionField<bkey_i>,
    pub bindgen_union_field: [u64; 5usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_accounting__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_i_accounting__bindgen_ty_1>() - 40usize];
    [
        "Alignment of bkey_i_accounting__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_i_accounting__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_i_accounting__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_i_accounting__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_i_accounting__bindgen_ty_1::k_i",
    ][::std::mem::offset_of!(bkey_i_accounting__bindgen_ty_1, k_i) - 0usize];
};
impl Default for bkey_i_accounting__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_i_accounting"][::std::mem::size_of::<bkey_i_accounting>() - 40usize];
    [
        "Alignment of bkey_i_accounting",
    ][::std::mem::align_of::<bkey_i_accounting>() - 8usize];
    [
        "Offset of field: bkey_i_accounting::v",
    ][::std::mem::offset_of!(bkey_i_accounting, v) - 40usize];
};
impl Default for bkey_i_accounting {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_c_accounting {
    pub __bindgen_anon_1: bkey_s_c_accounting__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_c_accounting__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_c_accounting__bindgen_ty_1__bindgen_ty_1,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_c_accounting__bindgen_ty_1__bindgen_ty_1 {
    pub k: *const bkey,
    pub v: *const bch_accounting,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_accounting__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_accounting__bindgen_ty_1__bindgen_ty_1>()
        - 16usize];
    [
        "Alignment of bkey_s_c_accounting__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_accounting__bindgen_ty_1__bindgen_ty_1>()
        - 8usize];
    [
        "Offset of field: bkey_s_c_accounting__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_c_accounting__bindgen_ty_1__bindgen_ty_1, k)
        - 0usize];
    [
        "Offset of field: bkey_s_c_accounting__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_c_accounting__bindgen_ty_1__bindgen_ty_1, v)
        - 8usize];
};
impl Default for bkey_s_c_accounting__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_accounting__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_accounting__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_accounting__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_accounting__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_accounting__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_c_accounting__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_c_accounting__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_accounting",
    ][::std::mem::size_of::<bkey_s_c_accounting>() - 16usize];
    [
        "Alignment of bkey_s_c_accounting",
    ][::std::mem::align_of::<bkey_s_c_accounting>() - 8usize];
};
impl Default for bkey_s_c_accounting {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_accounting {
    pub __bindgen_anon_1: bkey_s_accounting__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_accounting__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_accounting__bindgen_ty_1__bindgen_ty_1,
    pub c: bkey_s_c_accounting,
    pub s: bkey_s,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_accounting__bindgen_ty_1__bindgen_ty_1 {
    pub k: *mut bkey,
    pub v: *mut bch_accounting,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_accounting__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_accounting__bindgen_ty_1__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_accounting__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_accounting__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_accounting__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_accounting__bindgen_ty_1__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_s_accounting__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_accounting__bindgen_ty_1__bindgen_ty_1, v) - 8usize];
};
impl Default for bkey_s_accounting__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_accounting__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_accounting__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_accounting__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_accounting__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_accounting__bindgen_ty_1::c",
    ][::std::mem::offset_of!(bkey_s_accounting__bindgen_ty_1, c) - 0usize];
    [
        "Offset of field: bkey_s_accounting__bindgen_ty_1::s",
    ][::std::mem::offset_of!(bkey_s_accounting__bindgen_ty_1, s) - 0usize];
    [
        "Offset of field: bkey_s_accounting__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_accounting__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_accounting__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_s_accounting"][::std::mem::size_of::<bkey_s_accounting>() - 16usize];
    [
        "Alignment of bkey_s_accounting",
    ][::std::mem::align_of::<bkey_s_accounting>() - 8usize];
};
impl Default for bkey_s_accounting {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bkey_i_inode_alloc_cursor {
    pub __bindgen_anon_1: bkey_i_inode_alloc_cursor__bindgen_ty_1,
    pub v: bch_inode_alloc_cursor,
}
#[repr(C)]
pub struct bkey_i_inode_alloc_cursor__bindgen_ty_1 {
    pub k: __BindgenUnionField<bkey>,
    pub k_i: __BindgenUnionField<bkey_i>,
    pub bindgen_union_field: [u64; 5usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_inode_alloc_cursor__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_i_inode_alloc_cursor__bindgen_ty_1>() - 40usize];
    [
        "Alignment of bkey_i_inode_alloc_cursor__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_i_inode_alloc_cursor__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_i_inode_alloc_cursor__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_i_inode_alloc_cursor__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_i_inode_alloc_cursor__bindgen_ty_1::k_i",
    ][::std::mem::offset_of!(bkey_i_inode_alloc_cursor__bindgen_ty_1, k_i) - 0usize];
};
impl Default for bkey_i_inode_alloc_cursor__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_inode_alloc_cursor",
    ][::std::mem::size_of::<bkey_i_inode_alloc_cursor>() - 56usize];
    [
        "Alignment of bkey_i_inode_alloc_cursor",
    ][::std::mem::align_of::<bkey_i_inode_alloc_cursor>() - 8usize];
    [
        "Offset of field: bkey_i_inode_alloc_cursor::v",
    ][::std::mem::offset_of!(bkey_i_inode_alloc_cursor, v) - 40usize];
};
impl Default for bkey_i_inode_alloc_cursor {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_c_inode_alloc_cursor {
    pub __bindgen_anon_1: bkey_s_c_inode_alloc_cursor__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_c_inode_alloc_cursor__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_c_inode_alloc_cursor__bindgen_ty_1__bindgen_ty_1,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_c_inode_alloc_cursor__bindgen_ty_1__bindgen_ty_1 {
    pub k: *const bkey,
    pub v: *const bch_inode_alloc_cursor,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_inode_alloc_cursor__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_inode_alloc_cursor__bindgen_ty_1__bindgen_ty_1>()
        - 16usize];
    [
        "Alignment of bkey_s_c_inode_alloc_cursor__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_inode_alloc_cursor__bindgen_ty_1__bindgen_ty_1>()
        - 8usize];
    [
        "Offset of field: bkey_s_c_inode_alloc_cursor__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_c_inode_alloc_cursor__bindgen_ty_1__bindgen_ty_1, k)
        - 0usize];
    [
        "Offset of field: bkey_s_c_inode_alloc_cursor__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_c_inode_alloc_cursor__bindgen_ty_1__bindgen_ty_1, v)
        - 8usize];
};
impl Default for bkey_s_c_inode_alloc_cursor__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_inode_alloc_cursor__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_inode_alloc_cursor__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_inode_alloc_cursor__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_inode_alloc_cursor__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_inode_alloc_cursor__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_c_inode_alloc_cursor__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_c_inode_alloc_cursor__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_inode_alloc_cursor",
    ][::std::mem::size_of::<bkey_s_c_inode_alloc_cursor>() - 16usize];
    [
        "Alignment of bkey_s_c_inode_alloc_cursor",
    ][::std::mem::align_of::<bkey_s_c_inode_alloc_cursor>() - 8usize];
};
impl Default for bkey_s_c_inode_alloc_cursor {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_inode_alloc_cursor {
    pub __bindgen_anon_1: bkey_s_inode_alloc_cursor__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_inode_alloc_cursor__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_inode_alloc_cursor__bindgen_ty_1__bindgen_ty_1,
    pub c: bkey_s_c_inode_alloc_cursor,
    pub s: bkey_s,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_inode_alloc_cursor__bindgen_ty_1__bindgen_ty_1 {
    pub k: *mut bkey,
    pub v: *mut bch_inode_alloc_cursor,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_inode_alloc_cursor__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_inode_alloc_cursor__bindgen_ty_1__bindgen_ty_1>()
        - 16usize];
    [
        "Alignment of bkey_s_inode_alloc_cursor__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_inode_alloc_cursor__bindgen_ty_1__bindgen_ty_1>()
        - 8usize];
    [
        "Offset of field: bkey_s_inode_alloc_cursor__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_inode_alloc_cursor__bindgen_ty_1__bindgen_ty_1, k)
        - 0usize];
    [
        "Offset of field: bkey_s_inode_alloc_cursor__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_inode_alloc_cursor__bindgen_ty_1__bindgen_ty_1, v)
        - 8usize];
};
impl Default for bkey_s_inode_alloc_cursor__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_inode_alloc_cursor__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_inode_alloc_cursor__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_inode_alloc_cursor__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_inode_alloc_cursor__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_inode_alloc_cursor__bindgen_ty_1::c",
    ][::std::mem::offset_of!(bkey_s_inode_alloc_cursor__bindgen_ty_1, c) - 0usize];
    [
        "Offset of field: bkey_s_inode_alloc_cursor__bindgen_ty_1::s",
    ][::std::mem::offset_of!(bkey_s_inode_alloc_cursor__bindgen_ty_1, s) - 0usize];
    [
        "Offset of field: bkey_s_inode_alloc_cursor__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_inode_alloc_cursor__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_inode_alloc_cursor__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_inode_alloc_cursor",
    ][::std::mem::size_of::<bkey_s_inode_alloc_cursor>() - 16usize];
    [
        "Alignment of bkey_s_inode_alloc_cursor",
    ][::std::mem::align_of::<bkey_s_inode_alloc_cursor>() - 8usize];
};
impl Default for bkey_s_inode_alloc_cursor {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bkey_i_extent_whiteout {
    pub __bindgen_anon_1: bkey_i_extent_whiteout__bindgen_ty_1,
    pub v: bch_extent_whiteout,
}
#[repr(C)]
pub struct bkey_i_extent_whiteout__bindgen_ty_1 {
    pub k: __BindgenUnionField<bkey>,
    pub k_i: __BindgenUnionField<bkey_i>,
    pub bindgen_union_field: [u64; 5usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_extent_whiteout__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_i_extent_whiteout__bindgen_ty_1>() - 40usize];
    [
        "Alignment of bkey_i_extent_whiteout__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_i_extent_whiteout__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_i_extent_whiteout__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_i_extent_whiteout__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_i_extent_whiteout__bindgen_ty_1::k_i",
    ][::std::mem::offset_of!(bkey_i_extent_whiteout__bindgen_ty_1, k_i) - 0usize];
};
impl Default for bkey_i_extent_whiteout__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_extent_whiteout",
    ][::std::mem::size_of::<bkey_i_extent_whiteout>() - 40usize];
    [
        "Alignment of bkey_i_extent_whiteout",
    ][::std::mem::align_of::<bkey_i_extent_whiteout>() - 8usize];
    [
        "Offset of field: bkey_i_extent_whiteout::v",
    ][::std::mem::offset_of!(bkey_i_extent_whiteout, v) - 40usize];
};
impl Default for bkey_i_extent_whiteout {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_c_extent_whiteout {
    pub __bindgen_anon_1: bkey_s_c_extent_whiteout__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_c_extent_whiteout__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_c_extent_whiteout__bindgen_ty_1__bindgen_ty_1,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_c_extent_whiteout__bindgen_ty_1__bindgen_ty_1 {
    pub k: *const bkey,
    pub v: *const bch_extent_whiteout,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_extent_whiteout__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_extent_whiteout__bindgen_ty_1__bindgen_ty_1>()
        - 16usize];
    [
        "Alignment of bkey_s_c_extent_whiteout__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_extent_whiteout__bindgen_ty_1__bindgen_ty_1>()
        - 8usize];
    [
        "Offset of field: bkey_s_c_extent_whiteout__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_c_extent_whiteout__bindgen_ty_1__bindgen_ty_1, k)
        - 0usize];
    [
        "Offset of field: bkey_s_c_extent_whiteout__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_c_extent_whiteout__bindgen_ty_1__bindgen_ty_1, v)
        - 8usize];
};
impl Default for bkey_s_c_extent_whiteout__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_extent_whiteout__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_extent_whiteout__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_extent_whiteout__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_extent_whiteout__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_extent_whiteout__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_c_extent_whiteout__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_c_extent_whiteout__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_extent_whiteout",
    ][::std::mem::size_of::<bkey_s_c_extent_whiteout>() - 16usize];
    [
        "Alignment of bkey_s_c_extent_whiteout",
    ][::std::mem::align_of::<bkey_s_c_extent_whiteout>() - 8usize];
};
impl Default for bkey_s_c_extent_whiteout {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_extent_whiteout {
    pub __bindgen_anon_1: bkey_s_extent_whiteout__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_extent_whiteout__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_extent_whiteout__bindgen_ty_1__bindgen_ty_1,
    pub c: bkey_s_c_extent_whiteout,
    pub s: bkey_s,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_extent_whiteout__bindgen_ty_1__bindgen_ty_1 {
    pub k: *mut bkey,
    pub v: *mut bch_extent_whiteout,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_extent_whiteout__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_extent_whiteout__bindgen_ty_1__bindgen_ty_1>()
        - 16usize];
    [
        "Alignment of bkey_s_extent_whiteout__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_extent_whiteout__bindgen_ty_1__bindgen_ty_1>()
        - 8usize];
    [
        "Offset of field: bkey_s_extent_whiteout__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_s_extent_whiteout__bindgen_ty_1__bindgen_ty_1, k)
        - 0usize];
    [
        "Offset of field: bkey_s_extent_whiteout__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(bkey_s_extent_whiteout__bindgen_ty_1__bindgen_ty_1, v)
        - 8usize];
};
impl Default for bkey_s_extent_whiteout__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_extent_whiteout__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_extent_whiteout__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_extent_whiteout__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_extent_whiteout__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_extent_whiteout__bindgen_ty_1::c",
    ][::std::mem::offset_of!(bkey_s_extent_whiteout__bindgen_ty_1, c) - 0usize];
    [
        "Offset of field: bkey_s_extent_whiteout__bindgen_ty_1::s",
    ][::std::mem::offset_of!(bkey_s_extent_whiteout__bindgen_ty_1, s) - 0usize];
    [
        "Offset of field: bkey_s_extent_whiteout__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_extent_whiteout__bindgen_ty_1, s_c) - 0usize];
};
impl Default for bkey_s_extent_whiteout__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_extent_whiteout",
    ][::std::mem::size_of::<bkey_s_extent_whiteout>() - 16usize];
    [
        "Alignment of bkey_s_extent_whiteout",
    ][::std::mem::align_of::<bkey_s_extent_whiteout>() - 8usize];
};
impl Default for bkey_s_extent_whiteout {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bkey_i_logged_op_stripe_update {
    pub __bindgen_anon_1: bkey_i_logged_op_stripe_update__bindgen_ty_1,
    pub v: bch_logged_op_stripe_update,
}
#[repr(C)]
pub struct bkey_i_logged_op_stripe_update__bindgen_ty_1 {
    pub k: __BindgenUnionField<bkey>,
    pub k_i: __BindgenUnionField<bkey_i>,
    pub bindgen_union_field: [u64; 5usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_logged_op_stripe_update__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_i_logged_op_stripe_update__bindgen_ty_1>() - 40usize];
    [
        "Alignment of bkey_i_logged_op_stripe_update__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_i_logged_op_stripe_update__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_i_logged_op_stripe_update__bindgen_ty_1::k",
    ][::std::mem::offset_of!(bkey_i_logged_op_stripe_update__bindgen_ty_1, k) - 0usize];
    [
        "Offset of field: bkey_i_logged_op_stripe_update__bindgen_ty_1::k_i",
    ][::std::mem::offset_of!(bkey_i_logged_op_stripe_update__bindgen_ty_1, k_i)
        - 0usize];
};
impl Default for bkey_i_logged_op_stripe_update__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_i_logged_op_stripe_update",
    ][::std::mem::size_of::<bkey_i_logged_op_stripe_update>() - 80usize];
    [
        "Alignment of bkey_i_logged_op_stripe_update",
    ][::std::mem::align_of::<bkey_i_logged_op_stripe_update>() - 8usize];
    [
        "Offset of field: bkey_i_logged_op_stripe_update::v",
    ][::std::mem::offset_of!(bkey_i_logged_op_stripe_update, v) - 40usize];
};
impl Default for bkey_i_logged_op_stripe_update {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_c_logged_op_stripe_update {
    pub __bindgen_anon_1: bkey_s_c_logged_op_stripe_update__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_c_logged_op_stripe_update__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_c_logged_op_stripe_update__bindgen_ty_1__bindgen_ty_1,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_c_logged_op_stripe_update__bindgen_ty_1__bindgen_ty_1 {
    pub k: *const bkey,
    pub v: *const bch_logged_op_stripe_update,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_logged_op_stripe_update__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<
        bkey_s_c_logged_op_stripe_update__bindgen_ty_1__bindgen_ty_1,
    >() - 16usize];
    [
        "Alignment of bkey_s_c_logged_op_stripe_update__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<
        bkey_s_c_logged_op_stripe_update__bindgen_ty_1__bindgen_ty_1,
    >() - 8usize];
    [
        "Offset of field: bkey_s_c_logged_op_stripe_update__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(
        bkey_s_c_logged_op_stripe_update__bindgen_ty_1__bindgen_ty_1, k
    ) - 0usize];
    [
        "Offset of field: bkey_s_c_logged_op_stripe_update__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(
        bkey_s_c_logged_op_stripe_update__bindgen_ty_1__bindgen_ty_1, v
    ) - 8usize];
};
impl Default for bkey_s_c_logged_op_stripe_update__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_logged_op_stripe_update__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_c_logged_op_stripe_update__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_c_logged_op_stripe_update__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_c_logged_op_stripe_update__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_c_logged_op_stripe_update__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_c_logged_op_stripe_update__bindgen_ty_1, s_c)
        - 0usize];
};
impl Default for bkey_s_c_logged_op_stripe_update__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_c_logged_op_stripe_update",
    ][::std::mem::size_of::<bkey_s_c_logged_op_stripe_update>() - 16usize];
    [
        "Alignment of bkey_s_c_logged_op_stripe_update",
    ][::std::mem::align_of::<bkey_s_c_logged_op_stripe_update>() - 8usize];
};
impl Default for bkey_s_c_logged_op_stripe_update {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bkey_s_logged_op_stripe_update {
    pub __bindgen_anon_1: bkey_s_logged_op_stripe_update__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bkey_s_logged_op_stripe_update__bindgen_ty_1 {
    pub __bindgen_anon_1: bkey_s_logged_op_stripe_update__bindgen_ty_1__bindgen_ty_1,
    pub c: bkey_s_c_logged_op_stripe_update,
    pub s: bkey_s,
    pub s_c: bkey_s_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_s_logged_op_stripe_update__bindgen_ty_1__bindgen_ty_1 {
    pub k: *mut bkey,
    pub v: *mut bch_logged_op_stripe_update,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_logged_op_stripe_update__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_logged_op_stripe_update__bindgen_ty_1__bindgen_ty_1>()
        - 16usize];
    [
        "Alignment of bkey_s_logged_op_stripe_update__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<
        bkey_s_logged_op_stripe_update__bindgen_ty_1__bindgen_ty_1,
    >() - 8usize];
    [
        "Offset of field: bkey_s_logged_op_stripe_update__bindgen_ty_1__bindgen_ty_1::k",
    ][::std::mem::offset_of!(
        bkey_s_logged_op_stripe_update__bindgen_ty_1__bindgen_ty_1, k
    ) - 0usize];
    [
        "Offset of field: bkey_s_logged_op_stripe_update__bindgen_ty_1__bindgen_ty_1::v",
    ][::std::mem::offset_of!(
        bkey_s_logged_op_stripe_update__bindgen_ty_1__bindgen_ty_1, v
    ) - 8usize];
};
impl Default for bkey_s_logged_op_stripe_update__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_logged_op_stripe_update__bindgen_ty_1",
    ][::std::mem::size_of::<bkey_s_logged_op_stripe_update__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bkey_s_logged_op_stripe_update__bindgen_ty_1",
    ][::std::mem::align_of::<bkey_s_logged_op_stripe_update__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bkey_s_logged_op_stripe_update__bindgen_ty_1::c",
    ][::std::mem::offset_of!(bkey_s_logged_op_stripe_update__bindgen_ty_1, c) - 0usize];
    [
        "Offset of field: bkey_s_logged_op_stripe_update__bindgen_ty_1::s",
    ][::std::mem::offset_of!(bkey_s_logged_op_stripe_update__bindgen_ty_1, s) - 0usize];
    [
        "Offset of field: bkey_s_logged_op_stripe_update__bindgen_ty_1::s_c",
    ][::std::mem::offset_of!(bkey_s_logged_op_stripe_update__bindgen_ty_1, s_c)
        - 0usize];
};
impl Default for bkey_s_logged_op_stripe_update__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_s_logged_op_stripe_update",
    ][::std::mem::size_of::<bkey_s_logged_op_stripe_update>() - 16usize];
    [
        "Alignment of bkey_s_logged_op_stripe_update",
    ][::std::mem::align_of::<bkey_s_logged_op_stripe_update>() - 8usize];
};
impl Default for bkey_s_logged_op_stripe_update {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_validate_flags {
    BCH_VALIDATE_write = 1,
    BCH_VALIDATE_commit = 2,
    BCH_VALIDATE_silent = 4,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_validate_context {
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
    pub level: u8_,
    pub btree: btree_id,
    pub _bitfield_align_2: [u8; 0],
    pub _bitfield_2: __BindgenBitfieldUnit<[u8; 1usize]>,
    pub journal_offset: ::std::os::raw::c_uint,
    pub journal_seq: u64_,
}
pub const bkey_validate_context_BKEY_VALIDATE_unknown: bkey_validate_context__bindgen_ty_1 = bkey_validate_context__bindgen_ty_1::BKEY_VALIDATE_unknown;
pub const bkey_validate_context_BKEY_VALIDATE_superblock: bkey_validate_context__bindgen_ty_1 = bkey_validate_context__bindgen_ty_1::BKEY_VALIDATE_superblock;
pub const bkey_validate_context_BKEY_VALIDATE_journal: bkey_validate_context__bindgen_ty_1 = bkey_validate_context__bindgen_ty_1::BKEY_VALIDATE_journal;
pub const bkey_validate_context_BKEY_VALIDATE_btree_root: bkey_validate_context__bindgen_ty_1 = bkey_validate_context__bindgen_ty_1::BKEY_VALIDATE_btree_root;
pub const bkey_validate_context_BKEY_VALIDATE_btree_node: bkey_validate_context__bindgen_ty_1 = bkey_validate_context__bindgen_ty_1::BKEY_VALIDATE_btree_node;
pub const bkey_validate_context_BKEY_VALIDATE_commit: bkey_validate_context__bindgen_ty_1 = bkey_validate_context__bindgen_ty_1::BKEY_VALIDATE_commit;
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bkey_validate_context__bindgen_ty_1 {
    BKEY_VALIDATE_unknown = 0,
    BKEY_VALIDATE_superblock = 1,
    BKEY_VALIDATE_journal = 2,
    BKEY_VALIDATE_btree_root = 3,
    BKEY_VALIDATE_btree_node = 4,
    BKEY_VALIDATE_commit = 5,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bkey_validate_context",
    ][::std::mem::size_of::<bkey_validate_context>() - 24usize];
    [
        "Alignment of bkey_validate_context",
    ][::std::mem::align_of::<bkey_validate_context>() - 8usize];
    [
        "Offset of field: bkey_validate_context::level",
    ][::std::mem::offset_of!(bkey_validate_context, level) - 2usize];
    [
        "Offset of field: bkey_validate_context::btree",
    ][::std::mem::offset_of!(bkey_validate_context, btree) - 4usize];
    [
        "Offset of field: bkey_validate_context::journal_offset",
    ][::std::mem::offset_of!(bkey_validate_context, journal_offset) - 12usize];
    [
        "Offset of field: bkey_validate_context::journal_seq",
    ][::std::mem::offset_of!(bkey_validate_context, journal_seq) - 16usize];
};
impl Default for bkey_validate_context {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl bkey_validate_context {
    #[inline]
    pub fn from(&self) -> bkey_validate_context__bindgen_ty_1 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
    }
    #[inline]
    pub fn set_from(&mut self, val: bkey_validate_context__bindgen_ty_1) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 8u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn from_raw(this: *const Self) -> bkey_validate_context__bindgen_ty_1 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 8u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_from_raw(
        this: *mut Self,
        val: bkey_validate_context__bindgen_ty_1,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                8u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn flags(&self) -> bch_validate_flags {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 8u8) as u32) }
    }
    #[inline]
    pub fn set_flags(&mut self, val: bch_validate_flags) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(8usize, 8u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn flags_raw(this: *const Self) -> bch_validate_flags {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 8usize, 8u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_flags_raw(this: *mut Self, val: bch_validate_flags) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                8usize,
                8u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        from: bkey_validate_context__bindgen_ty_1,
        flags: bch_validate_flags,
    ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                8u8,
                {
                    let from: u32 = unsafe { ::std::mem::transmute(from) };
                    from as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                8usize,
                8u8,
                {
                    let flags: u32 = unsafe { ::std::mem::transmute(flags) };
                    flags as u64
                },
            );
        __bindgen_bitfield_unit
    }
    #[inline]
    pub fn root(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_root(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_2.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn root_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_2), 0usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_root_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_2),
                0usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_2(root: bool) -> __BindgenBitfieldUnit<[u8; 1usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                1u8,
                {
                    let root: u8 = unsafe { ::std::mem::transmute(root) };
                    root as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct btree_alloc {
    pub ob: open_buckets,
    pub k: bkey_i,
    pub k_pad: [__u64; 15usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of btree_alloc"][::std::mem::size_of::<btree_alloc>() - 200usize];
    ["Alignment of btree_alloc"][::std::mem::align_of::<btree_alloc>() - 8usize];
    [
        "Offset of field: btree_alloc::ob",
    ][::std::mem::offset_of!(btree_alloc, ob) - 0usize];
    [
        "Offset of field: btree_alloc::k",
    ][::std::mem::offset_of!(btree_alloc, k) - 40usize];
    [
        "Offset of field: btree_alloc::k_pad",
    ][::std::mem::offset_of!(btree_alloc, k_pad) - 80usize];
};
#[repr(C)]
pub struct bch_fs_btree_reserve_cache {
    pub lock: mutex,
    pub nr: ::std::os::raw::c_uint,
    pub data: [btree_alloc; 56usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_fs_btree_reserve_cache",
    ][::std::mem::size_of::<bch_fs_btree_reserve_cache>() - 11248usize];
    [
        "Alignment of bch_fs_btree_reserve_cache",
    ][::std::mem::align_of::<bch_fs_btree_reserve_cache>() - 8usize];
    [
        "Offset of field: bch_fs_btree_reserve_cache::lock",
    ][::std::mem::offset_of!(bch_fs_btree_reserve_cache, lock) - 0usize];
    [
        "Offset of field: bch_fs_btree_reserve_cache::nr",
    ][::std::mem::offset_of!(bch_fs_btree_reserve_cache, nr) - 40usize];
    [
        "Offset of field: bch_fs_btree_reserve_cache::data",
    ][::std::mem::offset_of!(bch_fs_btree_reserve_cache, data) - 48usize];
};
impl Default for bch_fs_btree_reserve_cache {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bch_fs_btree_interior_updates {
    pub pool: mempool_t,
    pub list: cds_list_head,
    pub unwritten: cds_list_head,
    pub lock: mutex,
    pub commit_lock: mutex,
    pub wait: closure_waitlist,
    pub worker: *mut workqueue_struct,
    pub work: work_struct,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_fs_btree_interior_updates",
    ][::std::mem::size_of::<bch_fs_btree_interior_updates>() - 296usize];
    [
        "Alignment of bch_fs_btree_interior_updates",
    ][::std::mem::align_of::<bch_fs_btree_interior_updates>() - 8usize];
    [
        "Offset of field: bch_fs_btree_interior_updates::pool",
    ][::std::mem::offset_of!(bch_fs_btree_interior_updates, pool) - 0usize];
    [
        "Offset of field: bch_fs_btree_interior_updates::list",
    ][::std::mem::offset_of!(bch_fs_btree_interior_updates, list) - 136usize];
    [
        "Offset of field: bch_fs_btree_interior_updates::unwritten",
    ][::std::mem::offset_of!(bch_fs_btree_interior_updates, unwritten) - 152usize];
    [
        "Offset of field: bch_fs_btree_interior_updates::lock",
    ][::std::mem::offset_of!(bch_fs_btree_interior_updates, lock) - 168usize];
    [
        "Offset of field: bch_fs_btree_interior_updates::commit_lock",
    ][::std::mem::offset_of!(bch_fs_btree_interior_updates, commit_lock) - 208usize];
    [
        "Offset of field: bch_fs_btree_interior_updates::wait",
    ][::std::mem::offset_of!(bch_fs_btree_interior_updates, wait) - 248usize];
    [
        "Offset of field: bch_fs_btree_interior_updates::worker",
    ][::std::mem::offset_of!(bch_fs_btree_interior_updates, worker) - 256usize];
    [
        "Offset of field: bch_fs_btree_interior_updates::work",
    ][::std::mem::offset_of!(bch_fs_btree_interior_updates, work) - 264usize];
};
impl Default for bch_fs_btree_interior_updates {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bch_fs_btree_node_rewrites {
    pub list: cds_list_head,
    pub pending: cds_list_head,
    pub lock: spinlock_t,
    pub wait: closure_waitlist,
    pub worker: *mut workqueue_struct,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_fs_btree_node_rewrites",
    ][::std::mem::size_of::<bch_fs_btree_node_rewrites>() - 88usize];
    [
        "Alignment of bch_fs_btree_node_rewrites",
    ][::std::mem::align_of::<bch_fs_btree_node_rewrites>() - 8usize];
    [
        "Offset of field: bch_fs_btree_node_rewrites::list",
    ][::std::mem::offset_of!(bch_fs_btree_node_rewrites, list) - 0usize];
    [
        "Offset of field: bch_fs_btree_node_rewrites::pending",
    ][::std::mem::offset_of!(bch_fs_btree_node_rewrites, pending) - 16usize];
    [
        "Offset of field: bch_fs_btree_node_rewrites::lock",
    ][::std::mem::offset_of!(bch_fs_btree_node_rewrites, lock) - 32usize];
    [
        "Offset of field: bch_fs_btree_node_rewrites::wait",
    ][::std::mem::offset_of!(bch_fs_btree_node_rewrites, wait) - 72usize];
    [
        "Offset of field: bch_fs_btree_node_rewrites::worker",
    ][::std::mem::offset_of!(bch_fs_btree_node_rewrites, worker) - 80usize];
};
impl Default for bch_fs_btree_node_rewrites {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type rcu_pending_process_fn = ::std::option::Option<
    unsafe extern "C" fn(arg1: *mut rcu_pending, arg2: *mut rcu_head),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rcu_pending_pcpu {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rcu_pending {
    pub p: *mut rcu_pending_pcpu,
    pub srcu: *mut srcu_struct,
    pub process: rcu_pending_process_fn,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of rcu_pending"][::std::mem::size_of::<rcu_pending>() - 24usize];
    ["Alignment of rcu_pending"][::std::mem::align_of::<rcu_pending>() - 8usize];
    ["Offset of field: rcu_pending::p"][::std::mem::offset_of!(rcu_pending, p) - 0usize];
    [
        "Offset of field: rcu_pending::srcu",
    ][::std::mem::offset_of!(rcu_pending, srcu) - 8usize];
    [
        "Offset of field: rcu_pending::process",
    ][::std::mem::offset_of!(rcu_pending, process) - 16usize];
};
impl Default for rcu_pending {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bch_fs_btree_key_cache {
    pub table: rhashtable,
    pub table_init_done: bool,
    pub shrink: *mut shrinker,
    pub shrink_iter: ::std::os::raw::c_uint,
    pub pending: [rcu_pending; 2usize],
    pub nr_pending: *mut usize,
    pub nr_keys: atomic_long_t,
    pub nr_dirty: atomic_long_t,
    pub requested_to_free: ::std::os::raw::c_ulong,
    pub freed: ::std::os::raw::c_ulong,
    pub skipped_dirty: ::std::os::raw::c_ulong,
    pub skipped_accessed: ::std::os::raw::c_ulong,
    pub skipped_lock_fail: ::std::os::raw::c_ulong,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_fs_btree_key_cache",
    ][::std::mem::size_of::<bch_fs_btree_key_cache>() - 320usize];
    [
        "Alignment of bch_fs_btree_key_cache",
    ][::std::mem::align_of::<bch_fs_btree_key_cache>() - 8usize];
    [
        "Offset of field: bch_fs_btree_key_cache::table",
    ][::std::mem::offset_of!(bch_fs_btree_key_cache, table) - 0usize];
    [
        "Offset of field: bch_fs_btree_key_cache::table_init_done",
    ][::std::mem::offset_of!(bch_fs_btree_key_cache, table_init_done) - 184usize];
    [
        "Offset of field: bch_fs_btree_key_cache::shrink",
    ][::std::mem::offset_of!(bch_fs_btree_key_cache, shrink) - 192usize];
    [
        "Offset of field: bch_fs_btree_key_cache::shrink_iter",
    ][::std::mem::offset_of!(bch_fs_btree_key_cache, shrink_iter) - 200usize];
    [
        "Offset of field: bch_fs_btree_key_cache::pending",
    ][::std::mem::offset_of!(bch_fs_btree_key_cache, pending) - 208usize];
    [
        "Offset of field: bch_fs_btree_key_cache::nr_pending",
    ][::std::mem::offset_of!(bch_fs_btree_key_cache, nr_pending) - 256usize];
    [
        "Offset of field: bch_fs_btree_key_cache::nr_keys",
    ][::std::mem::offset_of!(bch_fs_btree_key_cache, nr_keys) - 264usize];
    [
        "Offset of field: bch_fs_btree_key_cache::nr_dirty",
    ][::std::mem::offset_of!(bch_fs_btree_key_cache, nr_dirty) - 272usize];
    [
        "Offset of field: bch_fs_btree_key_cache::requested_to_free",
    ][::std::mem::offset_of!(bch_fs_btree_key_cache, requested_to_free) - 280usize];
    [
        "Offset of field: bch_fs_btree_key_cache::freed",
    ][::std::mem::offset_of!(bch_fs_btree_key_cache, freed) - 288usize];
    [
        "Offset of field: bch_fs_btree_key_cache::skipped_dirty",
    ][::std::mem::offset_of!(bch_fs_btree_key_cache, skipped_dirty) - 296usize];
    [
        "Offset of field: bch_fs_btree_key_cache::skipped_accessed",
    ][::std::mem::offset_of!(bch_fs_btree_key_cache, skipped_accessed) - 304usize];
    [
        "Offset of field: bch_fs_btree_key_cache::skipped_lock_fail",
    ][::std::mem::offset_of!(bch_fs_btree_key_cache, skipped_lock_fail) - 312usize];
};
impl Default for bch_fs_btree_key_cache {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct found_btree_node {
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
    pub btree_id: u8_,
    pub level: u8_,
    pub sectors_written: ::std::os::raw::c_uint,
    pub seq: u32_,
    pub journal_seq: u64_,
    pub cookie: u64_,
    pub min_key: bpos,
    pub max_key: bpos,
    pub nr_ptrs: ::std::os::raw::c_uint,
    pub ptrs: [bch_extent_ptr; 4usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of found_btree_node"][::std::mem::size_of::<found_btree_node>() - 112usize];
    [
        "Alignment of found_btree_node",
    ][::std::mem::align_of::<found_btree_node>() - 8usize];
    [
        "Offset of field: found_btree_node::btree_id",
    ][::std::mem::offset_of!(found_btree_node, btree_id) - 1usize];
    [
        "Offset of field: found_btree_node::level",
    ][::std::mem::offset_of!(found_btree_node, level) - 2usize];
    [
        "Offset of field: found_btree_node::sectors_written",
    ][::std::mem::offset_of!(found_btree_node, sectors_written) - 4usize];
    [
        "Offset of field: found_btree_node::seq",
    ][::std::mem::offset_of!(found_btree_node, seq) - 8usize];
    [
        "Offset of field: found_btree_node::journal_seq",
    ][::std::mem::offset_of!(found_btree_node, journal_seq) - 16usize];
    [
        "Offset of field: found_btree_node::cookie",
    ][::std::mem::offset_of!(found_btree_node, cookie) - 24usize];
    [
        "Offset of field: found_btree_node::min_key",
    ][::std::mem::offset_of!(found_btree_node, min_key) - 32usize];
    [
        "Offset of field: found_btree_node::max_key",
    ][::std::mem::offset_of!(found_btree_node, max_key) - 52usize];
    [
        "Offset of field: found_btree_node::nr_ptrs",
    ][::std::mem::offset_of!(found_btree_node, nr_ptrs) - 72usize];
    [
        "Offset of field: found_btree_node::ptrs",
    ][::std::mem::offset_of!(found_btree_node, ptrs) - 80usize];
};
impl found_btree_node {
    #[inline]
    pub fn range_updated(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_range_updated(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn range_updated_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_range_updated_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(range_updated: bool) -> __BindgenBitfieldUnit<[u8; 1usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                1u8,
                {
                    let range_updated: u8 = unsafe {
                        ::std::mem::transmute(range_updated)
                    };
                    range_updated as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Debug)]
pub struct darray_found_btree_node {
    pub nr: usize,
    pub size: usize,
    pub data: *mut found_btree_node,
    pub preallocated: __IncompleteArrayField<found_btree_node>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of darray_found_btree_node",
    ][::std::mem::size_of::<darray_found_btree_node>() - 24usize];
    [
        "Alignment of darray_found_btree_node",
    ][::std::mem::align_of::<darray_found_btree_node>() - 8usize];
    [
        "Offset of field: darray_found_btree_node::nr",
    ][::std::mem::offset_of!(darray_found_btree_node, nr) - 0usize];
    [
        "Offset of field: darray_found_btree_node::size",
    ][::std::mem::offset_of!(darray_found_btree_node, size) - 8usize];
    [
        "Offset of field: darray_found_btree_node::data",
    ][::std::mem::offset_of!(darray_found_btree_node, data) - 16usize];
    [
        "Offset of field: darray_found_btree_node::preallocated",
    ][::std::mem::offset_of!(darray_found_btree_node, preallocated) - 24usize];
};
impl Default for darray_found_btree_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct find_btree_nodes {
    pub ret: ::std::os::raw::c_int,
    pub lock: mutex,
    pub nodes: darray_found_btree_node,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of find_btree_nodes"][::std::mem::size_of::<find_btree_nodes>() - 72usize];
    [
        "Alignment of find_btree_nodes",
    ][::std::mem::align_of::<find_btree_nodes>() - 8usize];
    [
        "Offset of field: find_btree_nodes::ret",
    ][::std::mem::offset_of!(find_btree_nodes, ret) - 0usize];
    [
        "Offset of field: find_btree_nodes::lock",
    ][::std::mem::offset_of!(find_btree_nodes, lock) - 8usize];
    [
        "Offset of field: find_btree_nodes::nodes",
    ][::std::mem::offset_of!(find_btree_nodes, nodes) - 48usize];
};
impl Default for find_btree_nodes {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_extent_crc_unpacked {
    pub compressed_size: u32_,
    pub uncompressed_size: u32_,
    pub live_size: u32_,
    pub csum_type: u8_,
    pub compression_type: u8_,
    pub offset: u16_,
    pub nonce: u16_,
    pub csum: bch_csum,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_extent_crc_unpacked",
    ][::std::mem::size_of::<bch_extent_crc_unpacked>() - 40usize];
    [
        "Alignment of bch_extent_crc_unpacked",
    ][::std::mem::align_of::<bch_extent_crc_unpacked>() - 8usize];
    [
        "Offset of field: bch_extent_crc_unpacked::compressed_size",
    ][::std::mem::offset_of!(bch_extent_crc_unpacked, compressed_size) - 0usize];
    [
        "Offset of field: bch_extent_crc_unpacked::uncompressed_size",
    ][::std::mem::offset_of!(bch_extent_crc_unpacked, uncompressed_size) - 4usize];
    [
        "Offset of field: bch_extent_crc_unpacked::live_size",
    ][::std::mem::offset_of!(bch_extent_crc_unpacked, live_size) - 8usize];
    [
        "Offset of field: bch_extent_crc_unpacked::csum_type",
    ][::std::mem::offset_of!(bch_extent_crc_unpacked, csum_type) - 12usize];
    [
        "Offset of field: bch_extent_crc_unpacked::compression_type",
    ][::std::mem::offset_of!(bch_extent_crc_unpacked, compression_type) - 13usize];
    [
        "Offset of field: bch_extent_crc_unpacked::offset",
    ][::std::mem::offset_of!(bch_extent_crc_unpacked, offset) - 14usize];
    [
        "Offset of field: bch_extent_crc_unpacked::nonce",
    ][::std::mem::offset_of!(bch_extent_crc_unpacked, nonce) - 16usize];
    [
        "Offset of field: bch_extent_crc_unpacked::csum",
    ][::std::mem::offset_of!(bch_extent_crc_unpacked, csum) - 24usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct extent_ptr_decoded {
    pub has_ec: bool,
    pub do_ec_reconstruct: bool,
    pub crc_retry_nr: u8_,
    pub crc: bch_extent_crc_unpacked,
    pub ptr: bch_extent_ptr,
    pub ec: bch_extent_stripe_ptr,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of extent_ptr_decoded",
    ][::std::mem::size_of::<extent_ptr_decoded>() - 64usize];
    [
        "Alignment of extent_ptr_decoded",
    ][::std::mem::align_of::<extent_ptr_decoded>() - 8usize];
    [
        "Offset of field: extent_ptr_decoded::has_ec",
    ][::std::mem::offset_of!(extent_ptr_decoded, has_ec) - 0usize];
    [
        "Offset of field: extent_ptr_decoded::do_ec_reconstruct",
    ][::std::mem::offset_of!(extent_ptr_decoded, do_ec_reconstruct) - 1usize];
    [
        "Offset of field: extent_ptr_decoded::crc_retry_nr",
    ][::std::mem::offset_of!(extent_ptr_decoded, crc_retry_nr) - 2usize];
    [
        "Offset of field: extent_ptr_decoded::crc",
    ][::std::mem::offset_of!(extent_ptr_decoded, crc) - 8usize];
    [
        "Offset of field: extent_ptr_decoded::ptr",
    ][::std::mem::offset_of!(extent_ptr_decoded, ptr) - 48usize];
    [
        "Offset of field: extent_ptr_decoded::ec",
    ][::std::mem::offset_of!(extent_ptr_decoded, ec) - 56usize];
};
#[repr(C)]
#[derive(Debug)]
pub struct bch_io_failures {
    pub nr: u8_,
    pub data: [bch_io_failures_bch_dev_io_failures; 5usize],
    pub ec_msg: printbuf,
}
#[repr(C)]
#[repr(align(4))]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_io_failures_bch_dev_io_failures {
    pub dev: u8_,
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
    pub ec_errcode: s16,
    pub errcode: s16,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_io_failures_bch_dev_io_failures",
    ][::std::mem::size_of::<bch_io_failures_bch_dev_io_failures>() - 8usize];
    [
        "Alignment of bch_io_failures_bch_dev_io_failures",
    ][::std::mem::align_of::<bch_io_failures_bch_dev_io_failures>() - 4usize];
    [
        "Offset of field: bch_io_failures_bch_dev_io_failures::dev",
    ][::std::mem::offset_of!(bch_io_failures_bch_dev_io_failures, dev) - 0usize];
    [
        "Offset of field: bch_io_failures_bch_dev_io_failures::ec_errcode",
    ][::std::mem::offset_of!(bch_io_failures_bch_dev_io_failures, ec_errcode) - 2usize];
    [
        "Offset of field: bch_io_failures_bch_dev_io_failures::errcode",
    ][::std::mem::offset_of!(bch_io_failures_bch_dev_io_failures, errcode) - 4usize];
};
impl bch_io_failures_bch_dev_io_failures {
    #[inline]
    pub fn csum_nr(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 7u8) as u32) }
    }
    #[inline]
    pub fn set_csum_nr(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 7u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn csum_nr_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 7u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_csum_nr_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                7u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        csum_nr: ::std::os::raw::c_uint,
    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                7u8,
                {
                    let csum_nr: u32 = unsafe { ::std::mem::transmute(csum_nr) };
                    csum_nr as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_io_failures"][::std::mem::size_of::<bch_io_failures>() - 88usize];
    ["Alignment of bch_io_failures"][::std::mem::align_of::<bch_io_failures>() - 8usize];
    [
        "Offset of field: bch_io_failures::nr",
    ][::std::mem::offset_of!(bch_io_failures, nr) - 0usize];
    [
        "Offset of field: bch_io_failures::data",
    ][::std::mem::offset_of!(bch_io_failures, data) - 4usize];
    [
        "Offset of field: bch_io_failures::ec_msg",
    ][::std::mem::offset_of!(bch_io_failures, ec_msg) - 48usize];
};
impl Default for bch_io_failures {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_read_flags {
    BCH_READ_retry_if_stale = 1,
    BCH_READ_may_promote = 2,
    BCH_READ_user_mapped = 4,
    BCH_READ_soft_require_read_device = 8,
    BCH_READ_hard_require_read_device = 16,
    BCH_READ_last_fragment = 32,
    BCH_READ_must_bounce = 64,
    BCH_READ_must_clone = 128,
    BCH_READ_in_retry = 256,
    BCH_READ_no_poison_check = 512,
}
#[repr(C)]
pub struct journal_buf {
    pub io: closure,
    pub j: *mut journal,
    pub data: *mut jset,
    pub key: bkey_i,
    pub key_pad: [__u64; 4usize],
    pub cas: [*mut bch_dev; 4usize],
    pub devs_written: bch_devs_list,
    pub failed: bch_io_failures,
    pub wait: closure_waitlist,
    pub last_seq: u64_,
    pub expires: ::std::os::raw::c_long,
    pub flush_time: u64_,
    pub buf_size: ::std::os::raw::c_uint,
    pub sectors: ::std::os::raw::c_uint,
    pub disk_sectors: ::std::os::raw::c_uint,
    pub u64s_reserved: ::std::os::raw::c_uint,
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
    pub __bindgen_padding_0: [u16; 3usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of journal_buf"][::std::mem::size_of::<journal_buf>() - 336usize];
    ["Alignment of journal_buf"][::std::mem::align_of::<journal_buf>() - 8usize];
    [
        "Offset of field: journal_buf::io",
    ][::std::mem::offset_of!(journal_buf, io) - 0usize];
    [
        "Offset of field: journal_buf::j",
    ][::std::mem::offset_of!(journal_buf, j) - 48usize];
    [
        "Offset of field: journal_buf::data",
    ][::std::mem::offset_of!(journal_buf, data) - 56usize];
    [
        "Offset of field: journal_buf::key",
    ][::std::mem::offset_of!(journal_buf, key) - 64usize];
    [
        "Offset of field: journal_buf::key_pad",
    ][::std::mem::offset_of!(journal_buf, key_pad) - 104usize];
    [
        "Offset of field: journal_buf::cas",
    ][::std::mem::offset_of!(journal_buf, cas) - 136usize];
    [
        "Offset of field: journal_buf::devs_written",
    ][::std::mem::offset_of!(journal_buf, devs_written) - 168usize];
    [
        "Offset of field: journal_buf::failed",
    ][::std::mem::offset_of!(journal_buf, failed) - 192usize];
    [
        "Offset of field: journal_buf::wait",
    ][::std::mem::offset_of!(journal_buf, wait) - 280usize];
    [
        "Offset of field: journal_buf::last_seq",
    ][::std::mem::offset_of!(journal_buf, last_seq) - 288usize];
    [
        "Offset of field: journal_buf::expires",
    ][::std::mem::offset_of!(journal_buf, expires) - 296usize];
    [
        "Offset of field: journal_buf::flush_time",
    ][::std::mem::offset_of!(journal_buf, flush_time) - 304usize];
    [
        "Offset of field: journal_buf::buf_size",
    ][::std::mem::offset_of!(journal_buf, buf_size) - 312usize];
    [
        "Offset of field: journal_buf::sectors",
    ][::std::mem::offset_of!(journal_buf, sectors) - 316usize];
    [
        "Offset of field: journal_buf::disk_sectors",
    ][::std::mem::offset_of!(journal_buf, disk_sectors) - 320usize];
    [
        "Offset of field: journal_buf::u64s_reserved",
    ][::std::mem::offset_of!(journal_buf, u64s_reserved) - 324usize];
};
impl Default for journal_buf {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl journal_buf {
    #[inline]
    pub fn noflush(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_noflush(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn noflush_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_noflush_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn must_flush(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_must_flush(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(1usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn must_flush_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 1usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_must_flush_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                1usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn separate_flush(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_separate_flush(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(2usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn separate_flush_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 2usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_separate_flush_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                2usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn need_flush_to_write_buffer(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_need_flush_to_write_buffer(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(3usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn need_flush_to_write_buffer_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 3usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_need_flush_to_write_buffer_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                3usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn write_started(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_write_started(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(4usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn write_started_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 4usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_write_started_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                4usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn write_allocated(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_write_allocated(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(5usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn write_allocated_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 5usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_write_allocated_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                5usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn write_done(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_write_done(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(6usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn write_done_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 6usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_write_done_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                6usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn empty(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_empty(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(7usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn empty_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 7usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_empty_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                7usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn has_overwrites(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_has_overwrites(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(8usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn has_overwrites_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 8usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_has_overwrites_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                8usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        noflush: bool,
        must_flush: bool,
        separate_flush: bool,
        need_flush_to_write_buffer: bool,
        write_started: bool,
        write_allocated: bool,
        write_done: bool,
        empty: bool,
        has_overwrites: bool,
    ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                1u8,
                {
                    let noflush: u8 = unsafe { ::std::mem::transmute(noflush) };
                    noflush as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                1usize,
                1u8,
                {
                    let must_flush: u8 = unsafe { ::std::mem::transmute(must_flush) };
                    must_flush as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                2usize,
                1u8,
                {
                    let separate_flush: u8 = unsafe {
                        ::std::mem::transmute(separate_flush)
                    };
                    separate_flush as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                3usize,
                1u8,
                {
                    let need_flush_to_write_buffer: u8 = unsafe {
                        ::std::mem::transmute(need_flush_to_write_buffer)
                    };
                    need_flush_to_write_buffer as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                4usize,
                1u8,
                {
                    let write_started: u8 = unsafe {
                        ::std::mem::transmute(write_started)
                    };
                    write_started as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                5usize,
                1u8,
                {
                    let write_allocated: u8 = unsafe {
                        ::std::mem::transmute(write_allocated)
                    };
                    write_allocated as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                6usize,
                1u8,
                {
                    let write_done: u8 = unsafe { ::std::mem::transmute(write_done) };
                    write_done as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                7usize,
                1u8,
                {
                    let empty: u8 = unsafe { ::std::mem::transmute(empty) };
                    empty as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                8usize,
                1u8,
                {
                    let has_overwrites: u8 = unsafe {
                        ::std::mem::transmute(has_overwrites)
                    };
                    has_overwrites as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct journal_ringbuf {
    pub buf: *mut journal_buf,
    pub data: *mut jset,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of journal_ringbuf"][::std::mem::size_of::<journal_ringbuf>() - 16usize];
    ["Alignment of journal_ringbuf"][::std::mem::align_of::<journal_ringbuf>() - 8usize];
    [
        "Offset of field: journal_ringbuf::buf",
    ][::std::mem::offset_of!(journal_ringbuf, buf) - 0usize];
    [
        "Offset of field: journal_ringbuf::data",
    ][::std::mem::offset_of!(journal_ringbuf, data) - 8usize];
};
impl Default for journal_ringbuf {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct journal_entry_pin_list {
    pub unflushed: [cds_list_head; 6usize],
    pub flushed: [cds_list_head; 6usize],
    pub count: atomic_t,
    pub unreplayed: bool,
    pub devs: bch_replicas_padded,
    pub bytes: usize,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of journal_entry_pin_list",
    ][::std::mem::size_of::<journal_entry_pin_list>() - 224usize];
    [
        "Alignment of journal_entry_pin_list",
    ][::std::mem::align_of::<journal_entry_pin_list>() - 8usize];
    [
        "Offset of field: journal_entry_pin_list::unflushed",
    ][::std::mem::offset_of!(journal_entry_pin_list, unflushed) - 0usize];
    [
        "Offset of field: journal_entry_pin_list::flushed",
    ][::std::mem::offset_of!(journal_entry_pin_list, flushed) - 96usize];
    [
        "Offset of field: journal_entry_pin_list::count",
    ][::std::mem::offset_of!(journal_entry_pin_list, count) - 192usize];
    [
        "Offset of field: journal_entry_pin_list::unreplayed",
    ][::std::mem::offset_of!(journal_entry_pin_list, unreplayed) - 196usize];
    [
        "Offset of field: journal_entry_pin_list::devs",
    ][::std::mem::offset_of!(journal_entry_pin_list, devs) - 197usize];
    [
        "Offset of field: journal_entry_pin_list::bytes",
    ][::std::mem::offset_of!(journal_entry_pin_list, bytes) - 216usize];
};
impl Default for journal_entry_pin_list {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type journal_pin_flush_fn = ::std::option::Option<
    unsafe extern "C" fn(
        j: *mut journal,
        arg1: *mut journal_entry_pin,
        arg2: u64_,
    ) -> ::std::os::raw::c_int,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct journal_entry_pin {
    pub list: cds_list_head,
    pub flush: journal_pin_flush_fn,
    pub seq: u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of journal_entry_pin"][::std::mem::size_of::<journal_entry_pin>() - 32usize];
    [
        "Alignment of journal_entry_pin",
    ][::std::mem::align_of::<journal_entry_pin>() - 8usize];
    [
        "Offset of field: journal_entry_pin::list",
    ][::std::mem::offset_of!(journal_entry_pin, list) - 0usize];
    [
        "Offset of field: journal_entry_pin::flush",
    ][::std::mem::offset_of!(journal_entry_pin, flush) - 16usize];
    [
        "Offset of field: journal_entry_pin::seq",
    ][::std::mem::offset_of!(journal_entry_pin, seq) - 24usize];
};
impl Default for journal_entry_pin {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct journal_res {
    pub ref_: bool,
    pub has_overwrites: bool,
    pub u64s: u16_,
    pub offset: u32_,
    pub seq: u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of journal_res"][::std::mem::size_of::<journal_res>() - 16usize];
    ["Alignment of journal_res"][::std::mem::align_of::<journal_res>() - 8usize];
    [
        "Offset of field: journal_res::ref_",
    ][::std::mem::offset_of!(journal_res, ref_) - 0usize];
    [
        "Offset of field: journal_res::has_overwrites",
    ][::std::mem::offset_of!(journal_res, has_overwrites) - 1usize];
    [
        "Offset of field: journal_res::u64s",
    ][::std::mem::offset_of!(journal_res, u64s) - 2usize];
    [
        "Offset of field: journal_res::offset",
    ][::std::mem::offset_of!(journal_res, offset) - 4usize];
    [
        "Offset of field: journal_res::seq",
    ][::std::mem::offset_of!(journal_res, seq) - 8usize];
};
#[repr(C)]
#[derive(Copy, Clone)]
pub union journal_res_state {
    pub __bindgen_anon_1: journal_res_state__bindgen_ty_1,
    pub __bindgen_anon_2: journal_res_state__bindgen_ty_2,
    pub __bindgen_anon_3: journal_res_state__bindgen_ty_3,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct journal_res_state__bindgen_ty_1 {
    pub counter: atomic64_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of journal_res_state__bindgen_ty_1",
    ][::std::mem::size_of::<journal_res_state__bindgen_ty_1>() - 8usize];
    [
        "Alignment of journal_res_state__bindgen_ty_1",
    ][::std::mem::align_of::<journal_res_state__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: journal_res_state__bindgen_ty_1::counter",
    ][::std::mem::offset_of!(journal_res_state__bindgen_ty_1, counter) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct journal_res_state__bindgen_ty_2 {
    pub v: u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of journal_res_state__bindgen_ty_2",
    ][::std::mem::size_of::<journal_res_state__bindgen_ty_2>() - 8usize];
    [
        "Alignment of journal_res_state__bindgen_ty_2",
    ][::std::mem::align_of::<journal_res_state__bindgen_ty_2>() - 8usize];
    [
        "Offset of field: journal_res_state__bindgen_ty_2::v",
    ][::std::mem::offset_of!(journal_res_state__bindgen_ty_2, v) - 0usize];
};
#[repr(C)]
#[repr(align(8))]
#[derive(Debug, Default, Copy, Clone)]
pub struct journal_res_state__bindgen_ty_3 {
    pub _bitfield_align_1: [u32; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of journal_res_state__bindgen_ty_3",
    ][::std::mem::size_of::<journal_res_state__bindgen_ty_3>() - 8usize];
    [
        "Alignment of journal_res_state__bindgen_ty_3",
    ][::std::mem::align_of::<journal_res_state__bindgen_ty_3>() - 8usize];
};
impl journal_res_state__bindgen_ty_3 {
    #[inline]
    pub fn cur_entry_offset(&self) -> u64_ {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 22u8) as u64) }
    }
    #[inline]
    pub fn set_cur_entry_offset(&mut self, val: u64_) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 22u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn cur_entry_offset_raw(this: *const Self) -> u64_ {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 22u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_cur_entry_offset_raw(this: *mut Self, val: u64_) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                22u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn idx(&self) -> u64_ {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 2u8) as u64) }
    }
    #[inline]
    pub fn set_idx(&mut self, val: u64_) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(22usize, 2u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn idx_raw(this: *const Self) -> u64_ {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 22usize, 2u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_idx_raw(this: *mut Self, val: u64_) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                22usize,
                2u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn buf0_count(&self) -> u64_ {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 10u8) as u64) }
    }
    #[inline]
    pub fn set_buf0_count(&mut self, val: u64_) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(24usize, 10u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn buf0_count_raw(this: *const Self) -> u64_ {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 24usize, 10u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_buf0_count_raw(this: *mut Self, val: u64_) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                24usize,
                10u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn buf1_count(&self) -> u64_ {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(34usize, 10u8) as u64) }
    }
    #[inline]
    pub fn set_buf1_count(&mut self, val: u64_) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(34usize, 10u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn buf1_count_raw(this: *const Self) -> u64_ {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 34usize, 10u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_buf1_count_raw(this: *mut Self, val: u64_) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                34usize,
                10u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn buf2_count(&self) -> u64_ {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(44usize, 10u8) as u64) }
    }
    #[inline]
    pub fn set_buf2_count(&mut self, val: u64_) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(44usize, 10u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn buf2_count_raw(this: *const Self) -> u64_ {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 44usize, 10u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_buf2_count_raw(this: *mut Self, val: u64_) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                44usize,
                10u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn buf3_count(&self) -> u64_ {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(54usize, 10u8) as u64) }
    }
    #[inline]
    pub fn set_buf3_count(&mut self, val: u64_) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(54usize, 10u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn buf3_count_raw(this: *const Self) -> u64_ {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 54usize, 10u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_buf3_count_raw(this: *mut Self, val: u64_) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                54usize,
                10u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        cur_entry_offset: u64_,
        idx: u64_,
        buf0_count: u64_,
        buf1_count: u64_,
        buf2_count: u64_,
        buf3_count: u64_,
    ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                22u8,
                {
                    let cur_entry_offset: u64 = unsafe {
                        ::std::mem::transmute(cur_entry_offset)
                    };
                    cur_entry_offset as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                22usize,
                2u8,
                {
                    let idx: u64 = unsafe { ::std::mem::transmute(idx) };
                    idx as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                24usize,
                10u8,
                {
                    let buf0_count: u64 = unsafe { ::std::mem::transmute(buf0_count) };
                    buf0_count as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                34usize,
                10u8,
                {
                    let buf1_count: u64 = unsafe { ::std::mem::transmute(buf1_count) };
                    buf1_count as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                44usize,
                10u8,
                {
                    let buf2_count: u64 = unsafe { ::std::mem::transmute(buf2_count) };
                    buf2_count as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                54usize,
                10u8,
                {
                    let buf3_count: u64 = unsafe { ::std::mem::transmute(buf3_count) };
                    buf3_count as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of journal_res_state"][::std::mem::size_of::<journal_res_state>() - 8usize];
    [
        "Alignment of journal_res_state",
    ][::std::mem::align_of::<journal_res_state>() - 8usize];
};
impl Default for journal_res_state {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct journal_space {
    pub next_entry: ::std::os::raw::c_uint,
    pub total: ::std::os::raw::c_uint,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of journal_space"][::std::mem::size_of::<journal_space>() - 8usize];
    ["Alignment of journal_space"][::std::mem::align_of::<journal_space>() - 4usize];
    [
        "Offset of field: journal_space::next_entry",
    ][::std::mem::offset_of!(journal_space, next_entry) - 0usize];
    [
        "Offset of field: journal_space::total",
    ][::std::mem::offset_of!(journal_space, total) - 4usize];
};
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum journal_space_from {
    journal_space_discarded = 0,
    journal_space_clean_ondisk = 1,
    journal_space_clean = 2,
    journal_space_total = 3,
    journal_space_nr = 4,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct journal_rewind_range {
    pub from: u64_,
    pub to: u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of journal_rewind_range",
    ][::std::mem::size_of::<journal_rewind_range>() - 16usize];
    [
        "Alignment of journal_rewind_range",
    ][::std::mem::align_of::<journal_rewind_range>() - 8usize];
    [
        "Offset of field: journal_rewind_range::from",
    ][::std::mem::offset_of!(journal_rewind_range, from) - 0usize];
    [
        "Offset of field: journal_rewind_range::to",
    ][::std::mem::offset_of!(journal_rewind_range, to) - 8usize];
};
#[repr(C)]
#[repr(align(64))]
pub struct journal {
    pub __bindgen_anon_1: journal__bindgen_ty_1,
    pub flags: ::std::os::raw::c_ulong,
    pub cur_entry_u64s: ::std::os::raw::c_uint,
    pub cur_entry_sectors: ::std::os::raw::c_uint,
    pub entry_u64s_reserved: ::std::os::raw::c_uint,
    pub cur_entry_error: ::std::os::raw::c_int,
    pub cur_entry_offset_if_blocked: ::std::os::raw::c_uint,
    pub buf_size_want: ::std::os::raw::c_uint,
    pub early_journal_entries: darray_u64,
    pub buf_lock: mutex,
    pub ring: [journal_ringbuf; 4usize],
    pub in_flight: journal__bindgen_ty_2,
    pub free_buf: *mut ::std::os::raw::c_void,
    pub free_buf_size: ::std::os::raw::c_uint,
    pub lock: spinlock_t,
    pub blocked: ::std::os::raw::c_uint,
    pub wait: wait_queue_head_t,
    pub async_wait: closure_waitlist,
    pub reclaim_flush_wait: closure_waitlist,
    pub write_work: delayed_work,
    pub wq: *mut workqueue_struct,
    pub discard_wq: *mut workqueue_struct,
    pub seq: atomic64_t,
    pub seq_write_started: u64_,
    pub seq_ondisk: u64_,
    pub flushed_seq_ondisk: u64_,
    pub flushing_seq: u64_,
    pub last_seq_ondisk: u64_,
    pub err_seq: u64_,
    pub last_empty_seq: u64_,
    pub oldest_seq_found_ondisk: u64_,
    pub rewind_seq: u64_,
    pub rewind_seq_ondisk: u64_,
    pub rewind_ranges: journal__bindgen_ty_3,
    pub pin: journal__bindgen_ty_4,
    pub last_seq: u64_,
    pub dirty_entry_bytes: usize,
    pub space: [journal_space; 4usize],
    pub replay_journal_seq: u64_,
    pub replay_journal_seq_end: u64_,
    pub __bindgen_padding_0: u64,
    pub wp: write_point,
    pub err_lock: spinlock_t,
    pub reclaim_lock: mutex,
    pub reclaim_wait: wait_queue_head_t,
    pub reclaim_thread: *mut task_struct,
    pub reclaim_kicked: bool,
    pub next_reclaim: ::std::os::raw::c_ulong,
    pub nr_direct_reclaim: u64_,
    pub nr_background_reclaim: u64_,
    pub last_flushed: ::std::os::raw::c_ulong,
    pub flush_in_progress: *mut journal_entry_pin,
    pub flush_in_progress_dropped: bool,
    pub pin_flush_wait: wait_queue_head_t,
    pub can_discard: bool,
    pub last_flush_write: ::std::os::raw::c_ulong,
    pub write_start_time: u64_,
    pub nr_flush_writes: u64_,
    pub nr_noflush_writes: u64_,
    pub entry_bytes_written: u64_,
    pub flush_write_time: *mut bch2_time_stats,
    pub noflush_write_time: *mut bch2_time_stats,
    pub flush_seq_time: *mut bch2_time_stats,
}
#[repr(C)]
#[repr(align(64))]
#[derive(Copy, Clone)]
pub struct journal__bindgen_ty_1 {
    pub reservations: journal_res_state,
    pub watermark: bch_watermark,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of journal__bindgen_ty_1",
    ][::std::mem::size_of::<journal__bindgen_ty_1>() - 64usize];
    [
        "Alignment of journal__bindgen_ty_1",
    ][::std::mem::align_of::<journal__bindgen_ty_1>() - 64usize];
    [
        "Offset of field: journal__bindgen_ty_1::reservations",
    ][::std::mem::offset_of!(journal__bindgen_ty_1, reservations) - 0usize];
    [
        "Offset of field: journal__bindgen_ty_1::watermark",
    ][::std::mem::offset_of!(journal__bindgen_ty_1, watermark) - 8usize];
};
impl Default for journal__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct journal__bindgen_ty_2 {
    pub front: u64_,
    pub back: u64_,
    pub size: u64_,
    pub mask: u64_,
    pub data: *mut journal_buf,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of journal__bindgen_ty_2",
    ][::std::mem::size_of::<journal__bindgen_ty_2>() - 40usize];
    [
        "Alignment of journal__bindgen_ty_2",
    ][::std::mem::align_of::<journal__bindgen_ty_2>() - 8usize];
    [
        "Offset of field: journal__bindgen_ty_2::front",
    ][::std::mem::offset_of!(journal__bindgen_ty_2, front) - 0usize];
    [
        "Offset of field: journal__bindgen_ty_2::back",
    ][::std::mem::offset_of!(journal__bindgen_ty_2, back) - 8usize];
    [
        "Offset of field: journal__bindgen_ty_2::size",
    ][::std::mem::offset_of!(journal__bindgen_ty_2, size) - 16usize];
    [
        "Offset of field: journal__bindgen_ty_2::mask",
    ][::std::mem::offset_of!(journal__bindgen_ty_2, mask) - 24usize];
    [
        "Offset of field: journal__bindgen_ty_2::data",
    ][::std::mem::offset_of!(journal__bindgen_ty_2, data) - 32usize];
};
impl Default for journal__bindgen_ty_2 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug)]
pub struct journal__bindgen_ty_3 {
    pub nr: usize,
    pub size: usize,
    pub data: *mut journal_rewind_range,
    pub preallocated: __IncompleteArrayField<journal_rewind_range>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of journal__bindgen_ty_3",
    ][::std::mem::size_of::<journal__bindgen_ty_3>() - 24usize];
    [
        "Alignment of journal__bindgen_ty_3",
    ][::std::mem::align_of::<journal__bindgen_ty_3>() - 8usize];
    [
        "Offset of field: journal__bindgen_ty_3::nr",
    ][::std::mem::offset_of!(journal__bindgen_ty_3, nr) - 0usize];
    [
        "Offset of field: journal__bindgen_ty_3::size",
    ][::std::mem::offset_of!(journal__bindgen_ty_3, size) - 8usize];
    [
        "Offset of field: journal__bindgen_ty_3::data",
    ][::std::mem::offset_of!(journal__bindgen_ty_3, data) - 16usize];
    [
        "Offset of field: journal__bindgen_ty_3::preallocated",
    ][::std::mem::offset_of!(journal__bindgen_ty_3, preallocated) - 24usize];
};
impl Default for journal__bindgen_ty_3 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct journal__bindgen_ty_4 {
    pub front: u64_,
    pub back: u64_,
    pub size: u64_,
    pub mask: u64_,
    pub data: *mut journal_entry_pin_list,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of journal__bindgen_ty_4",
    ][::std::mem::size_of::<journal__bindgen_ty_4>() - 40usize];
    [
        "Alignment of journal__bindgen_ty_4",
    ][::std::mem::align_of::<journal__bindgen_ty_4>() - 8usize];
    [
        "Offset of field: journal__bindgen_ty_4::front",
    ][::std::mem::offset_of!(journal__bindgen_ty_4, front) - 0usize];
    [
        "Offset of field: journal__bindgen_ty_4::back",
    ][::std::mem::offset_of!(journal__bindgen_ty_4, back) - 8usize];
    [
        "Offset of field: journal__bindgen_ty_4::size",
    ][::std::mem::offset_of!(journal__bindgen_ty_4, size) - 16usize];
    [
        "Offset of field: journal__bindgen_ty_4::mask",
    ][::std::mem::offset_of!(journal__bindgen_ty_4, mask) - 24usize];
    [
        "Offset of field: journal__bindgen_ty_4::data",
    ][::std::mem::offset_of!(journal__bindgen_ty_4, data) - 32usize];
};
impl Default for journal__bindgen_ty_4 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of journal"][::std::mem::size_of::<journal>() - 1984usize];
    ["Alignment of journal"][::std::mem::align_of::<journal>() - 64usize];
    [
        "Offset of field: journal::flags",
    ][::std::mem::offset_of!(journal, flags) - 64usize];
    [
        "Offset of field: journal::cur_entry_u64s",
    ][::std::mem::offset_of!(journal, cur_entry_u64s) - 72usize];
    [
        "Offset of field: journal::cur_entry_sectors",
    ][::std::mem::offset_of!(journal, cur_entry_sectors) - 76usize];
    [
        "Offset of field: journal::entry_u64s_reserved",
    ][::std::mem::offset_of!(journal, entry_u64s_reserved) - 80usize];
    [
        "Offset of field: journal::cur_entry_error",
    ][::std::mem::offset_of!(journal, cur_entry_error) - 84usize];
    [
        "Offset of field: journal::cur_entry_offset_if_blocked",
    ][::std::mem::offset_of!(journal, cur_entry_offset_if_blocked) - 88usize];
    [
        "Offset of field: journal::buf_size_want",
    ][::std::mem::offset_of!(journal, buf_size_want) - 92usize];
    [
        "Offset of field: journal::early_journal_entries",
    ][::std::mem::offset_of!(journal, early_journal_entries) - 96usize];
    [
        "Offset of field: journal::buf_lock",
    ][::std::mem::offset_of!(journal, buf_lock) - 120usize];
    ["Offset of field: journal::ring"][::std::mem::offset_of!(journal, ring) - 160usize];
    [
        "Offset of field: journal::in_flight",
    ][::std::mem::offset_of!(journal, in_flight) - 224usize];
    [
        "Offset of field: journal::free_buf",
    ][::std::mem::offset_of!(journal, free_buf) - 264usize];
    [
        "Offset of field: journal::free_buf_size",
    ][::std::mem::offset_of!(journal, free_buf_size) - 272usize];
    ["Offset of field: journal::lock"][::std::mem::offset_of!(journal, lock) - 280usize];
    [
        "Offset of field: journal::blocked",
    ][::std::mem::offset_of!(journal, blocked) - 320usize];
    ["Offset of field: journal::wait"][::std::mem::offset_of!(journal, wait) - 328usize];
    [
        "Offset of field: journal::async_wait",
    ][::std::mem::offset_of!(journal, async_wait) - 384usize];
    [
        "Offset of field: journal::reclaim_flush_wait",
    ][::std::mem::offset_of!(journal, reclaim_flush_wait) - 392usize];
    [
        "Offset of field: journal::write_work",
    ][::std::mem::offset_of!(journal, write_work) - 400usize];
    ["Offset of field: journal::wq"][::std::mem::offset_of!(journal, wq) - 464usize];
    [
        "Offset of field: journal::discard_wq",
    ][::std::mem::offset_of!(journal, discard_wq) - 472usize];
    ["Offset of field: journal::seq"][::std::mem::offset_of!(journal, seq) - 480usize];
    [
        "Offset of field: journal::seq_write_started",
    ][::std::mem::offset_of!(journal, seq_write_started) - 488usize];
    [
        "Offset of field: journal::seq_ondisk",
    ][::std::mem::offset_of!(journal, seq_ondisk) - 496usize];
    [
        "Offset of field: journal::flushed_seq_ondisk",
    ][::std::mem::offset_of!(journal, flushed_seq_ondisk) - 504usize];
    [
        "Offset of field: journal::flushing_seq",
    ][::std::mem::offset_of!(journal, flushing_seq) - 512usize];
    [
        "Offset of field: journal::last_seq_ondisk",
    ][::std::mem::offset_of!(journal, last_seq_ondisk) - 520usize];
    [
        "Offset of field: journal::err_seq",
    ][::std::mem::offset_of!(journal, err_seq) - 528usize];
    [
        "Offset of field: journal::last_empty_seq",
    ][::std::mem::offset_of!(journal, last_empty_seq) - 536usize];
    [
        "Offset of field: journal::oldest_seq_found_ondisk",
    ][::std::mem::offset_of!(journal, oldest_seq_found_ondisk) - 544usize];
    [
        "Offset of field: journal::rewind_seq",
    ][::std::mem::offset_of!(journal, rewind_seq) - 552usize];
    [
        "Offset of field: journal::rewind_seq_ondisk",
    ][::std::mem::offset_of!(journal, rewind_seq_ondisk) - 560usize];
    [
        "Offset of field: journal::rewind_ranges",
    ][::std::mem::offset_of!(journal, rewind_ranges) - 568usize];
    ["Offset of field: journal::pin"][::std::mem::offset_of!(journal, pin) - 592usize];
    [
        "Offset of field: journal::last_seq",
    ][::std::mem::offset_of!(journal, last_seq) - 632usize];
    [
        "Offset of field: journal::dirty_entry_bytes",
    ][::std::mem::offset_of!(journal, dirty_entry_bytes) - 640usize];
    [
        "Offset of field: journal::space",
    ][::std::mem::offset_of!(journal, space) - 648usize];
    [
        "Offset of field: journal::replay_journal_seq",
    ][::std::mem::offset_of!(journal, replay_journal_seq) - 680usize];
    [
        "Offset of field: journal::replay_journal_seq_end",
    ][::std::mem::offset_of!(journal, replay_journal_seq_end) - 688usize];
    ["Offset of field: journal::wp"][::std::mem::offset_of!(journal, wp) - 704usize];
    [
        "Offset of field: journal::err_lock",
    ][::std::mem::offset_of!(journal, err_lock) - 1600usize];
    [
        "Offset of field: journal::reclaim_lock",
    ][::std::mem::offset_of!(journal, reclaim_lock) - 1640usize];
    [
        "Offset of field: journal::reclaim_wait",
    ][::std::mem::offset_of!(journal, reclaim_wait) - 1680usize];
    [
        "Offset of field: journal::reclaim_thread",
    ][::std::mem::offset_of!(journal, reclaim_thread) - 1736usize];
    [
        "Offset of field: journal::reclaim_kicked",
    ][::std::mem::offset_of!(journal, reclaim_kicked) - 1744usize];
    [
        "Offset of field: journal::next_reclaim",
    ][::std::mem::offset_of!(journal, next_reclaim) - 1752usize];
    [
        "Offset of field: journal::nr_direct_reclaim",
    ][::std::mem::offset_of!(journal, nr_direct_reclaim) - 1760usize];
    [
        "Offset of field: journal::nr_background_reclaim",
    ][::std::mem::offset_of!(journal, nr_background_reclaim) - 1768usize];
    [
        "Offset of field: journal::last_flushed",
    ][::std::mem::offset_of!(journal, last_flushed) - 1776usize];
    [
        "Offset of field: journal::flush_in_progress",
    ][::std::mem::offset_of!(journal, flush_in_progress) - 1784usize];
    [
        "Offset of field: journal::flush_in_progress_dropped",
    ][::std::mem::offset_of!(journal, flush_in_progress_dropped) - 1792usize];
    [
        "Offset of field: journal::pin_flush_wait",
    ][::std::mem::offset_of!(journal, pin_flush_wait) - 1800usize];
    [
        "Offset of field: journal::can_discard",
    ][::std::mem::offset_of!(journal, can_discard) - 1856usize];
    [
        "Offset of field: journal::last_flush_write",
    ][::std::mem::offset_of!(journal, last_flush_write) - 1864usize];
    [
        "Offset of field: journal::write_start_time",
    ][::std::mem::offset_of!(journal, write_start_time) - 1872usize];
    [
        "Offset of field: journal::nr_flush_writes",
    ][::std::mem::offset_of!(journal, nr_flush_writes) - 1880usize];
    [
        "Offset of field: journal::nr_noflush_writes",
    ][::std::mem::offset_of!(journal, nr_noflush_writes) - 1888usize];
    [
        "Offset of field: journal::entry_bytes_written",
    ][::std::mem::offset_of!(journal, entry_bytes_written) - 1896usize];
    [
        "Offset of field: journal::flush_write_time",
    ][::std::mem::offset_of!(journal, flush_write_time) - 1904usize];
    [
        "Offset of field: journal::noflush_write_time",
    ][::std::mem::offset_of!(journal, noflush_write_time) - 1912usize];
    [
        "Offset of field: journal::flush_seq_time",
    ][::std::mem::offset_of!(journal, flush_seq_time) - 1920usize];
};
impl Default for journal {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct journal_device {
    pub bucket_seq: *mut u64_,
    pub sectors_free: ::std::os::raw::c_uint,
    pub discard_idx: ::std::os::raw::c_uint,
    pub dirty_idx_ondisk: ::std::os::raw::c_uint,
    pub dirty_idx: ::std::os::raw::c_uint,
    pub cur_idx: ::std::os::raw::c_uint,
    pub nr: ::std::os::raw::c_uint,
    pub buckets: *mut u64_,
    pub bio_set: bio_set,
    pub discard_lock: mutex,
    pub discard: work_struct,
    pub read: closure,
    pub highest_seq_found: u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of journal_device"][::std::mem::size_of::<journal_device>() - 448usize];
    ["Alignment of journal_device"][::std::mem::align_of::<journal_device>() - 8usize];
    [
        "Offset of field: journal_device::bucket_seq",
    ][::std::mem::offset_of!(journal_device, bucket_seq) - 0usize];
    [
        "Offset of field: journal_device::sectors_free",
    ][::std::mem::offset_of!(journal_device, sectors_free) - 8usize];
    [
        "Offset of field: journal_device::discard_idx",
    ][::std::mem::offset_of!(journal_device, discard_idx) - 12usize];
    [
        "Offset of field: journal_device::dirty_idx_ondisk",
    ][::std::mem::offset_of!(journal_device, dirty_idx_ondisk) - 16usize];
    [
        "Offset of field: journal_device::dirty_idx",
    ][::std::mem::offset_of!(journal_device, dirty_idx) - 20usize];
    [
        "Offset of field: journal_device::cur_idx",
    ][::std::mem::offset_of!(journal_device, cur_idx) - 24usize];
    [
        "Offset of field: journal_device::nr",
    ][::std::mem::offset_of!(journal_device, nr) - 28usize];
    [
        "Offset of field: journal_device::buckets",
    ][::std::mem::offset_of!(journal_device, buckets) - 32usize];
    [
        "Offset of field: journal_device::bio_set",
    ][::std::mem::offset_of!(journal_device, bio_set) - 40usize];
    [
        "Offset of field: journal_device::discard_lock",
    ][::std::mem::offset_of!(journal_device, discard_lock) - 320usize];
    [
        "Offset of field: journal_device::discard",
    ][::std::mem::offset_of!(journal_device, discard) - 360usize];
    [
        "Offset of field: journal_device::read",
    ][::std::mem::offset_of!(journal_device, read) - 392usize];
    [
        "Offset of field: journal_device::highest_seq_found",
    ][::std::mem::offset_of!(journal_device, highest_seq_found) - 440usize];
};
impl Default for journal_device {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct journal_entry_res {
    pub u64s: ::std::os::raw::c_uint,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of journal_entry_res"][::std::mem::size_of::<journal_entry_res>() - 4usize];
    [
        "Alignment of journal_entry_res",
    ][::std::mem::align_of::<journal_entry_res>() - 4usize];
    [
        "Offset of field: journal_entry_res::u64s",
    ][::std::mem::offset_of!(journal_entry_res, u64s) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct journal_start_info {
    pub last_seq: u64_,
    pub replay_end: u64_,
    pub cur_seq: u64_,
    pub clean: bool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of journal_start_info",
    ][::std::mem::size_of::<journal_start_info>() - 32usize];
    [
        "Alignment of journal_start_info",
    ][::std::mem::align_of::<journal_start_info>() - 8usize];
    [
        "Offset of field: journal_start_info::last_seq",
    ][::std::mem::offset_of!(journal_start_info, last_seq) - 0usize];
    [
        "Offset of field: journal_start_info::replay_end",
    ][::std::mem::offset_of!(journal_start_info, replay_end) - 8usize];
    [
        "Offset of field: journal_start_info::cur_seq",
    ][::std::mem::offset_of!(journal_start_info, cur_seq) - 16usize];
    [
        "Offset of field: journal_start_info::clean",
    ][::std::mem::offset_of!(journal_start_info, clean) - 24usize];
};
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_wb_btree {
    BCH_WB_BTREE_lru = 0,
    BCH_WB_BTREE_need_discard = 1,
    BCH_WB_BTREE_backpointers = 2,
    BCH_WB_BTREE_deleted_inodes = 3,
    BCH_WB_BTREE_reconcile_work = 4,
    BCH_WB_BTREE_accounting = 5,
    BCH_WB_BTREE_reconcile_hipri = 6,
    BCH_WB_BTREE_reconcile_pending = 7,
    BCH_WB_BTREE_reconcile_work_phys = 8,
    BCH_WB_BTREE_reconcile_hipri_phys = 9,
    BCH_WB_BTREE_stripe_backpointers = 10,
    BCH_WB_BTREE_NR = 11,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct wb_key_ref {
    pub __bindgen_anon_1: wb_key_ref__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union wb_key_ref__bindgen_ty_1 {
    pub __bindgen_anon_1: wb_key_ref__bindgen_ty_1__bindgen_ty_1,
    pub __bindgen_anon_2: wb_key_ref__bindgen_ty_1__bindgen_ty_2,
}
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct wb_key_ref__bindgen_ty_1__bindgen_ty_1 {
    pub idx: u32_,
    pub pos: [u8_; 20usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of wb_key_ref__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<wb_key_ref__bindgen_ty_1__bindgen_ty_1>() - 24usize];
    [
        "Alignment of wb_key_ref__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<wb_key_ref__bindgen_ty_1__bindgen_ty_1>() - 1usize];
    [
        "Offset of field: wb_key_ref__bindgen_ty_1__bindgen_ty_1::idx",
    ][::std::mem::offset_of!(wb_key_ref__bindgen_ty_1__bindgen_ty_1, idx) - 0usize];
    [
        "Offset of field: wb_key_ref__bindgen_ty_1__bindgen_ty_1::pos",
    ][::std::mem::offset_of!(wb_key_ref__bindgen_ty_1__bindgen_ty_1, pos) - 4usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct wb_key_ref__bindgen_ty_1__bindgen_ty_2 {
    pub lo: u64_,
    pub mi: u64_,
    pub hi: u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of wb_key_ref__bindgen_ty_1__bindgen_ty_2",
    ][::std::mem::size_of::<wb_key_ref__bindgen_ty_1__bindgen_ty_2>() - 24usize];
    [
        "Alignment of wb_key_ref__bindgen_ty_1__bindgen_ty_2",
    ][::std::mem::align_of::<wb_key_ref__bindgen_ty_1__bindgen_ty_2>() - 8usize];
    [
        "Offset of field: wb_key_ref__bindgen_ty_1__bindgen_ty_2::lo",
    ][::std::mem::offset_of!(wb_key_ref__bindgen_ty_1__bindgen_ty_2, lo) - 0usize];
    [
        "Offset of field: wb_key_ref__bindgen_ty_1__bindgen_ty_2::mi",
    ][::std::mem::offset_of!(wb_key_ref__bindgen_ty_1__bindgen_ty_2, mi) - 8usize];
    [
        "Offset of field: wb_key_ref__bindgen_ty_1__bindgen_ty_2::hi",
    ][::std::mem::offset_of!(wb_key_ref__bindgen_ty_1__bindgen_ty_2, hi) - 16usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of wb_key_ref__bindgen_ty_1",
    ][::std::mem::size_of::<wb_key_ref__bindgen_ty_1>() - 24usize];
    [
        "Alignment of wb_key_ref__bindgen_ty_1",
    ][::std::mem::align_of::<wb_key_ref__bindgen_ty_1>() - 8usize];
};
impl Default for wb_key_ref__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of wb_key_ref"][::std::mem::size_of::<wb_key_ref>() - 24usize];
    ["Alignment of wb_key_ref"][::std::mem::align_of::<wb_key_ref>() - 8usize];
};
impl Default for wb_key_ref {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct btree_write_buffered_key {
    pub journal_seq: u64_,
    pub k: bkey_i,
    pub k_pad: [__u64; 4usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of btree_write_buffered_key",
    ][::std::mem::size_of::<btree_write_buffered_key>() - 80usize];
    [
        "Alignment of btree_write_buffered_key",
    ][::std::mem::align_of::<btree_write_buffered_key>() - 8usize];
    [
        "Offset of field: btree_write_buffered_key::journal_seq",
    ][::std::mem::offset_of!(btree_write_buffered_key, journal_seq) - 0usize];
    [
        "Offset of field: btree_write_buffered_key::k",
    ][::std::mem::offset_of!(btree_write_buffered_key, k) - 8usize];
    [
        "Offset of field: btree_write_buffered_key::k_pad",
    ][::std::mem::offset_of!(btree_write_buffered_key, k_pad) - 48usize];
};
#[repr(C)]
pub struct btree_write_buffer_keys {
    pub keys: darray_u64,
    pub pin: journal_entry_pin,
    pub lock: mutex,
    pub wb_btree: bch_wb_btree,
    pub is_flushing: bool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of btree_write_buffer_keys",
    ][::std::mem::size_of::<btree_write_buffer_keys>() - 104usize];
    [
        "Alignment of btree_write_buffer_keys",
    ][::std::mem::align_of::<btree_write_buffer_keys>() - 8usize];
    [
        "Offset of field: btree_write_buffer_keys::keys",
    ][::std::mem::offset_of!(btree_write_buffer_keys, keys) - 0usize];
    [
        "Offset of field: btree_write_buffer_keys::pin",
    ][::std::mem::offset_of!(btree_write_buffer_keys, pin) - 24usize];
    [
        "Offset of field: btree_write_buffer_keys::lock",
    ][::std::mem::offset_of!(btree_write_buffer_keys, lock) - 56usize];
    [
        "Offset of field: btree_write_buffer_keys::wb_btree",
    ][::std::mem::offset_of!(btree_write_buffer_keys, wb_btree) - 96usize];
    [
        "Offset of field: btree_write_buffer_keys::is_flushing",
    ][::std::mem::offset_of!(btree_write_buffer_keys, is_flushing) - 100usize];
};
impl Default for btree_write_buffer_keys {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum wb_flush_caller {
    WB_FLUSH_thread = 0,
    WB_FLUSH_journal_pin = 1,
    WB_FLUSH_sync = 2,
    WB_FLUSH_maybe = 3,
    WB_FLUSH_tryflush = 4,
    WB_FLUSH_NR = 5,
}
#[repr(C)]
pub struct bch_fs_btree_write_buffer {
    pub c: *mut bch_fs,
    pub idx: bch_wb_btree,
    pub sorted: bch_fs_btree_write_buffer__bindgen_ty_1,
    pub inc: btree_write_buffer_keys,
    pub flushing: btree_write_buffer_keys,
    pub flush_work: work_struct,
    pub flush_work_caller: wb_flush_caller,
    pub nr_flushes: u64_,
    pub nr_flushes_caller: [u64_; 5usize],
    pub nr_keys_flushed: u64_,
    pub nr_keys_fast: u64_,
    pub nr_keys_slowpath: u64_,
    pub accounting: bch_fs_btree_write_buffer__bindgen_ty_2,
}
#[repr(C)]
pub struct bch_fs_btree_write_buffer__bindgen_ty_1 {
    pub nr: usize,
    pub size: usize,
    pub data: *mut wb_key_ref,
    pub preallocated: __IncompleteArrayField<wb_key_ref>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_fs_btree_write_buffer__bindgen_ty_1",
    ][::std::mem::size_of::<bch_fs_btree_write_buffer__bindgen_ty_1>() - 24usize];
    [
        "Alignment of bch_fs_btree_write_buffer__bindgen_ty_1",
    ][::std::mem::align_of::<bch_fs_btree_write_buffer__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bch_fs_btree_write_buffer__bindgen_ty_1::nr",
    ][::std::mem::offset_of!(bch_fs_btree_write_buffer__bindgen_ty_1, nr) - 0usize];
    [
        "Offset of field: bch_fs_btree_write_buffer__bindgen_ty_1::size",
    ][::std::mem::offset_of!(bch_fs_btree_write_buffer__bindgen_ty_1, size) - 8usize];
    [
        "Offset of field: bch_fs_btree_write_buffer__bindgen_ty_1::data",
    ][::std::mem::offset_of!(bch_fs_btree_write_buffer__bindgen_ty_1, data) - 16usize];
    [
        "Offset of field: bch_fs_btree_write_buffer__bindgen_ty_1::preallocated",
    ][::std::mem::offset_of!(bch_fs_btree_write_buffer__bindgen_ty_1, preallocated)
        - 24usize];
};
impl Default for bch_fs_btree_write_buffer__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug)]
pub struct bch_fs_btree_write_buffer__bindgen_ty_2 {
    pub nr: usize,
    pub size: usize,
    pub data: *mut btree_write_buffered_key,
    pub preallocated: __IncompleteArrayField<btree_write_buffered_key>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_fs_btree_write_buffer__bindgen_ty_2",
    ][::std::mem::size_of::<bch_fs_btree_write_buffer__bindgen_ty_2>() - 24usize];
    [
        "Alignment of bch_fs_btree_write_buffer__bindgen_ty_2",
    ][::std::mem::align_of::<bch_fs_btree_write_buffer__bindgen_ty_2>() - 8usize];
    [
        "Offset of field: bch_fs_btree_write_buffer__bindgen_ty_2::nr",
    ][::std::mem::offset_of!(bch_fs_btree_write_buffer__bindgen_ty_2, nr) - 0usize];
    [
        "Offset of field: bch_fs_btree_write_buffer__bindgen_ty_2::size",
    ][::std::mem::offset_of!(bch_fs_btree_write_buffer__bindgen_ty_2, size) - 8usize];
    [
        "Offset of field: bch_fs_btree_write_buffer__bindgen_ty_2::data",
    ][::std::mem::offset_of!(bch_fs_btree_write_buffer__bindgen_ty_2, data) - 16usize];
    [
        "Offset of field: bch_fs_btree_write_buffer__bindgen_ty_2::preallocated",
    ][::std::mem::offset_of!(bch_fs_btree_write_buffer__bindgen_ty_2, preallocated)
        - 24usize];
};
impl Default for bch_fs_btree_write_buffer__bindgen_ty_2 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_fs_btree_write_buffer",
    ][::std::mem::size_of::<bch_fs_btree_write_buffer>() - 384usize];
    [
        "Alignment of bch_fs_btree_write_buffer",
    ][::std::mem::align_of::<bch_fs_btree_write_buffer>() - 8usize];
    [
        "Offset of field: bch_fs_btree_write_buffer::c",
    ][::std::mem::offset_of!(bch_fs_btree_write_buffer, c) - 0usize];
    [
        "Offset of field: bch_fs_btree_write_buffer::idx",
    ][::std::mem::offset_of!(bch_fs_btree_write_buffer, idx) - 8usize];
    [
        "Offset of field: bch_fs_btree_write_buffer::sorted",
    ][::std::mem::offset_of!(bch_fs_btree_write_buffer, sorted) - 16usize];
    [
        "Offset of field: bch_fs_btree_write_buffer::inc",
    ][::std::mem::offset_of!(bch_fs_btree_write_buffer, inc) - 40usize];
    [
        "Offset of field: bch_fs_btree_write_buffer::flushing",
    ][::std::mem::offset_of!(bch_fs_btree_write_buffer, flushing) - 144usize];
    [
        "Offset of field: bch_fs_btree_write_buffer::flush_work",
    ][::std::mem::offset_of!(bch_fs_btree_write_buffer, flush_work) - 248usize];
    [
        "Offset of field: bch_fs_btree_write_buffer::flush_work_caller",
    ][::std::mem::offset_of!(bch_fs_btree_write_buffer, flush_work_caller) - 280usize];
    [
        "Offset of field: bch_fs_btree_write_buffer::nr_flushes",
    ][::std::mem::offset_of!(bch_fs_btree_write_buffer, nr_flushes) - 288usize];
    [
        "Offset of field: bch_fs_btree_write_buffer::nr_flushes_caller",
    ][::std::mem::offset_of!(bch_fs_btree_write_buffer, nr_flushes_caller) - 296usize];
    [
        "Offset of field: bch_fs_btree_write_buffer::nr_keys_flushed",
    ][::std::mem::offset_of!(bch_fs_btree_write_buffer, nr_keys_flushed) - 336usize];
    [
        "Offset of field: bch_fs_btree_write_buffer::nr_keys_fast",
    ][::std::mem::offset_of!(bch_fs_btree_write_buffer, nr_keys_fast) - 344usize];
    [
        "Offset of field: bch_fs_btree_write_buffer::nr_keys_slowpath",
    ][::std::mem::offset_of!(bch_fs_btree_write_buffer, nr_keys_slowpath) - 352usize];
    [
        "Offset of field: bch_fs_btree_write_buffer::accounting",
    ][::std::mem::offset_of!(bch_fs_btree_write_buffer, accounting) - 360usize];
};
impl Default for bch_fs_btree_write_buffer {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum six_lock_type {
    SIX_LOCK_read = 0,
    SIX_LOCK_intent = 1,
    SIX_LOCK_write = 2,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct six_lock_waiter {
    pub trans_start_time: u64_,
    pub task: *mut task_struct,
    pub lock_want: six_lock_type,
    pub lock_acquired: bool,
    pub slot_idx: u16_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of six_lock_waiter"][::std::mem::size_of::<six_lock_waiter>() - 24usize];
    ["Alignment of six_lock_waiter"][::std::mem::align_of::<six_lock_waiter>() - 8usize];
    [
        "Offset of field: six_lock_waiter::trans_start_time",
    ][::std::mem::offset_of!(six_lock_waiter, trans_start_time) - 0usize];
    [
        "Offset of field: six_lock_waiter::task",
    ][::std::mem::offset_of!(six_lock_waiter, task) - 8usize];
    [
        "Offset of field: six_lock_waiter::lock_want",
    ][::std::mem::offset_of!(six_lock_waiter, lock_want) - 16usize];
    [
        "Offset of field: six_lock_waiter::lock_acquired",
    ][::std::mem::offset_of!(six_lock_waiter, lock_acquired) - 20usize];
    [
        "Offset of field: six_lock_waiter::slot_idx",
    ][::std::mem::offset_of!(six_lock_waiter, slot_idx) - 22usize];
};
impl Default for six_lock_waiter {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct six_lock_wait_slot {
    pub w: *mut six_lock_waiter,
    pub start_time: u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of six_lock_wait_slot",
    ][::std::mem::size_of::<six_lock_wait_slot>() - 16usize];
    [
        "Alignment of six_lock_wait_slot",
    ][::std::mem::align_of::<six_lock_wait_slot>() - 8usize];
    [
        "Offset of field: six_lock_wait_slot::w",
    ][::std::mem::offset_of!(six_lock_wait_slot, w) - 0usize];
    [
        "Offset of field: six_lock_wait_slot::start_time",
    ][::std::mem::offset_of!(six_lock_wait_slot, start_time) - 8usize];
};
impl Default for six_lock_wait_slot {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug)]
pub struct six_lock_wait_fifo {
    pub size: u16_,
    pub nr: u16_,
    pub next_free_hint: u16_,
    pub data: __IncompleteArrayField<six_lock_wait_slot>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of six_lock_wait_fifo"][::std::mem::size_of::<six_lock_wait_fifo>() - 8usize];
    [
        "Alignment of six_lock_wait_fifo",
    ][::std::mem::align_of::<six_lock_wait_fifo>() - 8usize];
    [
        "Offset of field: six_lock_wait_fifo::size",
    ][::std::mem::offset_of!(six_lock_wait_fifo, size) - 0usize];
    [
        "Offset of field: six_lock_wait_fifo::nr",
    ][::std::mem::offset_of!(six_lock_wait_fifo, nr) - 2usize];
    [
        "Offset of field: six_lock_wait_fifo::next_free_hint",
    ][::std::mem::offset_of!(six_lock_wait_fifo, next_free_hint) - 4usize];
    [
        "Offset of field: six_lock_wait_fifo::data",
    ][::std::mem::offset_of!(six_lock_wait_fifo, data) - 8usize];
};
impl Default for six_lock_wait_fifo {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct six_lock {
    pub state: atomic_t,
    pub seq: u32_,
    pub intent_lock_recurse: ::std::os::raw::c_uint,
    pub write_lock_recurse: ::std::os::raw::c_uint,
    pub owner: *mut task_struct,
    pub readers: *mut ::std::os::raw::c_uint,
    pub wait_lock: raw_spinlock_t,
    pub wait_fifo: *mut six_lock_wait_fifo,
    pub inline_fifo: six_lock_wait_fifo,
    pub inline_fifo_data: [six_lock_wait_slot; 8usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of six_lock"][::std::mem::size_of::<six_lock>() - 216usize];
    ["Alignment of six_lock"][::std::mem::align_of::<six_lock>() - 8usize];
    [
        "Offset of field: six_lock::state",
    ][::std::mem::offset_of!(six_lock, state) - 0usize];
    ["Offset of field: six_lock::seq"][::std::mem::offset_of!(six_lock, seq) - 4usize];
    [
        "Offset of field: six_lock::intent_lock_recurse",
    ][::std::mem::offset_of!(six_lock, intent_lock_recurse) - 8usize];
    [
        "Offset of field: six_lock::write_lock_recurse",
    ][::std::mem::offset_of!(six_lock, write_lock_recurse) - 12usize];
    [
        "Offset of field: six_lock::owner",
    ][::std::mem::offset_of!(six_lock, owner) - 16usize];
    [
        "Offset of field: six_lock::readers",
    ][::std::mem::offset_of!(six_lock, readers) - 24usize];
    [
        "Offset of field: six_lock::wait_lock",
    ][::std::mem::offset_of!(six_lock, wait_lock) - 32usize];
    [
        "Offset of field: six_lock::wait_fifo",
    ][::std::mem::offset_of!(six_lock, wait_fifo) - 72usize];
    [
        "Offset of field: six_lock::inline_fifo",
    ][::std::mem::offset_of!(six_lock, inline_fifo) - 80usize];
    [
        "Offset of field: six_lock::inline_fifo_data",
    ][::std::mem::offset_of!(six_lock, inline_fifo_data) - 88usize];
};
impl Default for six_lock {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct btree_nr_keys {
    pub live_u64s: u16_,
    pub bset_u64s: [u16_; 3usize],
    pub packed_keys: u16_,
    pub unpacked_keys: u16_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of btree_nr_keys"][::std::mem::size_of::<btree_nr_keys>() - 12usize];
    ["Alignment of btree_nr_keys"][::std::mem::align_of::<btree_nr_keys>() - 2usize];
    [
        "Offset of field: btree_nr_keys::live_u64s",
    ][::std::mem::offset_of!(btree_nr_keys, live_u64s) - 0usize];
    [
        "Offset of field: btree_nr_keys::bset_u64s",
    ][::std::mem::offset_of!(btree_nr_keys, bset_u64s) - 2usize];
    [
        "Offset of field: btree_nr_keys::packed_keys",
    ][::std::mem::offset_of!(btree_nr_keys, packed_keys) - 8usize];
    [
        "Offset of field: btree_nr_keys::unpacked_keys",
    ][::std::mem::offset_of!(btree_nr_keys, unpacked_keys) - 10usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bset_tree {
    pub size: u16_,
    pub extra: u16_,
    pub data_offset: u16_,
    pub aux_data_offset: u16_,
    pub end_offset: u16_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bset_tree"][::std::mem::size_of::<bset_tree>() - 10usize];
    ["Alignment of bset_tree"][::std::mem::align_of::<bset_tree>() - 2usize];
    [
        "Offset of field: bset_tree::size",
    ][::std::mem::offset_of!(bset_tree, size) - 0usize];
    [
        "Offset of field: bset_tree::extra",
    ][::std::mem::offset_of!(bset_tree, extra) - 2usize];
    [
        "Offset of field: bset_tree::data_offset",
    ][::std::mem::offset_of!(bset_tree, data_offset) - 4usize];
    [
        "Offset of field: bset_tree::aux_data_offset",
    ][::std::mem::offset_of!(bset_tree, aux_data_offset) - 6usize];
    [
        "Offset of field: bset_tree::end_offset",
    ][::std::mem::offset_of!(bset_tree, end_offset) - 8usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct btree_write {
    pub journal: journal_entry_pin,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of btree_write"][::std::mem::size_of::<btree_write>() - 32usize];
    ["Alignment of btree_write"][::std::mem::align_of::<btree_write>() - 8usize];
    [
        "Offset of field: btree_write::journal",
    ][::std::mem::offset_of!(btree_write, journal) - 0usize];
};
impl Default for btree_write {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct btree_bkey_cached_common {
    pub lock: six_lock,
    pub level: u8_,
    pub btree_id: u8_,
    pub cached: bool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of btree_bkey_cached_common",
    ][::std::mem::size_of::<btree_bkey_cached_common>() - 224usize];
    [
        "Alignment of btree_bkey_cached_common",
    ][::std::mem::align_of::<btree_bkey_cached_common>() - 8usize];
    [
        "Offset of field: btree_bkey_cached_common::lock",
    ][::std::mem::offset_of!(btree_bkey_cached_common, lock) - 0usize];
    [
        "Offset of field: btree_bkey_cached_common::level",
    ][::std::mem::offset_of!(btree_bkey_cached_common, level) - 216usize];
    [
        "Offset of field: btree_bkey_cached_common::btree_id",
    ][::std::mem::offset_of!(btree_bkey_cached_common, btree_id) - 217usize];
    [
        "Offset of field: btree_bkey_cached_common::cached",
    ][::std::mem::offset_of!(btree_bkey_cached_common, cached) - 218usize];
};
impl Default for btree_bkey_cached_common {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum btree_node_cache_state {
    BTREE_NODE_CACHE_NONE = 0,
    BTREE_NODE_CACHE_FREED = 1,
    BTREE_NODE_CACHE_FREEABLE = 2,
    BTREE_NODE_CACHE_CLEAN = 3,
    BTREE_NODE_CACHE_DIRTY = 4,
}
#[repr(C)]
pub struct btree {
    pub c: btree_bkey_cached_common,
    pub hash: rhash_head,
    pub hash_val: u64_,
    pub flags: ::std::os::raw::c_ulong,
    pub written: u16_,
    pub nsets: u8_,
    pub nr_key_bits: u8_,
    pub version_ondisk: u16_,
    pub format: bkey_format,
    pub unpack: [btree_bkey_unpack_field; 6usize],
    pub data: *mut btree_node,
    pub aux_data: *mut ::std::os::raw::c_void,
    pub set: [bset_tree; 3usize],
    pub nr: btree_nr_keys,
    pub sib_u64s: [u16_; 2usize],
    pub whiteout_u64s: u16_,
    pub byte_order: u8_,
    pub unpack_fn_len: u8_,
    pub writes: [btree_write; 2usize],
    pub key: bkey_i,
    pub key_pad: [__u64; 15usize],
    pub write_blocked: cds_list_head,
    pub will_make_reachable: ::std::os::raw::c_ulong,
    pub ob: open_buckets,
    pub list: cds_list_head,
    pub cache_state: btree_node_cache_state,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct btree_bkey_unpack_field {
    pub byte_offset: u8_,
    pub load_size: u8_,
    pub shift: u8_,
    pub _pad: u8_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of btree_bkey_unpack_field",
    ][::std::mem::size_of::<btree_bkey_unpack_field>() - 4usize];
    [
        "Alignment of btree_bkey_unpack_field",
    ][::std::mem::align_of::<btree_bkey_unpack_field>() - 1usize];
    [
        "Offset of field: btree_bkey_unpack_field::byte_offset",
    ][::std::mem::offset_of!(btree_bkey_unpack_field, byte_offset) - 0usize];
    [
        "Offset of field: btree_bkey_unpack_field::load_size",
    ][::std::mem::offset_of!(btree_bkey_unpack_field, load_size) - 1usize];
    [
        "Offset of field: btree_bkey_unpack_field::shift",
    ][::std::mem::offset_of!(btree_bkey_unpack_field, shift) - 2usize];
    [
        "Offset of field: btree_bkey_unpack_field::_pad",
    ][::std::mem::offset_of!(btree_bkey_unpack_field, _pad) - 3usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of btree"][::std::mem::size_of::<btree>() - 720usize];
    ["Alignment of btree"][::std::mem::align_of::<btree>() - 8usize];
    ["Offset of field: btree::c"][::std::mem::offset_of!(btree, c) - 0usize];
    ["Offset of field: btree::hash"][::std::mem::offset_of!(btree, hash) - 224usize];
    [
        "Offset of field: btree::hash_val",
    ][::std::mem::offset_of!(btree, hash_val) - 232usize];
    ["Offset of field: btree::flags"][::std::mem::offset_of!(btree, flags) - 240usize];
    [
        "Offset of field: btree::written",
    ][::std::mem::offset_of!(btree, written) - 248usize];
    ["Offset of field: btree::nsets"][::std::mem::offset_of!(btree, nsets) - 250usize];
    [
        "Offset of field: btree::nr_key_bits",
    ][::std::mem::offset_of!(btree, nr_key_bits) - 251usize];
    [
        "Offset of field: btree::version_ondisk",
    ][::std::mem::offset_of!(btree, version_ondisk) - 252usize];
    ["Offset of field: btree::format"][::std::mem::offset_of!(btree, format) - 256usize];
    ["Offset of field: btree::unpack"][::std::mem::offset_of!(btree, unpack) - 312usize];
    ["Offset of field: btree::data"][::std::mem::offset_of!(btree, data) - 336usize];
    [
        "Offset of field: btree::aux_data",
    ][::std::mem::offset_of!(btree, aux_data) - 344usize];
    ["Offset of field: btree::set"][::std::mem::offset_of!(btree, set) - 352usize];
    ["Offset of field: btree::nr"][::std::mem::offset_of!(btree, nr) - 382usize];
    [
        "Offset of field: btree::sib_u64s",
    ][::std::mem::offset_of!(btree, sib_u64s) - 394usize];
    [
        "Offset of field: btree::whiteout_u64s",
    ][::std::mem::offset_of!(btree, whiteout_u64s) - 398usize];
    [
        "Offset of field: btree::byte_order",
    ][::std::mem::offset_of!(btree, byte_order) - 400usize];
    [
        "Offset of field: btree::unpack_fn_len",
    ][::std::mem::offset_of!(btree, unpack_fn_len) - 401usize];
    ["Offset of field: btree::writes"][::std::mem::offset_of!(btree, writes) - 408usize];
    ["Offset of field: btree::key"][::std::mem::offset_of!(btree, key) - 472usize];
    [
        "Offset of field: btree::key_pad",
    ][::std::mem::offset_of!(btree, key_pad) - 512usize];
    [
        "Offset of field: btree::write_blocked",
    ][::std::mem::offset_of!(btree, write_blocked) - 632usize];
    [
        "Offset of field: btree::will_make_reachable",
    ][::std::mem::offset_of!(btree, will_make_reachable) - 648usize];
    ["Offset of field: btree::ob"][::std::mem::offset_of!(btree, ob) - 656usize];
    ["Offset of field: btree::list"][::std::mem::offset_of!(btree, list) - 696usize];
    [
        "Offset of field: btree::cache_state",
    ][::std::mem::offset_of!(btree, cache_state) - 712usize];
};
impl Default for btree {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_btree_cache_not_freed_reasons {
    BCH_BTREE_CACHE_NOT_FREED_cache_reserve = 0,
    BCH_BTREE_CACHE_NOT_FREED_lock_intent = 1,
    BCH_BTREE_CACHE_NOT_FREED_lock_write = 2,
    BCH_BTREE_CACHE_NOT_FREED_dirty = 3,
    BCH_BTREE_CACHE_NOT_FREED_read_in_flight = 4,
    BCH_BTREE_CACHE_NOT_FREED_write_in_flight = 5,
    BCH_BTREE_CACHE_NOT_FREED_permanent = 6,
    BCH_BTREE_CACHE_NOT_FREED_noevict = 7,
    BCH_BTREE_CACHE_NOT_FREED_write_blocked = 8,
    BCH_BTREE_CACHE_NOT_FREED_will_make_reachable = 9,
    BCH_BTREE_CACHE_NOT_FREED_access_bit = 10,
    BCH_BTREE_CACHE_NOT_FREED_REASONS_NR = 11,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct btree_cache_list {
    pub idx: ::std::os::raw::c_uint,
    pub shrink: *mut shrinker,
    pub nr_clean: usize,
    pub nr_dirty: usize,
    pub clean: cds_list_head,
    pub dirty: cds_list_head,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of btree_cache_list"][::std::mem::size_of::<btree_cache_list>() - 64usize];
    [
        "Alignment of btree_cache_list",
    ][::std::mem::align_of::<btree_cache_list>() - 8usize];
    [
        "Offset of field: btree_cache_list::idx",
    ][::std::mem::offset_of!(btree_cache_list, idx) - 0usize];
    [
        "Offset of field: btree_cache_list::shrink",
    ][::std::mem::offset_of!(btree_cache_list, shrink) - 8usize];
    [
        "Offset of field: btree_cache_list::nr_clean",
    ][::std::mem::offset_of!(btree_cache_list, nr_clean) - 16usize];
    [
        "Offset of field: btree_cache_list::nr_dirty",
    ][::std::mem::offset_of!(btree_cache_list, nr_dirty) - 24usize];
    [
        "Offset of field: btree_cache_list::clean",
    ][::std::mem::offset_of!(btree_cache_list, clean) - 32usize];
    [
        "Offset of field: btree_cache_list::dirty",
    ][::std::mem::offset_of!(btree_cache_list, dirty) - 48usize];
};
impl Default for btree_cache_list {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug)]
pub struct btree_root {
    pub b: *mut btree,
    pub key: bkey_i,
    pub key_pad: [__u64; 15usize],
    pub level: u8_,
    pub alive: u8_,
    pub error: s16,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of btree_root"][::std::mem::size_of::<btree_root>() - 176usize];
    ["Alignment of btree_root"][::std::mem::align_of::<btree_root>() - 8usize];
    ["Offset of field: btree_root::b"][::std::mem::offset_of!(btree_root, b) - 0usize];
    [
        "Offset of field: btree_root::key",
    ][::std::mem::offset_of!(btree_root, key) - 8usize];
    [
        "Offset of field: btree_root::key_pad",
    ][::std::mem::offset_of!(btree_root, key_pad) - 48usize];
    [
        "Offset of field: btree_root::level",
    ][::std::mem::offset_of!(btree_root, level) - 168usize];
    [
        "Offset of field: btree_root::alive",
    ][::std::mem::offset_of!(btree_root, alive) - 169usize];
    [
        "Offset of field: btree_root::error",
    ][::std::mem::offset_of!(btree_root, error) - 170usize];
};
impl Default for btree_root {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bch_fs_btree_cache {
    pub roots_b: [::std::os::raw::c_ulong; 28usize],
    pub roots_known: [btree_root; 28usize],
    pub roots_extra: bch_fs_btree_cache__bindgen_ty_1,
    pub root_lock: mutex,
    pub table: rhashtable,
    pub table_init_done: bool,
    pub lock: mutex,
    pub freeable: cds_list_head,
    pub freed_pcpu: cds_list_head,
    pub freed_nonpcpu: cds_list_head,
    pub live: [btree_cache_list; 2usize],
    pub nr_vmalloc: usize,
    pub nr_freeable: usize,
    pub nr_reserve: usize,
    pub nr_by_btree: [usize; 28usize],
    pub nr_in_flight: atomic_long_t,
    pub nr_in_flight_inner: atomic_long_t,
    pub nr_in_flight_wait: closure_waitlist,
    pub nr_freed: usize,
    pub nr_requested: usize,
    pub not_freed: [u64_; 11usize],
    pub alloc_lock: *mut task_struct,
    pub alloc_wait: closure_waitlist,
    pub pinned_nodes_start: bbpos,
    pub pinned_nodes_end: bbpos,
    pub pinned_nodes_mask: [u64_; 2usize],
}
#[repr(C)]
#[derive(Debug)]
pub struct bch_fs_btree_cache__bindgen_ty_1 {
    pub nr: usize,
    pub size: usize,
    pub data: *mut btree_root,
    pub preallocated: __IncompleteArrayField<btree_root>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_fs_btree_cache__bindgen_ty_1",
    ][::std::mem::size_of::<bch_fs_btree_cache__bindgen_ty_1>() - 24usize];
    [
        "Alignment of bch_fs_btree_cache__bindgen_ty_1",
    ][::std::mem::align_of::<bch_fs_btree_cache__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bch_fs_btree_cache__bindgen_ty_1::nr",
    ][::std::mem::offset_of!(bch_fs_btree_cache__bindgen_ty_1, nr) - 0usize];
    [
        "Offset of field: bch_fs_btree_cache__bindgen_ty_1::size",
    ][::std::mem::offset_of!(bch_fs_btree_cache__bindgen_ty_1, size) - 8usize];
    [
        "Offset of field: bch_fs_btree_cache__bindgen_ty_1::data",
    ][::std::mem::offset_of!(bch_fs_btree_cache__bindgen_ty_1, data) - 16usize];
    [
        "Offset of field: bch_fs_btree_cache__bindgen_ty_1::preallocated",
    ][::std::mem::offset_of!(bch_fs_btree_cache__bindgen_ty_1, preallocated) - 24usize];
};
impl Default for bch_fs_btree_cache__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_fs_btree_cache",
    ][::std::mem::size_of::<bch_fs_btree_cache>() - 6080usize];
    [
        "Alignment of bch_fs_btree_cache",
    ][::std::mem::align_of::<bch_fs_btree_cache>() - 8usize];
    [
        "Offset of field: bch_fs_btree_cache::roots_b",
    ][::std::mem::offset_of!(bch_fs_btree_cache, roots_b) - 0usize];
    [
        "Offset of field: bch_fs_btree_cache::roots_known",
    ][::std::mem::offset_of!(bch_fs_btree_cache, roots_known) - 224usize];
    [
        "Offset of field: bch_fs_btree_cache::roots_extra",
    ][::std::mem::offset_of!(bch_fs_btree_cache, roots_extra) - 5152usize];
    [
        "Offset of field: bch_fs_btree_cache::root_lock",
    ][::std::mem::offset_of!(bch_fs_btree_cache, root_lock) - 5176usize];
    [
        "Offset of field: bch_fs_btree_cache::table",
    ][::std::mem::offset_of!(bch_fs_btree_cache, table) - 5216usize];
    [
        "Offset of field: bch_fs_btree_cache::table_init_done",
    ][::std::mem::offset_of!(bch_fs_btree_cache, table_init_done) - 5400usize];
    [
        "Offset of field: bch_fs_btree_cache::lock",
    ][::std::mem::offset_of!(bch_fs_btree_cache, lock) - 5408usize];
    [
        "Offset of field: bch_fs_btree_cache::freeable",
    ][::std::mem::offset_of!(bch_fs_btree_cache, freeable) - 5448usize];
    [
        "Offset of field: bch_fs_btree_cache::freed_pcpu",
    ][::std::mem::offset_of!(bch_fs_btree_cache, freed_pcpu) - 5464usize];
    [
        "Offset of field: bch_fs_btree_cache::freed_nonpcpu",
    ][::std::mem::offset_of!(bch_fs_btree_cache, freed_nonpcpu) - 5480usize];
    [
        "Offset of field: bch_fs_btree_cache::live",
    ][::std::mem::offset_of!(bch_fs_btree_cache, live) - 5496usize];
    [
        "Offset of field: bch_fs_btree_cache::nr_vmalloc",
    ][::std::mem::offset_of!(bch_fs_btree_cache, nr_vmalloc) - 5624usize];
    [
        "Offset of field: bch_fs_btree_cache::nr_freeable",
    ][::std::mem::offset_of!(bch_fs_btree_cache, nr_freeable) - 5632usize];
    [
        "Offset of field: bch_fs_btree_cache::nr_reserve",
    ][::std::mem::offset_of!(bch_fs_btree_cache, nr_reserve) - 5640usize];
    [
        "Offset of field: bch_fs_btree_cache::nr_by_btree",
    ][::std::mem::offset_of!(bch_fs_btree_cache, nr_by_btree) - 5648usize];
    [
        "Offset of field: bch_fs_btree_cache::nr_in_flight",
    ][::std::mem::offset_of!(bch_fs_btree_cache, nr_in_flight) - 5872usize];
    [
        "Offset of field: bch_fs_btree_cache::nr_in_flight_inner",
    ][::std::mem::offset_of!(bch_fs_btree_cache, nr_in_flight_inner) - 5880usize];
    [
        "Offset of field: bch_fs_btree_cache::nr_in_flight_wait",
    ][::std::mem::offset_of!(bch_fs_btree_cache, nr_in_flight_wait) - 5888usize];
    [
        "Offset of field: bch_fs_btree_cache::nr_freed",
    ][::std::mem::offset_of!(bch_fs_btree_cache, nr_freed) - 5896usize];
    [
        "Offset of field: bch_fs_btree_cache::nr_requested",
    ][::std::mem::offset_of!(bch_fs_btree_cache, nr_requested) - 5904usize];
    [
        "Offset of field: bch_fs_btree_cache::not_freed",
    ][::std::mem::offset_of!(bch_fs_btree_cache, not_freed) - 5912usize];
    [
        "Offset of field: bch_fs_btree_cache::alloc_lock",
    ][::std::mem::offset_of!(bch_fs_btree_cache, alloc_lock) - 6000usize];
    [
        "Offset of field: bch_fs_btree_cache::alloc_wait",
    ][::std::mem::offset_of!(bch_fs_btree_cache, alloc_wait) - 6008usize];
    [
        "Offset of field: bch_fs_btree_cache::pinned_nodes_start",
    ][::std::mem::offset_of!(bch_fs_btree_cache, pinned_nodes_start) - 6016usize];
    [
        "Offset of field: bch_fs_btree_cache::pinned_nodes_end",
    ][::std::mem::offset_of!(bch_fs_btree_cache, pinned_nodes_end) - 6040usize];
    [
        "Offset of field: bch_fs_btree_cache::pinned_nodes_mask",
    ][::std::mem::offset_of!(bch_fs_btree_cache, pinned_nodes_mask) - 6064usize];
};
impl Default for bch_fs_btree_cache {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct btree_node_iter {
    pub data: [btree_node_iter_btree_node_iter_set; 3usize],
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct btree_node_iter_btree_node_iter_set {
    pub k: u16_,
    pub end: u16_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of btree_node_iter_btree_node_iter_set",
    ][::std::mem::size_of::<btree_node_iter_btree_node_iter_set>() - 4usize];
    [
        "Alignment of btree_node_iter_btree_node_iter_set",
    ][::std::mem::align_of::<btree_node_iter_btree_node_iter_set>() - 2usize];
    [
        "Offset of field: btree_node_iter_btree_node_iter_set::k",
    ][::std::mem::offset_of!(btree_node_iter_btree_node_iter_set, k) - 0usize];
    [
        "Offset of field: btree_node_iter_btree_node_iter_set::end",
    ][::std::mem::offset_of!(btree_node_iter_btree_node_iter_set, end) - 2usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of btree_node_iter"][::std::mem::size_of::<btree_node_iter>() - 12usize];
    ["Alignment of btree_node_iter"][::std::mem::align_of::<btree_node_iter>() - 2usize];
    [
        "Offset of field: btree_node_iter::data",
    ][::std::mem::offset_of!(btree_node_iter, data) - 0usize];
};
pub const BTREE_ITER_FLAG_BIT_slots: _bindgen_ty_21 = _bindgen_ty_21::BTREE_ITER_FLAG_BIT_slots;
pub const BTREE_ITER_FLAG_BIT_intent: _bindgen_ty_21 = _bindgen_ty_21::BTREE_ITER_FLAG_BIT_intent;
pub const BTREE_ITER_FLAG_BIT_prefetch: _bindgen_ty_21 = _bindgen_ty_21::BTREE_ITER_FLAG_BIT_prefetch;
pub const BTREE_ITER_FLAG_BIT_is_extents: _bindgen_ty_21 = _bindgen_ty_21::BTREE_ITER_FLAG_BIT_is_extents;
pub const BTREE_ITER_FLAG_BIT_not_extents: _bindgen_ty_21 = _bindgen_ty_21::BTREE_ITER_FLAG_BIT_not_extents;
pub const BTREE_ITER_FLAG_BIT_cached: _bindgen_ty_21 = _bindgen_ty_21::BTREE_ITER_FLAG_BIT_cached;
pub const BTREE_ITER_FLAG_BIT_with_key_cache: _bindgen_ty_21 = _bindgen_ty_21::BTREE_ITER_FLAG_BIT_with_key_cache;
pub const BTREE_ITER_FLAG_BIT_with_journal: _bindgen_ty_21 = _bindgen_ty_21::BTREE_ITER_FLAG_BIT_with_journal;
pub const BTREE_ITER_FLAG_BIT_snapshot_field: _bindgen_ty_21 = _bindgen_ty_21::BTREE_ITER_FLAG_BIT_snapshot_field;
pub const BTREE_ITER_FLAG_BIT_all_snapshots: _bindgen_ty_21 = _bindgen_ty_21::BTREE_ITER_FLAG_BIT_all_snapshots;
pub const BTREE_ITER_FLAG_BIT_filter_snapshots: _bindgen_ty_21 = _bindgen_ty_21::BTREE_ITER_FLAG_BIT_filter_snapshots;
pub const BTREE_ITER_FLAG_BIT_nofilter_whiteouts: _bindgen_ty_21 = _bindgen_ty_21::BTREE_ITER_FLAG_BIT_nofilter_whiteouts;
pub const BTREE_ITER_FLAG_BIT_nopreserve: _bindgen_ty_21 = _bindgen_ty_21::BTREE_ITER_FLAG_BIT_nopreserve;
pub const BTREE_ITER_FLAG_BIT_nofill: _bindgen_ty_21 = _bindgen_ty_21::BTREE_ITER_FLAG_BIT_nofill;
pub const BTREE_ITER_FLAG_BIT_cached_nofill: _bindgen_ty_21 = _bindgen_ty_21::BTREE_ITER_FLAG_BIT_cached_nofill;
pub const BTREE_ITER_FLAG_BIT_key_cache_fill: _bindgen_ty_21 = _bindgen_ty_21::BTREE_ITER_FLAG_BIT_key_cache_fill;
pub const BTREE_ITER_FLAG_BIT_must_create: _bindgen_ty_21 = _bindgen_ty_21::BTREE_ITER_FLAG_BIT_must_create;
pub const BTREE_ITER_FLAG_BIT_must_replace: _bindgen_ty_21 = _bindgen_ty_21::BTREE_ITER_FLAG_BIT_must_replace;
pub const BTREE_ITER_FLAG_BIT_internal_snapshot_node: _bindgen_ty_21 = _bindgen_ty_21::BTREE_ITER_FLAG_BIT_internal_snapshot_node;
pub const BTREE_ITER_FLAG_BIT_nojournal: _bindgen_ty_21 = _bindgen_ty_21::BTREE_ITER_FLAG_BIT_nojournal;
pub const BTREE_ITER_FLAG_BIT_key_cache_reclaim: _bindgen_ty_21 = _bindgen_ty_21::BTREE_ITER_FLAG_BIT_key_cache_reclaim;
pub const BTREE_ITER_FLAG_BIT_norun: _bindgen_ty_21 = _bindgen_ty_21::BTREE_ITER_FLAG_BIT_norun;
pub const BTREE_ITER_FLAG_BIT_transactional: _bindgen_ty_21 = _bindgen_ty_21::BTREE_ITER_FLAG_BIT_transactional;
pub const BTREE_ITER_FLAG_BIT_atomic: _bindgen_ty_21 = _bindgen_ty_21::BTREE_ITER_FLAG_BIT_atomic;
pub const BTREE_ITER_FLAG_BIT_gc: _bindgen_ty_21 = _bindgen_ty_21::BTREE_ITER_FLAG_BIT_gc;
pub const BTREE_ITER_FLAG_BIT_insert: _bindgen_ty_21 = _bindgen_ty_21::BTREE_ITER_FLAG_BIT_insert;
pub const BTREE_ITER_FLAG_BIT_overwrite: _bindgen_ty_21 = _bindgen_ty_21::BTREE_ITER_FLAG_BIT_overwrite;
pub const BTREE_ITER_FLAG_BIT_is_discard: _bindgen_ty_21 = _bindgen_ty_21::BTREE_ITER_FLAG_BIT_is_discard;
pub const BTREE_ITER_FLAG_BIT_set_needs_reconcile_done: _bindgen_ty_21 = _bindgen_ty_21::BTREE_ITER_FLAG_BIT_set_needs_reconcile_done;
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_21 {
    BTREE_ITER_FLAG_BIT_slots = 0,
    BTREE_ITER_FLAG_BIT_intent = 1,
    BTREE_ITER_FLAG_BIT_prefetch = 2,
    BTREE_ITER_FLAG_BIT_is_extents = 3,
    BTREE_ITER_FLAG_BIT_not_extents = 4,
    BTREE_ITER_FLAG_BIT_cached = 5,
    BTREE_ITER_FLAG_BIT_with_key_cache = 6,
    BTREE_ITER_FLAG_BIT_with_journal = 7,
    BTREE_ITER_FLAG_BIT_snapshot_field = 8,
    BTREE_ITER_FLAG_BIT_all_snapshots = 9,
    BTREE_ITER_FLAG_BIT_filter_snapshots = 10,
    BTREE_ITER_FLAG_BIT_nofilter_whiteouts = 11,
    BTREE_ITER_FLAG_BIT_nopreserve = 12,
    BTREE_ITER_FLAG_BIT_nofill = 13,
    BTREE_ITER_FLAG_BIT_cached_nofill = 14,
    BTREE_ITER_FLAG_BIT_key_cache_fill = 15,
    BTREE_ITER_FLAG_BIT_must_create = 16,
    BTREE_ITER_FLAG_BIT_must_replace = 17,
    BTREE_ITER_FLAG_BIT_internal_snapshot_node = 18,
    BTREE_ITER_FLAG_BIT_nojournal = 19,
    BTREE_ITER_FLAG_BIT_key_cache_reclaim = 20,
    BTREE_ITER_FLAG_BIT_norun = 21,
    BTREE_ITER_FLAG_BIT_transactional = 22,
    BTREE_ITER_FLAG_BIT_atomic = 23,
    BTREE_ITER_FLAG_BIT_gc = 24,
    BTREE_ITER_FLAG_BIT_insert = 25,
    BTREE_ITER_FLAG_BIT_overwrite = 26,
    BTREE_ITER_FLAG_BIT_is_discard = 27,
    BTREE_ITER_FLAG_BIT_set_needs_reconcile_done = 28,
}
impl btree_iter_update_trigger_flags {
    pub const BTREE_ITER_slots: btree_iter_update_trigger_flags = btree_iter_update_trigger_flags(
        1,
    );
    pub const BTREE_ITER_intent: btree_iter_update_trigger_flags = btree_iter_update_trigger_flags(
        2,
    );
    pub const BTREE_ITER_prefetch: btree_iter_update_trigger_flags = btree_iter_update_trigger_flags(
        4,
    );
    pub const BTREE_ITER_is_extents: btree_iter_update_trigger_flags = btree_iter_update_trigger_flags(
        8,
    );
    pub const BTREE_ITER_not_extents: btree_iter_update_trigger_flags = btree_iter_update_trigger_flags(
        16,
    );
    pub const BTREE_ITER_cached: btree_iter_update_trigger_flags = btree_iter_update_trigger_flags(
        32,
    );
    pub const BTREE_ITER_with_key_cache: btree_iter_update_trigger_flags = btree_iter_update_trigger_flags(
        64,
    );
    pub const BTREE_ITER_with_journal: btree_iter_update_trigger_flags = btree_iter_update_trigger_flags(
        128,
    );
    pub const BTREE_ITER_snapshot_field: btree_iter_update_trigger_flags = btree_iter_update_trigger_flags(
        256,
    );
    pub const BTREE_ITER_all_snapshots: btree_iter_update_trigger_flags = btree_iter_update_trigger_flags(
        512,
    );
    pub const BTREE_ITER_filter_snapshots: btree_iter_update_trigger_flags = btree_iter_update_trigger_flags(
        1024,
    );
    pub const BTREE_ITER_nofilter_whiteouts: btree_iter_update_trigger_flags = btree_iter_update_trigger_flags(
        2048,
    );
    pub const BTREE_ITER_nopreserve: btree_iter_update_trigger_flags = btree_iter_update_trigger_flags(
        4096,
    );
    pub const BTREE_ITER_nofill: btree_iter_update_trigger_flags = btree_iter_update_trigger_flags(
        8192,
    );
    pub const BTREE_ITER_cached_nofill: btree_iter_update_trigger_flags = btree_iter_update_trigger_flags(
        16384,
    );
    pub const BTREE_ITER_key_cache_fill: btree_iter_update_trigger_flags = btree_iter_update_trigger_flags(
        32768,
    );
    pub const STR_HASH_must_create: btree_iter_update_trigger_flags = btree_iter_update_trigger_flags(
        65536,
    );
    pub const STR_HASH_must_replace: btree_iter_update_trigger_flags = btree_iter_update_trigger_flags(
        131072,
    );
    pub const BTREE_UPDATE_internal_snapshot_node: btree_iter_update_trigger_flags = btree_iter_update_trigger_flags(
        262144,
    );
    pub const BTREE_UPDATE_nojournal: btree_iter_update_trigger_flags = btree_iter_update_trigger_flags(
        524288,
    );
    pub const BTREE_UPDATE_key_cache_reclaim: btree_iter_update_trigger_flags = btree_iter_update_trigger_flags(
        1048576,
    );
    pub const BTREE_TRIGGER_norun: btree_iter_update_trigger_flags = btree_iter_update_trigger_flags(
        2097152,
    );
    pub const BTREE_TRIGGER_transactional: btree_iter_update_trigger_flags = btree_iter_update_trigger_flags(
        4194304,
    );
    pub const BTREE_TRIGGER_atomic: btree_iter_update_trigger_flags = btree_iter_update_trigger_flags(
        8388608,
    );
    pub const BTREE_TRIGGER_gc: btree_iter_update_trigger_flags = btree_iter_update_trigger_flags(
        16777216,
    );
    pub const BTREE_TRIGGER_insert: btree_iter_update_trigger_flags = btree_iter_update_trigger_flags(
        33554432,
    );
    pub const BTREE_TRIGGER_overwrite: btree_iter_update_trigger_flags = btree_iter_update_trigger_flags(
        67108864,
    );
    pub const BTREE_TRIGGER_is_discard: btree_iter_update_trigger_flags = btree_iter_update_trigger_flags(
        134217728,
    );
    pub const BTREE_TRIGGER_set_needs_reconcile_done: btree_iter_update_trigger_flags = btree_iter_update_trigger_flags(
        268435456,
    );
}
impl ::std::ops::BitOr<btree_iter_update_trigger_flags>
for btree_iter_update_trigger_flags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        btree_iter_update_trigger_flags(self.0 | other.0)
    }
}
impl ::std::ops::BitOrAssign for btree_iter_update_trigger_flags {
    #[inline]
    fn bitor_assign(&mut self, rhs: btree_iter_update_trigger_flags) {
        self.0 |= rhs.0;
    }
}
impl ::std::ops::BitAnd<btree_iter_update_trigger_flags>
for btree_iter_update_trigger_flags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        btree_iter_update_trigger_flags(self.0 & other.0)
    }
}
impl ::std::ops::BitAndAssign for btree_iter_update_trigger_flags {
    #[inline]
    fn bitand_assign(&mut self, rhs: btree_iter_update_trigger_flags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct btree_iter_update_trigger_flags(pub ::std::os::raw::c_uint);
#[repr(C)]
#[derive(Copy, Clone)]
pub struct btree_trigger_op {
    pub btree: btree_id,
    pub level: ::std::os::raw::c_uint,
    pub old: bkey_s_c,
    pub new: bkey_s,
    pub new_buf_u64s: ::std::os::raw::c_uint,
    pub flags: btree_iter_update_trigger_flags,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of btree_trigger_op"][::std::mem::size_of::<btree_trigger_op>() - 48usize];
    [
        "Alignment of btree_trigger_op",
    ][::std::mem::align_of::<btree_trigger_op>() - 8usize];
    [
        "Offset of field: btree_trigger_op::btree",
    ][::std::mem::offset_of!(btree_trigger_op, btree) - 0usize];
    [
        "Offset of field: btree_trigger_op::level",
    ][::std::mem::offset_of!(btree_trigger_op, level) - 4usize];
    [
        "Offset of field: btree_trigger_op::old",
    ][::std::mem::offset_of!(btree_trigger_op, old) - 8usize];
    [
        "Offset of field: btree_trigger_op::new",
    ][::std::mem::offset_of!(btree_trigger_op, new) - 24usize];
    [
        "Offset of field: btree_trigger_op::new_buf_u64s",
    ][::std::mem::offset_of!(btree_trigger_op, new_buf_u64s) - 40usize];
    [
        "Offset of field: btree_trigger_op::flags",
    ][::std::mem::offset_of!(btree_trigger_op, flags) - 44usize];
};
impl Default for btree_trigger_op {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum btree_path_uptodate {
    BTREE_ITER_UPTODATE = 0,
    BTREE_ITER_NEED_RELOCK = 1,
    BTREE_ITER_NEED_TRAVERSE = 2,
}
pub type btree_path_idx_t = u16_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct btree_path {
    pub sorted_idx: btree_path_idx_t,
    pub ref_: u8_,
    pub intent_ref: u8_,
    pub pos: bpos,
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
    pub nodes_locked: u8_,
    pub l: [btree_path_btree_path_level; 4usize],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct btree_path_btree_path_level {
    pub b: *mut btree,
    pub iter: btree_node_iter,
    pub lock_seq: u32_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of btree_path_btree_path_level",
    ][::std::mem::size_of::<btree_path_btree_path_level>() - 24usize];
    [
        "Alignment of btree_path_btree_path_level",
    ][::std::mem::align_of::<btree_path_btree_path_level>() - 8usize];
    [
        "Offset of field: btree_path_btree_path_level::b",
    ][::std::mem::offset_of!(btree_path_btree_path_level, b) - 0usize];
    [
        "Offset of field: btree_path_btree_path_level::iter",
    ][::std::mem::offset_of!(btree_path_btree_path_level, iter) - 8usize];
    [
        "Offset of field: btree_path_btree_path_level::lock_seq",
    ][::std::mem::offset_of!(btree_path_btree_path_level, lock_seq) - 20usize];
};
impl Default for btree_path_btree_path_level {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of btree_path"][::std::mem::size_of::<btree_path>() - 128usize];
    ["Alignment of btree_path"][::std::mem::align_of::<btree_path>() - 8usize];
    [
        "Offset of field: btree_path::sorted_idx",
    ][::std::mem::offset_of!(btree_path, sorted_idx) - 0usize];
    [
        "Offset of field: btree_path::ref_",
    ][::std::mem::offset_of!(btree_path, ref_) - 2usize];
    [
        "Offset of field: btree_path::intent_ref",
    ][::std::mem::offset_of!(btree_path, intent_ref) - 3usize];
    [
        "Offset of field: btree_path::pos",
    ][::std::mem::offset_of!(btree_path, pos) - 4usize];
    [
        "Offset of field: btree_path::nodes_locked",
    ][::std::mem::offset_of!(btree_path, nodes_locked) - 26usize];
    ["Offset of field: btree_path::l"][::std::mem::offset_of!(btree_path, l) - 32usize];
};
impl Default for btree_path {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl btree_path {
    #[inline]
    pub fn btree_id(&self) -> btree_id {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 5u8) as u32) }
    }
    #[inline]
    pub fn set_btree_id(&mut self, val: btree_id) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 5u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn btree_id_raw(this: *const Self) -> btree_id {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 5u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_btree_id_raw(this: *mut Self, val: btree_id) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                5u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn cached(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_cached(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(5usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn cached_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 5usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_cached_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                5usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn preserve(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_preserve(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(6usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn preserve_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 6usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_preserve_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                6usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn uptodate(&self) -> btree_path_uptodate {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 2u8) as u32) }
    }
    #[inline]
    pub fn set_uptodate(&mut self, val: btree_path_uptodate) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(7usize, 2u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn uptodate_raw(this: *const Self) -> btree_path_uptodate {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 7usize, 2u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_uptodate_raw(this: *mut Self, val: btree_path_uptodate) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                7usize,
                2u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn should_be_locked(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_should_be_locked(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(9usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn should_be_locked_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 9usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_should_be_locked_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                9usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn level(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 3u8) as u32) }
    }
    #[inline]
    pub fn set_level(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(10usize, 3u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn level_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 10usize, 3u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_level_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                10usize,
                3u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn locks_want(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 3u8) as u32) }
    }
    #[inline]
    pub fn set_locks_want(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(13usize, 3u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn locks_want_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 13usize, 3u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_locks_want_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                13usize,
                3u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        btree_id: btree_id,
        cached: bool,
        preserve: bool,
        uptodate: btree_path_uptodate,
        should_be_locked: bool,
        level: ::std::os::raw::c_uint,
        locks_want: ::std::os::raw::c_uint,
    ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                5u8,
                {
                    let btree_id: u32 = unsafe { ::std::mem::transmute(btree_id) };
                    btree_id as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                5usize,
                1u8,
                {
                    let cached: u8 = unsafe { ::std::mem::transmute(cached) };
                    cached as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                6usize,
                1u8,
                {
                    let preserve: u8 = unsafe { ::std::mem::transmute(preserve) };
                    preserve as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                7usize,
                2u8,
                {
                    let uptodate: u32 = unsafe { ::std::mem::transmute(uptodate) };
                    uptodate as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                9usize,
                1u8,
                {
                    let should_be_locked: u8 = unsafe {
                        ::std::mem::transmute(should_be_locked)
                    };
                    should_be_locked as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                10usize,
                3u8,
                {
                    let level: u32 = unsafe { ::std::mem::transmute(level) };
                    level as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                13usize,
                3u8,
                {
                    let locks_want: u32 = unsafe { ::std::mem::transmute(locks_want) };
                    locks_want as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct btree_iter {
    pub trans: *mut btree_trans,
    pub path: btree_path_idx_t,
    pub update_path: btree_path_idx_t,
    pub key_cache_path: btree_path_idx_t,
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
    pub min_depth: u8_,
    pub flags: u16_,
    pub snapshot: ::std::os::raw::c_uint,
    pub pos: bpos,
    pub k: bkey,
    pub journal_idx: usize,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of btree_iter"][::std::mem::size_of::<btree_iter>() - 96usize];
    ["Alignment of btree_iter"][::std::mem::align_of::<btree_iter>() - 8usize];
    [
        "Offset of field: btree_iter::trans",
    ][::std::mem::offset_of!(btree_iter, trans) - 0usize];
    [
        "Offset of field: btree_iter::path",
    ][::std::mem::offset_of!(btree_iter, path) - 8usize];
    [
        "Offset of field: btree_iter::update_path",
    ][::std::mem::offset_of!(btree_iter, update_path) - 10usize];
    [
        "Offset of field: btree_iter::key_cache_path",
    ][::std::mem::offset_of!(btree_iter, key_cache_path) - 12usize];
    [
        "Offset of field: btree_iter::min_depth",
    ][::std::mem::offset_of!(btree_iter, min_depth) - 15usize];
    [
        "Offset of field: btree_iter::flags",
    ][::std::mem::offset_of!(btree_iter, flags) - 16usize];
    [
        "Offset of field: btree_iter::snapshot",
    ][::std::mem::offset_of!(btree_iter, snapshot) - 20usize];
    [
        "Offset of field: btree_iter::pos",
    ][::std::mem::offset_of!(btree_iter, pos) - 24usize];
    ["Offset of field: btree_iter::k"][::std::mem::offset_of!(btree_iter, k) - 48usize];
    [
        "Offset of field: btree_iter::journal_idx",
    ][::std::mem::offset_of!(btree_iter, journal_idx) - 88usize];
};
impl Default for btree_iter {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl btree_iter {
    #[inline]
    pub fn btree_id(&self) -> btree_id {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
    }
    #[inline]
    pub fn set_btree_id(&mut self, val: btree_id) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 8u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn btree_id_raw(this: *const Self) -> btree_id {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 8u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_btree_id_raw(this: *mut Self, val: btree_id) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                8u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(btree_id: btree_id) -> __BindgenBitfieldUnit<[u8; 1usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                8u8,
                {
                    let btree_id: u32 = unsafe { ::std::mem::transmute(btree_id) };
                    btree_id as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct btree_insert_entry {
    pub flags: ::std::os::raw::c_uint,
    pub sort_order: u8_,
    pub bkey_type: u8_,
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
    pub old_btree_u64s: u8_,
    pub k_buf_u64s: u8_,
    pub path: btree_path_idx_t,
    pub k: *mut bkey_i,
    pub old_k: bkey,
    pub old_v: *const bch_val,
    pub ip_allocated: ::std::os::raw::c_ulong,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of btree_insert_entry",
    ][::std::mem::size_of::<btree_insert_entry>() - 80usize];
    [
        "Alignment of btree_insert_entry",
    ][::std::mem::align_of::<btree_insert_entry>() - 8usize];
    [
        "Offset of field: btree_insert_entry::flags",
    ][::std::mem::offset_of!(btree_insert_entry, flags) - 0usize];
    [
        "Offset of field: btree_insert_entry::sort_order",
    ][::std::mem::offset_of!(btree_insert_entry, sort_order) - 4usize];
    [
        "Offset of field: btree_insert_entry::bkey_type",
    ][::std::mem::offset_of!(btree_insert_entry, bkey_type) - 5usize];
    [
        "Offset of field: btree_insert_entry::old_btree_u64s",
    ][::std::mem::offset_of!(btree_insert_entry, old_btree_u64s) - 8usize];
    [
        "Offset of field: btree_insert_entry::k_buf_u64s",
    ][::std::mem::offset_of!(btree_insert_entry, k_buf_u64s) - 9usize];
    [
        "Offset of field: btree_insert_entry::path",
    ][::std::mem::offset_of!(btree_insert_entry, path) - 10usize];
    [
        "Offset of field: btree_insert_entry::k",
    ][::std::mem::offset_of!(btree_insert_entry, k) - 16usize];
    [
        "Offset of field: btree_insert_entry::old_k",
    ][::std::mem::offset_of!(btree_insert_entry, old_k) - 24usize];
    [
        "Offset of field: btree_insert_entry::old_v",
    ][::std::mem::offset_of!(btree_insert_entry, old_v) - 64usize];
    [
        "Offset of field: btree_insert_entry::ip_allocated",
    ][::std::mem::offset_of!(btree_insert_entry, ip_allocated) - 72usize];
};
impl Default for btree_insert_entry {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl btree_insert_entry {
    #[inline]
    pub fn btree_id(&self) -> btree_id {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
    }
    #[inline]
    pub fn set_btree_id(&mut self, val: btree_id) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 8u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn btree_id_raw(this: *const Self) -> btree_id {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 8u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_btree_id_raw(this: *mut Self, val: btree_id) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                8u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn level(&self) -> u8_ {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 3u8) as u8) }
    }
    #[inline]
    pub fn set_level(&mut self, val: u8_) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(8usize, 3u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn level_raw(this: *const Self) -> u8_ {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 8usize, 3u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_level_raw(this: *mut Self, val: u8_) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                8usize,
                3u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn cached(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_cached(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(11usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn cached_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 11usize, 1u8)
                    as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_cached_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                11usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn insert_trigger_run(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_insert_trigger_run(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(12usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn insert_trigger_run_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 12usize, 1u8)
                    as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_insert_trigger_run_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                12usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn overwrite_trigger_run(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_overwrite_trigger_run(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(13usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn overwrite_trigger_run_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 13usize, 1u8)
                    as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_overwrite_trigger_run_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                13usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn key_cache_already_flushed(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_key_cache_already_flushed(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(14usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn key_cache_already_flushed_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 14usize, 1u8)
                    as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_key_cache_already_flushed_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                14usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn key_cache_flushing(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_key_cache_flushing(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(15usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn key_cache_flushing_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 15usize, 1u8)
                    as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_key_cache_flushing_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                15usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        btree_id: btree_id,
        level: u8_,
        cached: bool,
        insert_trigger_run: bool,
        overwrite_trigger_run: bool,
        key_cache_already_flushed: bool,
        key_cache_flushing: bool,
    ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                8u8,
                {
                    let btree_id: u32 = unsafe { ::std::mem::transmute(btree_id) };
                    btree_id as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                8usize,
                3u8,
                {
                    let level: u8 = unsafe { ::std::mem::transmute(level) };
                    level as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                11usize,
                1u8,
                {
                    let cached: u8 = unsafe { ::std::mem::transmute(cached) };
                    cached as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                12usize,
                1u8,
                {
                    let insert_trigger_run: u8 = unsafe {
                        ::std::mem::transmute(insert_trigger_run)
                    };
                    insert_trigger_run as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                13usize,
                1u8,
                {
                    let overwrite_trigger_run: u8 = unsafe {
                        ::std::mem::transmute(overwrite_trigger_run)
                    };
                    overwrite_trigger_run as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                14usize,
                1u8,
                {
                    let key_cache_already_flushed: u8 = unsafe {
                        ::std::mem::transmute(key_cache_already_flushed)
                    };
                    key_cache_already_flushed as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                15usize,
                1u8,
                {
                    let key_cache_flushing: u8 = unsafe {
                        ::std::mem::transmute(key_cache_flushing)
                    };
                    key_cache_flushing as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
pub type btree_trans_commit_hook_fn = ::std::option::Option<
    unsafe extern "C" fn(
        arg1: *mut btree_trans,
        arg2: *mut btree_trans_commit_hook,
    ) -> ::std::os::raw::c_int,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct btree_trans_commit_hook {
    pub fn_: btree_trans_commit_hook_fn,
    pub next: *mut btree_trans_commit_hook,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of btree_trans_commit_hook",
    ][::std::mem::size_of::<btree_trans_commit_hook>() - 16usize];
    [
        "Alignment of btree_trans_commit_hook",
    ][::std::mem::align_of::<btree_trans_commit_hook>() - 8usize];
    [
        "Offset of field: btree_trans_commit_hook::fn_",
    ][::std::mem::offset_of!(btree_trans_commit_hook, fn_) - 0usize];
    [
        "Offset of field: btree_trans_commit_hook::next",
    ][::std::mem::offset_of!(btree_trans_commit_hook, next) - 8usize];
};
impl Default for btree_trans_commit_hook {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug)]
pub struct btree_trans_paths {
    pub nr_paths: ::std::os::raw::c_ulong,
    pub paths: __IncompleteArrayField<btree_path>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of btree_trans_paths"][::std::mem::size_of::<btree_trans_paths>() - 8usize];
    [
        "Alignment of btree_trans_paths",
    ][::std::mem::align_of::<btree_trans_paths>() - 8usize];
    [
        "Offset of field: btree_trans_paths::nr_paths",
    ][::std::mem::offset_of!(btree_trans_paths, nr_paths) - 0usize];
    [
        "Offset of field: btree_trans_paths::paths",
    ][::std::mem::offset_of!(btree_trans_paths, paths) - 8usize];
};
impl Default for btree_trans_paths {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct btree_trans_subbuf {
    pub base: u16_,
    pub u64s: u16_,
    pub size: u16_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of btree_trans_subbuf"][::std::mem::size_of::<btree_trans_subbuf>() - 6usize];
    [
        "Alignment of btree_trans_subbuf",
    ][::std::mem::align_of::<btree_trans_subbuf>() - 2usize];
    [
        "Offset of field: btree_trans_subbuf::base",
    ][::std::mem::offset_of!(btree_trans_subbuf, base) - 0usize];
    [
        "Offset of field: btree_trans_subbuf::u64s",
    ][::std::mem::offset_of!(btree_trans_subbuf, u64s) - 2usize];
    [
        "Offset of field: btree_trans_subbuf::size",
    ][::std::mem::offset_of!(btree_trans_subbuf, size) - 4usize];
};
#[repr(C)]
pub struct btree_trans {
    pub c: *mut bch_fs,
    pub paths_allocated: *mut ::std::os::raw::c_ulong,
    pub paths: *mut btree_path,
    pub sorted: *mut btree_path_idx_t,
    pub updates: *mut btree_insert_entry,
    pub mem: *mut ::std::os::raw::c_void,
    pub mem_top: ::std::os::raw::c_uint,
    pub mem_bytes: ::std::os::raw::c_uint,
    pub realloc_bytes_required: ::std::os::raw::c_uint,
    pub nr_sorted: btree_path_idx_t,
    pub nr_paths: btree_path_idx_t,
    pub nr_paths_max: btree_path_idx_t,
    pub nr_updates: btree_path_idx_t,
    pub fn_idx: u8_,
    pub lock_must_abort: u8_,
    pub _bitfield_align_1: [u16; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
    pub restart_count: u32_,
    pub last_begin_time: u64_,
    pub last_begin_ip: ::std::os::raw::c_ulong,
    pub last_restarted_ip: ::std::os::raw::c_ulong,
    pub last_unlock_ip: ::std::os::raw::c_ulong,
    pub srcu_lock_time: ::std::os::raw::c_ulong,
    pub srcu_idx: ::std::os::raw::c_int,
    pub locking_root_id: btree_id,
    pub locking_hash_val: u64_,
    pub locking: *mut btree_bkey_cached_common,
    pub locking_wait: six_lock_waiter,
    pub queued_write_bios: *mut bio,
    pub fn_: *const ::std::os::raw::c_char,
    pub journal_entries: btree_trans_subbuf,
    pub accounting: btree_trans_subbuf,
    pub hooks: *mut btree_trans_commit_hook,
    pub journal_pin: *mut journal_entry_pin,
    pub journal_res: journal_res,
    pub journal_seq: *mut u64_,
    pub disk_res: *mut disk_reservation,
    pub fs_usage_delta: bch_fs_usage_base,
    pub journal_u64s: ::std::os::raw::c_uint,
    pub extra_journal_u64s: u32_,
    pub extra_disk_res: u64_,
    pub btree_path_down: bkey_i,
    pub btree_path_down_pad: [__u64; 15usize],
    pub list: cds_list_head,
    pub ref_: closure,
    pub rcu: rcu_head,
    pub _paths_allocated: [::std::os::raw::c_ulong; 1usize],
    pub trans_paths: btree_trans_paths,
    pub _paths: [btree_path; 64usize],
    pub _sorted: [btree_path_idx_t; 68usize],
    pub _updates: [btree_insert_entry; 64usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of btree_trans"][::std::mem::size_of::<btree_trans>() - 14008usize];
    ["Alignment of btree_trans"][::std::mem::align_of::<btree_trans>() - 8usize];
    ["Offset of field: btree_trans::c"][::std::mem::offset_of!(btree_trans, c) - 0usize];
    [
        "Offset of field: btree_trans::paths_allocated",
    ][::std::mem::offset_of!(btree_trans, paths_allocated) - 8usize];
    [
        "Offset of field: btree_trans::paths",
    ][::std::mem::offset_of!(btree_trans, paths) - 16usize];
    [
        "Offset of field: btree_trans::sorted",
    ][::std::mem::offset_of!(btree_trans, sorted) - 24usize];
    [
        "Offset of field: btree_trans::updates",
    ][::std::mem::offset_of!(btree_trans, updates) - 32usize];
    [
        "Offset of field: btree_trans::mem",
    ][::std::mem::offset_of!(btree_trans, mem) - 40usize];
    [
        "Offset of field: btree_trans::mem_top",
    ][::std::mem::offset_of!(btree_trans, mem_top) - 48usize];
    [
        "Offset of field: btree_trans::mem_bytes",
    ][::std::mem::offset_of!(btree_trans, mem_bytes) - 52usize];
    [
        "Offset of field: btree_trans::realloc_bytes_required",
    ][::std::mem::offset_of!(btree_trans, realloc_bytes_required) - 56usize];
    [
        "Offset of field: btree_trans::nr_sorted",
    ][::std::mem::offset_of!(btree_trans, nr_sorted) - 60usize];
    [
        "Offset of field: btree_trans::nr_paths",
    ][::std::mem::offset_of!(btree_trans, nr_paths) - 62usize];
    [
        "Offset of field: btree_trans::nr_paths_max",
    ][::std::mem::offset_of!(btree_trans, nr_paths_max) - 64usize];
    [
        "Offset of field: btree_trans::nr_updates",
    ][::std::mem::offset_of!(btree_trans, nr_updates) - 66usize];
    [
        "Offset of field: btree_trans::fn_idx",
    ][::std::mem::offset_of!(btree_trans, fn_idx) - 68usize];
    [
        "Offset of field: btree_trans::lock_must_abort",
    ][::std::mem::offset_of!(btree_trans, lock_must_abort) - 69usize];
    [
        "Offset of field: btree_trans::restart_count",
    ][::std::mem::offset_of!(btree_trans, restart_count) - 76usize];
    [
        "Offset of field: btree_trans::last_begin_time",
    ][::std::mem::offset_of!(btree_trans, last_begin_time) - 80usize];
    [
        "Offset of field: btree_trans::last_begin_ip",
    ][::std::mem::offset_of!(btree_trans, last_begin_ip) - 88usize];
    [
        "Offset of field: btree_trans::last_restarted_ip",
    ][::std::mem::offset_of!(btree_trans, last_restarted_ip) - 96usize];
    [
        "Offset of field: btree_trans::last_unlock_ip",
    ][::std::mem::offset_of!(btree_trans, last_unlock_ip) - 104usize];
    [
        "Offset of field: btree_trans::srcu_lock_time",
    ][::std::mem::offset_of!(btree_trans, srcu_lock_time) - 112usize];
    [
        "Offset of field: btree_trans::srcu_idx",
    ][::std::mem::offset_of!(btree_trans, srcu_idx) - 120usize];
    [
        "Offset of field: btree_trans::locking_root_id",
    ][::std::mem::offset_of!(btree_trans, locking_root_id) - 124usize];
    [
        "Offset of field: btree_trans::locking_hash_val",
    ][::std::mem::offset_of!(btree_trans, locking_hash_val) - 128usize];
    [
        "Offset of field: btree_trans::locking",
    ][::std::mem::offset_of!(btree_trans, locking) - 136usize];
    [
        "Offset of field: btree_trans::locking_wait",
    ][::std::mem::offset_of!(btree_trans, locking_wait) - 144usize];
    [
        "Offset of field: btree_trans::queued_write_bios",
    ][::std::mem::offset_of!(btree_trans, queued_write_bios) - 168usize];
    [
        "Offset of field: btree_trans::fn_",
    ][::std::mem::offset_of!(btree_trans, fn_) - 176usize];
    [
        "Offset of field: btree_trans::journal_entries",
    ][::std::mem::offset_of!(btree_trans, journal_entries) - 184usize];
    [
        "Offset of field: btree_trans::accounting",
    ][::std::mem::offset_of!(btree_trans, accounting) - 190usize];
    [
        "Offset of field: btree_trans::hooks",
    ][::std::mem::offset_of!(btree_trans, hooks) - 200usize];
    [
        "Offset of field: btree_trans::journal_pin",
    ][::std::mem::offset_of!(btree_trans, journal_pin) - 208usize];
    [
        "Offset of field: btree_trans::journal_res",
    ][::std::mem::offset_of!(btree_trans, journal_res) - 216usize];
    [
        "Offset of field: btree_trans::journal_seq",
    ][::std::mem::offset_of!(btree_trans, journal_seq) - 232usize];
    [
        "Offset of field: btree_trans::disk_res",
    ][::std::mem::offset_of!(btree_trans, disk_res) - 240usize];
    [
        "Offset of field: btree_trans::fs_usage_delta",
    ][::std::mem::offset_of!(btree_trans, fs_usage_delta) - 248usize];
    [
        "Offset of field: btree_trans::journal_u64s",
    ][::std::mem::offset_of!(btree_trans, journal_u64s) - 288usize];
    [
        "Offset of field: btree_trans::extra_journal_u64s",
    ][::std::mem::offset_of!(btree_trans, extra_journal_u64s) - 292usize];
    [
        "Offset of field: btree_trans::extra_disk_res",
    ][::std::mem::offset_of!(btree_trans, extra_disk_res) - 296usize];
    [
        "Offset of field: btree_trans::btree_path_down",
    ][::std::mem::offset_of!(btree_trans, btree_path_down) - 304usize];
    [
        "Offset of field: btree_trans::btree_path_down_pad",
    ][::std::mem::offset_of!(btree_trans, btree_path_down_pad) - 344usize];
    [
        "Offset of field: btree_trans::list",
    ][::std::mem::offset_of!(btree_trans, list) - 464usize];
    [
        "Offset of field: btree_trans::ref_",
    ][::std::mem::offset_of!(btree_trans, ref_) - 480usize];
    [
        "Offset of field: btree_trans::rcu",
    ][::std::mem::offset_of!(btree_trans, rcu) - 528usize];
    [
        "Offset of field: btree_trans::_paths_allocated",
    ][::std::mem::offset_of!(btree_trans, _paths_allocated) - 544usize];
    [
        "Offset of field: btree_trans::trans_paths",
    ][::std::mem::offset_of!(btree_trans, trans_paths) - 552usize];
    [
        "Offset of field: btree_trans::_paths",
    ][::std::mem::offset_of!(btree_trans, _paths) - 560usize];
    [
        "Offset of field: btree_trans::_sorted",
    ][::std::mem::offset_of!(btree_trans, _sorted) - 8752usize];
    [
        "Offset of field: btree_trans::_updates",
    ][::std::mem::offset_of!(btree_trans, _updates) - 8888usize];
};
impl Default for btree_trans {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl btree_trans {
    #[inline]
    pub fn lock_may_not_fail(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_lock_may_not_fail(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn lock_may_not_fail_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 4usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_lock_may_not_fail_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 4usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn locked(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_locked(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(1usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn locked_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 4usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 1usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_locked_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 4usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                1usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn write_locked(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_write_locked(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(2usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn write_locked_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 4usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 2usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_write_locked_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 4usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                2usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn srcu_held(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_srcu_held(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(3usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn srcu_held_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 4usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 3usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_srcu_held_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 4usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                3usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn btree_cache_cannibalize_locked(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_btree_cache_cannibalize_locked(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(4usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn btree_cache_cannibalize_locked_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 4usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 4usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_btree_cache_cannibalize_locked_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 4usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                4usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn pf_memalloc_nofs(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_pf_memalloc_nofs(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(5usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn pf_memalloc_nofs_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 4usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 5usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_pf_memalloc_nofs_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 4usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                5usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn used_mempool(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_used_mempool(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(6usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn used_mempool_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 4usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 6usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_used_mempool_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 4usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                6usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn in_traverse_all(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_in_traverse_all(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(7usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn in_traverse_all_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 4usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 7usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_in_traverse_all_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 4usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                7usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn paths_sorted(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_paths_sorted(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(8usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn paths_sorted_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 4usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 8usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_paths_sorted_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 4usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                8usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn memory_allocation_failure(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_memory_allocation_failure(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(9usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn memory_allocation_failure_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 4usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 9usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_memory_allocation_failure_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 4usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                9usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn journal_transaction_names(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_journal_transaction_names(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(10usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn journal_transaction_names_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 4usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 10usize, 1u8)
                    as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_journal_transaction_names_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 4usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                10usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn journal_replay_not_finished(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_journal_replay_not_finished(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(11usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn journal_replay_not_finished_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 4usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 11usize, 1u8)
                    as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_journal_replay_not_finished_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 4usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                11usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn notrace_relock_fail(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_notrace_relock_fail(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(12usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn notrace_relock_fail_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 4usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 12usize, 1u8)
                    as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_notrace_relock_fail_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 4usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                12usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn has_interior_updates(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_has_interior_updates(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(13usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn has_interior_updates_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 4usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 13usize, 1u8)
                    as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_has_interior_updates_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 4usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                13usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn restarted(&self) -> bch_errcode {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 16u8) as u32) }
    }
    #[inline]
    pub fn set_restarted(&mut self, val: bch_errcode) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(14usize, 16u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn restarted_raw(this: *const Self) -> bch_errcode {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 4usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 14usize, 16u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_restarted_raw(this: *mut Self, val: bch_errcode) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 4usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                14usize,
                16u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        lock_may_not_fail: bool,
        locked: bool,
        write_locked: bool,
        srcu_held: bool,
        btree_cache_cannibalize_locked: bool,
        pf_memalloc_nofs: bool,
        used_mempool: bool,
        in_traverse_all: bool,
        paths_sorted: bool,
        memory_allocation_failure: bool,
        journal_transaction_names: bool,
        journal_replay_not_finished: bool,
        notrace_relock_fail: bool,
        has_interior_updates: bool,
        restarted: bch_errcode,
    ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                1u8,
                {
                    let lock_may_not_fail: u8 = unsafe {
                        ::std::mem::transmute(lock_may_not_fail)
                    };
                    lock_may_not_fail as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                1usize,
                1u8,
                {
                    let locked: u8 = unsafe { ::std::mem::transmute(locked) };
                    locked as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                2usize,
                1u8,
                {
                    let write_locked: u8 = unsafe {
                        ::std::mem::transmute(write_locked)
                    };
                    write_locked as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                3usize,
                1u8,
                {
                    let srcu_held: u8 = unsafe { ::std::mem::transmute(srcu_held) };
                    srcu_held as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                4usize,
                1u8,
                {
                    let btree_cache_cannibalize_locked: u8 = unsafe {
                        ::std::mem::transmute(btree_cache_cannibalize_locked)
                    };
                    btree_cache_cannibalize_locked as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                5usize,
                1u8,
                {
                    let pf_memalloc_nofs: u8 = unsafe {
                        ::std::mem::transmute(pf_memalloc_nofs)
                    };
                    pf_memalloc_nofs as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                6usize,
                1u8,
                {
                    let used_mempool: u8 = unsafe {
                        ::std::mem::transmute(used_mempool)
                    };
                    used_mempool as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                7usize,
                1u8,
                {
                    let in_traverse_all: u8 = unsafe {
                        ::std::mem::transmute(in_traverse_all)
                    };
                    in_traverse_all as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                8usize,
                1u8,
                {
                    let paths_sorted: u8 = unsafe {
                        ::std::mem::transmute(paths_sorted)
                    };
                    paths_sorted as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                9usize,
                1u8,
                {
                    let memory_allocation_failure: u8 = unsafe {
                        ::std::mem::transmute(memory_allocation_failure)
                    };
                    memory_allocation_failure as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                10usize,
                1u8,
                {
                    let journal_transaction_names: u8 = unsafe {
                        ::std::mem::transmute(journal_transaction_names)
                    };
                    journal_transaction_names as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                11usize,
                1u8,
                {
                    let journal_replay_not_finished: u8 = unsafe {
                        ::std::mem::transmute(journal_replay_not_finished)
                    };
                    journal_replay_not_finished as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                12usize,
                1u8,
                {
                    let notrace_relock_fail: u8 = unsafe {
                        ::std::mem::transmute(notrace_relock_fail)
                    };
                    notrace_relock_fail as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                13usize,
                1u8,
                {
                    let has_interior_updates: u8 = unsafe {
                        ::std::mem::transmute(has_interior_updates)
                    };
                    has_interior_updates as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                14usize,
                16u8,
                {
                    let restarted: u32 = unsafe { ::std::mem::transmute(restarted) };
                    restarted as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct btree_trans_buf {
    pub trans: *mut btree_trans,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of btree_trans_buf"][::std::mem::size_of::<btree_trans_buf>() - 8usize];
    ["Alignment of btree_trans_buf"][::std::mem::align_of::<btree_trans_buf>() - 8usize];
    [
        "Offset of field: btree_trans_buf::trans",
    ][::std::mem::offset_of!(btree_trans_buf, trans) - 0usize];
};
impl Default for btree_trans_buf {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[repr(align(16))]
#[derive(Copy, Clone)]
pub struct btree_transaction_stats {
    pub duration: bch2_time_stats,
    pub lock_hold_times: bch2_time_stats,
    pub lock_wait_times: bch2_time_stats,
    pub lock: mutex,
    pub nr_max_paths: ::std::os::raw::c_uint,
    pub max_mem: ::std::os::raw::c_uint,
    pub max_paths_text: *mut ::std::os::raw::c_char,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of btree_transaction_stats",
    ][::std::mem::size_of::<btree_transaction_stats>() - 736usize];
    [
        "Alignment of btree_transaction_stats",
    ][::std::mem::align_of::<btree_transaction_stats>() - 16usize];
    [
        "Offset of field: btree_transaction_stats::duration",
    ][::std::mem::offset_of!(btree_transaction_stats, duration) - 0usize];
    [
        "Offset of field: btree_transaction_stats::lock_hold_times",
    ][::std::mem::offset_of!(btree_transaction_stats, lock_hold_times) - 224usize];
    [
        "Offset of field: btree_transaction_stats::lock_wait_times",
    ][::std::mem::offset_of!(btree_transaction_stats, lock_wait_times) - 448usize];
    [
        "Offset of field: btree_transaction_stats::lock",
    ][::std::mem::offset_of!(btree_transaction_stats, lock) - 672usize];
    [
        "Offset of field: btree_transaction_stats::nr_max_paths",
    ][::std::mem::offset_of!(btree_transaction_stats, nr_max_paths) - 712usize];
    [
        "Offset of field: btree_transaction_stats::max_mem",
    ][::std::mem::offset_of!(btree_transaction_stats, max_mem) - 716usize];
    [
        "Offset of field: btree_transaction_stats::max_paths_text",
    ][::std::mem::offset_of!(btree_transaction_stats, max_paths_text) - 720usize];
};
impl Default for btree_transaction_stats {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[repr(align(16))]
pub struct bch_fs_btree_trans {
    pub lock: seqmutex,
    pub list: cds_list_head,
    pub pool: mempool_t,
    pub malloc_pool: mempool_t,
    pub bufs: *mut btree_trans_buf,
    pub barrier: srcu_struct,
    pub barrier_initialized: bool,
    pub stats: [btree_transaction_stats; 128usize],
    pub stats_json_lock: mutex,
    pub stats_json_buf: printbuf,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_fs_btree_trans",
    ][::std::mem::size_of::<bch_fs_btree_trans>() - 94640usize];
    [
        "Alignment of bch_fs_btree_trans",
    ][::std::mem::align_of::<bch_fs_btree_trans>() - 16usize];
    [
        "Offset of field: bch_fs_btree_trans::lock",
    ][::std::mem::offset_of!(bch_fs_btree_trans, lock) - 0usize];
    [
        "Offset of field: bch_fs_btree_trans::list",
    ][::std::mem::offset_of!(bch_fs_btree_trans, list) - 48usize];
    [
        "Offset of field: bch_fs_btree_trans::pool",
    ][::std::mem::offset_of!(bch_fs_btree_trans, pool) - 64usize];
    [
        "Offset of field: bch_fs_btree_trans::malloc_pool",
    ][::std::mem::offset_of!(bch_fs_btree_trans, malloc_pool) - 200usize];
    [
        "Offset of field: bch_fs_btree_trans::bufs",
    ][::std::mem::offset_of!(bch_fs_btree_trans, bufs) - 336usize];
    [
        "Offset of field: bch_fs_btree_trans::barrier",
    ][::std::mem::offset_of!(bch_fs_btree_trans, barrier) - 344usize];
    [
        "Offset of field: bch_fs_btree_trans::barrier_initialized",
    ][::std::mem::offset_of!(bch_fs_btree_trans, barrier_initialized) - 344usize];
    [
        "Offset of field: bch_fs_btree_trans::stats",
    ][::std::mem::offset_of!(bch_fs_btree_trans, stats) - 352usize];
    [
        "Offset of field: bch_fs_btree_trans::stats_json_lock",
    ][::std::mem::offset_of!(bch_fs_btree_trans, stats_json_lock) - 94560usize];
    [
        "Offset of field: bch_fs_btree_trans::stats_json_buf",
    ][::std::mem::offset_of!(bch_fs_btree_trans, stats_json_buf) - 94600usize];
};
impl Default for bch_fs_btree_trans {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum btree_flags {
    BTREE_NODE_FLAGS_START = 2,
    BTREE_NODE_read_in_flight = 3,
    BTREE_NODE_read_error = 4,
    BTREE_NODE_dirty = 5,
    BTREE_NODE_need_write = 6,
    BTREE_NODE_write_blocked = 7,
    BTREE_NODE_will_make_reachable = 8,
    BTREE_NODE_noevict = 9,
    BTREE_NODE_write_idx = 10,
    BTREE_NODE_accessed = 11,
    BTREE_NODE_write_in_flight = 12,
    BTREE_NODE_write_in_flight_inner = 13,
    BTREE_NODE_just_written = 14,
    BTREE_NODE_dying = 15,
    BTREE_NODE_fake = 16,
    BTREE_NODE_need_rewrite = 17,
    BTREE_NODE_need_rewrite_error = 18,
    BTREE_NODE_need_rewrite_ptr_written_zero = 19,
    BTREE_NODE_never_write = 20,
    BTREE_NODE_pinned = 21,
    BTREE_NODE_permanent = 22,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct btree_evicted_size {
    pub mask: u64_,
    pub entries: *mut u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of btree_evicted_size",
    ][::std::mem::size_of::<btree_evicted_size>() - 16usize];
    [
        "Alignment of btree_evicted_size",
    ][::std::mem::align_of::<btree_evicted_size>() - 8usize];
    [
        "Offset of field: btree_evicted_size::mask",
    ][::std::mem::offset_of!(btree_evicted_size, mask) - 0usize];
    [
        "Offset of field: btree_evicted_size::entries",
    ][::std::mem::offset_of!(btree_evicted_size, entries) - 8usize];
};
impl Default for btree_evicted_size {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[repr(align(16))]
pub struct bch_fs_btree {
    pub foreground_merge_threshold: u16_,
    pub bounce_pool: mempool_t,
    pub write_stats: [bch_fs_btree_btree_write_stats; 5usize],
    pub bio: bio_set,
    pub fill_iter: mempool_t,
    pub read_complete_wq: *mut workqueue_struct,
    pub read_errors_soft: ratelimit_state,
    pub read_errors_hard: ratelimit_state,
    pub write_complete_wq: *mut workqueue_struct,
    pub root_journal_res: journal_entry_res,
    pub cache: bch_fs_btree_cache,
    pub evicted_size: btree_evicted_size,
    pub key_cache: bch_fs_btree_key_cache,
    pub write_buffer: [bch_fs_btree_write_buffer; 11usize],
    pub write_buffer_wq: *mut workqueue_struct,
    pub write_buffer_shard_wq: *mut workqueue_struct,
    pub write_buffer_flush_wait: closure_waitlist,
    pub trans: bch_fs_btree_trans,
    pub reserve_cache: bch_fs_btree_reserve_cache,
    pub interior_updates: bch_fs_btree_interior_updates,
    pub node_rewrites: bch_fs_btree_node_rewrites,
    pub node_scan: find_btree_nodes,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_fs_btree_btree_write_stats {
    pub nr: atomic64_t,
    pub bytes: atomic64_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_fs_btree_btree_write_stats",
    ][::std::mem::size_of::<bch_fs_btree_btree_write_stats>() - 16usize];
    [
        "Alignment of bch_fs_btree_btree_write_stats",
    ][::std::mem::align_of::<bch_fs_btree_btree_write_stats>() - 8usize];
    [
        "Offset of field: bch_fs_btree_btree_write_stats::nr",
    ][::std::mem::offset_of!(bch_fs_btree_btree_write_stats, nr) - 0usize];
    [
        "Offset of field: bch_fs_btree_btree_write_stats::bytes",
    ][::std::mem::offset_of!(bch_fs_btree_btree_write_stats, bytes) - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_fs_btree"][::std::mem::size_of::<bch_fs_btree>() - 117824usize];
    ["Alignment of bch_fs_btree"][::std::mem::align_of::<bch_fs_btree>() - 16usize];
    [
        "Offset of field: bch_fs_btree::foreground_merge_threshold",
    ][::std::mem::offset_of!(bch_fs_btree, foreground_merge_threshold) - 0usize];
    [
        "Offset of field: bch_fs_btree::bounce_pool",
    ][::std::mem::offset_of!(bch_fs_btree, bounce_pool) - 8usize];
    [
        "Offset of field: bch_fs_btree::write_stats",
    ][::std::mem::offset_of!(bch_fs_btree, write_stats) - 144usize];
    [
        "Offset of field: bch_fs_btree::bio",
    ][::std::mem::offset_of!(bch_fs_btree, bio) - 224usize];
    [
        "Offset of field: bch_fs_btree::fill_iter",
    ][::std::mem::offset_of!(bch_fs_btree, fill_iter) - 504usize];
    [
        "Offset of field: bch_fs_btree::read_complete_wq",
    ][::std::mem::offset_of!(bch_fs_btree, read_complete_wq) - 640usize];
    [
        "Offset of field: bch_fs_btree::read_errors_soft",
    ][::std::mem::offset_of!(bch_fs_btree, read_errors_soft) - 648usize];
    [
        "Offset of field: bch_fs_btree::read_errors_hard",
    ][::std::mem::offset_of!(bch_fs_btree, read_errors_hard) - 720usize];
    [
        "Offset of field: bch_fs_btree::write_complete_wq",
    ][::std::mem::offset_of!(bch_fs_btree, write_complete_wq) - 792usize];
    [
        "Offset of field: bch_fs_btree::root_journal_res",
    ][::std::mem::offset_of!(bch_fs_btree, root_journal_res) - 800usize];
    [
        "Offset of field: bch_fs_btree::cache",
    ][::std::mem::offset_of!(bch_fs_btree, cache) - 808usize];
    [
        "Offset of field: bch_fs_btree::evicted_size",
    ][::std::mem::offset_of!(bch_fs_btree, evicted_size) - 6888usize];
    [
        "Offset of field: bch_fs_btree::key_cache",
    ][::std::mem::offset_of!(bch_fs_btree, key_cache) - 6904usize];
    [
        "Offset of field: bch_fs_btree::write_buffer",
    ][::std::mem::offset_of!(bch_fs_btree, write_buffer) - 7224usize];
    [
        "Offset of field: bch_fs_btree::write_buffer_wq",
    ][::std::mem::offset_of!(bch_fs_btree, write_buffer_wq) - 11448usize];
    [
        "Offset of field: bch_fs_btree::write_buffer_shard_wq",
    ][::std::mem::offset_of!(bch_fs_btree, write_buffer_shard_wq) - 11456usize];
    [
        "Offset of field: bch_fs_btree::write_buffer_flush_wait",
    ][::std::mem::offset_of!(bch_fs_btree, write_buffer_flush_wait) - 11464usize];
    [
        "Offset of field: bch_fs_btree::trans",
    ][::std::mem::offset_of!(bch_fs_btree, trans) - 11472usize];
    [
        "Offset of field: bch_fs_btree::reserve_cache",
    ][::std::mem::offset_of!(bch_fs_btree, reserve_cache) - 106112usize];
    [
        "Offset of field: bch_fs_btree::interior_updates",
    ][::std::mem::offset_of!(bch_fs_btree, interior_updates) - 117360usize];
    [
        "Offset of field: bch_fs_btree::node_rewrites",
    ][::std::mem::offset_of!(bch_fs_btree, node_rewrites) - 117656usize];
    [
        "Offset of field: bch_fs_btree::node_scan",
    ][::std::mem::offset_of!(bch_fs_btree, node_scan) - 117744usize];
};
impl Default for bch_fs_btree {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum btree_node_type {
    BKEY_TYPE_btree = 0,
    BKEY_TYPE_extents = 1,
    BKEY_TYPE_inodes = 2,
    BKEY_TYPE_dirents = 3,
    BKEY_TYPE_xattrs = 4,
    BKEY_TYPE_alloc = 5,
    BKEY_TYPE_quotas = 6,
    BKEY_TYPE_stripes = 7,
    BKEY_TYPE_reflink = 8,
    BKEY_TYPE_subvolumes = 9,
    BKEY_TYPE_snapshots = 10,
    BKEY_TYPE_lru = 11,
    BKEY_TYPE_freespace = 12,
    BKEY_TYPE_need_discard = 13,
    BKEY_TYPE_backpointers = 14,
    BKEY_TYPE_bucket_gens = 15,
    BKEY_TYPE_snapshot_trees = 16,
    BKEY_TYPE_deleted_inodes = 17,
    BKEY_TYPE_logged_ops = 18,
    BKEY_TYPE_reconcile_work = 19,
    BKEY_TYPE_subvolume_children = 20,
    BKEY_TYPE_accounting = 21,
    BKEY_TYPE_reconcile_hipri = 22,
    BKEY_TYPE_reconcile_pending = 23,
    BKEY_TYPE_reconcile_scan = 24,
    BKEY_TYPE_reconcile_work_phys = 25,
    BKEY_TYPE_reconcile_hipri_phys = 26,
    BKEY_TYPE_bucket_to_stripe = 27,
    BKEY_TYPE_stripe_backpointers = 28,
    BKEY_TYPE_NR = 29,
}
unsafe extern "C" {
    pub fn bch2_btree_node_type_str(
        arg1: btree_node_type,
    ) -> *const ::std::os::raw::c_char;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bch_fs_compress {
    pub bounce: [mempool_t; 2usize],
    pub workspace: [mempool_t; 4usize],
    pub zstd_workspace_size: usize,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_fs_compress"][::std::mem::size_of::<bch_fs_compress>() - 824usize];
    ["Alignment of bch_fs_compress"][::std::mem::align_of::<bch_fs_compress>() - 8usize];
    [
        "Offset of field: bch_fs_compress::bounce",
    ][::std::mem::offset_of!(bch_fs_compress, bounce) - 0usize];
    [
        "Offset of field: bch_fs_compress::workspace",
    ][::std::mem::offset_of!(bch_fs_compress, workspace) - 272usize];
    [
        "Offset of field: bch_fs_compress::zstd_workspace_size",
    ][::std::mem::offset_of!(bch_fs_compress, zstd_workspace_size) - 816usize];
};
impl Default for bch_fs_compress {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[repr(align(64))]
#[derive(Copy, Clone)]
pub struct bch_fs_copygc {
    pub thread: *mut task_struct,
    pub __bindgen_padding_0: [u64; 7usize],
    pub write_point: write_point,
    pub wait_at: s64,
    pub wait: s64,
    pub running: bool,
    pub run_count: u32_,
    pub kick_count: u32_,
    pub running_wq: wait_queue_head_t,
    pub wq: *mut workqueue_struct,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_fs_copygc"][::std::mem::size_of::<bch_fs_copygc>() - 1088usize];
    ["Alignment of bch_fs_copygc"][::std::mem::align_of::<bch_fs_copygc>() - 64usize];
    [
        "Offset of field: bch_fs_copygc::thread",
    ][::std::mem::offset_of!(bch_fs_copygc, thread) - 0usize];
    [
        "Offset of field: bch_fs_copygc::write_point",
    ][::std::mem::offset_of!(bch_fs_copygc, write_point) - 64usize];
    [
        "Offset of field: bch_fs_copygc::wait_at",
    ][::std::mem::offset_of!(bch_fs_copygc, wait_at) - 960usize];
    [
        "Offset of field: bch_fs_copygc::wait",
    ][::std::mem::offset_of!(bch_fs_copygc, wait) - 968usize];
    [
        "Offset of field: bch_fs_copygc::running",
    ][::std::mem::offset_of!(bch_fs_copygc, running) - 976usize];
    [
        "Offset of field: bch_fs_copygc::run_count",
    ][::std::mem::offset_of!(bch_fs_copygc, run_count) - 980usize];
    [
        "Offset of field: bch_fs_copygc::kick_count",
    ][::std::mem::offset_of!(bch_fs_copygc, kick_count) - 984usize];
    [
        "Offset of field: bch_fs_copygc::running_wq",
    ][::std::mem::offset_of!(bch_fs_copygc, running_wq) - 992usize];
    [
        "Offset of field: bch_fs_copygc::wq",
    ][::std::mem::offset_of!(bch_fs_copygc, wq) - 1048usize];
};
impl Default for bch_fs_copygc {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[repr(align(8))]
#[derive(Debug, Default, Copy, Clone)]
pub struct gc_stripe {
    pub _bindgen_opaque_blob: [u64; 24usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of gc_stripe"][::std::mem::size_of::<gc_stripe>() - 192usize];
    ["Alignment of gc_stripe"][::std::mem::align_of::<gc_stripe>() - 8usize];
};
#[repr(C)]
pub struct bch_fs_ec {
    pub stripe_buf_bytes: ::std::os::raw::c_long,
    pub stripe_buf_lock: spinlock_t,
    pub stripe_buf_wait: closure_waitlist,
    pub stripes_new: [cds_hlist_head; 32usize],
    pub stripes_new_buckets: [cds_hlist_head; 64usize],
    pub stripes_new_lock: spinlock_t,
    pub stripe_head_list: cds_list_head,
    pub stripe_head_lock: mutex,
    pub dev_stripe_state_list: cds_list_head,
    pub dev_stripe_state_lock: mutex,
    pub stripe_new_list: cds_list_head,
    pub stripe_new_lock: mutex,
    pub stripe_new_wait: wait_queue_head_t,
    pub stripe_new_seq: atomic64_t,
    pub stripe_create_wq: *mut workqueue_struct,
    pub stripe_hint: u64_,
    pub stripe_delete_work: work_struct,
    pub block_bioset: bio_set,
    pub gc_stripes: bch_fs_ec__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug)]
pub struct bch_fs_ec__bindgen_ty_1 {
    pub tree: __genradix,
    pub type_: __IncompleteArrayField<gc_stripe>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_fs_ec__bindgen_ty_1",
    ][::std::mem::size_of::<bch_fs_ec__bindgen_ty_1>() - 8usize];
    [
        "Alignment of bch_fs_ec__bindgen_ty_1",
    ][::std::mem::align_of::<bch_fs_ec__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bch_fs_ec__bindgen_ty_1::tree",
    ][::std::mem::offset_of!(bch_fs_ec__bindgen_ty_1, tree) - 0usize];
    [
        "Offset of field: bch_fs_ec__bindgen_ty_1::type_",
    ][::std::mem::offset_of!(bch_fs_ec__bindgen_ty_1, type_) - 8usize];
};
impl Default for bch_fs_ec__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_fs_ec"][::std::mem::size_of::<bch_fs_ec>() - 1432usize];
    ["Alignment of bch_fs_ec"][::std::mem::align_of::<bch_fs_ec>() - 8usize];
    [
        "Offset of field: bch_fs_ec::stripe_buf_bytes",
    ][::std::mem::offset_of!(bch_fs_ec, stripe_buf_bytes) - 0usize];
    [
        "Offset of field: bch_fs_ec::stripe_buf_lock",
    ][::std::mem::offset_of!(bch_fs_ec, stripe_buf_lock) - 8usize];
    [
        "Offset of field: bch_fs_ec::stripe_buf_wait",
    ][::std::mem::offset_of!(bch_fs_ec, stripe_buf_wait) - 48usize];
    [
        "Offset of field: bch_fs_ec::stripes_new",
    ][::std::mem::offset_of!(bch_fs_ec, stripes_new) - 56usize];
    [
        "Offset of field: bch_fs_ec::stripes_new_buckets",
    ][::std::mem::offset_of!(bch_fs_ec, stripes_new_buckets) - 312usize];
    [
        "Offset of field: bch_fs_ec::stripes_new_lock",
    ][::std::mem::offset_of!(bch_fs_ec, stripes_new_lock) - 824usize];
    [
        "Offset of field: bch_fs_ec::stripe_head_list",
    ][::std::mem::offset_of!(bch_fs_ec, stripe_head_list) - 864usize];
    [
        "Offset of field: bch_fs_ec::stripe_head_lock",
    ][::std::mem::offset_of!(bch_fs_ec, stripe_head_lock) - 880usize];
    [
        "Offset of field: bch_fs_ec::dev_stripe_state_list",
    ][::std::mem::offset_of!(bch_fs_ec, dev_stripe_state_list) - 920usize];
    [
        "Offset of field: bch_fs_ec::dev_stripe_state_lock",
    ][::std::mem::offset_of!(bch_fs_ec, dev_stripe_state_lock) - 936usize];
    [
        "Offset of field: bch_fs_ec::stripe_new_list",
    ][::std::mem::offset_of!(bch_fs_ec, stripe_new_list) - 976usize];
    [
        "Offset of field: bch_fs_ec::stripe_new_lock",
    ][::std::mem::offset_of!(bch_fs_ec, stripe_new_lock) - 992usize];
    [
        "Offset of field: bch_fs_ec::stripe_new_wait",
    ][::std::mem::offset_of!(bch_fs_ec, stripe_new_wait) - 1032usize];
    [
        "Offset of field: bch_fs_ec::stripe_new_seq",
    ][::std::mem::offset_of!(bch_fs_ec, stripe_new_seq) - 1088usize];
    [
        "Offset of field: bch_fs_ec::stripe_create_wq",
    ][::std::mem::offset_of!(bch_fs_ec, stripe_create_wq) - 1096usize];
    [
        "Offset of field: bch_fs_ec::stripe_hint",
    ][::std::mem::offset_of!(bch_fs_ec, stripe_hint) - 1104usize];
    [
        "Offset of field: bch_fs_ec::stripe_delete_work",
    ][::std::mem::offset_of!(bch_fs_ec, stripe_delete_work) - 1112usize];
    [
        "Offset of field: bch_fs_ec::block_bioset",
    ][::std::mem::offset_of!(bch_fs_ec, block_bioset) - 1144usize];
    [
        "Offset of field: bch_fs_ec::gc_stripes",
    ][::std::mem::offset_of!(bch_fs_ec, gc_stripes) - 1424usize];
};
impl Default for bch_fs_ec {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct keylist {
    pub __bindgen_anon_1: keylist__bindgen_ty_1,
    pub __bindgen_anon_2: keylist__bindgen_ty_2,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union keylist__bindgen_ty_1 {
    pub keys: *mut bkey_i,
    pub keys_p: *mut u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of keylist__bindgen_ty_1",
    ][::std::mem::size_of::<keylist__bindgen_ty_1>() - 8usize];
    [
        "Alignment of keylist__bindgen_ty_1",
    ][::std::mem::align_of::<keylist__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: keylist__bindgen_ty_1::keys",
    ][::std::mem::offset_of!(keylist__bindgen_ty_1, keys) - 0usize];
    [
        "Offset of field: keylist__bindgen_ty_1::keys_p",
    ][::std::mem::offset_of!(keylist__bindgen_ty_1, keys_p) - 0usize];
};
impl Default for keylist__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union keylist__bindgen_ty_2 {
    pub top: *mut bkey_i,
    pub top_p: *mut u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of keylist__bindgen_ty_2",
    ][::std::mem::size_of::<keylist__bindgen_ty_2>() - 8usize];
    [
        "Alignment of keylist__bindgen_ty_2",
    ][::std::mem::align_of::<keylist__bindgen_ty_2>() - 8usize];
    [
        "Offset of field: keylist__bindgen_ty_2::top",
    ][::std::mem::offset_of!(keylist__bindgen_ty_2, top) - 0usize];
    [
        "Offset of field: keylist__bindgen_ty_2::top_p",
    ][::std::mem::offset_of!(keylist__bindgen_ty_2, top_p) - 0usize];
};
impl Default for keylist__bindgen_ty_2 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of keylist"][::std::mem::size_of::<keylist>() - 16usize];
    ["Alignment of keylist"][::std::mem::align_of::<keylist>() - 8usize];
};
impl Default for keylist {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[repr(align(64))]
#[derive(Copy, Clone)]
pub struct nocow_lock_bucket {
    pub wait: closure_waitlist,
    pub lock: spinlock_t,
    pub b: [u64_; 6usize],
    pub l: [atomic_t; 6usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of nocow_lock_bucket"][::std::mem::size_of::<nocow_lock_bucket>() - 128usize];
    [
        "Alignment of nocow_lock_bucket",
    ][::std::mem::align_of::<nocow_lock_bucket>() - 64usize];
    [
        "Offset of field: nocow_lock_bucket::wait",
    ][::std::mem::offset_of!(nocow_lock_bucket, wait) - 0usize];
    [
        "Offset of field: nocow_lock_bucket::lock",
    ][::std::mem::offset_of!(nocow_lock_bucket, lock) - 8usize];
    [
        "Offset of field: nocow_lock_bucket::b",
    ][::std::mem::offset_of!(nocow_lock_bucket, b) - 48usize];
    [
        "Offset of field: nocow_lock_bucket::l",
    ][::std::mem::offset_of!(nocow_lock_bucket, l) - 96usize];
};
impl Default for nocow_lock_bucket {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[repr(align(64))]
#[derive(Copy, Clone)]
pub struct bucket_nocow_lock_table {
    pub l: [nocow_lock_bucket; 1024usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bucket_nocow_lock_table",
    ][::std::mem::size_of::<bucket_nocow_lock_table>() - 131072usize];
    [
        "Alignment of bucket_nocow_lock_table",
    ][::std::mem::align_of::<bucket_nocow_lock_table>() - 64usize];
    [
        "Offset of field: bucket_nocow_lock_table::l",
    ][::std::mem::offset_of!(bucket_nocow_lock_table, l) - 0usize];
};
impl Default for bucket_nocow_lock_table {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_ioctl_err_msg {
    pub msg_ptr: __u64,
    pub msg_len: __u32,
    pub pad: __u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_ioctl_err_msg"][::std::mem::size_of::<bch_ioctl_err_msg>() - 16usize];
    [
        "Alignment of bch_ioctl_err_msg",
    ][::std::mem::align_of::<bch_ioctl_err_msg>() - 8usize];
    [
        "Offset of field: bch_ioctl_err_msg::msg_ptr",
    ][::std::mem::offset_of!(bch_ioctl_err_msg, msg_ptr) - 0usize];
    [
        "Offset of field: bch_ioctl_err_msg::msg_len",
    ][::std::mem::offset_of!(bch_ioctl_err_msg, msg_len) - 8usize];
    [
        "Offset of field: bch_ioctl_err_msg::pad",
    ][::std::mem::offset_of!(bch_ioctl_err_msg, pad) - 12usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_ioctl_query_uuid {
    pub uuid: __uuid_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_ioctl_query_uuid",
    ][::std::mem::size_of::<bch_ioctl_query_uuid>() - 16usize];
    [
        "Alignment of bch_ioctl_query_uuid",
    ][::std::mem::align_of::<bch_ioctl_query_uuid>() - 1usize];
    [
        "Offset of field: bch_ioctl_query_uuid::uuid",
    ][::std::mem::offset_of!(bch_ioctl_query_uuid, uuid) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_ioctl_disk {
    pub flags: __u32,
    pub pad: __u32,
    pub dev: __u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_ioctl_disk"][::std::mem::size_of::<bch_ioctl_disk>() - 16usize];
    ["Alignment of bch_ioctl_disk"][::std::mem::align_of::<bch_ioctl_disk>() - 8usize];
    [
        "Offset of field: bch_ioctl_disk::flags",
    ][::std::mem::offset_of!(bch_ioctl_disk, flags) - 0usize];
    [
        "Offset of field: bch_ioctl_disk::pad",
    ][::std::mem::offset_of!(bch_ioctl_disk, pad) - 4usize];
    [
        "Offset of field: bch_ioctl_disk::dev",
    ][::std::mem::offset_of!(bch_ioctl_disk, dev) - 8usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_ioctl_disk_v2 {
    pub flags: __u32,
    pub pad: __u32,
    pub dev: __u64,
    pub err: bch_ioctl_err_msg,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_ioctl_disk_v2"][::std::mem::size_of::<bch_ioctl_disk_v2>() - 32usize];
    [
        "Alignment of bch_ioctl_disk_v2",
    ][::std::mem::align_of::<bch_ioctl_disk_v2>() - 8usize];
    [
        "Offset of field: bch_ioctl_disk_v2::flags",
    ][::std::mem::offset_of!(bch_ioctl_disk_v2, flags) - 0usize];
    [
        "Offset of field: bch_ioctl_disk_v2::pad",
    ][::std::mem::offset_of!(bch_ioctl_disk_v2, pad) - 4usize];
    [
        "Offset of field: bch_ioctl_disk_v2::dev",
    ][::std::mem::offset_of!(bch_ioctl_disk_v2, dev) - 8usize];
    [
        "Offset of field: bch_ioctl_disk_v2::err",
    ][::std::mem::offset_of!(bch_ioctl_disk_v2, err) - 16usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_ioctl_disk_set_state {
    pub flags: __u32,
    pub new_state: __u8,
    pub pad: [__u8; 3usize],
    pub dev: __u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_ioctl_disk_set_state",
    ][::std::mem::size_of::<bch_ioctl_disk_set_state>() - 16usize];
    [
        "Alignment of bch_ioctl_disk_set_state",
    ][::std::mem::align_of::<bch_ioctl_disk_set_state>() - 8usize];
    [
        "Offset of field: bch_ioctl_disk_set_state::flags",
    ][::std::mem::offset_of!(bch_ioctl_disk_set_state, flags) - 0usize];
    [
        "Offset of field: bch_ioctl_disk_set_state::new_state",
    ][::std::mem::offset_of!(bch_ioctl_disk_set_state, new_state) - 4usize];
    [
        "Offset of field: bch_ioctl_disk_set_state::pad",
    ][::std::mem::offset_of!(bch_ioctl_disk_set_state, pad) - 5usize];
    [
        "Offset of field: bch_ioctl_disk_set_state::dev",
    ][::std::mem::offset_of!(bch_ioctl_disk_set_state, dev) - 8usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_ioctl_disk_set_state_v2 {
    pub flags: __u32,
    pub new_state: __u8,
    pub pad: [__u8; 3usize],
    pub dev: __u64,
    pub err: bch_ioctl_err_msg,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_ioctl_disk_set_state_v2",
    ][::std::mem::size_of::<bch_ioctl_disk_set_state_v2>() - 32usize];
    [
        "Alignment of bch_ioctl_disk_set_state_v2",
    ][::std::mem::align_of::<bch_ioctl_disk_set_state_v2>() - 8usize];
    [
        "Offset of field: bch_ioctl_disk_set_state_v2::flags",
    ][::std::mem::offset_of!(bch_ioctl_disk_set_state_v2, flags) - 0usize];
    [
        "Offset of field: bch_ioctl_disk_set_state_v2::new_state",
    ][::std::mem::offset_of!(bch_ioctl_disk_set_state_v2, new_state) - 4usize];
    [
        "Offset of field: bch_ioctl_disk_set_state_v2::pad",
    ][::std::mem::offset_of!(bch_ioctl_disk_set_state_v2, pad) - 5usize];
    [
        "Offset of field: bch_ioctl_disk_set_state_v2::dev",
    ][::std::mem::offset_of!(bch_ioctl_disk_set_state_v2, dev) - 8usize];
    [
        "Offset of field: bch_ioctl_disk_set_state_v2::err",
    ][::std::mem::offset_of!(bch_ioctl_disk_set_state_v2, err) - 16usize];
};
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_data_ops {
    BCH_DATA_OP_scrub = 0,
    BCH_DATA_OP_rereplicate = 1,
    BCH_DATA_OP_migrate = 2,
    BCH_DATA_OP_rewrite_old_nodes = 3,
    BCH_DATA_OP_drop_extra_replicas = 4,
    BCH_DATA_OP_NR = 5,
}
#[repr(C, packed(8))]
#[derive(Copy, Clone)]
pub struct bch_ioctl_data {
    pub op: __u16,
    pub start_btree: __u8,
    pub end_btree: __u8,
    pub flags: __u32,
    pub start_pos: bpos,
    pub end_pos: bpos,
    pub __bindgen_anon_1: bch_ioctl_data__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bch_ioctl_data__bindgen_ty_1 {
    pub scrub: bch_ioctl_data__bindgen_ty_1__bindgen_ty_1,
    pub migrate: bch_ioctl_data__bindgen_ty_1__bindgen_ty_2,
    pub __bindgen_anon_1: bch_ioctl_data__bindgen_ty_1__bindgen_ty_3,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_ioctl_data__bindgen_ty_1__bindgen_ty_1 {
    pub dev: __u32,
    pub data_types: __u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_ioctl_data__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bch_ioctl_data__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Alignment of bch_ioctl_data__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bch_ioctl_data__bindgen_ty_1__bindgen_ty_1>() - 4usize];
    [
        "Offset of field: bch_ioctl_data__bindgen_ty_1__bindgen_ty_1::dev",
    ][::std::mem::offset_of!(bch_ioctl_data__bindgen_ty_1__bindgen_ty_1, dev) - 0usize];
    [
        "Offset of field: bch_ioctl_data__bindgen_ty_1__bindgen_ty_1::data_types",
    ][::std::mem::offset_of!(bch_ioctl_data__bindgen_ty_1__bindgen_ty_1, data_types)
        - 4usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_ioctl_data__bindgen_ty_1__bindgen_ty_2 {
    pub dev: __u32,
    pub pad: __u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_ioctl_data__bindgen_ty_1__bindgen_ty_2",
    ][::std::mem::size_of::<bch_ioctl_data__bindgen_ty_1__bindgen_ty_2>() - 8usize];
    [
        "Alignment of bch_ioctl_data__bindgen_ty_1__bindgen_ty_2",
    ][::std::mem::align_of::<bch_ioctl_data__bindgen_ty_1__bindgen_ty_2>() - 4usize];
    [
        "Offset of field: bch_ioctl_data__bindgen_ty_1__bindgen_ty_2::dev",
    ][::std::mem::offset_of!(bch_ioctl_data__bindgen_ty_1__bindgen_ty_2, dev) - 0usize];
    [
        "Offset of field: bch_ioctl_data__bindgen_ty_1__bindgen_ty_2::pad",
    ][::std::mem::offset_of!(bch_ioctl_data__bindgen_ty_1__bindgen_ty_2, pad) - 4usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_ioctl_data__bindgen_ty_1__bindgen_ty_3 {
    pub pad: [__u64; 8usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_ioctl_data__bindgen_ty_1__bindgen_ty_3",
    ][::std::mem::size_of::<bch_ioctl_data__bindgen_ty_1__bindgen_ty_3>() - 64usize];
    [
        "Alignment of bch_ioctl_data__bindgen_ty_1__bindgen_ty_3",
    ][::std::mem::align_of::<bch_ioctl_data__bindgen_ty_1__bindgen_ty_3>() - 8usize];
    [
        "Offset of field: bch_ioctl_data__bindgen_ty_1__bindgen_ty_3::pad",
    ][::std::mem::offset_of!(bch_ioctl_data__bindgen_ty_1__bindgen_ty_3, pad) - 0usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_ioctl_data__bindgen_ty_1",
    ][::std::mem::size_of::<bch_ioctl_data__bindgen_ty_1>() - 64usize];
    [
        "Alignment of bch_ioctl_data__bindgen_ty_1",
    ][::std::mem::align_of::<bch_ioctl_data__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bch_ioctl_data__bindgen_ty_1::scrub",
    ][::std::mem::offset_of!(bch_ioctl_data__bindgen_ty_1, scrub) - 0usize];
    [
        "Offset of field: bch_ioctl_data__bindgen_ty_1::migrate",
    ][::std::mem::offset_of!(bch_ioctl_data__bindgen_ty_1, migrate) - 0usize];
};
impl Default for bch_ioctl_data__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_ioctl_data"][::std::mem::size_of::<bch_ioctl_data>() - 112usize];
    ["Alignment of bch_ioctl_data"][::std::mem::align_of::<bch_ioctl_data>() - 8usize];
    [
        "Offset of field: bch_ioctl_data::op",
    ][::std::mem::offset_of!(bch_ioctl_data, op) - 0usize];
    [
        "Offset of field: bch_ioctl_data::start_btree",
    ][::std::mem::offset_of!(bch_ioctl_data, start_btree) - 2usize];
    [
        "Offset of field: bch_ioctl_data::end_btree",
    ][::std::mem::offset_of!(bch_ioctl_data, end_btree) - 3usize];
    [
        "Offset of field: bch_ioctl_data::flags",
    ][::std::mem::offset_of!(bch_ioctl_data, flags) - 4usize];
    [
        "Offset of field: bch_ioctl_data::start_pos",
    ][::std::mem::offset_of!(bch_ioctl_data, start_pos) - 8usize];
    [
        "Offset of field: bch_ioctl_data::end_pos",
    ][::std::mem::offset_of!(bch_ioctl_data, end_pos) - 28usize];
};
impl Default for bch_ioctl_data {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_data_event {
    BCH_DATA_EVENT_PROGRESS = 0,
    BCH_DATA_EVENT_NR = 1,
}
#[repr(C, packed(8))]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_ioctl_data_progress {
    pub data_type: __u8,
    pub btree_id: __u8,
    pub pad: [__u8; 2usize],
    pub pos: bpos,
    pub sectors_done: __u64,
    pub sectors_total: __u64,
    pub sectors_error_corrected: __u64,
    pub sectors_error_uncorrected: __u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_ioctl_data_progress",
    ][::std::mem::size_of::<bch_ioctl_data_progress>() - 56usize];
    [
        "Alignment of bch_ioctl_data_progress",
    ][::std::mem::align_of::<bch_ioctl_data_progress>() - 8usize];
    [
        "Offset of field: bch_ioctl_data_progress::data_type",
    ][::std::mem::offset_of!(bch_ioctl_data_progress, data_type) - 0usize];
    [
        "Offset of field: bch_ioctl_data_progress::btree_id",
    ][::std::mem::offset_of!(bch_ioctl_data_progress, btree_id) - 1usize];
    [
        "Offset of field: bch_ioctl_data_progress::pad",
    ][::std::mem::offset_of!(bch_ioctl_data_progress, pad) - 2usize];
    [
        "Offset of field: bch_ioctl_data_progress::pos",
    ][::std::mem::offset_of!(bch_ioctl_data_progress, pos) - 4usize];
    [
        "Offset of field: bch_ioctl_data_progress::sectors_done",
    ][::std::mem::offset_of!(bch_ioctl_data_progress, sectors_done) - 24usize];
    [
        "Offset of field: bch_ioctl_data_progress::sectors_total",
    ][::std::mem::offset_of!(bch_ioctl_data_progress, sectors_total) - 32usize];
    [
        "Offset of field: bch_ioctl_data_progress::sectors_error_corrected",
    ][::std::mem::offset_of!(bch_ioctl_data_progress, sectors_error_corrected)
        - 40usize];
    [
        "Offset of field: bch_ioctl_data_progress::sectors_error_uncorrected",
    ][::std::mem::offset_of!(bch_ioctl_data_progress, sectors_error_uncorrected)
        - 48usize];
};
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_ioctl_data_event_ret {
    BCH_IOCTL_DATA_EVENT_RET_done = 1,
    BCH_IOCTL_DATA_EVENT_RET_device_offline = 2,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bch_ioctl_data_event__bindgen_ty_1 {
    pub p: bch_ioctl_data_progress,
    pub pad2: [__u64; 15usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_ioctl_data_event__bindgen_ty_1",
    ][::std::mem::size_of::<bch_ioctl_data_event__bindgen_ty_1>() - 120usize];
    [
        "Alignment of bch_ioctl_data_event__bindgen_ty_1",
    ][::std::mem::align_of::<bch_ioctl_data_event__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bch_ioctl_data_event__bindgen_ty_1::p",
    ][::std::mem::offset_of!(bch_ioctl_data_event__bindgen_ty_1, p) - 0usize];
    [
        "Offset of field: bch_ioctl_data_event__bindgen_ty_1::pad2",
    ][::std::mem::offset_of!(bch_ioctl_data_event__bindgen_ty_1, pad2) - 0usize];
};
impl Default for bch_ioctl_data_event__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C, packed)]
pub struct bch_replicas_usage {
    pub sectors: __u64,
    pub r: bch_replicas_entry_v1,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_replicas_usage",
    ][::std::mem::size_of::<bch_replicas_usage>() - 11usize];
    [
        "Alignment of bch_replicas_usage",
    ][::std::mem::align_of::<bch_replicas_usage>() - 1usize];
    [
        "Offset of field: bch_replicas_usage::sectors",
    ][::std::mem::offset_of!(bch_replicas_usage, sectors) - 0usize];
    [
        "Offset of field: bch_replicas_usage::r",
    ][::std::mem::offset_of!(bch_replicas_usage, r) - 8usize];
};
impl Default for bch_replicas_usage {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct bch_ioctl_fs_usage {
    pub capacity: __u64,
    pub used: __u64,
    pub online_reserved: __u64,
    pub persistent_reserved: [__u64; 4usize],
    pub replica_entries_bytes: __u32,
    pub pad: __u32,
    pub replicas: __IncompleteArrayField<bch_replicas_usage>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_ioctl_fs_usage",
    ][::std::mem::size_of::<bch_ioctl_fs_usage>() - 64usize];
    [
        "Alignment of bch_ioctl_fs_usage",
    ][::std::mem::align_of::<bch_ioctl_fs_usage>() - 8usize];
    [
        "Offset of field: bch_ioctl_fs_usage::capacity",
    ][::std::mem::offset_of!(bch_ioctl_fs_usage, capacity) - 0usize];
    [
        "Offset of field: bch_ioctl_fs_usage::used",
    ][::std::mem::offset_of!(bch_ioctl_fs_usage, used) - 8usize];
    [
        "Offset of field: bch_ioctl_fs_usage::online_reserved",
    ][::std::mem::offset_of!(bch_ioctl_fs_usage, online_reserved) - 16usize];
    [
        "Offset of field: bch_ioctl_fs_usage::persistent_reserved",
    ][::std::mem::offset_of!(bch_ioctl_fs_usage, persistent_reserved) - 24usize];
    [
        "Offset of field: bch_ioctl_fs_usage::replica_entries_bytes",
    ][::std::mem::offset_of!(bch_ioctl_fs_usage, replica_entries_bytes) - 56usize];
    [
        "Offset of field: bch_ioctl_fs_usage::pad",
    ][::std::mem::offset_of!(bch_ioctl_fs_usage, pad) - 60usize];
    [
        "Offset of field: bch_ioctl_fs_usage::replicas",
    ][::std::mem::offset_of!(bch_ioctl_fs_usage, replicas) - 64usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_ioctl_dev_usage {
    pub dev: __u64,
    pub flags: __u32,
    pub state: __u8,
    pub pad: [__u8; 7usize],
    pub bucket_size: __u32,
    pub nr_buckets: __u64,
    pub buckets_ec: __u64,
    pub d: [bch_ioctl_dev_usage_bch_ioctl_dev_usage_type; 10usize],
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_ioctl_dev_usage_bch_ioctl_dev_usage_type {
    pub buckets: __u64,
    pub sectors: __u64,
    pub fragmented: __u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_ioctl_dev_usage_bch_ioctl_dev_usage_type",
    ][::std::mem::size_of::<bch_ioctl_dev_usage_bch_ioctl_dev_usage_type>() - 24usize];
    [
        "Alignment of bch_ioctl_dev_usage_bch_ioctl_dev_usage_type",
    ][::std::mem::align_of::<bch_ioctl_dev_usage_bch_ioctl_dev_usage_type>() - 8usize];
    [
        "Offset of field: bch_ioctl_dev_usage_bch_ioctl_dev_usage_type::buckets",
    ][::std::mem::offset_of!(bch_ioctl_dev_usage_bch_ioctl_dev_usage_type, buckets)
        - 0usize];
    [
        "Offset of field: bch_ioctl_dev_usage_bch_ioctl_dev_usage_type::sectors",
    ][::std::mem::offset_of!(bch_ioctl_dev_usage_bch_ioctl_dev_usage_type, sectors)
        - 8usize];
    [
        "Offset of field: bch_ioctl_dev_usage_bch_ioctl_dev_usage_type::fragmented",
    ][::std::mem::offset_of!(bch_ioctl_dev_usage_bch_ioctl_dev_usage_type, fragmented)
        - 16usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_ioctl_dev_usage",
    ][::std::mem::size_of::<bch_ioctl_dev_usage>() - 280usize];
    [
        "Alignment of bch_ioctl_dev_usage",
    ][::std::mem::align_of::<bch_ioctl_dev_usage>() - 8usize];
    [
        "Offset of field: bch_ioctl_dev_usage::dev",
    ][::std::mem::offset_of!(bch_ioctl_dev_usage, dev) - 0usize];
    [
        "Offset of field: bch_ioctl_dev_usage::flags",
    ][::std::mem::offset_of!(bch_ioctl_dev_usage, flags) - 8usize];
    [
        "Offset of field: bch_ioctl_dev_usage::state",
    ][::std::mem::offset_of!(bch_ioctl_dev_usage, state) - 12usize];
    [
        "Offset of field: bch_ioctl_dev_usage::pad",
    ][::std::mem::offset_of!(bch_ioctl_dev_usage, pad) - 13usize];
    [
        "Offset of field: bch_ioctl_dev_usage::bucket_size",
    ][::std::mem::offset_of!(bch_ioctl_dev_usage, bucket_size) - 20usize];
    [
        "Offset of field: bch_ioctl_dev_usage::nr_buckets",
    ][::std::mem::offset_of!(bch_ioctl_dev_usage, nr_buckets) - 24usize];
    [
        "Offset of field: bch_ioctl_dev_usage::buckets_ec",
    ][::std::mem::offset_of!(bch_ioctl_dev_usage, buckets_ec) - 32usize];
    [
        "Offset of field: bch_ioctl_dev_usage::d",
    ][::std::mem::offset_of!(bch_ioctl_dev_usage, d) - 40usize];
};
#[repr(C)]
#[derive(Debug, Default)]
pub struct bch_ioctl_dev_usage_v2 {
    pub dev: __u64,
    pub flags: __u32,
    pub state: __u8,
    pub nr_data_types: __u8,
    pub pad: [__u8; 6usize],
    pub bucket_size: __u32,
    pub nr_buckets: __u64,
    pub d: __IncompleteArrayField<bch_ioctl_dev_usage_bch_ioctl_dev_usage_type>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_ioctl_dev_usage_v2",
    ][::std::mem::size_of::<bch_ioctl_dev_usage_v2>() - 32usize];
    [
        "Alignment of bch_ioctl_dev_usage_v2",
    ][::std::mem::align_of::<bch_ioctl_dev_usage_v2>() - 8usize];
    [
        "Offset of field: bch_ioctl_dev_usage_v2::dev",
    ][::std::mem::offset_of!(bch_ioctl_dev_usage_v2, dev) - 0usize];
    [
        "Offset of field: bch_ioctl_dev_usage_v2::flags",
    ][::std::mem::offset_of!(bch_ioctl_dev_usage_v2, flags) - 8usize];
    [
        "Offset of field: bch_ioctl_dev_usage_v2::state",
    ][::std::mem::offset_of!(bch_ioctl_dev_usage_v2, state) - 12usize];
    [
        "Offset of field: bch_ioctl_dev_usage_v2::nr_data_types",
    ][::std::mem::offset_of!(bch_ioctl_dev_usage_v2, nr_data_types) - 13usize];
    [
        "Offset of field: bch_ioctl_dev_usage_v2::pad",
    ][::std::mem::offset_of!(bch_ioctl_dev_usage_v2, pad) - 14usize];
    [
        "Offset of field: bch_ioctl_dev_usage_v2::bucket_size",
    ][::std::mem::offset_of!(bch_ioctl_dev_usage_v2, bucket_size) - 20usize];
    [
        "Offset of field: bch_ioctl_dev_usage_v2::nr_buckets",
    ][::std::mem::offset_of!(bch_ioctl_dev_usage_v2, nr_buckets) - 24usize];
    [
        "Offset of field: bch_ioctl_dev_usage_v2::d",
    ][::std::mem::offset_of!(bch_ioctl_dev_usage_v2, d) - 32usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_ioctl_read_super {
    pub flags: __u32,
    pub pad: __u32,
    pub dev: __u64,
    pub size: __u64,
    pub sb: __u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_ioctl_read_super",
    ][::std::mem::size_of::<bch_ioctl_read_super>() - 32usize];
    [
        "Alignment of bch_ioctl_read_super",
    ][::std::mem::align_of::<bch_ioctl_read_super>() - 8usize];
    [
        "Offset of field: bch_ioctl_read_super::flags",
    ][::std::mem::offset_of!(bch_ioctl_read_super, flags) - 0usize];
    [
        "Offset of field: bch_ioctl_read_super::pad",
    ][::std::mem::offset_of!(bch_ioctl_read_super, pad) - 4usize];
    [
        "Offset of field: bch_ioctl_read_super::dev",
    ][::std::mem::offset_of!(bch_ioctl_read_super, dev) - 8usize];
    [
        "Offset of field: bch_ioctl_read_super::size",
    ][::std::mem::offset_of!(bch_ioctl_read_super, size) - 16usize];
    [
        "Offset of field: bch_ioctl_read_super::sb",
    ][::std::mem::offset_of!(bch_ioctl_read_super, sb) - 24usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_ioctl_disk_get_idx {
    pub dev: __u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_ioctl_disk_get_idx",
    ][::std::mem::size_of::<bch_ioctl_disk_get_idx>() - 8usize];
    [
        "Alignment of bch_ioctl_disk_get_idx",
    ][::std::mem::align_of::<bch_ioctl_disk_get_idx>() - 8usize];
    [
        "Offset of field: bch_ioctl_disk_get_idx::dev",
    ][::std::mem::offset_of!(bch_ioctl_disk_get_idx, dev) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_ioctl_disk_resize {
    pub flags: __u32,
    pub pad: __u32,
    pub dev: __u64,
    pub nbuckets: __u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_ioctl_disk_resize",
    ][::std::mem::size_of::<bch_ioctl_disk_resize>() - 24usize];
    [
        "Alignment of bch_ioctl_disk_resize",
    ][::std::mem::align_of::<bch_ioctl_disk_resize>() - 8usize];
    [
        "Offset of field: bch_ioctl_disk_resize::flags",
    ][::std::mem::offset_of!(bch_ioctl_disk_resize, flags) - 0usize];
    [
        "Offset of field: bch_ioctl_disk_resize::pad",
    ][::std::mem::offset_of!(bch_ioctl_disk_resize, pad) - 4usize];
    [
        "Offset of field: bch_ioctl_disk_resize::dev",
    ][::std::mem::offset_of!(bch_ioctl_disk_resize, dev) - 8usize];
    [
        "Offset of field: bch_ioctl_disk_resize::nbuckets",
    ][::std::mem::offset_of!(bch_ioctl_disk_resize, nbuckets) - 16usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_ioctl_disk_resize_v2 {
    pub flags: __u32,
    pub pad: __u32,
    pub dev: __u64,
    pub nbuckets: __u64,
    pub err: bch_ioctl_err_msg,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_ioctl_disk_resize_v2",
    ][::std::mem::size_of::<bch_ioctl_disk_resize_v2>() - 40usize];
    [
        "Alignment of bch_ioctl_disk_resize_v2",
    ][::std::mem::align_of::<bch_ioctl_disk_resize_v2>() - 8usize];
    [
        "Offset of field: bch_ioctl_disk_resize_v2::flags",
    ][::std::mem::offset_of!(bch_ioctl_disk_resize_v2, flags) - 0usize];
    [
        "Offset of field: bch_ioctl_disk_resize_v2::pad",
    ][::std::mem::offset_of!(bch_ioctl_disk_resize_v2, pad) - 4usize];
    [
        "Offset of field: bch_ioctl_disk_resize_v2::dev",
    ][::std::mem::offset_of!(bch_ioctl_disk_resize_v2, dev) - 8usize];
    [
        "Offset of field: bch_ioctl_disk_resize_v2::nbuckets",
    ][::std::mem::offset_of!(bch_ioctl_disk_resize_v2, nbuckets) - 16usize];
    [
        "Offset of field: bch_ioctl_disk_resize_v2::err",
    ][::std::mem::offset_of!(bch_ioctl_disk_resize_v2, err) - 24usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_ioctl_disk_resize_journal {
    pub flags: __u32,
    pub pad: __u32,
    pub dev: __u64,
    pub nbuckets: __u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_ioctl_disk_resize_journal",
    ][::std::mem::size_of::<bch_ioctl_disk_resize_journal>() - 24usize];
    [
        "Alignment of bch_ioctl_disk_resize_journal",
    ][::std::mem::align_of::<bch_ioctl_disk_resize_journal>() - 8usize];
    [
        "Offset of field: bch_ioctl_disk_resize_journal::flags",
    ][::std::mem::offset_of!(bch_ioctl_disk_resize_journal, flags) - 0usize];
    [
        "Offset of field: bch_ioctl_disk_resize_journal::pad",
    ][::std::mem::offset_of!(bch_ioctl_disk_resize_journal, pad) - 4usize];
    [
        "Offset of field: bch_ioctl_disk_resize_journal::dev",
    ][::std::mem::offset_of!(bch_ioctl_disk_resize_journal, dev) - 8usize];
    [
        "Offset of field: bch_ioctl_disk_resize_journal::nbuckets",
    ][::std::mem::offset_of!(bch_ioctl_disk_resize_journal, nbuckets) - 16usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_ioctl_disk_resize_journal_v2 {
    pub flags: __u32,
    pub pad: __u32,
    pub dev: __u64,
    pub nbuckets: __u64,
    pub err: bch_ioctl_err_msg,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_ioctl_disk_resize_journal_v2",
    ][::std::mem::size_of::<bch_ioctl_disk_resize_journal_v2>() - 40usize];
    [
        "Alignment of bch_ioctl_disk_resize_journal_v2",
    ][::std::mem::align_of::<bch_ioctl_disk_resize_journal_v2>() - 8usize];
    [
        "Offset of field: bch_ioctl_disk_resize_journal_v2::flags",
    ][::std::mem::offset_of!(bch_ioctl_disk_resize_journal_v2, flags) - 0usize];
    [
        "Offset of field: bch_ioctl_disk_resize_journal_v2::pad",
    ][::std::mem::offset_of!(bch_ioctl_disk_resize_journal_v2, pad) - 4usize];
    [
        "Offset of field: bch_ioctl_disk_resize_journal_v2::dev",
    ][::std::mem::offset_of!(bch_ioctl_disk_resize_journal_v2, dev) - 8usize];
    [
        "Offset of field: bch_ioctl_disk_resize_journal_v2::nbuckets",
    ][::std::mem::offset_of!(bch_ioctl_disk_resize_journal_v2, nbuckets) - 16usize];
    [
        "Offset of field: bch_ioctl_disk_resize_journal_v2::err",
    ][::std::mem::offset_of!(bch_ioctl_disk_resize_journal_v2, err) - 24usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_ioctl_subvolume {
    pub flags: __u32,
    pub dirfd: __u32,
    pub mode: __u16,
    pub pad: [__u16; 3usize],
    pub dst_ptr: __u64,
    pub src_ptr: __u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_ioctl_subvolume",
    ][::std::mem::size_of::<bch_ioctl_subvolume>() - 32usize];
    [
        "Alignment of bch_ioctl_subvolume",
    ][::std::mem::align_of::<bch_ioctl_subvolume>() - 8usize];
    [
        "Offset of field: bch_ioctl_subvolume::flags",
    ][::std::mem::offset_of!(bch_ioctl_subvolume, flags) - 0usize];
    [
        "Offset of field: bch_ioctl_subvolume::dirfd",
    ][::std::mem::offset_of!(bch_ioctl_subvolume, dirfd) - 4usize];
    [
        "Offset of field: bch_ioctl_subvolume::mode",
    ][::std::mem::offset_of!(bch_ioctl_subvolume, mode) - 8usize];
    [
        "Offset of field: bch_ioctl_subvolume::pad",
    ][::std::mem::offset_of!(bch_ioctl_subvolume, pad) - 10usize];
    [
        "Offset of field: bch_ioctl_subvolume::dst_ptr",
    ][::std::mem::offset_of!(bch_ioctl_subvolume, dst_ptr) - 16usize];
    [
        "Offset of field: bch_ioctl_subvolume::src_ptr",
    ][::std::mem::offset_of!(bch_ioctl_subvolume, src_ptr) - 24usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_ioctl_subvolume_v2 {
    pub flags: __u32,
    pub dirfd: __u32,
    pub mode: __u16,
    pub pad: [__u16; 3usize],
    pub dst_ptr: __u64,
    pub src_ptr: __u64,
    pub err: bch_ioctl_err_msg,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_ioctl_subvolume_v2",
    ][::std::mem::size_of::<bch_ioctl_subvolume_v2>() - 48usize];
    [
        "Alignment of bch_ioctl_subvolume_v2",
    ][::std::mem::align_of::<bch_ioctl_subvolume_v2>() - 8usize];
    [
        "Offset of field: bch_ioctl_subvolume_v2::flags",
    ][::std::mem::offset_of!(bch_ioctl_subvolume_v2, flags) - 0usize];
    [
        "Offset of field: bch_ioctl_subvolume_v2::dirfd",
    ][::std::mem::offset_of!(bch_ioctl_subvolume_v2, dirfd) - 4usize];
    [
        "Offset of field: bch_ioctl_subvolume_v2::mode",
    ][::std::mem::offset_of!(bch_ioctl_subvolume_v2, mode) - 8usize];
    [
        "Offset of field: bch_ioctl_subvolume_v2::pad",
    ][::std::mem::offset_of!(bch_ioctl_subvolume_v2, pad) - 10usize];
    [
        "Offset of field: bch_ioctl_subvolume_v2::dst_ptr",
    ][::std::mem::offset_of!(bch_ioctl_subvolume_v2, dst_ptr) - 16usize];
    [
        "Offset of field: bch_ioctl_subvolume_v2::src_ptr",
    ][::std::mem::offset_of!(bch_ioctl_subvolume_v2, src_ptr) - 24usize];
    [
        "Offset of field: bch_ioctl_subvolume_v2::err",
    ][::std::mem::offset_of!(bch_ioctl_subvolume_v2, err) - 32usize];
};
#[repr(C)]
#[derive(Debug, Default)]
pub struct bch_ioctl_fsck_offline {
    pub flags: __u64,
    pub opts: __u64,
    pub nr_devs: __u64,
    pub devs: __IncompleteArrayField<__u64>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_ioctl_fsck_offline",
    ][::std::mem::size_of::<bch_ioctl_fsck_offline>() - 24usize];
    [
        "Alignment of bch_ioctl_fsck_offline",
    ][::std::mem::align_of::<bch_ioctl_fsck_offline>() - 8usize];
    [
        "Offset of field: bch_ioctl_fsck_offline::flags",
    ][::std::mem::offset_of!(bch_ioctl_fsck_offline, flags) - 0usize];
    [
        "Offset of field: bch_ioctl_fsck_offline::opts",
    ][::std::mem::offset_of!(bch_ioctl_fsck_offline, opts) - 8usize];
    [
        "Offset of field: bch_ioctl_fsck_offline::nr_devs",
    ][::std::mem::offset_of!(bch_ioctl_fsck_offline, nr_devs) - 16usize];
    [
        "Offset of field: bch_ioctl_fsck_offline::devs",
    ][::std::mem::offset_of!(bch_ioctl_fsck_offline, devs) - 24usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_ioctl_fsck_online {
    pub flags: __u64,
    pub opts: __u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_ioctl_fsck_online",
    ][::std::mem::size_of::<bch_ioctl_fsck_online>() - 16usize];
    [
        "Alignment of bch_ioctl_fsck_online",
    ][::std::mem::align_of::<bch_ioctl_fsck_online>() - 8usize];
    [
        "Offset of field: bch_ioctl_fsck_online::flags",
    ][::std::mem::offset_of!(bch_ioctl_fsck_online, flags) - 0usize];
    [
        "Offset of field: bch_ioctl_fsck_online::opts",
    ][::std::mem::offset_of!(bch_ioctl_fsck_online, opts) - 8usize];
};
#[repr(C)]
pub struct bch_ioctl_query_accounting {
    pub capacity: __u64,
    pub used: __u64,
    pub online_reserved: __u64,
    pub accounting_u64s: __u32,
    pub accounting_types_mask: __u32,
    pub accounting: __IncompleteArrayField<bkey_i_accounting>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_ioctl_query_accounting",
    ][::std::mem::size_of::<bch_ioctl_query_accounting>() - 32usize];
    [
        "Alignment of bch_ioctl_query_accounting",
    ][::std::mem::align_of::<bch_ioctl_query_accounting>() - 8usize];
    [
        "Offset of field: bch_ioctl_query_accounting::capacity",
    ][::std::mem::offset_of!(bch_ioctl_query_accounting, capacity) - 0usize];
    [
        "Offset of field: bch_ioctl_query_accounting::used",
    ][::std::mem::offset_of!(bch_ioctl_query_accounting, used) - 8usize];
    [
        "Offset of field: bch_ioctl_query_accounting::online_reserved",
    ][::std::mem::offset_of!(bch_ioctl_query_accounting, online_reserved) - 16usize];
    [
        "Offset of field: bch_ioctl_query_accounting::accounting_u64s",
    ][::std::mem::offset_of!(bch_ioctl_query_accounting, accounting_u64s) - 24usize];
    [
        "Offset of field: bch_ioctl_query_accounting::accounting_types_mask",
    ][::std::mem::offset_of!(bch_ioctl_query_accounting, accounting_types_mask)
        - 28usize];
    [
        "Offset of field: bch_ioctl_query_accounting::accounting",
    ][::std::mem::offset_of!(bch_ioctl_query_accounting, accounting) - 32usize];
};
impl Default for bch_ioctl_query_accounting {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct bch_ioctl_query_counters {
    pub nr: __u16,
    pub flags: __u16,
    pub pad: __u32,
    pub d: __IncompleteArrayField<__u64>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_ioctl_query_counters",
    ][::std::mem::size_of::<bch_ioctl_query_counters>() - 8usize];
    [
        "Alignment of bch_ioctl_query_counters",
    ][::std::mem::align_of::<bch_ioctl_query_counters>() - 8usize];
    [
        "Offset of field: bch_ioctl_query_counters::nr",
    ][::std::mem::offset_of!(bch_ioctl_query_counters, nr) - 0usize];
    [
        "Offset of field: bch_ioctl_query_counters::flags",
    ][::std::mem::offset_of!(bch_ioctl_query_counters, flags) - 2usize];
    [
        "Offset of field: bch_ioctl_query_counters::pad",
    ][::std::mem::offset_of!(bch_ioctl_query_counters, pad) - 4usize];
    [
        "Offset of field: bch_ioctl_query_counters::d",
    ][::std::mem::offset_of!(bch_ioctl_query_counters, d) - 8usize];
};
#[repr(C)]
#[derive(Debug, Default)]
pub struct bch_ioctl_subvol_dirent {
    pub reclen: __u32,
    pub subvolid: __u32,
    pub flags: __u32,
    pub snapshot_parent: __u32,
    pub otime_sec: __u64,
    pub otime_nsec: __u32,
    pub pad: __u32,
    pub path: __IncompleteArrayField<::std::os::raw::c_char>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_ioctl_subvol_dirent",
    ][::std::mem::size_of::<bch_ioctl_subvol_dirent>() - 32usize];
    [
        "Alignment of bch_ioctl_subvol_dirent",
    ][::std::mem::align_of::<bch_ioctl_subvol_dirent>() - 8usize];
    [
        "Offset of field: bch_ioctl_subvol_dirent::reclen",
    ][::std::mem::offset_of!(bch_ioctl_subvol_dirent, reclen) - 0usize];
    [
        "Offset of field: bch_ioctl_subvol_dirent::subvolid",
    ][::std::mem::offset_of!(bch_ioctl_subvol_dirent, subvolid) - 4usize];
    [
        "Offset of field: bch_ioctl_subvol_dirent::flags",
    ][::std::mem::offset_of!(bch_ioctl_subvol_dirent, flags) - 8usize];
    [
        "Offset of field: bch_ioctl_subvol_dirent::snapshot_parent",
    ][::std::mem::offset_of!(bch_ioctl_subvol_dirent, snapshot_parent) - 12usize];
    [
        "Offset of field: bch_ioctl_subvol_dirent::otime_sec",
    ][::std::mem::offset_of!(bch_ioctl_subvol_dirent, otime_sec) - 16usize];
    [
        "Offset of field: bch_ioctl_subvol_dirent::otime_nsec",
    ][::std::mem::offset_of!(bch_ioctl_subvol_dirent, otime_nsec) - 24usize];
    [
        "Offset of field: bch_ioctl_subvol_dirent::pad",
    ][::std::mem::offset_of!(bch_ioctl_subvol_dirent, pad) - 28usize];
    [
        "Offset of field: bch_ioctl_subvol_dirent::path",
    ][::std::mem::offset_of!(bch_ioctl_subvol_dirent, path) - 32usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_ioctl_subvol_readdir {
    pub pos: __u32,
    pub buf_size: __u32,
    pub buf: __u64,
    pub used: __u32,
    pub pad: __u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_ioctl_subvol_readdir",
    ][::std::mem::size_of::<bch_ioctl_subvol_readdir>() - 24usize];
    [
        "Alignment of bch_ioctl_subvol_readdir",
    ][::std::mem::align_of::<bch_ioctl_subvol_readdir>() - 8usize];
    [
        "Offset of field: bch_ioctl_subvol_readdir::pos",
    ][::std::mem::offset_of!(bch_ioctl_subvol_readdir, pos) - 0usize];
    [
        "Offset of field: bch_ioctl_subvol_readdir::buf_size",
    ][::std::mem::offset_of!(bch_ioctl_subvol_readdir, buf_size) - 4usize];
    [
        "Offset of field: bch_ioctl_subvol_readdir::buf",
    ][::std::mem::offset_of!(bch_ioctl_subvol_readdir, buf) - 8usize];
    [
        "Offset of field: bch_ioctl_subvol_readdir::used",
    ][::std::mem::offset_of!(bch_ioctl_subvol_readdir, used) - 16usize];
    [
        "Offset of field: bch_ioctl_subvol_readdir::pad",
    ][::std::mem::offset_of!(bch_ioctl_subvol_readdir, pad) - 20usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_ioctl_subvol_to_path {
    pub subvolid: __u32,
    pub buf_size: __u32,
    pub buf: __u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_ioctl_subvol_to_path",
    ][::std::mem::size_of::<bch_ioctl_subvol_to_path>() - 16usize];
    [
        "Alignment of bch_ioctl_subvol_to_path",
    ][::std::mem::align_of::<bch_ioctl_subvol_to_path>() - 8usize];
    [
        "Offset of field: bch_ioctl_subvol_to_path::subvolid",
    ][::std::mem::offset_of!(bch_ioctl_subvol_to_path, subvolid) - 0usize];
    [
        "Offset of field: bch_ioctl_subvol_to_path::buf_size",
    ][::std::mem::offset_of!(bch_ioctl_subvol_to_path, buf_size) - 4usize];
    [
        "Offset of field: bch_ioctl_subvol_to_path::buf",
    ][::std::mem::offset_of!(bch_ioctl_subvol_to_path, buf) - 8usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_ioctl_snapshot_node {
    pub id: __u32,
    pub parent: __u32,
    pub children: [__u32; 2usize],
    pub subvol: __u32,
    pub flags: __u32,
    pub pad: [__u32; 2usize],
    pub sectors: __u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_ioctl_snapshot_node",
    ][::std::mem::size_of::<bch_ioctl_snapshot_node>() - 40usize];
    [
        "Alignment of bch_ioctl_snapshot_node",
    ][::std::mem::align_of::<bch_ioctl_snapshot_node>() - 8usize];
    [
        "Offset of field: bch_ioctl_snapshot_node::id",
    ][::std::mem::offset_of!(bch_ioctl_snapshot_node, id) - 0usize];
    [
        "Offset of field: bch_ioctl_snapshot_node::parent",
    ][::std::mem::offset_of!(bch_ioctl_snapshot_node, parent) - 4usize];
    [
        "Offset of field: bch_ioctl_snapshot_node::children",
    ][::std::mem::offset_of!(bch_ioctl_snapshot_node, children) - 8usize];
    [
        "Offset of field: bch_ioctl_snapshot_node::subvol",
    ][::std::mem::offset_of!(bch_ioctl_snapshot_node, subvol) - 16usize];
    [
        "Offset of field: bch_ioctl_snapshot_node::flags",
    ][::std::mem::offset_of!(bch_ioctl_snapshot_node, flags) - 20usize];
    [
        "Offset of field: bch_ioctl_snapshot_node::pad",
    ][::std::mem::offset_of!(bch_ioctl_snapshot_node, pad) - 24usize];
    [
        "Offset of field: bch_ioctl_snapshot_node::sectors",
    ][::std::mem::offset_of!(bch_ioctl_snapshot_node, sectors) - 32usize];
};
#[repr(C)]
#[derive(Debug, Default)]
pub struct bch_ioctl_snapshot_tree_query {
    pub tree_id: __u32,
    pub master_subvol: __u32,
    pub root_snapshot: __u32,
    pub nr: __u32,
    pub total: __u32,
    pub pad: __u32,
    pub nodes: __IncompleteArrayField<bch_ioctl_snapshot_node>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_ioctl_snapshot_tree_query",
    ][::std::mem::size_of::<bch_ioctl_snapshot_tree_query>() - 24usize];
    [
        "Alignment of bch_ioctl_snapshot_tree_query",
    ][::std::mem::align_of::<bch_ioctl_snapshot_tree_query>() - 8usize];
    [
        "Offset of field: bch_ioctl_snapshot_tree_query::tree_id",
    ][::std::mem::offset_of!(bch_ioctl_snapshot_tree_query, tree_id) - 0usize];
    [
        "Offset of field: bch_ioctl_snapshot_tree_query::master_subvol",
    ][::std::mem::offset_of!(bch_ioctl_snapshot_tree_query, master_subvol) - 4usize];
    [
        "Offset of field: bch_ioctl_snapshot_tree_query::root_snapshot",
    ][::std::mem::offset_of!(bch_ioctl_snapshot_tree_query, root_snapshot) - 8usize];
    [
        "Offset of field: bch_ioctl_snapshot_tree_query::nr",
    ][::std::mem::offset_of!(bch_ioctl_snapshot_tree_query, nr) - 12usize];
    [
        "Offset of field: bch_ioctl_snapshot_tree_query::total",
    ][::std::mem::offset_of!(bch_ioctl_snapshot_tree_query, total) - 16usize];
    [
        "Offset of field: bch_ioctl_snapshot_tree_query::pad",
    ][::std::mem::offset_of!(bch_ioctl_snapshot_tree_query, pad) - 20usize];
    [
        "Offset of field: bch_ioctl_snapshot_tree_query::nodes",
    ][::std::mem::offset_of!(bch_ioctl_snapshot_tree_query, nodes) - 24usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_ioctl_pread_raw {
    pub offset: __u64,
    pub len: __u64,
    pub buf: __u64,
    pub flags: __u32,
    pub errors: __u32,
    pub err: bch_ioctl_err_msg,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_ioctl_pread_raw",
    ][::std::mem::size_of::<bch_ioctl_pread_raw>() - 48usize];
    [
        "Alignment of bch_ioctl_pread_raw",
    ][::std::mem::align_of::<bch_ioctl_pread_raw>() - 8usize];
    [
        "Offset of field: bch_ioctl_pread_raw::offset",
    ][::std::mem::offset_of!(bch_ioctl_pread_raw, offset) - 0usize];
    [
        "Offset of field: bch_ioctl_pread_raw::len",
    ][::std::mem::offset_of!(bch_ioctl_pread_raw, len) - 8usize];
    [
        "Offset of field: bch_ioctl_pread_raw::buf",
    ][::std::mem::offset_of!(bch_ioctl_pread_raw, buf) - 16usize];
    [
        "Offset of field: bch_ioctl_pread_raw::flags",
    ][::std::mem::offset_of!(bch_ioctl_pread_raw, flags) - 24usize];
    [
        "Offset of field: bch_ioctl_pread_raw::errors",
    ][::std::mem::offset_of!(bch_ioctl_pread_raw, errors) - 28usize];
    [
        "Offset of field: bch_ioctl_pread_raw::err",
    ][::std::mem::offset_of!(bch_ioctl_pread_raw, err) - 32usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_ioctl_unpoison {
    pub offset: __u64,
    pub len: __u64,
    pub flags: __u32,
    pub pad: __u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_ioctl_unpoison",
    ][::std::mem::size_of::<bch_ioctl_unpoison>() - 24usize];
    [
        "Alignment of bch_ioctl_unpoison",
    ][::std::mem::align_of::<bch_ioctl_unpoison>() - 8usize];
    [
        "Offset of field: bch_ioctl_unpoison::offset",
    ][::std::mem::offset_of!(bch_ioctl_unpoison, offset) - 0usize];
    [
        "Offset of field: bch_ioctl_unpoison::len",
    ][::std::mem::offset_of!(bch_ioctl_unpoison, len) - 8usize];
    [
        "Offset of field: bch_ioctl_unpoison::flags",
    ][::std::mem::offset_of!(bch_ioctl_unpoison, flags) - 16usize];
    [
        "Offset of field: bch_ioctl_unpoison::pad",
    ][::std::mem::offset_of!(bch_ioctl_unpoison, pad) - 20usize];
};
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bch_move_stats {
    pub name: [::std::os::raw::c_char; 32usize],
    pub phys: bool,
    pub ret: bch_ioctl_data_event_ret,
    pub __bindgen_anon_1: bch_move_stats__bindgen_ty_1,
    pub keys_moved: atomic64_t,
    pub keys_raced: atomic64_t,
    pub sectors_seen: atomic64_t,
    pub sectors_moved: atomic64_t,
    pub sectors_raced: atomic64_t,
    pub sectors_error_corrected: atomic64_t,
    pub sectors_error_uncorrected: atomic64_t,
    pub devs_error_uncorrected: bch_devs_mask,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bch_move_stats__bindgen_ty_1 {
    pub __bindgen_anon_1: bch_move_stats__bindgen_ty_1__bindgen_ty_1,
    pub __bindgen_anon_2: bch_move_stats__bindgen_ty_1__bindgen_ty_2,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bch_move_stats__bindgen_ty_1__bindgen_ty_1 {
    pub data_type: bch_data_type,
    pub pos: bbpos,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_move_stats__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bch_move_stats__bindgen_ty_1__bindgen_ty_1>() - 28usize];
    [
        "Alignment of bch_move_stats__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bch_move_stats__bindgen_ty_1__bindgen_ty_1>() - 4usize];
    [
        "Offset of field: bch_move_stats__bindgen_ty_1__bindgen_ty_1::data_type",
    ][::std::mem::offset_of!(bch_move_stats__bindgen_ty_1__bindgen_ty_1, data_type)
        - 0usize];
    [
        "Offset of field: bch_move_stats__bindgen_ty_1__bindgen_ty_1::pos",
    ][::std::mem::offset_of!(bch_move_stats__bindgen_ty_1__bindgen_ty_1, pos) - 4usize];
};
impl Default for bch_move_stats__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_move_stats__bindgen_ty_1__bindgen_ty_2 {
    pub dev: ::std::os::raw::c_uint,
    pub offset: u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_move_stats__bindgen_ty_1__bindgen_ty_2",
    ][::std::mem::size_of::<bch_move_stats__bindgen_ty_1__bindgen_ty_2>() - 16usize];
    [
        "Alignment of bch_move_stats__bindgen_ty_1__bindgen_ty_2",
    ][::std::mem::align_of::<bch_move_stats__bindgen_ty_1__bindgen_ty_2>() - 8usize];
    [
        "Offset of field: bch_move_stats__bindgen_ty_1__bindgen_ty_2::dev",
    ][::std::mem::offset_of!(bch_move_stats__bindgen_ty_1__bindgen_ty_2, dev) - 0usize];
    [
        "Offset of field: bch_move_stats__bindgen_ty_1__bindgen_ty_2::offset",
    ][::std::mem::offset_of!(bch_move_stats__bindgen_ty_1__bindgen_ty_2, offset)
        - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_move_stats__bindgen_ty_1",
    ][::std::mem::size_of::<bch_move_stats__bindgen_ty_1>() - 32usize];
    [
        "Alignment of bch_move_stats__bindgen_ty_1",
    ][::std::mem::align_of::<bch_move_stats__bindgen_ty_1>() - 8usize];
};
impl Default for bch_move_stats__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_move_stats"][::std::mem::size_of::<bch_move_stats>() - 136usize];
    ["Alignment of bch_move_stats"][::std::mem::align_of::<bch_move_stats>() - 8usize];
    [
        "Offset of field: bch_move_stats::name",
    ][::std::mem::offset_of!(bch_move_stats, name) - 0usize];
    [
        "Offset of field: bch_move_stats::phys",
    ][::std::mem::offset_of!(bch_move_stats, phys) - 32usize];
    [
        "Offset of field: bch_move_stats::ret",
    ][::std::mem::offset_of!(bch_move_stats, ret) - 36usize];
    [
        "Offset of field: bch_move_stats::keys_moved",
    ][::std::mem::offset_of!(bch_move_stats, keys_moved) - 72usize];
    [
        "Offset of field: bch_move_stats::keys_raced",
    ][::std::mem::offset_of!(bch_move_stats, keys_raced) - 80usize];
    [
        "Offset of field: bch_move_stats::sectors_seen",
    ][::std::mem::offset_of!(bch_move_stats, sectors_seen) - 88usize];
    [
        "Offset of field: bch_move_stats::sectors_moved",
    ][::std::mem::offset_of!(bch_move_stats, sectors_moved) - 96usize];
    [
        "Offset of field: bch_move_stats::sectors_raced",
    ][::std::mem::offset_of!(bch_move_stats, sectors_raced) - 104usize];
    [
        "Offset of field: bch_move_stats::sectors_error_corrected",
    ][::std::mem::offset_of!(bch_move_stats, sectors_error_corrected) - 112usize];
    [
        "Offset of field: bch_move_stats::sectors_error_uncorrected",
    ][::std::mem::offset_of!(bch_move_stats, sectors_error_uncorrected) - 120usize];
    [
        "Offset of field: bch_move_stats::devs_error_uncorrected",
    ][::std::mem::offset_of!(bch_move_stats, devs_error_uncorrected) - 128usize];
};
impl Default for bch_move_stats {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct move_bucket_key {
    pub bucket: bpos,
    pub gen_: ::std::os::raw::c_uint,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of move_bucket_key"][::std::mem::size_of::<move_bucket_key>() - 24usize];
    ["Alignment of move_bucket_key"][::std::mem::align_of::<move_bucket_key>() - 4usize];
    [
        "Offset of field: move_bucket_key::bucket",
    ][::std::mem::offset_of!(move_bucket_key, bucket) - 0usize];
    [
        "Offset of field: move_bucket_key::gen_",
    ][::std::mem::offset_of!(move_bucket_key, gen_) - 20usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct move_bucket {
    pub next: *mut move_bucket,
    pub hash: rhash_head,
    pub k: move_bucket_key,
    pub sectors: ::std::os::raw::c_uint,
    pub count: atomic_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of move_bucket"][::std::mem::size_of::<move_bucket>() - 48usize];
    ["Alignment of move_bucket"][::std::mem::align_of::<move_bucket>() - 8usize];
    [
        "Offset of field: move_bucket::next",
    ][::std::mem::offset_of!(move_bucket, next) - 0usize];
    [
        "Offset of field: move_bucket::hash",
    ][::std::mem::offset_of!(move_bucket, hash) - 8usize];
    [
        "Offset of field: move_bucket::k",
    ][::std::mem::offset_of!(move_bucket, k) - 16usize];
    [
        "Offset of field: move_bucket::sectors",
    ][::std::mem::offset_of!(move_bucket, sectors) - 40usize];
    [
        "Offset of field: move_bucket::count",
    ][::std::mem::offset_of!(move_bucket, count) - 44usize];
};
impl Default for move_bucket {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug)]
pub struct scrub_journal_repair {
    pub btree_id: btree_id,
    pub bad_devs: ::std::os::raw::c_uint,
    pub k: bkey_i,
    pub k_pad: [__u64; 41usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of scrub_journal_repair",
    ][::std::mem::size_of::<scrub_journal_repair>() - 376usize];
    [
        "Alignment of scrub_journal_repair",
    ][::std::mem::align_of::<scrub_journal_repair>() - 8usize];
    [
        "Offset of field: scrub_journal_repair::btree_id",
    ][::std::mem::offset_of!(scrub_journal_repair, btree_id) - 0usize];
    [
        "Offset of field: scrub_journal_repair::bad_devs",
    ][::std::mem::offset_of!(scrub_journal_repair, bad_devs) - 4usize];
    [
        "Offset of field: scrub_journal_repair::k",
    ][::std::mem::offset_of!(scrub_journal_repair, k) - 8usize];
    [
        "Offset of field: scrub_journal_repair::k_pad",
    ][::std::mem::offset_of!(scrub_journal_repair, k_pad) - 48usize];
};
impl Default for scrub_journal_repair {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug)]
pub struct darray_scrub_journal_repair {
    pub nr: usize,
    pub size: usize,
    pub data: *mut scrub_journal_repair,
    pub preallocated: __IncompleteArrayField<scrub_journal_repair>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of darray_scrub_journal_repair",
    ][::std::mem::size_of::<darray_scrub_journal_repair>() - 24usize];
    [
        "Alignment of darray_scrub_journal_repair",
    ][::std::mem::align_of::<darray_scrub_journal_repair>() - 8usize];
    [
        "Offset of field: darray_scrub_journal_repair::nr",
    ][::std::mem::offset_of!(darray_scrub_journal_repair, nr) - 0usize];
    [
        "Offset of field: darray_scrub_journal_repair::size",
    ][::std::mem::offset_of!(darray_scrub_journal_repair, size) - 8usize];
    [
        "Offset of field: darray_scrub_journal_repair::data",
    ][::std::mem::offset_of!(darray_scrub_journal_repair, data) - 16usize];
    [
        "Offset of field: darray_scrub_journal_repair::preallocated",
    ][::std::mem::offset_of!(darray_scrub_journal_repair, preallocated) - 24usize];
};
impl Default for darray_scrub_journal_repair {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct progress_indicator {
    pub msg: *const ::std::os::raw::c_char,
    pub pos: bbpos,
    pub next_print: ::std::os::raw::c_ulong,
    pub nodes_seen: u64_,
    pub nodes_total: u64_,
    pub last_node: *mut btree,
    pub silent: bool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of progress_indicator",
    ][::std::mem::size_of::<progress_indicator>() - 72usize];
    [
        "Alignment of progress_indicator",
    ][::std::mem::align_of::<progress_indicator>() - 8usize];
    [
        "Offset of field: progress_indicator::msg",
    ][::std::mem::offset_of!(progress_indicator, msg) - 0usize];
    [
        "Offset of field: progress_indicator::pos",
    ][::std::mem::offset_of!(progress_indicator, pos) - 8usize];
    [
        "Offset of field: progress_indicator::next_print",
    ][::std::mem::offset_of!(progress_indicator, next_print) - 32usize];
    [
        "Offset of field: progress_indicator::nodes_seen",
    ][::std::mem::offset_of!(progress_indicator, nodes_seen) - 40usize];
    [
        "Offset of field: progress_indicator::nodes_total",
    ][::std::mem::offset_of!(progress_indicator, nodes_total) - 48usize];
    [
        "Offset of field: progress_indicator::last_node",
    ][::std::mem::offset_of!(progress_indicator, last_node) - 56usize];
    [
        "Offset of field: progress_indicator::silent",
    ][::std::mem::offset_of!(progress_indicator, silent) - 64usize];
};
impl Default for progress_indicator {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C" {
    pub fn bch2_progress_init(
        s: *mut progress_indicator,
        msg: *const ::std::os::raw::c_char,
        c: *mut bch_fs,
        leaf_btree_id_mask: u64_,
        inner_btree_id_mask: u64_,
    );
}
unsafe extern "C" {
    pub fn bch2_progress_update_iter(
        arg1: *mut btree_trans,
        arg2: *mut progress_indicator,
        arg3: *mut btree_iter,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_progress_to_text(arg1: *mut printbuf, arg2: *mut progress_indicator);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bch_fs_reconcile {
    pub thread: *mut task_struct,
    pub kick: u32_,
    pub running: bool,
    pub wait_iotime_start: u64_,
    pub wait_iotime_end: u64_,
    pub wait_wallclock_start: u64_,
    pub phase: ::std::os::raw::c_uint,
    pub work_pos: bbpos,
    pub work_stats: bch_move_stats,
    pub progress: progress_indicator,
    pub scan_start: bbpos,
    pub scan_end: bbpos,
    pub scan_stats: bch_move_stats,
    pub scans_in_flight: rhashtable,
    pub scans_in_flight_init_done: bool,
    pub scans_in_flight_lock: mutex,
    pub on_battery: bool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_fs_reconcile"][::std::mem::size_of::<bch_fs_reconcile>() - 704usize];
    [
        "Alignment of bch_fs_reconcile",
    ][::std::mem::align_of::<bch_fs_reconcile>() - 8usize];
    [
        "Offset of field: bch_fs_reconcile::thread",
    ][::std::mem::offset_of!(bch_fs_reconcile, thread) - 0usize];
    [
        "Offset of field: bch_fs_reconcile::kick",
    ][::std::mem::offset_of!(bch_fs_reconcile, kick) - 8usize];
    [
        "Offset of field: bch_fs_reconcile::running",
    ][::std::mem::offset_of!(bch_fs_reconcile, running) - 12usize];
    [
        "Offset of field: bch_fs_reconcile::wait_iotime_start",
    ][::std::mem::offset_of!(bch_fs_reconcile, wait_iotime_start) - 16usize];
    [
        "Offset of field: bch_fs_reconcile::wait_iotime_end",
    ][::std::mem::offset_of!(bch_fs_reconcile, wait_iotime_end) - 24usize];
    [
        "Offset of field: bch_fs_reconcile::wait_wallclock_start",
    ][::std::mem::offset_of!(bch_fs_reconcile, wait_wallclock_start) - 32usize];
    [
        "Offset of field: bch_fs_reconcile::phase",
    ][::std::mem::offset_of!(bch_fs_reconcile, phase) - 40usize];
    [
        "Offset of field: bch_fs_reconcile::work_pos",
    ][::std::mem::offset_of!(bch_fs_reconcile, work_pos) - 44usize];
    [
        "Offset of field: bch_fs_reconcile::work_stats",
    ][::std::mem::offset_of!(bch_fs_reconcile, work_stats) - 72usize];
    [
        "Offset of field: bch_fs_reconcile::progress",
    ][::std::mem::offset_of!(bch_fs_reconcile, progress) - 208usize];
    [
        "Offset of field: bch_fs_reconcile::scan_start",
    ][::std::mem::offset_of!(bch_fs_reconcile, scan_start) - 280usize];
    [
        "Offset of field: bch_fs_reconcile::scan_end",
    ][::std::mem::offset_of!(bch_fs_reconcile, scan_end) - 304usize];
    [
        "Offset of field: bch_fs_reconcile::scan_stats",
    ][::std::mem::offset_of!(bch_fs_reconcile, scan_stats) - 328usize];
    [
        "Offset of field: bch_fs_reconcile::scans_in_flight",
    ][::std::mem::offset_of!(bch_fs_reconcile, scans_in_flight) - 464usize];
    [
        "Offset of field: bch_fs_reconcile::scans_in_flight_init_done",
    ][::std::mem::offset_of!(bch_fs_reconcile, scans_in_flight_init_done) - 648usize];
    [
        "Offset of field: bch_fs_reconcile::scans_in_flight_lock",
    ][::std::mem::offset_of!(bch_fs_reconcile, scans_in_flight_lock) - 656usize];
    [
        "Offset of field: bch_fs_reconcile::on_battery",
    ][::std::mem::offset_of!(bch_fs_reconcile, on_battery) - 696usize];
};
impl Default for bch_fs_reconcile {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_async_obj_lists {
    BCH_ASYNC_OBJ_LIST_promote = 0,
    BCH_ASYNC_OBJ_LIST_rbio = 1,
    BCH_ASYNC_OBJ_LIST_write_op = 2,
    BCH_ASYNC_OBJ_LIST_btree_read_bio = 3,
    BCH_ASYNC_OBJ_LIST_btree_write_bio = 4,
    BCH_ASYNC_OBJ_NR = 5,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_qid {
    pub q: [u32_; 3usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_qid"][::std::mem::size_of::<bch_qid>() - 12usize];
    ["Alignment of bch_qid"][::std::mem::align_of::<bch_qid>() - 4usize];
    ["Offset of field: bch_qid::q"][::std::mem::offset_of!(bch_qid, q) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct memquota_counter {
    pub v: u64_,
    pub hardlimit: u64_,
    pub softlimit: u64_,
    pub timer: s64,
    pub warns: ::std::os::raw::c_int,
    pub warning_issued: ::std::os::raw::c_int,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of memquota_counter"][::std::mem::size_of::<memquota_counter>() - 40usize];
    [
        "Alignment of memquota_counter",
    ][::std::mem::align_of::<memquota_counter>() - 8usize];
    [
        "Offset of field: memquota_counter::v",
    ][::std::mem::offset_of!(memquota_counter, v) - 0usize];
    [
        "Offset of field: memquota_counter::hardlimit",
    ][::std::mem::offset_of!(memquota_counter, hardlimit) - 8usize];
    [
        "Offset of field: memquota_counter::softlimit",
    ][::std::mem::offset_of!(memquota_counter, softlimit) - 16usize];
    [
        "Offset of field: memquota_counter::timer",
    ][::std::mem::offset_of!(memquota_counter, timer) - 24usize];
    [
        "Offset of field: memquota_counter::warns",
    ][::std::mem::offset_of!(memquota_counter, warns) - 32usize];
    [
        "Offset of field: memquota_counter::warning_issued",
    ][::std::mem::offset_of!(memquota_counter, warning_issued) - 36usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_memquota {
    pub c: [memquota_counter; 2usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_memquota"][::std::mem::size_of::<bch_memquota>() - 80usize];
    ["Alignment of bch_memquota"][::std::mem::align_of::<bch_memquota>() - 8usize];
    [
        "Offset of field: bch_memquota::c",
    ][::std::mem::offset_of!(bch_memquota, c) - 0usize];
};
#[repr(C)]
#[derive(Debug)]
pub struct bch_memquota_table {
    pub tree: __genradix,
    pub type_: __IncompleteArrayField<bch_memquota>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_memquota_table"][::std::mem::size_of::<bch_memquota_table>() - 8usize];
    [
        "Alignment of bch_memquota_table",
    ][::std::mem::align_of::<bch_memquota_table>() - 8usize];
    [
        "Offset of field: bch_memquota_table::tree",
    ][::std::mem::offset_of!(bch_memquota_table, tree) - 0usize];
    [
        "Offset of field: bch_memquota_table::type_",
    ][::std::mem::offset_of!(bch_memquota_table, type_) - 8usize];
};
impl Default for bch_memquota_table {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct quota_limit {
    pub timelimit: u32_,
    pub warnlimit: u32_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of quota_limit"][::std::mem::size_of::<quota_limit>() - 8usize];
    ["Alignment of quota_limit"][::std::mem::align_of::<quota_limit>() - 4usize];
    [
        "Offset of field: quota_limit::timelimit",
    ][::std::mem::offset_of!(quota_limit, timelimit) - 0usize];
    [
        "Offset of field: quota_limit::warnlimit",
    ][::std::mem::offset_of!(quota_limit, warnlimit) - 4usize];
};
#[repr(C)]
pub struct bch_memquota_type {
    pub limits: [quota_limit; 2usize],
    pub table: bch_memquota_table,
    pub lock: mutex,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_memquota_type"][::std::mem::size_of::<bch_memquota_type>() - 64usize];
    [
        "Alignment of bch_memquota_type",
    ][::std::mem::align_of::<bch_memquota_type>() - 8usize];
    [
        "Offset of field: bch_memquota_type::limits",
    ][::std::mem::offset_of!(bch_memquota_type, limits) - 0usize];
    [
        "Offset of field: bch_memquota_type::table",
    ][::std::mem::offset_of!(bch_memquota_type, table) - 16usize];
    [
        "Offset of field: bch_memquota_type::lock",
    ][::std::mem::offset_of!(bch_memquota_type, lock) - 24usize];
};
impl Default for bch_memquota_type {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_sb_error_entry_cpu {
    pub _bitfield_align_1: [u64; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
    pub last_error_time: u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_sb_error_entry_cpu",
    ][::std::mem::size_of::<bch_sb_error_entry_cpu>() - 16usize];
    [
        "Alignment of bch_sb_error_entry_cpu",
    ][::std::mem::align_of::<bch_sb_error_entry_cpu>() - 8usize];
    [
        "Offset of field: bch_sb_error_entry_cpu::last_error_time",
    ][::std::mem::offset_of!(bch_sb_error_entry_cpu, last_error_time) - 8usize];
};
impl bch_sb_error_entry_cpu {
    #[inline]
    pub fn id(&self) -> u64_ {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 16u8) as u64) }
    }
    #[inline]
    pub fn set_id(&mut self, val: u64_) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 16u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn id_raw(this: *const Self) -> u64_ {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 16u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_id_raw(this: *mut Self, val: u64_) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                16u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn nr(&self) -> u64_ {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 48u8) as u64) }
    }
    #[inline]
    pub fn set_nr(&mut self, val: u64_) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            self._bitfield_1.set(16usize, 48u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn nr_raw(this: *const Self) -> u64_ {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 8usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 16usize, 48u8)
                    as u64,
            )
        }
    }
    #[inline]
    pub unsafe fn set_nr_raw(this: *mut Self, val: u64_) {
        unsafe {
            let val: u64 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 8usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                16usize,
                48u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(id: u64_, nr: u64_) -> __BindgenBitfieldUnit<[u8; 8usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                16u8,
                {
                    let id: u64 = unsafe { ::std::mem::transmute(id) };
                    id as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                16usize,
                48u8,
                {
                    let nr: u64 = unsafe { ::std::mem::transmute(nr) };
                    nr as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Debug)]
pub struct bch_sb_errors_cpu {
    pub nr: usize,
    pub size: usize,
    pub data: *mut bch_sb_error_entry_cpu,
    pub preallocated: __IncompleteArrayField<bch_sb_error_entry_cpu>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_sb_errors_cpu"][::std::mem::size_of::<bch_sb_errors_cpu>() - 24usize];
    [
        "Alignment of bch_sb_errors_cpu",
    ][::std::mem::align_of::<bch_sb_errors_cpu>() - 8usize];
    [
        "Offset of field: bch_sb_errors_cpu::nr",
    ][::std::mem::offset_of!(bch_sb_errors_cpu, nr) - 0usize];
    [
        "Offset of field: bch_sb_errors_cpu::size",
    ][::std::mem::offset_of!(bch_sb_errors_cpu, size) - 8usize];
    [
        "Offset of field: bch_sb_errors_cpu::data",
    ][::std::mem::offset_of!(bch_sb_errors_cpu, data) - 16usize];
    [
        "Offset of field: bch_sb_errors_cpu::preallocated",
    ][::std::mem::offset_of!(bch_sb_errors_cpu, preallocated) - 24usize];
};
impl Default for bch_sb_errors_cpu {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bch_fs_errors {
    pub msgs: cds_list_head,
    pub msgs_lock: mutex,
    pub msgs_alloc_err: bool,
    pub counts: bch_sb_errors_cpu,
    pub counts_lock: mutex,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_fs_errors"][::std::mem::size_of::<bch_fs_errors>() - 128usize];
    ["Alignment of bch_fs_errors"][::std::mem::align_of::<bch_fs_errors>() - 8usize];
    [
        "Offset of field: bch_fs_errors::msgs",
    ][::std::mem::offset_of!(bch_fs_errors, msgs) - 0usize];
    [
        "Offset of field: bch_fs_errors::msgs_lock",
    ][::std::mem::offset_of!(bch_fs_errors, msgs_lock) - 16usize];
    [
        "Offset of field: bch_fs_errors::msgs_alloc_err",
    ][::std::mem::offset_of!(bch_fs_errors, msgs_alloc_err) - 56usize];
    [
        "Offset of field: bch_fs_errors::counts",
    ][::std::mem::offset_of!(bch_fs_errors, counts) - 64usize];
    [
        "Offset of field: bch_fs_errors::counts_lock",
    ][::std::mem::offset_of!(bch_fs_errors, counts_lock) - 88usize];
};
impl Default for bch_fs_errors {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bch_fs_recovery {
    pub scheduled_passes_ephemeral: u64_,
    pub current_passes: u64_,
    pub current_pass: bch_recovery_pass,
    pub rewound_from: bch_recovery_pass,
    pub rewound_to: bch_recovery_pass,
    pub pass_done: bch_recovery_pass,
    pub passes_complete: u64_,
    pub passes_failing: u64_,
    pub passes_ratelimiting: u64_,
    pub lock: spinlock_t,
    pub run_lock: mutex,
    pub work: work_struct,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_fs_recovery"][::std::mem::size_of::<bch_fs_recovery>() - 168usize];
    ["Alignment of bch_fs_recovery"][::std::mem::align_of::<bch_fs_recovery>() - 8usize];
    [
        "Offset of field: bch_fs_recovery::scheduled_passes_ephemeral",
    ][::std::mem::offset_of!(bch_fs_recovery, scheduled_passes_ephemeral) - 0usize];
    [
        "Offset of field: bch_fs_recovery::current_passes",
    ][::std::mem::offset_of!(bch_fs_recovery, current_passes) - 8usize];
    [
        "Offset of field: bch_fs_recovery::current_pass",
    ][::std::mem::offset_of!(bch_fs_recovery, current_pass) - 16usize];
    [
        "Offset of field: bch_fs_recovery::rewound_from",
    ][::std::mem::offset_of!(bch_fs_recovery, rewound_from) - 20usize];
    [
        "Offset of field: bch_fs_recovery::rewound_to",
    ][::std::mem::offset_of!(bch_fs_recovery, rewound_to) - 24usize];
    [
        "Offset of field: bch_fs_recovery::pass_done",
    ][::std::mem::offset_of!(bch_fs_recovery, pass_done) - 28usize];
    [
        "Offset of field: bch_fs_recovery::passes_complete",
    ][::std::mem::offset_of!(bch_fs_recovery, passes_complete) - 32usize];
    [
        "Offset of field: bch_fs_recovery::passes_failing",
    ][::std::mem::offset_of!(bch_fs_recovery, passes_failing) - 40usize];
    [
        "Offset of field: bch_fs_recovery::passes_ratelimiting",
    ][::std::mem::offset_of!(bch_fs_recovery, passes_ratelimiting) - 48usize];
    [
        "Offset of field: bch_fs_recovery::lock",
    ][::std::mem::offset_of!(bch_fs_recovery, lock) - 56usize];
    [
        "Offset of field: bch_fs_recovery::run_lock",
    ][::std::mem::offset_of!(bch_fs_recovery, run_lock) - 96usize];
    [
        "Offset of field: bch_fs_recovery::work",
    ][::std::mem::offset_of!(bch_fs_recovery, work) - 136usize];
};
impl Default for bch_fs_recovery {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bch_fs_counters {
    pub mount: [u64_; 134usize],
    pub now: *mut u64_,
    pub recent: [[u64_; 134usize]; 20usize],
    pub work: delayed_work,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_fs_counters"][::std::mem::size_of::<bch_fs_counters>() - 22584usize];
    ["Alignment of bch_fs_counters"][::std::mem::align_of::<bch_fs_counters>() - 8usize];
    [
        "Offset of field: bch_fs_counters::mount",
    ][::std::mem::offset_of!(bch_fs_counters, mount) - 0usize];
    [
        "Offset of field: bch_fs_counters::now",
    ][::std::mem::offset_of!(bch_fs_counters, now) - 1072usize];
    [
        "Offset of field: bch_fs_counters::recent",
    ][::std::mem::offset_of!(bch_fs_counters, recent) - 1080usize];
    [
        "Offset of field: bch_fs_counters::work",
    ][::std::mem::offset_of!(bch_fs_counters, work) - 22520usize];
};
impl Default for bch_fs_counters {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_sb_cpu {
    pub uuid: __uuid_t,
    pub user_uuid: __uuid_t,
    pub version: u16_,
    pub version_incompat: u16_,
    pub version_incompat_allowed: u16_,
    pub version_min: u16_,
    pub version_upgrade_complete: u16_,
    pub nr_devices: u8_,
    pub clean: u8_,
    pub multi_device: bool,
    pub encryption_type: u8_,
    pub extent_type_u64s: [u8_; 31usize],
    pub extent_types_known: u8_,
    pub extent_bp_shift: u8_,
    pub time_base_lo: u64_,
    pub time_base_hi: u32_,
    pub time_units_per_sec: ::std::os::raw::c_uint,
    pub nsec_per_time_unit: ::std::os::raw::c_uint,
    pub features: u64_,
    pub compat: u64_,
    pub recovery_passes_required: u64_,
    pub errors_silent: [::std::os::raw::c_ulong; 6usize],
    pub btrees_lost_data: u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_sb_cpu"][::std::mem::size_of::<bch_sb_cpu>() - 184usize];
    ["Alignment of bch_sb_cpu"][::std::mem::align_of::<bch_sb_cpu>() - 8usize];
    [
        "Offset of field: bch_sb_cpu::uuid",
    ][::std::mem::offset_of!(bch_sb_cpu, uuid) - 0usize];
    [
        "Offset of field: bch_sb_cpu::user_uuid",
    ][::std::mem::offset_of!(bch_sb_cpu, user_uuid) - 16usize];
    [
        "Offset of field: bch_sb_cpu::version",
    ][::std::mem::offset_of!(bch_sb_cpu, version) - 32usize];
    [
        "Offset of field: bch_sb_cpu::version_incompat",
    ][::std::mem::offset_of!(bch_sb_cpu, version_incompat) - 34usize];
    [
        "Offset of field: bch_sb_cpu::version_incompat_allowed",
    ][::std::mem::offset_of!(bch_sb_cpu, version_incompat_allowed) - 36usize];
    [
        "Offset of field: bch_sb_cpu::version_min",
    ][::std::mem::offset_of!(bch_sb_cpu, version_min) - 38usize];
    [
        "Offset of field: bch_sb_cpu::version_upgrade_complete",
    ][::std::mem::offset_of!(bch_sb_cpu, version_upgrade_complete) - 40usize];
    [
        "Offset of field: bch_sb_cpu::nr_devices",
    ][::std::mem::offset_of!(bch_sb_cpu, nr_devices) - 42usize];
    [
        "Offset of field: bch_sb_cpu::clean",
    ][::std::mem::offset_of!(bch_sb_cpu, clean) - 43usize];
    [
        "Offset of field: bch_sb_cpu::multi_device",
    ][::std::mem::offset_of!(bch_sb_cpu, multi_device) - 44usize];
    [
        "Offset of field: bch_sb_cpu::encryption_type",
    ][::std::mem::offset_of!(bch_sb_cpu, encryption_type) - 45usize];
    [
        "Offset of field: bch_sb_cpu::extent_type_u64s",
    ][::std::mem::offset_of!(bch_sb_cpu, extent_type_u64s) - 46usize];
    [
        "Offset of field: bch_sb_cpu::extent_types_known",
    ][::std::mem::offset_of!(bch_sb_cpu, extent_types_known) - 77usize];
    [
        "Offset of field: bch_sb_cpu::extent_bp_shift",
    ][::std::mem::offset_of!(bch_sb_cpu, extent_bp_shift) - 78usize];
    [
        "Offset of field: bch_sb_cpu::time_base_lo",
    ][::std::mem::offset_of!(bch_sb_cpu, time_base_lo) - 80usize];
    [
        "Offset of field: bch_sb_cpu::time_base_hi",
    ][::std::mem::offset_of!(bch_sb_cpu, time_base_hi) - 88usize];
    [
        "Offset of field: bch_sb_cpu::time_units_per_sec",
    ][::std::mem::offset_of!(bch_sb_cpu, time_units_per_sec) - 92usize];
    [
        "Offset of field: bch_sb_cpu::nsec_per_time_unit",
    ][::std::mem::offset_of!(bch_sb_cpu, nsec_per_time_unit) - 96usize];
    [
        "Offset of field: bch_sb_cpu::features",
    ][::std::mem::offset_of!(bch_sb_cpu, features) - 104usize];
    [
        "Offset of field: bch_sb_cpu::compat",
    ][::std::mem::offset_of!(bch_sb_cpu, compat) - 112usize];
    [
        "Offset of field: bch_sb_cpu::recovery_passes_required",
    ][::std::mem::offset_of!(bch_sb_cpu, recovery_passes_required) - 120usize];
    [
        "Offset of field: bch_sb_cpu::errors_silent",
    ][::std::mem::offset_of!(bch_sb_cpu, errors_silent) - 128usize];
    [
        "Offset of field: bch_sb_cpu::btrees_lost_data",
    ][::std::mem::offset_of!(bch_sb_cpu, btrees_lost_data) - 176usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_member_cpu {
    pub nbuckets: u64_,
    pub nbuckets_minus_first: u64_,
    pub first_bucket: u16_,
    pub bucket_size: u16_,
    pub group: u16_,
    pub state: u8_,
    pub discard: u8_,
    pub data_allowed: u8_,
    pub durability: u8_,
    pub freespace_initialized: u8_,
    pub initialized: u8_,
    pub resize_on_mount: u8_,
    pub rotational: u8_,
    pub valid: u8_,
    pub btree_bitmap_shift: u8_,
    pub btree_allocated_bitmap: u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_member_cpu"][::std::mem::size_of::<bch_member_cpu>() - 40usize];
    ["Alignment of bch_member_cpu"][::std::mem::align_of::<bch_member_cpu>() - 8usize];
    [
        "Offset of field: bch_member_cpu::nbuckets",
    ][::std::mem::offset_of!(bch_member_cpu, nbuckets) - 0usize];
    [
        "Offset of field: bch_member_cpu::nbuckets_minus_first",
    ][::std::mem::offset_of!(bch_member_cpu, nbuckets_minus_first) - 8usize];
    [
        "Offset of field: bch_member_cpu::first_bucket",
    ][::std::mem::offset_of!(bch_member_cpu, first_bucket) - 16usize];
    [
        "Offset of field: bch_member_cpu::bucket_size",
    ][::std::mem::offset_of!(bch_member_cpu, bucket_size) - 18usize];
    [
        "Offset of field: bch_member_cpu::group",
    ][::std::mem::offset_of!(bch_member_cpu, group) - 20usize];
    [
        "Offset of field: bch_member_cpu::state",
    ][::std::mem::offset_of!(bch_member_cpu, state) - 22usize];
    [
        "Offset of field: bch_member_cpu::discard",
    ][::std::mem::offset_of!(bch_member_cpu, discard) - 23usize];
    [
        "Offset of field: bch_member_cpu::data_allowed",
    ][::std::mem::offset_of!(bch_member_cpu, data_allowed) - 24usize];
    [
        "Offset of field: bch_member_cpu::durability",
    ][::std::mem::offset_of!(bch_member_cpu, durability) - 25usize];
    [
        "Offset of field: bch_member_cpu::freespace_initialized",
    ][::std::mem::offset_of!(bch_member_cpu, freespace_initialized) - 26usize];
    [
        "Offset of field: bch_member_cpu::initialized",
    ][::std::mem::offset_of!(bch_member_cpu, initialized) - 27usize];
    [
        "Offset of field: bch_member_cpu::resize_on_mount",
    ][::std::mem::offset_of!(bch_member_cpu, resize_on_mount) - 28usize];
    [
        "Offset of field: bch_member_cpu::rotational",
    ][::std::mem::offset_of!(bch_member_cpu, rotational) - 29usize];
    [
        "Offset of field: bch_member_cpu::valid",
    ][::std::mem::offset_of!(bch_member_cpu, valid) - 30usize];
    [
        "Offset of field: bch_member_cpu::btree_bitmap_shift",
    ][::std::mem::offset_of!(bch_member_cpu, btree_bitmap_shift) - 31usize];
    [
        "Offset of field: bch_member_cpu::btree_allocated_bitmap",
    ][::std::mem::offset_of!(bch_member_cpu, btree_allocated_bitmap) - 32usize];
};
#[repr(C)]
#[derive(Debug)]
pub struct snapshot_id_list {
    pub nr: usize,
    pub size: usize,
    pub data: *mut u32_,
    pub preallocated: __IncompleteArrayField<u32_>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of snapshot_id_list"][::std::mem::size_of::<snapshot_id_list>() - 24usize];
    [
        "Alignment of snapshot_id_list",
    ][::std::mem::align_of::<snapshot_id_list>() - 8usize];
    [
        "Offset of field: snapshot_id_list::nr",
    ][::std::mem::offset_of!(snapshot_id_list, nr) - 0usize];
    [
        "Offset of field: snapshot_id_list::size",
    ][::std::mem::offset_of!(snapshot_id_list, size) - 8usize];
    [
        "Offset of field: snapshot_id_list::data",
    ][::std::mem::offset_of!(snapshot_id_list, data) - 16usize];
    [
        "Offset of field: snapshot_id_list::preallocated",
    ][::std::mem::offset_of!(snapshot_id_list, preallocated) - 24usize];
};
impl Default for snapshot_id_list {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct snapshot_t {
    pub state: snapshot_t_snapshot_id_state,
    pub parent: u32_,
    pub skip: [u32_; 3usize],
    pub depth: u32_,
    pub children: [u32_; 2usize],
    pub subvol: u32_,
    pub tree: u32_,
    pub is_ancestor: [::std::os::raw::c_ulong; 2usize],
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum snapshot_t_snapshot_id_state {
    SNAPSHOT_ID_empty = 0,
    SNAPSHOT_ID_live = 1,
    SNAPSHOT_ID_deleted = 2,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of snapshot_t"][::std::mem::size_of::<snapshot_t>() - 56usize];
    ["Alignment of snapshot_t"][::std::mem::align_of::<snapshot_t>() - 8usize];
    [
        "Offset of field: snapshot_t::state",
    ][::std::mem::offset_of!(snapshot_t, state) - 0usize];
    [
        "Offset of field: snapshot_t::parent",
    ][::std::mem::offset_of!(snapshot_t, parent) - 4usize];
    [
        "Offset of field: snapshot_t::skip",
    ][::std::mem::offset_of!(snapshot_t, skip) - 8usize];
    [
        "Offset of field: snapshot_t::depth",
    ][::std::mem::offset_of!(snapshot_t, depth) - 20usize];
    [
        "Offset of field: snapshot_t::children",
    ][::std::mem::offset_of!(snapshot_t, children) - 24usize];
    [
        "Offset of field: snapshot_t::subvol",
    ][::std::mem::offset_of!(snapshot_t, subvol) - 32usize];
    [
        "Offset of field: snapshot_t::tree",
    ][::std::mem::offset_of!(snapshot_t, tree) - 36usize];
    [
        "Offset of field: snapshot_t::is_ancestor",
    ][::std::mem::offset_of!(snapshot_t, is_ancestor) - 40usize];
};
impl Default for snapshot_t {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug)]
pub struct snapshot_table {
    pub rcu: rcu_head,
    pub nr: usize,
    pub s: __IncompleteArrayField<snapshot_t>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of snapshot_table"][::std::mem::size_of::<snapshot_table>() - 24usize];
    ["Alignment of snapshot_table"][::std::mem::align_of::<snapshot_table>() - 8usize];
    [
        "Offset of field: snapshot_table::rcu",
    ][::std::mem::offset_of!(snapshot_table, rcu) - 0usize];
    [
        "Offset of field: snapshot_table::nr",
    ][::std::mem::offset_of!(snapshot_table, nr) - 16usize];
    [
        "Offset of field: snapshot_table::s",
    ][::std::mem::offset_of!(snapshot_table, s) - 24usize];
};
impl Default for snapshot_table {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct snapshot_interior_delete {
    pub id: u32_,
    pub live_child: u32_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of snapshot_interior_delete",
    ][::std::mem::size_of::<snapshot_interior_delete>() - 8usize];
    [
        "Alignment of snapshot_interior_delete",
    ][::std::mem::align_of::<snapshot_interior_delete>() - 4usize];
    [
        "Offset of field: snapshot_interior_delete::id",
    ][::std::mem::offset_of!(snapshot_interior_delete, id) - 0usize];
    [
        "Offset of field: snapshot_interior_delete::live_child",
    ][::std::mem::offset_of!(snapshot_interior_delete, live_child) - 4usize];
};
#[repr(C)]
#[derive(Debug)]
pub struct interior_delete_list {
    pub nr: usize,
    pub size: usize,
    pub data: *mut snapshot_interior_delete,
    pub preallocated: __IncompleteArrayField<snapshot_interior_delete>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of interior_delete_list",
    ][::std::mem::size_of::<interior_delete_list>() - 24usize];
    [
        "Alignment of interior_delete_list",
    ][::std::mem::align_of::<interior_delete_list>() - 8usize];
    [
        "Offset of field: interior_delete_list::nr",
    ][::std::mem::offset_of!(interior_delete_list, nr) - 0usize];
    [
        "Offset of field: interior_delete_list::size",
    ][::std::mem::offset_of!(interior_delete_list, size) - 8usize];
    [
        "Offset of field: interior_delete_list::data",
    ][::std::mem::offset_of!(interior_delete_list, data) - 16usize];
    [
        "Offset of field: interior_delete_list::preallocated",
    ][::std::mem::offset_of!(interior_delete_list, preallocated) - 24usize];
};
impl Default for interior_delete_list {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct snapshot_delete {
    pub lock: mutex,
    pub work: work_struct,
    pub thread: *mut task_struct,
    pub progress_lock: mutex,
    pub deleting_from_trees: snapshot_id_list,
    pub delete_leaves: snapshot_id_list,
    pub delete_interior: interior_delete_list,
    pub no_keys: interior_delete_list,
    pub eytzinger_delete_list: interior_delete_list,
    pub running: bool,
    pub version: ::std::os::raw::c_uint,
    pub progress: progress_indicator,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of snapshot_delete"][::std::mem::size_of::<snapshot_delete>() - 320usize];
    ["Alignment of snapshot_delete"][::std::mem::align_of::<snapshot_delete>() - 8usize];
    [
        "Offset of field: snapshot_delete::lock",
    ][::std::mem::offset_of!(snapshot_delete, lock) - 0usize];
    [
        "Offset of field: snapshot_delete::work",
    ][::std::mem::offset_of!(snapshot_delete, work) - 40usize];
    [
        "Offset of field: snapshot_delete::thread",
    ][::std::mem::offset_of!(snapshot_delete, thread) - 72usize];
    [
        "Offset of field: snapshot_delete::progress_lock",
    ][::std::mem::offset_of!(snapshot_delete, progress_lock) - 80usize];
    [
        "Offset of field: snapshot_delete::deleting_from_trees",
    ][::std::mem::offset_of!(snapshot_delete, deleting_from_trees) - 120usize];
    [
        "Offset of field: snapshot_delete::delete_leaves",
    ][::std::mem::offset_of!(snapshot_delete, delete_leaves) - 144usize];
    [
        "Offset of field: snapshot_delete::delete_interior",
    ][::std::mem::offset_of!(snapshot_delete, delete_interior) - 168usize];
    [
        "Offset of field: snapshot_delete::no_keys",
    ][::std::mem::offset_of!(snapshot_delete, no_keys) - 192usize];
    [
        "Offset of field: snapshot_delete::eytzinger_delete_list",
    ][::std::mem::offset_of!(snapshot_delete, eytzinger_delete_list) - 216usize];
    [
        "Offset of field: snapshot_delete::running",
    ][::std::mem::offset_of!(snapshot_delete, running) - 240usize];
    [
        "Offset of field: snapshot_delete::version",
    ][::std::mem::offset_of!(snapshot_delete, version) - 244usize];
    [
        "Offset of field: snapshot_delete::progress",
    ][::std::mem::offset_of!(snapshot_delete, progress) - 248usize];
};
impl Default for snapshot_delete {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bch_fs_snapshots {
    pub table: *mut snapshot_table,
    pub table_lock: mutex,
    pub create_lock: percpu_rw_semaphore,
    pub delete: snapshot_delete,
    pub wait_for_pagecache_and_delete_work: work_struct,
    pub unlinked: snapshot_id_list,
    pub unlinked_lock: mutex,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_fs_snapshots"][::std::mem::size_of::<bch_fs_snapshots>() - 504usize];
    [
        "Alignment of bch_fs_snapshots",
    ][::std::mem::align_of::<bch_fs_snapshots>() - 8usize];
    [
        "Offset of field: bch_fs_snapshots::table",
    ][::std::mem::offset_of!(bch_fs_snapshots, table) - 0usize];
    [
        "Offset of field: bch_fs_snapshots::table_lock",
    ][::std::mem::offset_of!(bch_fs_snapshots, table_lock) - 8usize];
    [
        "Offset of field: bch_fs_snapshots::create_lock",
    ][::std::mem::offset_of!(bch_fs_snapshots, create_lock) - 48usize];
    [
        "Offset of field: bch_fs_snapshots::delete",
    ][::std::mem::offset_of!(bch_fs_snapshots, delete) - 88usize];
    [
        "Offset of field: bch_fs_snapshots::wait_for_pagecache_and_delete_work",
    ][::std::mem::offset_of!(bch_fs_snapshots, wait_for_pagecache_and_delete_work)
        - 408usize];
    [
        "Offset of field: bch_fs_snapshots::unlinked",
    ][::std::mem::offset_of!(bch_fs_snapshots, unlinked) - 440usize];
    [
        "Offset of field: bch_fs_snapshots::unlinked_lock",
    ][::std::mem::offset_of!(bch_fs_snapshots, unlinked_lock) - 464usize];
};
impl Default for bch_fs_snapshots {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct subvol_inum {
    pub subvol: u64_,
    pub inum: u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of subvol_inum"][::std::mem::size_of::<subvol_inum>() - 16usize];
    ["Alignment of subvol_inum"][::std::mem::align_of::<subvol_inum>() - 8usize];
    [
        "Offset of field: subvol_inum::subvol",
    ][::std::mem::offset_of!(subvol_inum, subvol) - 0usize];
    [
        "Offset of field: subvol_inum::inum",
    ][::std::mem::offset_of!(subvol_inum, inum) - 8usize];
};
#[repr(C)]
pub struct bch_fs_vfs {
    pub inodes: fast_list,
    pub inodes_table: rhashtable,
    pub inodes_by_inum_table: rhltable,
    pub writepage_bioset: bio_set,
    pub dio_write_bioset: bio_set,
    pub dio_read_bioset: bio_set,
    pub nocow_flush_bioset: bio_set,
    pub writepage_buf_pool: mempool_t,
    pub writeback_wq: *mut workqueue_struct,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_fs_vfs"][::std::mem::size_of::<bch_fs_vfs>() - 1704usize];
    ["Alignment of bch_fs_vfs"][::std::mem::align_of::<bch_fs_vfs>() - 8usize];
    [
        "Offset of field: bch_fs_vfs::inodes",
    ][::std::mem::offset_of!(bch_fs_vfs, inodes) - 0usize];
    [
        "Offset of field: bch_fs_vfs::inodes_table",
    ][::std::mem::offset_of!(bch_fs_vfs, inodes_table) - 72usize];
    [
        "Offset of field: bch_fs_vfs::inodes_by_inum_table",
    ][::std::mem::offset_of!(bch_fs_vfs, inodes_by_inum_table) - 256usize];
    [
        "Offset of field: bch_fs_vfs::writepage_bioset",
    ][::std::mem::offset_of!(bch_fs_vfs, writepage_bioset) - 440usize];
    [
        "Offset of field: bch_fs_vfs::dio_write_bioset",
    ][::std::mem::offset_of!(bch_fs_vfs, dio_write_bioset) - 720usize];
    [
        "Offset of field: bch_fs_vfs::dio_read_bioset",
    ][::std::mem::offset_of!(bch_fs_vfs, dio_read_bioset) - 1000usize];
    [
        "Offset of field: bch_fs_vfs::nocow_flush_bioset",
    ][::std::mem::offset_of!(bch_fs_vfs, nocow_flush_bioset) - 1280usize];
    [
        "Offset of field: bch_fs_vfs::writepage_buf_pool",
    ][::std::mem::offset_of!(bch_fs_vfs, writepage_buf_pool) - 1560usize];
    [
        "Offset of field: bch_fs_vfs::writeback_wq",
    ][::std::mem::offset_of!(bch_fs_vfs, writeback_wq) - 1696usize];
};
impl Default for bch_fs_vfs {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C" {
    pub fn bch2_print_str_loglevel(
        arg1: *mut bch_fs,
        arg2: ::std::os::raw::c_int,
        arg3: *const ::std::os::raw::c_char,
    );
}
unsafe extern "C" {
    pub fn bch2_print_str(
        arg1: *mut bch_fs,
        arg2: *const ::std::os::raw::c_char,
        arg3: *const ::std::os::raw::c_char,
    );
}
unsafe extern "C" {
    pub fn bch2_print_opts(
        arg1: *mut bch_opts,
        arg2: *const ::std::os::raw::c_char,
        ...
    );
}
unsafe extern "C" {
    pub fn __bch2_print(c: *mut bch_fs, fmt: *const ::std::os::raw::c_char, ...);
}
unsafe extern "C" {
    pub static mut bch2_key_merging_disabled: static_key_false;
}
unsafe extern "C" {
    pub static mut bch2_btree_node_merging_disabled: static_key_false;
}
unsafe extern "C" {
    pub static mut bch2_btree_gc_always_rewrite: static_key_false;
}
unsafe extern "C" {
    pub static mut bch2_btree_gc_rewrite_disabled: static_key_false;
}
unsafe extern "C" {
    pub static mut bch2_btree_shrinker_disabled: static_key_false;
}
unsafe extern "C" {
    pub static mut bch2_backpointers_no_use_write_buffer: static_key_false;
}
unsafe extern "C" {
    pub static mut bch2_debug_check_btree_locking: static_key_false;
}
unsafe extern "C" {
    pub static mut bch2_debug_check_iterators: static_key_false;
}
unsafe extern "C" {
    pub static mut bch2_debug_check_bset_lookups: static_key_false;
}
unsafe extern "C" {
    pub static mut bch2_debug_check_btree_accounting: static_key_false;
}
unsafe extern "C" {
    pub static mut bch2_debug_check_bkey_unpack: static_key_false;
}
unsafe extern "C" {
    pub static mut bch2_journal_seq_verify: static_key_false;
}
unsafe extern "C" {
    pub static mut bch2_inject_invalid_keys: static_key_false;
}
unsafe extern "C" {
    pub static mut bch2_test_alloc_startup: static_key_false;
}
unsafe extern "C" {
    pub static mut bch2_force_reconstruct_read: static_key_false;
}
unsafe extern "C" {
    pub static mut bch2_test_restart_gc: static_key_false;
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_time_stats {
    BCH_TIME_btree_node_mem_alloc = 0,
    BCH_TIME_btree_node_split = 1,
    BCH_TIME_btree_node_compact = 2,
    BCH_TIME_btree_node_merge = 3,
    BCH_TIME_btree_node_sort = 4,
    BCH_TIME_btree_node_read = 5,
    BCH_TIME_btree_node_read_done = 6,
    BCH_TIME_btree_node_write = 7,
    BCH_TIME_btree_interior_update_foreground = 8,
    BCH_TIME_btree_interior_update_total = 9,
    BCH_TIME_btree_node_cache_scan = 10,
    BCH_TIME_btree_key_cache_scan = 11,
    BCH_TIME_btree_write_buffer_flush = 12,
    BCH_TIME_btree_gc = 13,
    BCH_TIME_data_write = 14,
    BCH_TIME_data_read = 15,
    BCH_TIME_data_promote = 16,
    BCH_TIME_journal_flush_write = 17,
    BCH_TIME_journal_noflush_write = 18,
    BCH_TIME_journal_flush_seq = 19,
    BCH_TIME_journal_pin_flush_btree = 20,
    BCH_TIME_journal_pin_flush_key_cache = 21,
    BCH_TIME_journal_pin_flush_other = 22,
    BCH_TIME_blocked_journal_low_on_space = 23,
    BCH_TIME_blocked_journal_low_on_pin = 24,
    BCH_TIME_blocked_journal_max_in_flight = 25,
    BCH_TIME_blocked_journal_max_open = 26,
    BCH_TIME_blocked_journal_write_buffer_flush = 27,
    BCH_TIME_blocked_key_cache_flush = 28,
    BCH_TIME_blocked_allocate = 29,
    BCH_TIME_blocked_allocate_open_bucket = 30,
    BCH_TIME_blocked_write_buffer_full = 31,
    BCH_TIME_blocked_writeback_throttle = 32,
    BCH_TIME_nocow_lock_contended = 33,
    BCH_TIME_blocked_discard_journal_flush = 34,
    BCH_TIME_STAT_NR = 35,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct io_count {
    pub sectors: [[u64_; 11usize]; 2usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of io_count"][::std::mem::size_of::<io_count>() - 176usize];
    ["Alignment of io_count"][::std::mem::align_of::<io_count>() - 8usize];
    [
        "Offset of field: io_count::sectors",
    ][::std::mem::offset_of!(io_count, sectors) - 0usize];
};
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_dev_read_ref {
    BCH_DEV_READ_REF_bch2_online_devs = 0,
    BCH_DEV_READ_REF_trans_mark_dev_sbs = 1,
    BCH_DEV_READ_REF_read_fua_test = 2,
    BCH_DEV_READ_REF_sb_field_resize = 3,
    BCH_DEV_READ_REF_write_super = 4,
    BCH_DEV_READ_REF_journal_read = 5,
    BCH_DEV_READ_REF_fs_journal_alloc = 6,
    BCH_DEV_READ_REF_fs_resize_on_mount = 7,
    BCH_DEV_READ_REF_sb_journal_sort = 8,
    BCH_DEV_READ_REF_btree_node_read = 9,
    BCH_DEV_READ_REF_btree_node_read_all_replicas = 10,
    BCH_DEV_READ_REF_btree_node_scrub = 11,
    BCH_DEV_READ_REF_btree_node_write = 12,
    BCH_DEV_READ_REF_btree_node_scan = 13,
    BCH_DEV_READ_REF_btree_verify_replicas = 14,
    BCH_DEV_READ_REF_btree_node_ondisk_to_text = 15,
    BCH_DEV_READ_REF_io_read = 16,
    BCH_DEV_READ_REF_check_extent_checksums = 17,
    BCH_DEV_READ_REF_ec_block = 18,
    BCH_DEV_READ_REF_NR = 19,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_dev_write_ref {
    BCH_DEV_WRITE_REF_journal_write = 0,
    BCH_DEV_WRITE_REF_journal_discard = 1,
    BCH_DEV_WRITE_REF_discard_bucket = 2,
    BCH_DEV_WRITE_REF_discard_one_bucket_fast = 3,
    BCH_DEV_WRITE_REF_do_invalidates = 4,
    BCH_DEV_WRITE_REF_stripe_update_extents = 5,
    BCH_DEV_WRITE_REF_nocow_flush = 6,
    BCH_DEV_WRITE_REF_io_write = 7,
    BCH_DEV_WRITE_REF_ec_block = 8,
    BCH_DEV_WRITE_REF_ec_bucket_zero = 9,
    BCH_DEV_WRITE_REF_NR = 10,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bucket_bitmap {
    pub buckets: *mut ::std::os::raw::c_ulong,
    pub nr: u64_,
    pub lock: mutex,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bucket_bitmap"][::std::mem::size_of::<bucket_bitmap>() - 56usize];
    ["Alignment of bucket_bitmap"][::std::mem::align_of::<bucket_bitmap>() - 8usize];
    [
        "Offset of field: bucket_bitmap::buckets",
    ][::std::mem::offset_of!(bucket_bitmap, buckets) - 0usize];
    [
        "Offset of field: bucket_bitmap::nr",
    ][::std::mem::offset_of!(bucket_bitmap, nr) - 8usize];
    [
        "Offset of field: bucket_bitmap::lock",
    ][::std::mem::offset_of!(bucket_bitmap, lock) - 16usize];
};
impl Default for bucket_bitmap {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[repr(align(16))]
pub struct bch_dev {
    pub kobj: kobject,
    pub ref_: percpu_ref,
    pub ref_completion: completion,
    pub io_ref: [enumerated_ref; 2usize],
    pub fs: *mut bch_fs,
    pub dev_idx: u8_,
    pub mi: bch_member_cpu,
    pub btree_allocated_bitmap_gc: u64_,
    pub errors: [atomic64_t; 3usize],
    pub write_errors_start: ::std::os::raw::c_ulong,
    pub uuid: __uuid_t,
    pub name: [::std::os::raw::c_char; 32usize],
    pub disk_sb: bch_sb_handle,
    pub sb_read_scratch: *mut bch_sb,
    pub sb_write_error: ::std::os::raw::c_int,
    pub dev: dev_t,
    pub flush_seq: atomic_t,
    pub self_: bch_devs_mask,
    pub buckets_gc: bch_dev__bindgen_ty_1,
    pub bucket_gens: *mut bucket_gens,
    pub oldest_gen: *mut u8_,
    pub buckets_nouse: *mut ::std::os::raw::c_ulong,
    pub bucket_backpointer_mismatch: bucket_bitmap,
    pub bucket_backpointer_empty: bucket_bitmap,
    pub usage: *mut bch_dev_usage_full,
    pub alloc_cursor: [u64_; 3usize],
    pub alloc_wake_counter: atomic_t,
    pub nr_open_buckets: ::std::os::raw::c_uint,
    pub nr_partial_buckets: ::std::os::raw::c_uint,
    pub nr_btree_reserve: ::std::os::raw::c_uint,
    pub invalidate_work: work_struct,
    pub discard_fast_work: work_struct,
    pub discard_fast: darray_u64,
    pub discard_fast_lock: mutex,
    pub rebalance_work: atomic64_t,
    pub journal: journal_device,
    pub prev_journal_sector: u64_,
    pub io_error_work: work_struct,
    pub cur_latency: [atomic64_t; 2usize],
    pub io_latency: [bch2_time_stats_quantiles; 2usize],
    pub congested: atomic_t,
    pub congested_last: u64_,
    pub io_done: *mut io_count,
}
#[repr(C)]
#[derive(Debug)]
pub struct bch_dev__bindgen_ty_1 {
    pub tree: __genradix,
    pub type_: __IncompleteArrayField<bucket>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_dev__bindgen_ty_1",
    ][::std::mem::size_of::<bch_dev__bindgen_ty_1>() - 8usize];
    [
        "Alignment of bch_dev__bindgen_ty_1",
    ][::std::mem::align_of::<bch_dev__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bch_dev__bindgen_ty_1::tree",
    ][::std::mem::offset_of!(bch_dev__bindgen_ty_1, tree) - 0usize];
    [
        "Offset of field: bch_dev__bindgen_ty_1::type_",
    ][::std::mem::offset_of!(bch_dev__bindgen_ty_1, type_) - 8usize];
};
impl Default for bch_dev__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_dev"][::std::mem::size_of::<bch_dev>() - 2432usize];
    ["Alignment of bch_dev"][::std::mem::align_of::<bch_dev>() - 16usize];
    ["Offset of field: bch_dev::kobj"][::std::mem::offset_of!(bch_dev, kobj) - 0usize];
    ["Offset of field: bch_dev::ref_"][::std::mem::offset_of!(bch_dev, ref_) - 104usize];
    [
        "Offset of field: bch_dev::ref_completion",
    ][::std::mem::offset_of!(bch_dev, ref_completion) - 128usize];
    [
        "Offset of field: bch_dev::io_ref",
    ][::std::mem::offset_of!(bch_dev, io_ref) - 192usize];
    ["Offset of field: bch_dev::fs"][::std::mem::offset_of!(bch_dev, fs) - 384usize];
    [
        "Offset of field: bch_dev::dev_idx",
    ][::std::mem::offset_of!(bch_dev, dev_idx) - 392usize];
    ["Offset of field: bch_dev::mi"][::std::mem::offset_of!(bch_dev, mi) - 400usize];
    [
        "Offset of field: bch_dev::btree_allocated_bitmap_gc",
    ][::std::mem::offset_of!(bch_dev, btree_allocated_bitmap_gc) - 440usize];
    [
        "Offset of field: bch_dev::errors",
    ][::std::mem::offset_of!(bch_dev, errors) - 448usize];
    [
        "Offset of field: bch_dev::write_errors_start",
    ][::std::mem::offset_of!(bch_dev, write_errors_start) - 472usize];
    ["Offset of field: bch_dev::uuid"][::std::mem::offset_of!(bch_dev, uuid) - 480usize];
    ["Offset of field: bch_dev::name"][::std::mem::offset_of!(bch_dev, name) - 496usize];
    [
        "Offset of field: bch_dev::disk_sb",
    ][::std::mem::offset_of!(bch_dev, disk_sb) - 528usize];
    [
        "Offset of field: bch_dev::sb_read_scratch",
    ][::std::mem::offset_of!(bch_dev, sb_read_scratch) - 600usize];
    [
        "Offset of field: bch_dev::sb_write_error",
    ][::std::mem::offset_of!(bch_dev, sb_write_error) - 608usize];
    ["Offset of field: bch_dev::dev"][::std::mem::offset_of!(bch_dev, dev) - 616usize];
    [
        "Offset of field: bch_dev::flush_seq",
    ][::std::mem::offset_of!(bch_dev, flush_seq) - 624usize];
    [
        "Offset of field: bch_dev::self_",
    ][::std::mem::offset_of!(bch_dev, self_) - 632usize];
    [
        "Offset of field: bch_dev::buckets_gc",
    ][::std::mem::offset_of!(bch_dev, buckets_gc) - 640usize];
    [
        "Offset of field: bch_dev::bucket_gens",
    ][::std::mem::offset_of!(bch_dev, bucket_gens) - 648usize];
    [
        "Offset of field: bch_dev::oldest_gen",
    ][::std::mem::offset_of!(bch_dev, oldest_gen) - 656usize];
    [
        "Offset of field: bch_dev::buckets_nouse",
    ][::std::mem::offset_of!(bch_dev, buckets_nouse) - 664usize];
    [
        "Offset of field: bch_dev::bucket_backpointer_mismatch",
    ][::std::mem::offset_of!(bch_dev, bucket_backpointer_mismatch) - 672usize];
    [
        "Offset of field: bch_dev::bucket_backpointer_empty",
    ][::std::mem::offset_of!(bch_dev, bucket_backpointer_empty) - 728usize];
    [
        "Offset of field: bch_dev::usage",
    ][::std::mem::offset_of!(bch_dev, usage) - 784usize];
    [
        "Offset of field: bch_dev::alloc_cursor",
    ][::std::mem::offset_of!(bch_dev, alloc_cursor) - 792usize];
    [
        "Offset of field: bch_dev::alloc_wake_counter",
    ][::std::mem::offset_of!(bch_dev, alloc_wake_counter) - 816usize];
    [
        "Offset of field: bch_dev::nr_open_buckets",
    ][::std::mem::offset_of!(bch_dev, nr_open_buckets) - 820usize];
    [
        "Offset of field: bch_dev::nr_partial_buckets",
    ][::std::mem::offset_of!(bch_dev, nr_partial_buckets) - 824usize];
    [
        "Offset of field: bch_dev::nr_btree_reserve",
    ][::std::mem::offset_of!(bch_dev, nr_btree_reserve) - 828usize];
    [
        "Offset of field: bch_dev::invalidate_work",
    ][::std::mem::offset_of!(bch_dev, invalidate_work) - 832usize];
    [
        "Offset of field: bch_dev::discard_fast_work",
    ][::std::mem::offset_of!(bch_dev, discard_fast_work) - 864usize];
    [
        "Offset of field: bch_dev::discard_fast",
    ][::std::mem::offset_of!(bch_dev, discard_fast) - 896usize];
    [
        "Offset of field: bch_dev::discard_fast_lock",
    ][::std::mem::offset_of!(bch_dev, discard_fast_lock) - 920usize];
    [
        "Offset of field: bch_dev::rebalance_work",
    ][::std::mem::offset_of!(bch_dev, rebalance_work) - 960usize];
    [
        "Offset of field: bch_dev::journal",
    ][::std::mem::offset_of!(bch_dev, journal) - 968usize];
    [
        "Offset of field: bch_dev::prev_journal_sector",
    ][::std::mem::offset_of!(bch_dev, prev_journal_sector) - 1416usize];
    [
        "Offset of field: bch_dev::io_error_work",
    ][::std::mem::offset_of!(bch_dev, io_error_work) - 1424usize];
    [
        "Offset of field: bch_dev::cur_latency",
    ][::std::mem::offset_of!(bch_dev, cur_latency) - 1456usize];
    [
        "Offset of field: bch_dev::io_latency",
    ][::std::mem::offset_of!(bch_dev, io_latency) - 1472usize];
    [
        "Offset of field: bch_dev::congested",
    ][::std::mem::offset_of!(bch_dev, congested) - 2400usize];
    [
        "Offset of field: bch_dev::congested_last",
    ][::std::mem::offset_of!(bch_dev, congested_last) - 2408usize];
    [
        "Offset of field: bch_dev::io_done",
    ][::std::mem::offset_of!(bch_dev, io_done) - 2416usize];
};
impl Default for bch_dev {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_fs_flags {
    BCH_FS_new_fs = 0,
    BCH_FS_started = 1,
    BCH_FS_clean_recovery = 2,
    BCH_FS_btree_running = 3,
    BCH_FS_accounting_replay_done = 4,
    BCH_FS_may_go_rw = 5,
    BCH_FS_scrub_journal = 6,
    BCH_FS_may_upgrade_downgrade = 7,
    BCH_FS_rw = 8,
    BCH_FS_rw_init_done = 9,
    BCH_FS_was_rw = 10,
    BCH_FS_stopping = 11,
    BCH_FS_emergency_ro = 12,
    BCH_FS_going_ro = 13,
    BCH_FS_write_disable_complete = 14,
    BCH_FS_clean_shutdown = 15,
    BCH_FS_in_recovery = 16,
    BCH_FS_in_fsck = 17,
    BCH_FS_initial_gc_unfixed = 18,
    BCH_FS_need_delete_dead_snapshots = 19,
    BCH_FS_error = 20,
    BCH_FS_topology_error = 21,
    BCH_FS_errors_fixed = 22,
    BCH_FS_errors_fixed_silent = 23,
    BCH_FS_errors_not_fixed = 24,
    BCH_FS_no_invalid_checks = 25,
    BCH_FS_discard_mount_opt_set = 26,
    BCH_FS_sb_dirty = 27,
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct journal_seq_blacklist_table {
    pub nr: usize,
    pub entries: __IncompleteArrayField<
        journal_seq_blacklist_table_journal_seq_blacklist_table_entry,
    >,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct journal_seq_blacklist_table_journal_seq_blacklist_table_entry {
    pub start: u64_,
    pub end: u64_,
    pub dirty: bool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of journal_seq_blacklist_table_journal_seq_blacklist_table_entry",
    ][::std::mem::size_of::<
        journal_seq_blacklist_table_journal_seq_blacklist_table_entry,
    >() - 24usize];
    [
        "Alignment of journal_seq_blacklist_table_journal_seq_blacklist_table_entry",
    ][::std::mem::align_of::<
        journal_seq_blacklist_table_journal_seq_blacklist_table_entry,
    >() - 8usize];
    [
        "Offset of field: journal_seq_blacklist_table_journal_seq_blacklist_table_entry::start",
    ][::std::mem::offset_of!(
        journal_seq_blacklist_table_journal_seq_blacklist_table_entry, start
    ) - 0usize];
    [
        "Offset of field: journal_seq_blacklist_table_journal_seq_blacklist_table_entry::end",
    ][::std::mem::offset_of!(
        journal_seq_blacklist_table_journal_seq_blacklist_table_entry, end
    ) - 8usize];
    [
        "Offset of field: journal_seq_blacklist_table_journal_seq_blacklist_table_entry::dirty",
    ][::std::mem::offset_of!(
        journal_seq_blacklist_table_journal_seq_blacklist_table_entry, dirty
    ) - 16usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of journal_seq_blacklist_table",
    ][::std::mem::size_of::<journal_seq_blacklist_table>() - 8usize];
    [
        "Alignment of journal_seq_blacklist_table",
    ][::std::mem::align_of::<journal_seq_blacklist_table>() - 8usize];
    [
        "Offset of field: journal_seq_blacklist_table::nr",
    ][::std::mem::offset_of!(journal_seq_blacklist_table, nr) - 0usize];
    [
        "Offset of field: journal_seq_blacklist_table::entries",
    ][::std::mem::offset_of!(journal_seq_blacklist_table, entries) - 8usize];
};
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_write_ref {
    BCH_WRITE_REF_journal = 0,
    BCH_WRITE_REF_trans = 1,
    BCH_WRITE_REF_write = 2,
    BCH_WRITE_REF_promote = 3,
    BCH_WRITE_REF_node_rewrite = 4,
    BCH_WRITE_REF_stripe_create = 5,
    BCH_WRITE_REF_stripe_delete = 6,
    BCH_WRITE_REF_reflink = 7,
    BCH_WRITE_REF_fallocate = 8,
    BCH_WRITE_REF_fsync = 9,
    BCH_WRITE_REF_dio_write = 10,
    BCH_WRITE_REF_discard = 11,
    BCH_WRITE_REF_discard_fast = 12,
    BCH_WRITE_REF_check_discard_freespace_key = 13,
    BCH_WRITE_REF_invalidate = 14,
    BCH_WRITE_REF_delete_dead_snapshots = 15,
    BCH_WRITE_REF_gc_gens = 16,
    BCH_WRITE_REF_snapshot_delete_pagecache = 17,
    BCH_WRITE_REF_sysfs = 18,
    BCH_WRITE_REF_btree_write_buffer = 19,
    BCH_WRITE_REF_btree_node_scrub = 20,
    BCH_WRITE_REF_async_recovery_passes = 21,
    BCH_WRITE_REF_ioctl_data = 22,
    BCH_WRITE_REF_NR = 23,
}
#[repr(C)]
#[repr(align(64))]
pub struct bch_fs {
    pub cl: closure,
    pub list: cds_list_head,
    pub kobj: kobject,
    pub counters_kobj: kobject,
    pub internal: kobject,
    pub opts_dir: kobject,
    pub time_stats: kobject,
    pub time_stats_json: kobject,
    pub flags: ::std::os::raw::c_ulong,
    pub minor: ::std::os::raw::c_int,
    pub chardev: *mut device,
    pub vfs_sb: *mut super_block,
    pub dev: dev_t,
    pub name: [::std::os::raw::c_char; 40usize],
    pub stdio: *mut stdio_redirect,
    pub stdio_filter: *mut task_struct,
    pub loglevel: ::std::os::raw::c_uint,
    pub prev_loglevel: ::std::os::raw::c_uint,
    pub recovery_task: *mut task_struct,
    pub state_lock: rw_semaphore,
    pub writes: enumerated_ref,
    pub ro_ref: refcount_t,
    pub ro_ref_wait: wait_queue_head_t,
    pub read_only_work: work_struct,
    pub devs: [*mut bch_dev; 64usize],
    pub devs_online: bch_devs_mask,
    pub devs_removed: bch_devs_mask,
    pub devs_rotational: bch_devs_mask,
    pub opts: bch_opts,
    pub opt_change_lock: mutex,
    pub opt_change_cookie: u32_,
    pub mount_opts: bch_opts_mask,
    pub sb: bch_sb_cpu,
    pub disk_sb: bch_sb_handle,
    pub sb_write: closure,
    pub sb_lock: mutex,
    pub incompat_versions_requested: [::std::os::raw::c_ulong; 1usize],
    pub cf_encoding: *mut unicode_map,
    pub block_bits: ::std::os::raw::c_ushort,
    pub maybe_schedule_btree_bitmap_gc: delayed_work,
    pub counters: bch_fs_counters,
    pub times: [bch2_time_stats; 35usize],
    pub errors: bch_fs_errors,
    pub __bindgen_padding_0: [u64; 4usize],
    pub journal: journal,
    pub journal_replay_seq_start: u64_,
    pub journal_replay_seq_end: u64_,
    pub journal_entries: bch_fs__bindgen_ty_1,
    pub journal_entries_base_seq: u64_,
    pub journal_keys: journal_keys,
    pub journal_iters: cds_list_head,
    pub journal_seq_blacklist_table: *mut journal_seq_blacklist_table,
    pub recovery: bch_fs_recovery,
    pub btree: bch_fs_btree,
    pub gc: bch_fs_gc,
    pub gc_gens: bch_fs_gc_gens,
    pub accounting: bch_accounting_mem,
    pub replicas: bch_replicas_cpu,
    pub disk_groups: *mut bch_disk_groups_cpu,
    pub capacity: bch_fs_capacity,
    pub __bindgen_padding_1: [u64; 5usize],
    pub allocator: bch_fs_allocator,
    pub discards: bch_fs_discards,
    pub snapshots: bch_fs_snapshots,
    pub write_error_lock: spinlock_t,
    pub write_ref_wq: *mut workqueue_struct,
    pub promote_wq: *mut workqueue_struct,
    pub promote_limit: *mut semaphore,
    pub io_clock: [io_clock; 2usize],
    pub clock_journal_res: journal_entry_res,
    pub rewind_limit_res: journal_entry_res,
    pub btree_update_wq: *mut workqueue_struct,
    pub bio_read: bio_set,
    pub bio_read_split: bio_set,
    pub bio_write: bio_set,
    pub replica_set: bio_set,
    pub bio_bounce_pages_lock: mutex,
    pub bio_bounce_bufs: mempool_t,
    pub __bindgen_padding_2: [u64; 7usize],
    pub nocow_locks: bucket_nocow_lock_table,
    pub update_table: rhltable,
    pub chacha20_key: bch_key,
    pub chacha20_key_set: bool,
    pub key_version: atomic64_t,
    pub moving_context_list: cds_list_head,
    pub moving_context_lock: mutex,
    pub scrub_journal_repairs: darray_scrub_journal_repair,
    pub scrub_journal_repairs_lock: mutex,
    pub compress: bch_fs_compress,
    pub reconcile: bch_fs_reconcile,
    pub __bindgen_padding_3: [u64; 5usize],
    pub copygc: bch_fs_copygc,
    pub ec: bch_fs_ec,
    pub reflink_gc_table: reflink_gc_table,
    pub reflink_gc_nr: usize,
    pub quotas: [bch_memquota_type; 3usize],
}
#[repr(C)]
#[derive(Debug)]
pub struct bch_fs__bindgen_ty_1 {
    pub tree: __genradix,
    pub type_: __IncompleteArrayField<*mut journal_replay>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_fs__bindgen_ty_1",
    ][::std::mem::size_of::<bch_fs__bindgen_ty_1>() - 8usize];
    [
        "Alignment of bch_fs__bindgen_ty_1",
    ][::std::mem::align_of::<bch_fs__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bch_fs__bindgen_ty_1::tree",
    ][::std::mem::offset_of!(bch_fs__bindgen_ty_1, tree) - 0usize];
    [
        "Offset of field: bch_fs__bindgen_ty_1::type_",
    ][::std::mem::offset_of!(bch_fs__bindgen_ty_1, type_) - 8usize];
};
impl Default for bch_fs__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_fs"][::std::mem::size_of::<bch_fs>() - 634240usize];
    ["Alignment of bch_fs"][::std::mem::align_of::<bch_fs>() - 64usize];
    ["Offset of field: bch_fs::cl"][::std::mem::offset_of!(bch_fs, cl) - 0usize];
    ["Offset of field: bch_fs::list"][::std::mem::offset_of!(bch_fs, list) - 48usize];
    ["Offset of field: bch_fs::kobj"][::std::mem::offset_of!(bch_fs, kobj) - 64usize];
    [
        "Offset of field: bch_fs::counters_kobj",
    ][::std::mem::offset_of!(bch_fs, counters_kobj) - 168usize];
    [
        "Offset of field: bch_fs::internal",
    ][::std::mem::offset_of!(bch_fs, internal) - 272usize];
    [
        "Offset of field: bch_fs::opts_dir",
    ][::std::mem::offset_of!(bch_fs, opts_dir) - 376usize];
    [
        "Offset of field: bch_fs::time_stats",
    ][::std::mem::offset_of!(bch_fs, time_stats) - 480usize];
    [
        "Offset of field: bch_fs::time_stats_json",
    ][::std::mem::offset_of!(bch_fs, time_stats_json) - 584usize];
    ["Offset of field: bch_fs::flags"][::std::mem::offset_of!(bch_fs, flags) - 688usize];
    ["Offset of field: bch_fs::minor"][::std::mem::offset_of!(bch_fs, minor) - 696usize];
    [
        "Offset of field: bch_fs::chardev",
    ][::std::mem::offset_of!(bch_fs, chardev) - 704usize];
    [
        "Offset of field: bch_fs::vfs_sb",
    ][::std::mem::offset_of!(bch_fs, vfs_sb) - 712usize];
    ["Offset of field: bch_fs::dev"][::std::mem::offset_of!(bch_fs, dev) - 720usize];
    ["Offset of field: bch_fs::name"][::std::mem::offset_of!(bch_fs, name) - 728usize];
    ["Offset of field: bch_fs::stdio"][::std::mem::offset_of!(bch_fs, stdio) - 768usize];
    [
        "Offset of field: bch_fs::stdio_filter",
    ][::std::mem::offset_of!(bch_fs, stdio_filter) - 776usize];
    [
        "Offset of field: bch_fs::loglevel",
    ][::std::mem::offset_of!(bch_fs, loglevel) - 784usize];
    [
        "Offset of field: bch_fs::prev_loglevel",
    ][::std::mem::offset_of!(bch_fs, prev_loglevel) - 788usize];
    [
        "Offset of field: bch_fs::recovery_task",
    ][::std::mem::offset_of!(bch_fs, recovery_task) - 792usize];
    [
        "Offset of field: bch_fs::state_lock",
    ][::std::mem::offset_of!(bch_fs, state_lock) - 800usize];
    [
        "Offset of field: bch_fs::writes",
    ][::std::mem::offset_of!(bch_fs, writes) - 856usize];
    [
        "Offset of field: bch_fs::ro_ref",
    ][::std::mem::offset_of!(bch_fs, ro_ref) - 952usize];
    [
        "Offset of field: bch_fs::ro_ref_wait",
    ][::std::mem::offset_of!(bch_fs, ro_ref_wait) - 960usize];
    [
        "Offset of field: bch_fs::read_only_work",
    ][::std::mem::offset_of!(bch_fs, read_only_work) - 1016usize];
    ["Offset of field: bch_fs::devs"][::std::mem::offset_of!(bch_fs, devs) - 1048usize];
    [
        "Offset of field: bch_fs::devs_online",
    ][::std::mem::offset_of!(bch_fs, devs_online) - 1560usize];
    [
        "Offset of field: bch_fs::devs_removed",
    ][::std::mem::offset_of!(bch_fs, devs_removed) - 1568usize];
    [
        "Offset of field: bch_fs::devs_rotational",
    ][::std::mem::offset_of!(bch_fs, devs_rotational) - 1576usize];
    ["Offset of field: bch_fs::opts"][::std::mem::offset_of!(bch_fs, opts) - 1584usize];
    [
        "Offset of field: bch_fs::opt_change_lock",
    ][::std::mem::offset_of!(bch_fs, opt_change_lock) - 1816usize];
    [
        "Offset of field: bch_fs::opt_change_cookie",
    ][::std::mem::offset_of!(bch_fs, opt_change_cookie) - 1856usize];
    [
        "Offset of field: bch_fs::mount_opts",
    ][::std::mem::offset_of!(bch_fs, mount_opts) - 1864usize];
    ["Offset of field: bch_fs::sb"][::std::mem::offset_of!(bch_fs, sb) - 1880usize];
    [
        "Offset of field: bch_fs::disk_sb",
    ][::std::mem::offset_of!(bch_fs, disk_sb) - 2064usize];
    [
        "Offset of field: bch_fs::sb_write",
    ][::std::mem::offset_of!(bch_fs, sb_write) - 2136usize];
    [
        "Offset of field: bch_fs::sb_lock",
    ][::std::mem::offset_of!(bch_fs, sb_lock) - 2184usize];
    [
        "Offset of field: bch_fs::incompat_versions_requested",
    ][::std::mem::offset_of!(bch_fs, incompat_versions_requested) - 2224usize];
    [
        "Offset of field: bch_fs::cf_encoding",
    ][::std::mem::offset_of!(bch_fs, cf_encoding) - 2232usize];
    [
        "Offset of field: bch_fs::block_bits",
    ][::std::mem::offset_of!(bch_fs, block_bits) - 2240usize];
    [
        "Offset of field: bch_fs::maybe_schedule_btree_bitmap_gc",
    ][::std::mem::offset_of!(bch_fs, maybe_schedule_btree_bitmap_gc) - 2248usize];
    [
        "Offset of field: bch_fs::counters",
    ][::std::mem::offset_of!(bch_fs, counters) - 2312usize];
    [
        "Offset of field: bch_fs::times",
    ][::std::mem::offset_of!(bch_fs, times) - 24896usize];
    [
        "Offset of field: bch_fs::errors",
    ][::std::mem::offset_of!(bch_fs, errors) - 32736usize];
    [
        "Offset of field: bch_fs::journal",
    ][::std::mem::offset_of!(bch_fs, journal) - 32896usize];
    [
        "Offset of field: bch_fs::journal_replay_seq_start",
    ][::std::mem::offset_of!(bch_fs, journal_replay_seq_start) - 34880usize];
    [
        "Offset of field: bch_fs::journal_replay_seq_end",
    ][::std::mem::offset_of!(bch_fs, journal_replay_seq_end) - 34888usize];
    [
        "Offset of field: bch_fs::journal_entries",
    ][::std::mem::offset_of!(bch_fs, journal_entries) - 34896usize];
    [
        "Offset of field: bch_fs::journal_entries_base_seq",
    ][::std::mem::offset_of!(bch_fs, journal_entries_base_seq) - 34904usize];
    [
        "Offset of field: bch_fs::journal_keys",
    ][::std::mem::offset_of!(bch_fs, journal_keys) - 34912usize];
    [
        "Offset of field: bch_fs::journal_iters",
    ][::std::mem::offset_of!(bch_fs, journal_iters) - 35040usize];
    [
        "Offset of field: bch_fs::journal_seq_blacklist_table",
    ][::std::mem::offset_of!(bch_fs, journal_seq_blacklist_table) - 35056usize];
    [
        "Offset of field: bch_fs::recovery",
    ][::std::mem::offset_of!(bch_fs, recovery) - 35064usize];
    [
        "Offset of field: bch_fs::btree",
    ][::std::mem::offset_of!(bch_fs, btree) - 35232usize];
    ["Offset of field: bch_fs::gc"][::std::mem::offset_of!(bch_fs, gc) - 153056usize];
    [
        "Offset of field: bch_fs::gc_gens",
    ][::std::mem::offset_of!(bch_fs, gc_gens) - 153144usize];
    [
        "Offset of field: bch_fs::accounting",
    ][::std::mem::offset_of!(bch_fs, accounting) - 153240usize];
    [
        "Offset of field: bch_fs::replicas",
    ][::std::mem::offset_of!(bch_fs, replicas) - 153272usize];
    [
        "Offset of field: bch_fs::disk_groups",
    ][::std::mem::offset_of!(bch_fs, disk_groups) - 153288usize];
    [
        "Offset of field: bch_fs::capacity",
    ][::std::mem::offset_of!(bch_fs, capacity) - 153296usize];
    [
        "Offset of field: bch_fs::allocator",
    ][::std::mem::offset_of!(bch_fs, allocator) - 153472usize];
    [
        "Offset of field: bch_fs::discards",
    ][::std::mem::offset_of!(bch_fs, discards) - 495744usize];
    [
        "Offset of field: bch_fs::snapshots",
    ][::std::mem::offset_of!(bch_fs, snapshots) - 496384usize];
    [
        "Offset of field: bch_fs::write_error_lock",
    ][::std::mem::offset_of!(bch_fs, write_error_lock) - 496888usize];
    [
        "Offset of field: bch_fs::write_ref_wq",
    ][::std::mem::offset_of!(bch_fs, write_ref_wq) - 496928usize];
    [
        "Offset of field: bch_fs::promote_wq",
    ][::std::mem::offset_of!(bch_fs, promote_wq) - 496936usize];
    [
        "Offset of field: bch_fs::promote_limit",
    ][::std::mem::offset_of!(bch_fs, promote_limit) - 496944usize];
    [
        "Offset of field: bch_fs::io_clock",
    ][::std::mem::offset_of!(bch_fs, io_clock) - 496952usize];
    [
        "Offset of field: bch_fs::clock_journal_res",
    ][::std::mem::offset_of!(bch_fs, clock_journal_res) - 497128usize];
    [
        "Offset of field: bch_fs::rewind_limit_res",
    ][::std::mem::offset_of!(bch_fs, rewind_limit_res) - 497132usize];
    [
        "Offset of field: bch_fs::btree_update_wq",
    ][::std::mem::offset_of!(bch_fs, btree_update_wq) - 497136usize];
    [
        "Offset of field: bch_fs::bio_read",
    ][::std::mem::offset_of!(bch_fs, bio_read) - 497144usize];
    [
        "Offset of field: bch_fs::bio_read_split",
    ][::std::mem::offset_of!(bch_fs, bio_read_split) - 497424usize];
    [
        "Offset of field: bch_fs::bio_write",
    ][::std::mem::offset_of!(bch_fs, bio_write) - 497704usize];
    [
        "Offset of field: bch_fs::replica_set",
    ][::std::mem::offset_of!(bch_fs, replica_set) - 497984usize];
    [
        "Offset of field: bch_fs::bio_bounce_pages_lock",
    ][::std::mem::offset_of!(bch_fs, bio_bounce_pages_lock) - 498264usize];
    [
        "Offset of field: bch_fs::bio_bounce_bufs",
    ][::std::mem::offset_of!(bch_fs, bio_bounce_bufs) - 498304usize];
    [
        "Offset of field: bch_fs::nocow_locks",
    ][::std::mem::offset_of!(bch_fs, nocow_locks) - 498496usize];
    [
        "Offset of field: bch_fs::update_table",
    ][::std::mem::offset_of!(bch_fs, update_table) - 629568usize];
    [
        "Offset of field: bch_fs::chacha20_key",
    ][::std::mem::offset_of!(bch_fs, chacha20_key) - 629752usize];
    [
        "Offset of field: bch_fs::chacha20_key_set",
    ][::std::mem::offset_of!(bch_fs, chacha20_key_set) - 629784usize];
    [
        "Offset of field: bch_fs::key_version",
    ][::std::mem::offset_of!(bch_fs, key_version) - 629792usize];
    [
        "Offset of field: bch_fs::moving_context_list",
    ][::std::mem::offset_of!(bch_fs, moving_context_list) - 629800usize];
    [
        "Offset of field: bch_fs::moving_context_lock",
    ][::std::mem::offset_of!(bch_fs, moving_context_lock) - 629816usize];
    [
        "Offset of field: bch_fs::scrub_journal_repairs",
    ][::std::mem::offset_of!(bch_fs, scrub_journal_repairs) - 629856usize];
    [
        "Offset of field: bch_fs::scrub_journal_repairs_lock",
    ][::std::mem::offset_of!(bch_fs, scrub_journal_repairs_lock) - 629880usize];
    [
        "Offset of field: bch_fs::compress",
    ][::std::mem::offset_of!(bch_fs, compress) - 629920usize];
    [
        "Offset of field: bch_fs::reconcile",
    ][::std::mem::offset_of!(bch_fs, reconcile) - 630744usize];
    [
        "Offset of field: bch_fs::copygc",
    ][::std::mem::offset_of!(bch_fs, copygc) - 631488usize];
    ["Offset of field: bch_fs::ec"][::std::mem::offset_of!(bch_fs, ec) - 632576usize];
    [
        "Offset of field: bch_fs::reflink_gc_table",
    ][::std::mem::offset_of!(bch_fs, reflink_gc_table) - 634008usize];
    [
        "Offset of field: bch_fs::reflink_gc_nr",
    ][::std::mem::offset_of!(bch_fs, reflink_gc_nr) - 634016usize];
    [
        "Offset of field: bch_fs::quotas",
    ][::std::mem::offset_of!(bch_fs, quotas) - 634024usize];
};
impl Default for bch_fs {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C" {
    #[link_name = "__bch2_err_throw__extern"]
    pub fn __bch2_err_throw(
        c: *mut bch_fs,
        err: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_ro_ref_tryget__extern"]
    pub fn bch2_ro_ref_tryget(c: *mut bch_fs) -> bool;
}
unsafe extern "C" {
    #[link_name = "bch2_ro_ref_put__extern"]
    pub fn bch2_ro_ref_put(c: *mut bch_fs);
}
unsafe extern "C" {
    #[link_name = "bch2_time_to_timespec__extern"]
    pub fn bch2_time_to_timespec(c: *const bch_fs, time: s64) -> timespec;
}
unsafe extern "C" {
    #[link_name = "timespec_to_bch2_time__extern"]
    pub fn timespec_to_bch2_time(c: *const bch_fs, ts: timespec) -> s64;
}
unsafe extern "C" {
    #[link_name = "bch2_current_time__extern"]
    pub fn bch2_current_time(c: *const bch_fs) -> s64;
}
unsafe extern "C" {
    #[link_name = "bch2_current_io_time__extern"]
    pub fn bch2_current_io_time(c: *const bch_fs, rw: ::std::os::raw::c_int) -> u64_;
}
unsafe extern "C" {
    #[link_name = "bch2_set_ra_pages__extern"]
    pub fn bch2_set_ra_pages(c: *mut bch_fs, ra_pages: ::std::os::raw::c_uint);
}
unsafe extern "C" {
    #[link_name = "bch2_fs_stdio_redirect__extern"]
    pub fn bch2_fs_stdio_redirect(c: *mut bch_fs) -> *mut stdio_redirect;
}
unsafe extern "C" {
    #[link_name = "bch2_discard_opt_enabled__extern"]
    pub fn bch2_discard_opt_enabled(c: *mut bch_fs, ca: *mut bch_dev) -> bool;
}
unsafe extern "C" {
    #[link_name = "bch2_fs_casefold_enabled__extern"]
    pub fn bch2_fs_casefold_enabled(c: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_fs_name__extern"]
    pub fn bch2_fs_name(c: *const bch_fs) -> *const ::std::os::raw::c_char;
}
unsafe extern "C" {
    #[link_name = "bch2_dev_name__extern"]
    pub fn bch2_dev_name(ca: *const bch_dev) -> *const ::std::os::raw::c_char;
}
unsafe extern "C" {
    #[link_name = "bch2_dev_rotational__extern"]
    pub fn bch2_dev_rotational(c: *mut bch_fs, dev: ::std::os::raw::c_uint) -> bool;
}
unsafe extern "C" {
    pub fn __bch2_log_msg_start(
        arg1: *const ::std::os::raw::c_char,
        arg2: *mut printbuf,
    );
}
unsafe extern "C" {
    #[link_name = "bch2_log_msg_start__extern"]
    pub fn bch2_log_msg_start(c: *mut bch_fs, out: *mut printbuf);
}
#[repr(C)]
#[derive(Debug)]
pub struct bch_log_msg {
    pub c: *mut bch_fs,
    pub loglevel: u8_,
    pub m: printbuf,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_log_msg"][::std::mem::size_of::<bch_log_msg>() - 56usize];
    ["Alignment of bch_log_msg"][::std::mem::align_of::<bch_log_msg>() - 8usize];
    ["Offset of field: bch_log_msg::c"][::std::mem::offset_of!(bch_log_msg, c) - 0usize];
    [
        "Offset of field: bch_log_msg::loglevel",
    ][::std::mem::offset_of!(bch_log_msg, loglevel) - 8usize];
    [
        "Offset of field: bch_log_msg::m",
    ][::std::mem::offset_of!(bch_log_msg, m) - 16usize];
};
impl Default for bch_log_msg {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C" {
    #[link_name = "bch2_log_msg_exit__extern"]
    pub fn bch2_log_msg_exit(msg: *mut bch_log_msg);
}
unsafe extern "C" {
    #[link_name = "bch2_log_msg_init__extern"]
    pub fn bch2_log_msg_init(
        c: *mut bch_fs,
        loglevel: ::std::os::raw::c_uint,
        suppress: bool,
        atomic: bool,
    ) -> bch_log_msg;
}
unsafe extern "C" {
    pub fn bch2_bkey_packed_to_binary_text(
        arg1: *mut printbuf,
        arg2: *const bkey_format,
        arg3: *const bkey_packed,
    );
}
unsafe extern "C" {
    pub fn bch2_bkey_greatest_differing_bit(
        arg1: *const btree,
        arg2: *const bkey_packed,
        arg3: *const bkey_packed,
    ) -> ::std::os::raw::c_uint;
}
unsafe extern "C" {
    pub fn bch2_bkey_ffs(
        arg1: *const btree,
        arg2: *const bkey_packed,
    ) -> ::std::os::raw::c_uint;
}
unsafe extern "C" {
    pub fn __bch2_bkey_cmp_packed_format_checked(
        arg1: *const bkey_packed,
        arg2: *const bkey_packed,
        arg3: *const btree,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn __bch2_bkey_cmp_left_packed_format_checked(
        arg1: *const btree,
        arg2: *const bkey_packed,
        arg3: *const bpos,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_bkey_cmp_packed(
        arg1: *const btree,
        arg2: *const bkey_packed,
        arg3: *const bkey_packed,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn __bch2_bkey_cmp_left_packed(
        arg1: *const btree,
        arg2: *const bkey_packed,
        arg3: *const bpos,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bpos_eq__extern"]
    pub fn bpos_eq(l: bpos, r: bpos) -> bool;
}
unsafe extern "C" {
    #[link_name = "bpos_lt__extern"]
    pub fn bpos_lt(l: bpos, r: bpos) -> bool;
}
unsafe extern "C" {
    #[link_name = "bpos_le__extern"]
    pub fn bpos_le(l: bpos, r: bpos) -> bool;
}
unsafe extern "C" {
    #[link_name = "bpos_gt__extern"]
    pub fn bpos_gt(l: bpos, r: bpos) -> bool;
}
unsafe extern "C" {
    #[link_name = "bpos_ge__extern"]
    pub fn bpos_ge(l: bpos, r: bpos) -> bool;
}
unsafe extern "C" {
    #[link_name = "bpos_cmp__extern"]
    pub fn bpos_cmp(l: bpos, r: bpos) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bpos_min__extern"]
    pub fn bpos_min(l: bpos, r: bpos) -> bpos;
}
unsafe extern "C" {
    #[link_name = "bpos_max__extern"]
    pub fn bpos_max(l: bpos, r: bpos) -> bpos;
}
unsafe extern "C" {
    pub fn bch2_bpos_swab(arg1: *mut bpos);
}
unsafe extern "C" {
    pub fn bch2_bkey_swab_key(arg1: *const bkey_format, arg2: *mut bkey_packed);
}
unsafe extern "C" {
    #[link_name = "bpos_successor__extern"]
    pub fn bpos_successor(p: bpos) -> bpos;
}
unsafe extern "C" {
    #[link_name = "bpos_predecessor__extern"]
    pub fn bpos_predecessor(p: bpos) -> bpos;
}
unsafe extern "C" {
    #[link_name = "bpos_nosnap_successor__extern"]
    pub fn bpos_nosnap_successor(p: bpos) -> bpos;
}
unsafe extern "C" {
    #[link_name = "bpos_nosnap_predecessor__extern"]
    pub fn bpos_nosnap_predecessor(p: bpos) -> bpos;
}
unsafe extern "C" {
    #[link_name = "bpos_with_snapshot__extern"]
    pub fn bpos_with_snapshot(p: bpos, snapshot: u32_) -> bpos;
}
unsafe extern "C" {
    pub static bch2_bkey_format_current: bkey_format;
}
unsafe extern "C" {
    pub fn bch2_bkey_transform(
        arg1: *const bkey_format,
        arg2: *mut bkey_packed,
        arg3: *const bkey_format,
        arg4: *const bkey_packed,
    ) -> bool;
}
unsafe extern "C" {
    pub fn __bch2_bkey_unpack_key(
        arg1: *const bkey_format,
        arg2: *const bkey_packed,
    ) -> bkey;
}
unsafe extern "C" {
    pub fn __bch2_bkey_unpack_key_b(
        arg1: *const btree,
        arg2: *const bkey_packed,
    ) -> bkey;
}
unsafe extern "C" {
    pub fn bch2_compute_bkey_unpack_consts(arg1: *mut btree);
}
unsafe extern "C" {
    pub fn bch2_bkey_pack_key(
        arg1: *mut bkey_packed,
        arg2: *const bkey,
        arg3: *const bkey_format,
    ) -> bool;
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bkey_pack_pos_ret {
    BKEY_PACK_POS_EXACT = 0,
    BKEY_PACK_POS_SMALLER = 1,
    BKEY_PACK_POS_FAIL = 2,
}
unsafe extern "C" {
    pub fn bch2_bkey_pack_pos_lossy(
        arg1: *mut bkey_packed,
        arg2: bpos,
        arg3: *const btree,
    ) -> bkey_pack_pos_ret;
}
unsafe extern "C" {
    pub fn bch2_bkey_unpack(
        arg1: *const btree,
        arg2: *mut bkey_i,
        arg3: *const bkey_packed,
    );
}
unsafe extern "C" {
    pub fn bch2_bkey_pack(
        arg1: *mut bkey_packed,
        arg2: *const bkey_i,
        arg3: *const bkey_format,
    ) -> bool;
}
unsafe extern "C" {
    #[link_name = "bch2_compile_bkey_format__extern"]
    pub fn bch2_compile_bkey_format(
        format: *const bkey_format,
        out: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_bkey_pack_test__extern"]
    pub fn bch2_bkey_pack_test();
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bkey_format_state {
    pub field_min: [u64_; 6usize],
    pub field_max: [u64_; 6usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_format_state"][::std::mem::size_of::<bkey_format_state>() - 96usize];
    [
        "Alignment of bkey_format_state",
    ][::std::mem::align_of::<bkey_format_state>() - 8usize];
    [
        "Offset of field: bkey_format_state::field_min",
    ][::std::mem::offset_of!(bkey_format_state, field_min) - 0usize];
    [
        "Offset of field: bkey_format_state::field_max",
    ][::std::mem::offset_of!(bkey_format_state, field_max) - 48usize];
};
unsafe extern "C" {
    pub fn bch2_bkey_format_init(arg1: *mut bkey_format_state);
}
unsafe extern "C" {
    #[link_name = "bch2_bkey_format_add_key__extern"]
    pub fn bch2_bkey_format_add_key(s: *mut bkey_format_state, k: *const bkey);
}
unsafe extern "C" {
    pub fn bch2_bkey_format_add_pos(arg1: *mut bkey_format_state, arg2: bpos);
}
unsafe extern "C" {
    pub fn bch2_bkey_format_done(arg1: *mut bkey_format_state) -> bkey_format;
}
unsafe extern "C" {
    #[link_name = "bch2_bkey_format_field_overflows__extern"]
    pub fn bch2_bkey_format_field_overflows(
        f: *mut bkey_format,
        i: ::std::os::raw::c_uint,
    ) -> bool;
}
unsafe extern "C" {
    pub fn bch2_bkey_format_invalid(
        arg1: *mut bch_fs,
        arg2: *mut bkey_format,
        arg3: bch_validate_flags,
        arg4: *mut printbuf,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_bkey_format_to_text(arg1: *mut printbuf, arg2: *const bkey_format);
}
unsafe extern "C" {
    pub static bch2_bkey_types: [*const ::std::os::raw::c_char; 0usize];
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bkey_ops {
    pub key_validate: ::std::option::Option<
        unsafe extern "C" fn(
            c: *mut bch_fs,
            k: bkey_s_c,
            from: bkey_validate_context,
        ) -> ::std::os::raw::c_int,
    >,
    pub val_to_text: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut printbuf, arg2: *mut bch_fs, arg3: bkey_s_c),
    >,
    pub swab: ::std::option::Option<
        unsafe extern "C" fn(arg1: *const bch_fs, arg2: bkey_s),
    >,
    pub key_merge: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut bch_fs, arg2: bkey_s, arg3: bkey_s_c) -> bool,
    >,
    pub trigger: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut btree_trans,
            arg2: btree_trigger_op,
        ) -> ::std::os::raw::c_int,
    >,
    pub check_repair: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut btree_trans,
            arg2: *mut btree_iter,
            arg3: btree_id,
            arg4: ::std::os::raw::c_uint,
            arg5: bkey_s_c,
        ) -> ::std::os::raw::c_int,
    >,
    pub compat: ::std::option::Option<
        unsafe extern "C" fn(
            id: btree_id,
            version: ::std::os::raw::c_uint,
            big_endian: ::std::os::raw::c_uint,
            write: ::std::os::raw::c_int,
            arg1: bkey_s,
        ),
    >,
    pub min_val_size: ::std::os::raw::c_uint,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_ops"][::std::mem::size_of::<bkey_ops>() - 64usize];
    ["Alignment of bkey_ops"][::std::mem::align_of::<bkey_ops>() - 8usize];
    [
        "Offset of field: bkey_ops::key_validate",
    ][::std::mem::offset_of!(bkey_ops, key_validate) - 0usize];
    [
        "Offset of field: bkey_ops::val_to_text",
    ][::std::mem::offset_of!(bkey_ops, val_to_text) - 8usize];
    [
        "Offset of field: bkey_ops::swab",
    ][::std::mem::offset_of!(bkey_ops, swab) - 16usize];
    [
        "Offset of field: bkey_ops::key_merge",
    ][::std::mem::offset_of!(bkey_ops, key_merge) - 24usize];
    [
        "Offset of field: bkey_ops::trigger",
    ][::std::mem::offset_of!(bkey_ops, trigger) - 32usize];
    [
        "Offset of field: bkey_ops::check_repair",
    ][::std::mem::offset_of!(bkey_ops, check_repair) - 40usize];
    [
        "Offset of field: bkey_ops::compat",
    ][::std::mem::offset_of!(bkey_ops, compat) - 48usize];
    [
        "Offset of field: bkey_ops::min_val_size",
    ][::std::mem::offset_of!(bkey_ops, min_val_size) - 56usize];
};
unsafe extern "C" {
    pub static bch2_bkey_null_ops: bkey_ops;
}
unsafe extern "C" {
    #[link_name = "bch2_bkey_type_ops__extern"]
    pub fn bch2_bkey_type_ops(type_: bch_bkey_type) -> *const bkey_ops;
}
unsafe extern "C" {
    pub fn bch2_bkey_val_validate(
        arg1: *mut bch_fs,
        arg2: bkey_s_c,
        arg3: bkey_validate_context,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn __bch2_bkey_validate(
        arg1: *mut bch_fs,
        arg2: bkey_s_c,
        arg3: bkey_validate_context,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_bkey_validate(
        arg1: *mut bch_fs,
        arg2: bkey_s_c,
        arg3: bkey_validate_context,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_bkey_in_btree_node(
        arg1: *mut bch_fs,
        arg2: *mut btree,
        arg3: bkey_s_c,
        from: bkey_validate_context,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_bpos_to_text(arg1: *mut printbuf, arg2: bpos);
}
unsafe extern "C" {
    pub fn bch2_bkey_to_text(arg1: *mut printbuf, arg2: *const bkey);
}
unsafe extern "C" {
    pub fn bch2_val_to_text(arg1: *mut printbuf, arg2: *mut bch_fs, arg3: bkey_s_c);
}
unsafe extern "C" {
    pub fn bch2_bkey_val_to_text(arg1: *mut printbuf, arg2: *mut bch_fs, arg3: bkey_s_c);
}
unsafe extern "C" {
    pub fn bch2_bkey_swab_val(c: *const bch_fs, arg1: bkey_s);
}
unsafe extern "C" {
    #[link_name = "bch2_bkey_maybe_mergable__extern"]
    pub fn bch2_bkey_maybe_mergable(l: *const bkey, r: *const bkey) -> bool;
}
unsafe extern "C" {
    pub fn bch2_bkey_merge(arg1: *mut bch_fs, arg2: bkey_s, arg3: bkey_s_c) -> bool;
}
unsafe extern "C" {
    #[link_name = "bch2_key_trigger__extern"]
    pub fn bch2_key_trigger(
        trans: *mut btree_trans,
        op: btree_trigger_op,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_key_trigger_old__extern"]
    pub fn bch2_key_trigger_old(
        trans: *mut btree_trans,
        btree_id: btree_id,
        level: ::std::os::raw::c_uint,
        old: bkey_s_c,
        flags: btree_iter_update_trigger_flags,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_key_trigger_new__extern"]
    pub fn bch2_key_trigger_new(
        trans: *mut btree_trans,
        btree_id: btree_id,
        level: ::std::os::raw::c_uint,
        new: bkey_s,
        new_buf_u64s: ::std::os::raw::c_uint,
        flags: btree_iter_update_trigger_flags,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_bkey_check_repair__extern"]
    pub fn bch2_bkey_check_repair(
        trans: *mut btree_trans,
        iter: *mut btree_iter,
        btree: btree_id,
        level: ::std::os::raw::c_uint,
        k: bkey_s_c,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_bkey_renumber(
        arg1: btree_node_type,
        arg2: *mut bkey_packed,
        arg3: ::std::os::raw::c_int,
    );
}
unsafe extern "C" {
    pub fn __bch2_bkey_compat(
        arg1: *const bch_fs,
        arg2: ::std::os::raw::c_uint,
        arg3: btree_id,
        arg4: ::std::os::raw::c_uint,
        arg5: ::std::os::raw::c_uint,
        arg6: ::std::os::raw::c_int,
        arg7: *mut bkey_format,
        arg8: *mut bkey_packed,
    );
}
unsafe extern "C" {
    #[link_name = "bch2_bkey_compat__extern"]
    pub fn bch2_bkey_compat(
        c: *const bch_fs,
        level: ::std::os::raw::c_uint,
        btree_id: btree_id,
        version: ::std::os::raw::c_uint,
        big_endian: ::std::os::raw::c_uint,
        write: ::std::os::raw::c_int,
        f: *mut bkey_format,
        k: *mut bkey_packed,
    );
}
unsafe extern "C" {
    pub fn bch2_set_bkey_error(
        c: *mut bch_fs,
        k: *mut bkey_i,
        arg1: bch_key_type_errors,
    );
}
unsafe extern "C" {
    pub static bch2_btree_node_flags: [*const ::std::os::raw::c_char; 0usize];
}
unsafe extern "C" {
    pub fn bch2_recalc_btree_reserve(arg1: *mut bch_fs);
}
unsafe extern "C" {
    pub fn bch2_btree_node_mem_free(arg1: *mut bch_fs, arg2: *mut btree);
}
unsafe extern "C" {
    pub fn bch2_btree_node_transition_state(
        arg1: *mut bch_fs_btree_cache,
        arg2: *mut btree,
        arg3: btree_node_cache_state,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_btree_node_transition_state_locked(
        arg1: *mut bch_fs_btree_cache,
        arg2: *mut btree,
        arg3: btree_node_cache_state,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_node_pin(arg1: *mut bch_fs, arg2: *mut btree);
}
unsafe extern "C" {
    pub fn bch2_btree_cache_unpin(arg1: *mut bch_fs);
}
unsafe extern "C" {
    pub fn bch2_btree_node_set_dirty(arg1: *mut bch_fs, arg2: *mut btree);
}
unsafe extern "C" {
    pub fn bch2_btree_node_write_done_clean(arg1: *mut bch_fs, arg2: *mut btree);
}
unsafe extern "C" {
    pub fn bch2_btree_cache_cannibalize_unlock(arg1: *mut btree_trans);
}
unsafe extern "C" {
    pub fn bch2_btree_cache_cannibalize_lock(
        arg1: *mut btree_trans,
        arg2: *mut closure,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_btree_node_data_free(arg1: *mut btree);
}
unsafe extern "C" {
    pub fn __bch2_btree_node_mem_alloc(arg1: *mut bch_fs) -> *mut btree;
}
unsafe extern "C" {
    pub fn bch2_btree_node_mem_alloc(arg1: *mut btree_trans, arg2: bool) -> *mut btree;
}
unsafe extern "C" {
    pub fn bch2_btree_node_get(
        arg1: *mut btree_trans,
        arg2: *mut btree_path,
        arg3: *const bkey_i,
        arg4: ::std::os::raw::c_uint,
        arg5: six_lock_type,
        arg6: btree_iter_update_trigger_flags,
        arg7: ::std::os::raw::c_ulong,
    ) -> *mut btree;
}
unsafe extern "C" {
    pub fn bch2_btree_node_get_noiter(
        arg1: *mut btree_trans,
        arg2: *const bkey_i,
        arg3: btree_id,
        arg4: ::std::os::raw::c_uint,
        arg5: bool,
    ) -> *mut btree;
}
unsafe extern "C" {
    pub fn bch2_btree_node_prefetch(
        arg1: *mut btree_trans,
        arg2: *mut btree_path,
        arg3: *const bkey_i,
        arg4: btree_id,
        arg5: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_btree_node_evict(arg1: *mut btree_trans, arg2: *const bkey_i);
}
unsafe extern "C" {
    pub fn bch2_fs_btree_cache_exit(arg1: *mut bch_fs);
}
unsafe extern "C" {
    pub fn bch2_fs_btree_cache_init(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_fs_btree_cache_init_early(arg1: *mut bch_fs_btree_cache);
}
unsafe extern "C" {
    pub fn bch2_fs_btree_evicted_size_init(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_fs_btree_evicted_size_exit(arg1: *mut bch_fs);
}
unsafe extern "C" {
    #[link_name = "bch2_btree_evicted_size_record__extern"]
    pub fn bch2_btree_evicted_size_record(c: *mut bch_fs, hash: u64_, live_u64s: u16_);
}
unsafe extern "C" {
    #[link_name = "bch2_btree_evicted_size_lookup__extern"]
    pub fn bch2_btree_evicted_size_lookup(
        c: *mut bch_fs,
        hash: u64_,
        out: *mut u16_,
    ) -> bool;
}
unsafe extern "C" {
    #[link_name = "bch2_btree_id_root__extern"]
    pub fn bch2_btree_id_root(
        c: *mut bch_fs,
        id: ::std::os::raw::c_uint,
    ) -> *mut btree_root;
}
unsafe extern "C" {
    #[link_name = "bch2_btree_root_pack__extern"]
    pub fn bch2_btree_root_pack(b: *mut btree) -> ::std::os::raw::c_ulong;
}
unsafe extern "C" {
    #[link_name = "bch2_btree_root_unpack_b__extern"]
    pub fn bch2_btree_root_unpack_b(v: ::std::os::raw::c_ulong) -> *mut btree;
}
unsafe extern "C" {
    #[link_name = "bch2_btree_root_unpack_level__extern"]
    pub fn bch2_btree_root_unpack_level(
        v: ::std::os::raw::c_ulong,
    ) -> ::std::os::raw::c_uint;
}
unsafe extern "C" {
    #[link_name = "bch2_btree_id_root_packed__extern"]
    pub fn bch2_btree_id_root_packed(
        c: *mut bch_fs,
        btree_id: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_ulong;
}
unsafe extern "C" {
    #[link_name = "bch2_btree_id_root_b__extern"]
    pub fn bch2_btree_id_root_b(
        c: *mut bch_fs,
        btree_id: ::std::os::raw::c_uint,
    ) -> *mut btree;
}
unsafe extern "C" {
    pub fn bch2_btree_id_str(arg1: btree_id) -> *const ::std::os::raw::c_char;
}
unsafe extern "C" {
    pub fn bch2_btree_id_to_text(arg1: *mut printbuf, arg2: btree_id);
}
unsafe extern "C" {
    pub fn bch2_btree_id_level_to_text(
        arg1: *mut printbuf,
        arg2: btree_id,
        arg3: ::std::os::raw::c_uint,
    );
}
unsafe extern "C" {
    pub fn __bch2_btree_pos_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: btree_id,
        arg4: ::std::os::raw::c_uint,
        arg5: bkey_s_c,
    );
}
unsafe extern "C" {
    pub fn bch2_btree_pos_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: *const btree,
    );
}
unsafe extern "C" {
    pub fn bch2_btree_node_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: *const btree,
    );
}
unsafe extern "C" {
    pub fn bch2_btree_cache_to_text(
        arg1: *mut printbuf,
        arg2: *const bch_fs_btree_cache,
    );
}
unsafe extern "C" {
    #[link_name = "bch2_bset_set_no_aux_tree__extern"]
    pub fn bch2_bset_set_no_aux_tree(b: *mut btree, t: *mut bset_tree);
}
unsafe extern "C" {
    pub fn bch2_btree_keys_init(arg1: *mut btree);
}
unsafe extern "C" {
    pub fn bch2_bset_init_first(arg1: *mut btree, arg2: *mut bset);
}
unsafe extern "C" {
    pub fn bch2_bset_init_next(arg1: *mut btree, arg2: *mut btree_node_entry);
}
unsafe extern "C" {
    pub fn bch2_bset_build_aux_tree(arg1: *mut btree, arg2: *mut bset_tree, arg3: bool);
}
unsafe extern "C" {
    pub fn bch2_bset_insert(
        arg1: *mut btree,
        arg2: *mut bkey_packed,
        arg3: *mut bkey_i,
        arg4: ::std::os::raw::c_uint,
    );
}
unsafe extern "C" {
    pub fn bch2_bset_delete(
        arg1: *mut btree,
        arg2: *mut bkey_packed,
        arg3: ::std::os::raw::c_uint,
    );
}
unsafe extern "C" {
    #[link_name = "bch2_bkey_to_bset_inlined__extern"]
    pub fn bch2_bkey_to_bset_inlined(
        b: *mut btree,
        k: *mut bkey_packed,
    ) -> *mut bset_tree;
}
unsafe extern "C" {
    pub fn bch2_bkey_to_bset(arg1: *mut btree, arg2: *mut bkey_packed) -> *mut bset_tree;
}
unsafe extern "C" {
    pub fn bch2_bkey_prev_filter(
        arg1: *mut btree,
        arg2: *mut bset_tree,
        arg3: *mut bkey_packed,
        arg4: ::std::os::raw::c_uint,
    ) -> *mut bkey_packed;
}
unsafe extern "C" {
    #[link_name = "bch2_bkey_prev_all__extern"]
    pub fn bch2_bkey_prev_all(
        b: *mut btree,
        t: *mut bset_tree,
        k: *mut bkey_packed,
    ) -> *mut bkey_packed;
}
unsafe extern "C" {
    #[link_name = "bch2_bkey_prev__extern"]
    pub fn bch2_bkey_prev(
        b: *mut btree,
        t: *mut bset_tree,
        k: *mut bkey_packed,
    ) -> *mut bkey_packed;
}
unsafe extern "C" {
    pub fn bch2_btree_node_iter_push(
        arg1: *mut btree_node_iter,
        arg2: *mut btree,
        arg3: *const bkey_packed,
        arg4: *const bkey_packed,
    );
}
unsafe extern "C" {
    pub fn bch2_btree_node_iter_init(
        arg1: *mut bch_fs,
        arg2: *mut btree,
        arg3: *mut btree_node_iter,
        arg4: *mut bpos,
    );
}
unsafe extern "C" {
    pub fn bch2_btree_node_iter_init_from_start(
        arg1: *mut btree_node_iter,
        arg2: *mut btree,
    );
}
unsafe extern "C" {
    pub fn bch2_btree_node_iter_bset_pos(
        arg1: *mut btree_node_iter,
        arg2: *mut btree,
        arg3: *mut bset_tree,
    ) -> *mut bkey_packed;
}
unsafe extern "C" {
    pub fn bch2_btree_node_iter_sort(arg1: *mut btree_node_iter, arg2: *mut btree);
}
unsafe extern "C" {
    pub fn bch2_btree_node_iter_set_drop(
        arg1: *mut btree_node_iter,
        arg2: *mut btree_node_iter_btree_node_iter_set,
    );
}
unsafe extern "C" {
    pub fn bch2_btree_node_iter_advance(arg1: *mut btree_node_iter, arg2: *mut btree);
}
unsafe extern "C" {
    #[link_name = "bch2_btree_node_iter_end__extern"]
    pub fn bch2_btree_node_iter_end(iter: *mut btree_node_iter) -> bool;
}
unsafe extern "C" {
    #[link_name = "__bch2_btree_node_iter_peek_all__extern"]
    pub fn __bch2_btree_node_iter_peek_all(
        iter: *mut btree_node_iter,
        b: *mut btree,
    ) -> *mut bkey_packed;
}
unsafe extern "C" {
    #[link_name = "bch2_btree_node_iter_peek_all__extern"]
    pub fn bch2_btree_node_iter_peek_all(
        iter: *mut btree_node_iter,
        b: *mut btree,
    ) -> *mut bkey_packed;
}
unsafe extern "C" {
    #[link_name = "bch2_btree_node_iter_peek__extern"]
    pub fn bch2_btree_node_iter_peek(
        iter: *mut btree_node_iter,
        b: *mut btree,
    ) -> *mut bkey_packed;
}
unsafe extern "C" {
    #[link_name = "bch2_btree_node_iter_next_all__extern"]
    pub fn bch2_btree_node_iter_next_all(
        iter: *mut btree_node_iter,
        b: *mut btree,
    ) -> *mut bkey_packed;
}
unsafe extern "C" {
    pub fn bch2_btree_node_iter_prev_all(
        arg1: *mut btree_node_iter,
        arg2: *mut btree,
    ) -> *mut bkey_packed;
}
unsafe extern "C" {
    pub fn bch2_btree_node_iter_prev(
        arg1: *mut btree_node_iter,
        arg2: *mut btree,
    ) -> *mut bkey_packed;
}
unsafe extern "C" {
    pub fn bch2_btree_node_iter_peek_unpack(
        arg1: *mut btree_node_iter,
        arg2: *mut btree,
        arg3: *mut bkey,
    ) -> bkey_s_c;
}
unsafe extern "C" {
    pub fn bch2_btree_node_count_keys(arg1: *mut btree) -> btree_nr_keys;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bset_stats {
    pub sets: [bset_stats__bindgen_ty_1; 3usize],
    pub floats: usize,
    pub failed: usize,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bset_stats__bindgen_ty_1 {
    pub nr: usize,
    pub bytes: usize,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bset_stats__bindgen_ty_1",
    ][::std::mem::size_of::<bset_stats__bindgen_ty_1>() - 16usize];
    [
        "Alignment of bset_stats__bindgen_ty_1",
    ][::std::mem::align_of::<bset_stats__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bset_stats__bindgen_ty_1::nr",
    ][::std::mem::offset_of!(bset_stats__bindgen_ty_1, nr) - 0usize];
    [
        "Offset of field: bset_stats__bindgen_ty_1::bytes",
    ][::std::mem::offset_of!(bset_stats__bindgen_ty_1, bytes) - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bset_stats"][::std::mem::size_of::<bset_stats>() - 64usize];
    ["Alignment of bset_stats"][::std::mem::align_of::<bset_stats>() - 8usize];
    [
        "Offset of field: bset_stats::sets",
    ][::std::mem::offset_of!(bset_stats, sets) - 0usize];
    [
        "Offset of field: bset_stats::floats",
    ][::std::mem::offset_of!(bset_stats, floats) - 48usize];
    [
        "Offset of field: bset_stats::failed",
    ][::std::mem::offset_of!(bset_stats, failed) - 56usize];
};
unsafe extern "C" {
    pub fn bch2_btree_keys_stats(arg1: *const btree, arg2: *mut bset_stats);
}
unsafe extern "C" {
    pub fn bch2_bfloat_to_text(
        arg1: *mut printbuf,
        arg2: *mut btree,
        arg3: *mut bkey_packed,
    );
}
unsafe extern "C" {
    pub fn bch2_btree_node_keys_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: *mut btree,
    );
}
unsafe extern "C" {
    pub fn bch2_bset_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: *mut btree,
        arg4: *mut bset,
        arg5: ::std::os::raw::c_uint,
    );
}
unsafe extern "C" {
    pub fn bch2_dump_btree_node_iter(arg1: *mut btree, arg2: *mut btree_node_iter);
}
unsafe extern "C" {
    pub fn __bch2_verify_btree_nr_keys(arg1: *mut btree);
}
unsafe extern "C" {
    pub fn __bch2_btree_node_iter_verify(arg1: *mut btree_node_iter, arg2: *mut btree);
}
unsafe extern "C" {
    #[link_name = "bch2_btree_node_iter_verify__extern"]
    pub fn bch2_btree_node_iter_verify(iter: *mut btree_node_iter, b: *mut btree);
}
unsafe extern "C" {
    #[link_name = "bch2_verify_btree_nr_keys__extern"]
    pub fn bch2_verify_btree_nr_keys(b: *mut btree);
}
unsafe extern "C" {
    pub static bch2_extent_entry_types: [*const ::std::os::raw::c_char; 0usize];
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bch_extent_crc {
    pub type_: u8_,
    pub crc32: bch_extent_crc32,
    pub crc64: bch_extent_crc64,
    pub crc128: bch_extent_crc128,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_extent_crc"][::std::mem::size_of::<bch_extent_crc>() - 24usize];
    ["Alignment of bch_extent_crc"][::std::mem::align_of::<bch_extent_crc>() - 8usize];
    [
        "Offset of field: bch_extent_crc::type_",
    ][::std::mem::offset_of!(bch_extent_crc, type_) - 0usize];
    [
        "Offset of field: bch_extent_crc::crc32",
    ][::std::mem::offset_of!(bch_extent_crc, crc32) - 0usize];
    [
        "Offset of field: bch_extent_crc::crc64",
    ][::std::mem::offset_of!(bch_extent_crc, crc64) - 0usize];
    [
        "Offset of field: bch_extent_crc::crc128",
    ][::std::mem::offset_of!(bch_extent_crc, crc128) - 0usize];
};
impl Default for bch_extent_crc {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C" {
    #[link_name = "bch2_extent_crc_unpack__extern"]
    pub fn bch2_extent_crc_unpack(
        k: *const bkey,
        crc: *const bch_extent_crc,
    ) -> bch_extent_crc_unpacked;
}
unsafe extern "C" {
    pub fn bch2_extent_crc_unpacked_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_extent_crc_unpacked,
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_ptrs_c {
    pub start: *const bch_extent_entry,
    pub end: *const bch_extent_entry,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_ptrs_c"][::std::mem::size_of::<bkey_ptrs_c>() - 16usize];
    ["Alignment of bkey_ptrs_c"][::std::mem::align_of::<bkey_ptrs_c>() - 8usize];
    [
        "Offset of field: bkey_ptrs_c::start",
    ][::std::mem::offset_of!(bkey_ptrs_c, start) - 0usize];
    [
        "Offset of field: bkey_ptrs_c::end",
    ][::std::mem::offset_of!(bkey_ptrs_c, end) - 8usize];
};
impl Default for bkey_ptrs_c {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_ptrs {
    pub start: *mut bch_extent_entry,
    pub end: *mut bch_extent_entry,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_ptrs"][::std::mem::size_of::<bkey_ptrs>() - 16usize];
    ["Alignment of bkey_ptrs"][::std::mem::align_of::<bkey_ptrs>() - 8usize];
    [
        "Offset of field: bkey_ptrs::start",
    ][::std::mem::offset_of!(bkey_ptrs, start) - 0usize];
    ["Offset of field: bkey_ptrs::end"][::std::mem::offset_of!(bkey_ptrs, end) - 8usize];
};
impl Default for bkey_ptrs {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C" {
    #[link_name = "bch2_bkey_ptrs_c__extern"]
    pub fn bch2_bkey_ptrs_c(k: bkey_s_c) -> bkey_ptrs_c;
}
unsafe extern "C" {
    #[link_name = "bch2_bkey_ptrs__extern"]
    pub fn bch2_bkey_ptrs(k: bkey_s) -> bkey_ptrs;
}
unsafe extern "C" {
    #[link_name = "bch2_io_failures_exit__extern"]
    pub fn bch2_io_failures_exit(f: *mut bch_io_failures);
}
unsafe extern "C" {
    pub fn bch2_io_failures_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: *mut bch_io_failures,
    );
}
unsafe extern "C" {
    pub fn bch2_dev_io_failures(
        arg1: *mut bch_io_failures,
        arg2: ::std::os::raw::c_uint,
    ) -> *mut bch_io_failures_bch_dev_io_failures;
}
unsafe extern "C" {
    pub fn bch2_dev_io_failures_mut(
        arg1: *mut bch_io_failures,
        arg2: ::std::os::raw::c_uint,
    ) -> *mut bch_io_failures_bch_dev_io_failures;
}
unsafe extern "C" {
    pub fn bch2_mark_io_failure(
        arg1: *mut bch_io_failures,
        arg2: *mut extent_ptr_decoded,
        arg3: ::std::os::raw::c_int,
    );
}
unsafe extern "C" {
    pub fn bch2_mark_dev_io_failure(
        arg1: *mut bch_io_failures,
        arg2: ::std::os::raw::c_uint,
        arg3: ::std::os::raw::c_int,
    );
}
unsafe extern "C" {
    pub fn bch2_bkey_pick_read_device(
        arg1: *mut bch_fs,
        arg2: bkey_s_c,
        arg3: *mut bch_io_failures,
        arg4: *mut extent_ptr_decoded,
        arg5: ::std::os::raw::c_uint,
        arg6: bch_read_flags,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_btree_ptr_validate(
        arg1: *mut bch_fs,
        arg2: bkey_s_c,
        arg3: bkey_validate_context,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_btree_ptr_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: bkey_s_c,
    );
}
unsafe extern "C" {
    pub fn bch2_btree_ptr_v2_validate(
        arg1: *mut bch_fs,
        arg2: bkey_s_c,
        arg3: bkey_validate_context,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_btree_ptr_v2_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: bkey_s_c,
    );
}
unsafe extern "C" {
    pub fn bch2_btree_ptr_v2_compat(
        arg1: btree_id,
        arg2: ::std::os::raw::c_uint,
        arg3: ::std::os::raw::c_uint,
        arg4: ::std::os::raw::c_int,
        arg5: bkey_s,
    );
}
unsafe extern "C" {
    pub fn bch2_extent_merge(arg1: *mut bch_fs, arg2: bkey_s, arg3: bkey_s_c) -> bool;
}
unsafe extern "C" {
    pub fn bch2_reservation_validate(
        arg1: *mut bch_fs,
        arg2: bkey_s_c,
        arg3: bkey_validate_context,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_reservation_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: bkey_s_c,
    );
}
unsafe extern "C" {
    pub fn bch2_reservation_merge(
        arg1: *mut bch_fs,
        arg2: bkey_s,
        arg3: bkey_s_c,
    ) -> bool;
}
unsafe extern "C" {
    pub fn bch2_bkey_narrow_crc(
        arg1: *const bch_fs,
        arg2: *mut bkey_i,
        arg3: bch_extent_crc_unpacked,
        arg4: bch_extent_crc_unpacked,
    ) -> bool;
}
unsafe extern "C" {
    pub fn bch2_extent_crc_append(
        arg1: *const bch_fs,
        arg2: *mut bkey_i,
        arg3: bch_extent_crc_unpacked,
    );
}
unsafe extern "C" {
    #[link_name = "bch2_bkey_devs__extern"]
    pub fn bch2_bkey_devs(c: *const bch_fs, k: bkey_s_c) -> bch_devs_list;
}
unsafe extern "C" {
    pub fn bch2_bkey_nr_dirty_ptrs(
        arg1: *const bch_fs,
        arg2: bkey_s_c,
    ) -> ::std::os::raw::c_uint;
}
unsafe extern "C" {
    pub fn bch2_bkey_nr_ptrs_allocated(
        arg1: *const bch_fs,
        arg2: bkey_s_c,
    ) -> ::std::os::raw::c_uint;
}
unsafe extern "C" {
    pub fn bch2_bkey_nr_ptrs_fully_allocated(
        arg1: *const bch_fs,
        arg2: bkey_s_c,
    ) -> ::std::os::raw::c_uint;
}
unsafe extern "C" {
    pub fn bch2_bkey_is_incompressible(arg1: *const bch_fs, arg2: bkey_s_c) -> bool;
}
unsafe extern "C" {
    pub fn bch2_bkey_propagate_incompressible(
        arg1: *const bch_fs,
        arg2: *mut bkey_i,
        arg3: bkey_s_c,
    );
}
unsafe extern "C" {
    pub fn bch2_bkey_sectors_compressed(
        arg1: *const bch_fs,
        arg2: bkey_s_c,
    ) -> ::std::os::raw::c_uint;
}
unsafe extern "C" {
    pub fn bch2_bkey_replicas(
        arg1: *mut bch_fs,
        arg2: bkey_s_c,
    ) -> ::std::os::raw::c_uint;
}
unsafe extern "C" {
    pub fn bch2_dev_durability(
        arg1: *mut bch_fs,
        arg2: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_uint;
}
unsafe extern "C" {
    pub fn bch2_extent_ptr_desired_durability(
        arg1: *mut btree_trans,
        arg2: *mut extent_ptr_decoded,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_extent_ptr_durability(
        arg1: *mut btree_trans,
        arg2: *mut extent_ptr_decoded,
    ) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bkey_durability {
    pub online: ::std::os::raw::c_uint,
    pub total: ::std::os::raw::c_uint,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_durability"][::std::mem::size_of::<bkey_durability>() - 8usize];
    ["Alignment of bkey_durability"][::std::mem::align_of::<bkey_durability>() - 4usize];
    [
        "Offset of field: bkey_durability::online",
    ][::std::mem::offset_of!(bkey_durability, online) - 0usize];
    [
        "Offset of field: bkey_durability::total",
    ][::std::mem::offset_of!(bkey_durability, total) - 4usize];
};
unsafe extern "C" {
    pub fn bch2_bkey_durability(
        arg1: *mut btree_trans,
        arg2: bkey_s_c,
        arg3: *mut bkey_durability,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_btree_ptr_durability(
        arg1: *mut bch_fs,
        arg2: bkey_s_c,
    ) -> bkey_durability;
}
unsafe extern "C" {
    pub fn bch2_bkey_can_read(arg1: *const bch_fs, arg2: bkey_s_c) -> bool;
}
unsafe extern "C" {
    pub fn bch2_bkey_has_device_c(
        arg1: *const bch_fs,
        arg2: bkey_s_c,
        arg3: ::std::os::raw::c_uint,
    ) -> *const bch_extent_ptr;
}
unsafe extern "C" {
    pub fn bch2_bkey_has_device_decode(
        arg1: *const bch_fs,
        arg2: bkey_s_c,
        arg3: ::std::os::raw::c_uint,
        arg4: *mut extent_ptr_decoded,
    ) -> bool;
}
unsafe extern "C" {
    #[link_name = "bch2_bkey_has_device__extern"]
    pub fn bch2_bkey_has_device(
        c: *const bch_fs,
        k: bkey_s,
        dev: ::std::os::raw::c_uint,
    ) -> *mut bch_extent_ptr;
}
unsafe extern "C" {
    #[link_name = "bch2_bkey_dev_ptr_bit__extern"]
    pub fn bch2_bkey_dev_ptr_bit(
        c: *mut bch_fs,
        k: bkey_s_c,
        dev: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_uint;
}
unsafe extern "C" {
    pub fn bch2_bkey_devs_rw(arg1: *mut bch_fs, arg2: bkey_s_c) -> bool;
}
unsafe extern "C" {
    pub fn bch2_bkey_has_target(
        arg1: *mut bch_fs,
        arg2: bkey_s_c,
        arg3: ::std::os::raw::c_uint,
    ) -> bool;
}
unsafe extern "C" {
    pub fn bch2_bkey_in_target(
        arg1: *mut bch_fs,
        arg2: bkey_s_c,
        arg3: ::std::os::raw::c_uint,
    ) -> bool;
}
unsafe extern "C" {
    pub fn bch2_bkey_has_dev_bad_or_evacuating(
        arg1: *mut bch_fs,
        arg2: bkey_s_c,
    ) -> bool;
}
unsafe extern "C" {
    pub fn bch2_bkey_extent_entry_drop_s(
        arg1: *const bch_fs,
        arg2: bkey_s,
        arg3: *mut bch_extent_entry,
    );
}
unsafe extern "C" {
    pub fn bch2_bkey_extent_entry_drop(
        arg1: *const bch_fs,
        arg2: *mut bkey_i,
        arg3: *mut bch_extent_entry,
    );
}
unsafe extern "C" {
    #[link_name = "bch2_bkey_append_ptr__extern"]
    pub fn bch2_bkey_append_ptr(c: *const bch_fs, k: *mut bkey_i, ptr: bch_extent_ptr);
}
unsafe extern "C" {
    pub fn bch2_extent_ptr_decoded_append(
        arg1: *const bch_fs,
        arg2: *mut bkey_i,
        arg3: *mut extent_ptr_decoded,
    );
}
unsafe extern "C" {
    pub fn bch2_bkey_drop_ptr_noerror(
        arg1: *const bch_fs,
        arg2: bkey_s,
        arg3: *mut bch_extent_ptr,
    );
}
unsafe extern "C" {
    pub fn bch2_bkey_drop_ptr(
        arg1: *const bch_fs,
        arg2: bkey_s,
        arg3: *mut bch_extent_ptr,
    );
}
unsafe extern "C" {
    pub fn bch2_bkey_drop_ptrs_mask(
        arg1: *const bch_fs,
        arg2: *mut bkey_i,
        arg3: ::std::os::raw::c_uint,
    );
}
unsafe extern "C" {
    pub fn bch2_bkey_drop_device_noerror(
        arg1: *const bch_fs,
        arg2: bkey_s,
        arg3: ::std::os::raw::c_uint,
    );
}
unsafe extern "C" {
    pub fn bch2_bkey_drop_device(
        arg1: *const bch_fs,
        arg2: bkey_s,
        arg3: ::std::os::raw::c_uint,
    );
}
unsafe extern "C" {
    pub fn bch2_bkey_drop_ec_mask(
        arg1: *const bch_fs,
        k: *mut bkey_i,
        arg2: ::std::os::raw::c_uint,
    );
}
unsafe extern "C" {
    pub fn bch2_bkey_matches_ptr(
        arg1: *mut bch_fs,
        arg2: bkey_s_c,
        arg3: bch_extent_ptr,
        arg4: u64_,
    ) -> bool;
}
unsafe extern "C" {
    pub fn bch2_bkey_ptrs_match(
        arg1: bkey_s_c,
        arg2: extent_ptr_decoded,
        arg3: bkey_s_c,
        arg4: extent_ptr_decoded,
    ) -> bool;
}
unsafe extern "C" {
    pub fn bch2_extents_match(c: *const bch_fs, arg1: bkey_s_c, arg2: bkey_s_c) -> bool;
}
unsafe extern "C" {
    pub fn bch2_extent_has_ptr(
        arg1: *const bch_fs,
        arg2: bkey_s_c,
        arg3: extent_ptr_decoded,
        arg4: bkey_s,
    ) -> *mut bch_extent_ptr;
}
unsafe extern "C" {
    pub fn bch2_extent_ptr_set_cached(
        arg1: *mut bch_fs,
        arg2: *mut bch_inode_opts,
        arg3: bkey_s,
        arg4: *mut bch_extent_ptr,
    );
}
unsafe extern "C" {
    pub fn bch2_bkey_drop_stale_ptrs(
        arg1: *mut btree_trans,
        arg2: *mut btree_iter,
        arg3: bkey_s_c,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_bkey_drop_extra_cached_ptrs(
        arg1: *mut bch_fs,
        arg2: *mut bch_inode_opts,
        arg3: bkey_s,
    );
}
unsafe extern "C" {
    pub fn bch2_bkey_drop_extra_durability(
        arg1: *mut btree_trans,
        arg2: *mut bch_inode_opts,
        arg3: *mut bkey_i,
        arg4: ::std::os::raw::c_uint,
        arg5: bool,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_bkey_drop_extra_ec_durability(
        arg1: *mut btree_trans,
        arg2: *mut bch_inode_opts,
        arg3: *mut bkey_i,
        arg4: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_extent_ptr_to_text(
        out: *mut printbuf,
        arg1: *mut bch_fs,
        arg2: *const bch_extent_ptr,
    );
}
unsafe extern "C" {
    pub fn bch2_bkey_ptrs_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: bkey_s_c,
    );
}
unsafe extern "C" {
    pub fn bch2_bkey_ptrs_validate(
        arg1: *mut bch_fs,
        arg2: bkey_s_c,
        arg3: bkey_validate_context,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_extent_ptr_eq__extern"]
    pub fn bch2_extent_ptr_eq(ptr1: bch_extent_ptr, ptr2: bch_extent_ptr) -> bool;
}
unsafe extern "C" {
    pub fn bch2_ptr_swab(arg1: *const bch_fs, arg2: bkey_s);
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_extent_overlap {
    BCH_EXTENT_OVERLAP_ALL = 0,
    BCH_EXTENT_OVERLAP_BACK = 1,
    BCH_EXTENT_OVERLAP_FRONT = 2,
    BCH_EXTENT_OVERLAP_MIDDLE = 3,
}
unsafe extern "C" {
    #[link_name = "bch2_extent_overlap__extern"]
    pub fn bch2_extent_overlap(k: *const bkey, m: *const bkey) -> bch_extent_overlap;
}
unsafe extern "C" {
    pub fn bch2_cut_front_s(
        arg1: *const bch_fs,
        arg2: bpos,
        arg3: bkey_s,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_cut_back_s(arg1: bpos, arg2: bkey_s) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_cut_front__extern"]
    pub fn bch2_cut_front(c: *const bch_fs, where_: bpos, k: *mut bkey_i);
}
unsafe extern "C" {
    #[link_name = "bch2_cut_back__extern"]
    pub fn bch2_cut_back(where_: bpos, k: *mut bkey_i);
}
unsafe extern "C" {
    /** bch_key_resize - adjust size of @k

 bkey_start_offset(k) will be preserved, modifies where the extent ends*/
    #[link_name = "bch2_key_resize__extern"]
    pub fn bch2_key_resize(k: *mut bkey, new_size: ::std::os::raw::c_uint);
}
unsafe extern "C" {
    #[link_name = "bch2_bkey_extent_ptrs_flags__extern"]
    pub fn bch2_bkey_extent_ptrs_flags(ptrs: bkey_ptrs_c) -> u64_;
}
unsafe extern "C" {
    #[link_name = "bch2_bkey_extent_flags__extern"]
    pub fn bch2_bkey_extent_flags(k: bkey_s_c) -> u64_;
}
unsafe extern "C" {
    pub fn bch2_bkey_extent_flags_set(
        arg1: *mut bch_fs,
        arg2: *mut bkey_i,
        arg3: u64_,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub static bch2_member_error_strs: [*mut ::std::os::raw::c_char; 0usize];
}
unsafe extern "C" {
    #[link_name = "__bch2_members_v2_get_mut__extern"]
    pub fn __bch2_members_v2_get_mut(
        mi: *mut bch_sb_field_members_v2,
        i: ::std::os::raw::c_uint,
    ) -> *mut bch_member;
}
unsafe extern "C" {
    #[link_name = "bch2_members_v2_get__extern"]
    pub fn bch2_members_v2_get(
        mi: *mut bch_sb_field_members_v2,
        i: ::std::os::raw::c_int,
    ) -> bch_member;
}
unsafe extern "C" {
    #[link_name = "bch2_members_v1_get__extern"]
    pub fn bch2_members_v1_get(
        mi: *mut bch_sb_field_members_v1,
        i: ::std::os::raw::c_int,
    ) -> bch_member;
}
unsafe extern "C" {
    pub fn bch2_sb_members_v2_init(c: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_sb_members_cpy_v2_v1(
        disk_sb: *mut bch_sb_handle,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_members_v2_get_mut(
        sb: *mut bch_sb,
        i: ::std::os::raw::c_int,
    ) -> *mut bch_member;
}
unsafe extern "C" {
    pub fn bch2_sb_member_get(sb: *mut bch_sb, i: ::std::os::raw::c_int) -> bch_member;
}
unsafe extern "C" {
    pub fn bch2_member_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_member,
        arg3: *mut bch_sb_field_disk_groups,
        arg4: *mut bch_sb,
        arg5: ::std::os::raw::c_uint,
    );
}
unsafe extern "C" {
    pub fn bch2_member_to_text_short_locked(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: *mut bch_dev,
    );
}
unsafe extern "C" {
    pub fn bch2_member_to_text_short(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: *mut bch_dev,
    );
}
unsafe extern "C" {
    pub fn bch2_devs_mask_to_text_locked(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: *mut bch_devs_mask,
    );
}
unsafe extern "C" {
    #[link_name = "bch2_dev_is_online__extern"]
    pub fn bch2_dev_is_online(ca: *mut bch_dev) -> bool;
}
unsafe extern "C" {
    #[link_name = "bch2_dev_rcu_noerror__extern"]
    pub fn bch2_dev_rcu_noerror(
        arg1: *mut bch_fs,
        arg2: ::std::os::raw::c_uint,
    ) -> *mut bch_dev;
}
unsafe extern "C" {
    #[link_name = "bch2_dev_idx_is_online__extern"]
    pub fn bch2_dev_idx_is_online(c: *mut bch_fs, dev: ::std::os::raw::c_uint) -> bool;
}
unsafe extern "C" {
    #[link_name = "bch2_dev_list_has_dev__extern"]
    pub fn bch2_dev_list_has_dev(
        devs: bch_devs_list,
        dev: ::std::os::raw::c_uint,
    ) -> bool;
}
unsafe extern "C" {
    #[link_name = "bch2_dev_list_drop_dev__extern"]
    pub fn bch2_dev_list_drop_dev(devs: *mut bch_devs_list, dev: ::std::os::raw::c_uint);
}
unsafe extern "C" {
    #[link_name = "bch2_dev_list_add_dev__extern"]
    pub fn bch2_dev_list_add_dev(devs: *mut bch_devs_list, dev: ::std::os::raw::c_uint);
}
unsafe extern "C" {
    #[link_name = "bch2_dev_list_single__extern"]
    pub fn bch2_dev_list_single(dev: ::std::os::raw::c_uint) -> bch_devs_list;
}
unsafe extern "C" {
    #[link_name = "__bch2_next_dev_idx__extern"]
    pub fn __bch2_next_dev_idx(
        c: *mut bch_fs,
        idx: ::std::os::raw::c_uint,
        mask: *const bch_devs_mask,
    ) -> *mut bch_dev;
}
unsafe extern "C" {
    #[link_name = "__bch2_next_dev__extern"]
    pub fn __bch2_next_dev(
        c: *mut bch_fs,
        ca: *mut bch_dev,
        mask: *const bch_devs_mask,
    ) -> *mut bch_dev;
}
unsafe extern "C" {
    #[link_name = "bch2_dev_get__extern"]
    pub fn bch2_dev_get(ca: *mut bch_dev);
}
unsafe extern "C" {
    #[link_name = "__bch2_dev_put__extern"]
    pub fn __bch2_dev_put(ca: *mut bch_dev);
}
unsafe extern "C" {
    #[link_name = "bch2_dev_put__extern"]
    pub fn bch2_dev_put(ca: *mut bch_dev);
}
unsafe extern "C" {
    #[link_name = "__free_bch2_dev_put__extern"]
    pub fn __free_bch2_dev_put(p: *mut ::std::os::raw::c_void);
}
unsafe extern "C" {
    #[link_name = "bch2_get_next_dev__extern"]
    pub fn bch2_get_next_dev(c: *mut bch_fs, ca: *mut bch_dev) -> *mut bch_dev;
}
unsafe extern "C" {
    #[link_name = "bch2_get_next_online_dev__extern"]
    pub fn bch2_get_next_online_dev(
        c: *mut bch_fs,
        ca: *mut bch_dev,
        state_mask: ::std::os::raw::c_uint,
        rw: ::std::os::raw::c_int,
        ref_idx: ::std::os::raw::c_uint,
    ) -> *mut bch_dev;
}
unsafe extern "C" {
    #[link_name = "bch2_dev_exists__extern"]
    pub fn bch2_dev_exists(c: *const bch_fs, dev: ::std::os::raw::c_uint) -> bool;
}
unsafe extern "C" {
    #[link_name = "bch2_dev_have_ref__extern"]
    pub fn bch2_dev_have_ref(
        c: *const bch_fs,
        dev: ::std::os::raw::c_uint,
    ) -> *mut bch_dev;
}
unsafe extern "C" {
    #[link_name = "bch2_dev_locked__extern"]
    pub fn bch2_dev_locked(c: *mut bch_fs, dev: ::std::os::raw::c_uint) -> *mut bch_dev;
}
unsafe extern "C" {
    #[link_name = "bch2_dev_bad_or_evacuating_rcu__extern"]
    pub fn bch2_dev_bad_or_evacuating_rcu(
        c: *mut bch_fs,
        dev: ::std::os::raw::c_uint,
    ) -> bool;
}
unsafe extern "C" {
    #[link_name = "bch2_dev_bad_or_evacuating__extern"]
    pub fn bch2_dev_bad_or_evacuating(
        c: *mut bch_fs,
        dev: ::std::os::raw::c_uint,
    ) -> bool;
}
unsafe extern "C" {
    pub fn bch2_dev_missing_bkey_msg(
        arg1: *mut bch_fs,
        arg2: bkey_s_c,
        arg3: ::std::os::raw::c_uint,
        out: *mut printbuf,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_dev_missing_bkey(
        arg1: *mut bch_fs,
        arg2: bkey_s_c,
        arg3: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_dev_missing_atomic(arg1: *mut bch_fs, arg2: ::std::os::raw::c_uint);
}
unsafe extern "C" {
    #[link_name = "bch2_dev_rcu__extern"]
    pub fn bch2_dev_rcu(c: *mut bch_fs, dev: ::std::os::raw::c_uint) -> *mut bch_dev;
}
unsafe extern "C" {
    #[link_name = "bch2_dev_tryget_noerror__extern"]
    pub fn bch2_dev_tryget_noerror(
        c: *mut bch_fs,
        dev: ::std::os::raw::c_uint,
    ) -> *mut bch_dev;
}
unsafe extern "C" {
    #[link_name = "class_bch2_dev_tryget_noerror_destructor__extern"]
    pub fn class_bch2_dev_tryget_noerror_destructor(p: *mut *mut bch_dev);
}
unsafe extern "C" {
    #[link_name = "class_bch2_dev_tryget_noerror_constructor__extern"]
    pub fn class_bch2_dev_tryget_noerror_constructor(
        c: *mut bch_fs,
        dev: ::std::os::raw::c_uint,
    ) -> *mut bch_dev;
}
unsafe extern "C" {
    #[link_name = "bch2_dev_tryget__extern"]
    pub fn bch2_dev_tryget(c: *mut bch_fs, dev: ::std::os::raw::c_uint) -> *mut bch_dev;
}
unsafe extern "C" {
    #[link_name = "bch2_dev_bkey_tryget__extern"]
    pub fn bch2_dev_bkey_tryget(
        c: *mut bch_fs,
        k: bkey_s_c,
        dev: ::std::os::raw::c_uint,
    ) -> *mut bch_dev;
}
unsafe extern "C" {
    #[link_name = "class_bch2_dev_bkey_tryget_destructor__extern"]
    pub fn class_bch2_dev_bkey_tryget_destructor(p: *mut *mut bch_dev);
}
unsafe extern "C" {
    #[link_name = "class_bch2_dev_bkey_tryget_constructor__extern"]
    pub fn class_bch2_dev_bkey_tryget_constructor(
        c: *mut bch_fs,
        k: bkey_s_c,
        dev: ::std::os::raw::c_uint,
    ) -> *mut bch_dev;
}
unsafe extern "C" {
    #[link_name = "bch2_dev_bucket_tryget_noerror__extern"]
    pub fn bch2_dev_bucket_tryget_noerror(c: *mut bch_fs, bucket: bpos) -> *mut bch_dev;
}
unsafe extern "C" {
    #[link_name = "class_bch2_dev_bucket_tryget_noerror_destructor__extern"]
    pub fn class_bch2_dev_bucket_tryget_noerror_destructor(p: *mut *mut bch_dev);
}
unsafe extern "C" {
    #[link_name = "class_bch2_dev_bucket_tryget_noerror_constructor__extern"]
    pub fn class_bch2_dev_bucket_tryget_noerror_constructor(
        c: *mut bch_fs,
        bucket: bpos,
    ) -> *mut bch_dev;
}
unsafe extern "C" {
    pub fn bch2_dev_bucket_missing(arg1: *mut bch_dev, arg2: u64_);
}
unsafe extern "C" {
    #[link_name = "bch2_dev_bucket_tryget__extern"]
    pub fn bch2_dev_bucket_tryget(c: *mut bch_fs, bucket: bpos) -> *mut bch_dev;
}
unsafe extern "C" {
    #[link_name = "class_bch2_dev_bucket_tryget_destructor__extern"]
    pub fn class_bch2_dev_bucket_tryget_destructor(p: *mut *mut bch_dev);
}
unsafe extern "C" {
    #[link_name = "class_bch2_dev_bucket_tryget_constructor__extern"]
    pub fn class_bch2_dev_bucket_tryget_constructor(
        c: *mut bch_fs,
        bucket: bpos,
    ) -> *mut bch_dev;
}
unsafe extern "C" {
    #[link_name = "bch2_dev_iterate_noerror__extern"]
    pub fn bch2_dev_iterate_noerror(
        c: *mut bch_fs,
        ca: *mut bch_dev,
        dev_idx: ::std::os::raw::c_uint,
    ) -> *mut bch_dev;
}
unsafe extern "C" {
    #[link_name = "bch2_dev_iterate__extern"]
    pub fn bch2_dev_iterate(
        c: *mut bch_fs,
        ca: *mut bch_dev,
        dev_idx: ::std::os::raw::c_uint,
    ) -> *mut bch_dev;
}
unsafe extern "C" {
    #[link_name = "bch2_dev_get_ioref__extern"]
    pub fn bch2_dev_get_ioref(
        c: *mut bch_fs,
        dev: ::std::os::raw::c_uint,
        rw: ::std::os::raw::c_int,
        ref_idx: ::std::os::raw::c_uint,
    ) -> *mut bch_dev;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_sb_field_ops {
    pub validate: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut bch_sb,
            arg2: *mut bch_sb_field,
            arg3: bch_validate_flags,
            arg4: *mut printbuf,
        ) -> ::std::os::raw::c_int,
    >,
    pub to_text: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut printbuf,
            arg2: *mut bch_fs,
            arg3: *mut bch_sb,
            arg4: *mut bch_sb_field,
        ),
    >,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_sb_field_ops"][::std::mem::size_of::<bch_sb_field_ops>() - 16usize];
    [
        "Alignment of bch_sb_field_ops",
    ][::std::mem::align_of::<bch_sb_field_ops>() - 8usize];
    [
        "Offset of field: bch_sb_field_ops::validate",
    ][::std::mem::offset_of!(bch_sb_field_ops, validate) - 0usize];
    [
        "Offset of field: bch_sb_field_ops::to_text",
    ][::std::mem::offset_of!(bch_sb_field_ops, to_text) - 8usize];
};
unsafe extern "C" {
    pub static bch_sb_field_ops_members_v1: bch_sb_field_ops;
}
unsafe extern "C" {
    pub static bch_sb_field_ops_members_v2: bch_sb_field_ops;
}
unsafe extern "C" {
    #[link_name = "bch2_member_alive__extern"]
    pub fn bch2_member_alive(m: *mut bch_member) -> bool;
}
unsafe extern "C" {
    #[link_name = "bch2_member_exists__extern"]
    pub fn bch2_member_exists(sb: *mut bch_sb, dev: ::std::os::raw::c_uint) -> bool;
}
unsafe extern "C" {
    pub fn bch2_sb_nr_devices(arg1: *const bch_sb) -> ::std::os::raw::c_uint;
}
unsafe extern "C" {
    #[link_name = "bch2_mi_to_cpu__extern"]
    pub fn bch2_mi_to_cpu(mi: *mut bch_member) -> bch_member_cpu;
}
unsafe extern "C" {
    pub fn bch2_sb_members_from_cpu(arg1: *mut bch_fs);
}
unsafe extern "C" {
    pub fn bch2_sb_members_to_cpu(arg1: *mut bch_fs);
}
unsafe extern "C" {
    pub fn bch2_dev_io_errors_to_text(arg1: *mut printbuf, arg2: *mut bch_dev);
}
unsafe extern "C" {
    pub fn bch2_dev_errors_reset(arg1: *mut bch_dev);
}
unsafe extern "C" {
    #[link_name = "__bch2_dev_btree_bitmap_marked_sectors__extern"]
    pub fn __bch2_dev_btree_bitmap_marked_sectors(
        ca: *mut bch_dev,
        start: u64_,
        sectors: ::std::os::raw::c_uint,
        with_gc: bool,
    ) -> bool;
}
unsafe extern "C" {
    #[link_name = "bch2_dev_btree_bitmap_marked_sectors__extern"]
    pub fn bch2_dev_btree_bitmap_marked_sectors(
        ca: *mut bch_dev,
        start: u64_,
        sectors: ::std::os::raw::c_uint,
    ) -> bool;
}
unsafe extern "C" {
    #[link_name = "bch2_dev_btree_bitmap_marked_sectors_any__extern"]
    pub fn bch2_dev_btree_bitmap_marked_sectors_any(
        ca: *mut bch_dev,
        start: u64_,
        sectors: ::std::os::raw::c_uint,
    ) -> bool;
}
unsafe extern "C" {
    pub fn bch2_dev_btree_bitmap_marked(arg1: *mut bch_fs, arg2: bkey_s_c) -> bool;
}
unsafe extern "C" {
    pub fn bch2_dev_btree_bitmap_marked_nogc(arg1: *mut bch_fs, arg2: bkey_s_c) -> bool;
}
unsafe extern "C" {
    pub fn bch2_dev_btree_bitmap_mark_locked(
        arg1: *mut bch_fs,
        arg2: bkey_s_c,
        arg3: *mut bool,
    );
}
unsafe extern "C" {
    pub fn bch2_dev_btree_bitmap_mark(arg1: *mut bch_fs, arg2: bkey_s_c);
}
unsafe extern "C" {
    pub fn bch2_btree_bitmap_gc(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_maybe_schedule_btree_bitmap_gc_stop(arg1: *mut bch_fs);
}
unsafe extern "C" {
    pub fn bch2_maybe_schedule_btree_bitmap_gc(arg1: *mut bch_fs);
}
unsafe extern "C" {
    pub fn bch2_sb_member_alloc(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_sb_members_clean_deleted(arg1: *mut bch_fs);
}
unsafe extern "C" {
    pub fn __bch2_dev_mi_field_upgrades(
        arg1: *mut bch_fs,
        arg2: *mut bch_dev,
        arg3: *mut bool,
    );
}
unsafe extern "C" {
    pub fn bch2_dev_mi_field_upgrades(arg1: *mut bch_dev);
}
unsafe extern "C" {
    pub fn bch2_fs_mi_field_upgrades(arg1: *mut bch_fs);
}
unsafe extern "C" {
    #[link_name = "bch2_prt_member_name__extern"]
    pub fn bch2_prt_member_name(
        out: *mut printbuf,
        c: *mut bch_fs,
        idx: ::std::os::raw::c_uint,
    );
}
unsafe extern "C" {
    #[link_name = "bch2_version_compatible__extern"]
    pub fn bch2_version_compatible(version: u16_) -> bool;
}
unsafe extern "C" {
    pub fn bch2_version_to_text(arg1: *mut printbuf, arg2: bcachefs_metadata_version);
}
unsafe extern "C" {
    pub fn bch2_latest_compatible_version(
        arg1: bcachefs_metadata_version,
    ) -> bcachefs_metadata_version;
}
unsafe extern "C" {
    pub fn bch2_set_version_incompat(
        arg1: *mut bch_fs,
        arg2: bcachefs_metadata_version,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_request_incompat_feature__extern"]
    pub fn bch2_request_incompat_feature(
        c: *mut bch_fs,
        version: bcachefs_metadata_version,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_sb_field_bytes__extern"]
    pub fn bch2_sb_field_bytes(f: *mut bch_sb_field) -> usize;
}
unsafe extern "C" {
    pub fn bch2_sb_field_get_id(
        arg1: *mut bch_sb,
        arg2: bch_sb_field_type,
    ) -> *mut bch_sb_field;
}
unsafe extern "C" {
    pub fn bch2_sb_field_resize_id(
        arg1: *mut bch_sb_handle,
        arg2: bch_sb_field_type,
        arg3: ::std::os::raw::c_uint,
    ) -> *mut bch_sb_field;
}
unsafe extern "C" {
    pub fn bch2_sb_field_get_minsize_id(
        arg1: *mut bch_sb_handle,
        arg2: bch_sb_field_type,
        arg3: ::std::os::raw::c_uint,
    ) -> *mut bch_sb_field;
}
unsafe extern "C" {
    pub fn bch2_sb_field_delete(arg1: *mut bch_sb_handle, arg2: bch_sb_field_type);
}
unsafe extern "C" {
    pub static bch2_sb_fields: [*const ::std::os::raw::c_char; 0usize];
}
unsafe extern "C" {
    #[link_name = "bch2_sb_magic__extern"]
    pub fn bch2_sb_magic(c: *mut bch_fs) -> __le64;
}
unsafe extern "C" {
    pub fn bch2_sb_to_fs(arg1: *mut bch_fs, arg2: *mut bch_sb) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_sb_from_fs(
        arg1: *mut bch_fs,
        arg2: *mut bch_dev,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_free_super(arg1: *mut bch_sb_handle);
}
unsafe extern "C" {
    pub fn bch2_sb_realloc(
        arg1: *mut bch_sb_handle,
        arg2: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_sb_validate(
        arg1: *mut bch_sb,
        arg2: *mut bch_opts,
        arg3: u64_,
        arg4: bch_validate_flags,
        arg5: *mut printbuf,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_read_super(
        arg1: *const ::std::os::raw::c_char,
        arg2: *mut bch_opts,
        arg3: *mut bch_sb_handle,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_read_super_silent(
        arg1: *const ::std::os::raw::c_char,
        arg2: *mut bch_opts,
        arg3: *mut bch_sb_handle,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_write_super(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn __bch2_check_set_feature(arg1: *mut bch_fs, arg2: ::std::os::raw::c_uint);
}
unsafe extern "C" {
    #[link_name = "bch2_check_set_feature__extern"]
    pub fn bch2_check_set_feature(c: *mut bch_fs, feat: ::std::os::raw::c_uint);
}
unsafe extern "C" {
    pub fn bch2_check_version_downgrade(arg1: *mut bch_fs) -> bool;
}
unsafe extern "C" {
    pub fn bch2_sb_upgrade(arg1: *mut bch_fs, arg2: ::std::os::raw::c_uint, arg3: bool);
}
unsafe extern "C" {
    pub fn bch2_sb_upgrade_incompat(arg1: *mut bch_fs);
}
unsafe extern "C" {
    pub fn __bch2_sb_field_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: *mut bch_sb,
        arg4: *mut bch_sb_field,
    );
}
unsafe extern "C" {
    pub fn bch2_sb_field_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: *mut bch_sb,
        arg4: *mut bch_sb_field,
    );
}
unsafe extern "C" {
    pub fn bch2_sb_layout_to_text(arg1: *mut printbuf, arg2: *mut bch_sb_layout);
}
unsafe extern "C" {
    pub fn bch2_sb_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: *mut bch_sb,
        arg4: bool,
        arg5: ::std::os::raw::c_uint,
    );
}
unsafe extern "C" {
    pub fn bch2_sb_counters_to_cpu(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_sb_counters_from_cpu(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_fs_counters_exit(arg1: *mut bch_fs);
}
unsafe extern "C" {
    pub fn bch2_fs_counters_init_early(arg1: *mut bch_fs);
}
unsafe extern "C" {
    pub fn bch2_fs_counters_init(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_fs_counters_init_late(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_counter_reset(arg1: *mut bch_fs, arg2: ::std::os::raw::c_uint);
}
unsafe extern "C" {
    pub static bch2_counter_names: [*const ::std::os::raw::c_char; 0usize];
}
unsafe extern "C" {
    pub static bch2_counter_flags_map: [bch_counters_flags; 0usize];
}
unsafe extern "C" {
    pub static bch2_counter_stable_map: [u16_; 0usize];
}
unsafe extern "C" {
    pub static bch_sb_field_ops_counters: bch_sb_field_ops;
}
unsafe extern "C" {
    pub fn bch2_ioctl_query_counters(
        arg1: *mut bch_fs,
        arg2: *mut bch_ioctl_query_counters,
    ) -> ::std::os::raw::c_long;
}
unsafe extern "C" {
    pub fn bch2_sb_recent_counters_to_text(out: *mut printbuf, c: *mut bch_fs_counters);
}
unsafe extern "C" {
    pub fn bch2_trans_updates_to_text(arg1: *mut printbuf, arg2: *mut btree_trans);
}
unsafe extern "C" {
    pub fn bch2_btree_path_to_text_short(
        arg1: *mut printbuf,
        arg2: *mut btree_trans,
        arg3: btree_path_idx_t,
        arg4: *mut btree_path,
    );
}
unsafe extern "C" {
    pub fn bch2_btree_path_to_text(
        arg1: *mut printbuf,
        arg2: *mut btree_trans,
        arg3: btree_path_idx_t,
        arg4: *mut btree_path,
    );
}
unsafe extern "C" {
    pub fn bch2_trans_paths_to_text(arg1: *mut printbuf, arg2: *mut btree_trans);
}
unsafe extern "C" {
    pub fn bch2_dump_trans_paths_updates(arg1: *mut btree_trans);
}
unsafe extern "C" {
    pub fn __bch2_btree_trans_sort_paths(arg1: *mut btree_trans);
}
unsafe extern "C" {
    pub fn __bch2_btree_path_make_mut(
        arg1: *mut btree_trans,
        arg2: btree_path_idx_t,
        arg3: bool,
        arg4: ::std::os::raw::c_ulong,
    ) -> btree_path_idx_t;
}
unsafe extern "C" {
    #[link_name = "bch2_btree_path_make_mut__extern"]
    pub fn bch2_btree_path_make_mut(
        trans: *mut btree_trans,
        path: btree_path_idx_t,
        intent: bool,
        ip: ::std::os::raw::c_ulong,
    ) -> btree_path_idx_t;
}
unsafe extern "C" {
    pub fn __bch2_btree_path_set_pos(
        arg1: *mut btree_trans,
        arg2: btree_path_idx_t,
        arg3: bpos,
        arg4: bool,
        arg5: ::std::os::raw::c_ulong,
    ) -> btree_path_idx_t;
}
unsafe extern "C" {
    #[link_name = "bch2_btree_path_set_pos__extern"]
    pub fn bch2_btree_path_set_pos(
        trans: *mut btree_trans,
        path: btree_path_idx_t,
        new_pos: bpos,
        intent: bool,
        ip: ::std::os::raw::c_ulong,
    ) -> btree_path_idx_t;
}
unsafe extern "C" {
    pub fn bch2_btree_path_traverse_one(
        arg1: *mut btree_trans,
        arg2: btree_path_idx_t,
        arg3: btree_iter_update_trigger_flags,
        arg4: ::std::os::raw::c_ulong,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_trans_verify_not_unlocked_or_in_restart__extern"]
    pub fn bch2_trans_verify_not_unlocked_or_in_restart(arg1: *mut btree_trans);
}
unsafe extern "C" {
    #[link_name = "bch2_btree_path_traverse__extern"]
    pub fn bch2_btree_path_traverse(
        trans: *mut btree_trans,
        path: btree_path_idx_t,
        flags: btree_iter_update_trigger_flags,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_path_get(
        arg1: *mut btree_trans,
        arg2: btree_id,
        arg3: bpos,
        arg4: ::std::os::raw::c_uint,
        arg5: ::std::os::raw::c_uint,
        arg6: btree_iter_update_trigger_flags,
        arg7: ::std::os::raw::c_ulong,
    ) -> btree_path_idx_t;
}
unsafe extern "C" {
    pub fn bch2_path_get_unlocked_mut(
        arg1: *mut btree_trans,
        arg2: btree_id,
        arg3: ::std::os::raw::c_uint,
        arg4: bpos,
        arg5: bool,
    ) -> btree_path_idx_t;
}
unsafe extern "C" {
    pub fn bch2_btree_path_peek_slot(arg1: *mut btree_path, arg2: *mut bkey) -> bkey_s_c;
}
unsafe extern "C" {
    #[link_name = "bch2_btree_path_peek_slot_exact__extern"]
    pub fn bch2_btree_path_peek_slot_exact(
        path: *mut btree_path,
        u: *mut bkey,
    ) -> bkey_s_c;
}
unsafe extern "C" {
    pub fn bch2_btree_path_level_init(
        arg1: *mut btree_trans,
        arg2: *mut btree_path,
        arg3: *mut btree,
    );
}
unsafe extern "C" {
    pub fn __bch2_trans_mutex_lock(
        arg1: *mut btree_trans,
        arg2: *mut mutex,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_trans_mutex_lock__extern"]
    pub fn bch2_trans_mutex_lock(
        trans: *mut btree_trans,
        lock: *mut mutex,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn __bch2_trans_verify_paths(arg1: *mut btree_trans);
}
unsafe extern "C" {
    pub fn __bch2_assert_pos_locked(arg1: *mut btree_trans, arg2: btree_id, arg3: bpos);
}
unsafe extern "C" {
    #[link_name = "bch2_trans_verify_paths__extern"]
    pub fn bch2_trans_verify_paths(trans: *mut btree_trans);
}
unsafe extern "C" {
    #[link_name = "bch2_assert_pos_locked__extern"]
    pub fn bch2_assert_pos_locked(trans: *mut btree_trans, btree: btree_id, pos: bpos);
}
unsafe extern "C" {
    pub fn bch2_btree_path_fix_key_modified(
        trans: *mut btree_trans,
        arg1: *mut btree,
        arg2: *mut bkey_packed,
    );
}
unsafe extern "C" {
    pub fn bch2_btree_node_iter_fix(
        trans: *mut btree_trans,
        arg1: *mut btree_path,
        arg2: *mut btree,
        arg3: *mut btree_node_iter,
        arg4: *mut bkey_packed,
        arg5: ::std::os::raw::c_uint,
        arg6: ::std::os::raw::c_uint,
    );
}
unsafe extern "C" {
    pub fn bch2_btree_path_relock_intent(
        arg1: *mut btree_trans,
        arg2: *mut btree_path,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_path_put(arg1: *mut btree_trans, arg2: btree_path_idx_t, arg3: bool);
}
unsafe extern "C" {
    pub fn bch2_trans_relock(arg1: *mut btree_trans) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_trans_relock_notrace(arg1: *mut btree_trans) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_trans_unlock(arg1: *mut btree_trans);
}
unsafe extern "C" {
    pub fn bch2_trans_unlock_long(arg1: *mut btree_trans);
}
unsafe extern "C" {
    #[link_name = "bch2_trans_short_wait_budget__extern"]
    pub fn bch2_trans_short_wait_budget(
        trans: *mut btree_trans,
        timeout: ::std::os::raw::c_long,
    ) -> ::std::os::raw::c_long;
}
unsafe extern "C" {
    pub fn bch2_trans_restart_error(arg1: *mut btree_trans, arg2: u32_) -> !;
}
unsafe extern "C" {
    #[link_name = "bch2_trans_verify_not_restarted__extern"]
    pub fn bch2_trans_verify_not_restarted(trans: *mut btree_trans, restart_count: u32_);
}
unsafe extern "C" {
    pub fn bch2_trans_unlocked_or_in_restart_error(arg1: *mut btree_trans) -> !;
}
unsafe extern "C" {
    pub fn bch2_btree_node_upgrade(
        arg1: *mut btree_trans,
        arg2: *mut btree_path,
        arg3: ::std::os::raw::c_uint,
    ) -> bool;
}
unsafe extern "C" {
    pub fn __bch2_btree_path_downgrade(
        arg1: *mut btree_trans,
        arg2: *mut btree_path,
        arg3: ::std::os::raw::c_uint,
    );
}
unsafe extern "C" {
    #[link_name = "bch2_btree_path_downgrade__extern"]
    pub fn bch2_btree_path_downgrade(trans: *mut btree_trans, path: *mut btree_path);
}
unsafe extern "C" {
    pub fn bch2_trans_downgrade(arg1: *mut btree_trans);
}
unsafe extern "C" {
    pub fn bch2_trans_revalidate_updates_in_node(
        arg1: *mut btree_trans,
        arg2: *mut btree,
    );
}
unsafe extern "C" {
    pub fn bch2_trans_node_add(
        trans: *mut btree_trans,
        arg1: *mut btree_path,
        arg2: *mut btree,
    );
}
unsafe extern "C" {
    pub fn bch2_trans_node_drop(trans: *mut btree_trans, arg1: *mut btree);
}
unsafe extern "C" {
    pub fn bch2_trans_node_reinit_iter(arg1: *mut btree_trans, arg2: *mut btree);
}
unsafe extern "C" {
    pub fn __bch2_btree_iter_traverse(iter: *mut btree_iter) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_btree_iter_traverse(arg1: *mut btree_iter) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_btree_iter_peek_node(arg1: *mut btree_iter) -> *mut btree;
}
unsafe extern "C" {
    pub fn bch2_btree_iter_peek_max(arg1: *mut btree_iter, arg2: bpos) -> bkey_s_c;
}
unsafe extern "C" {
    pub fn bch2_btree_iter_next(arg1: *mut btree_iter) -> bkey_s_c;
}
unsafe extern "C" {
    #[link_name = "bch2_btree_iter_peek__extern"]
    pub fn bch2_btree_iter_peek(iter: *mut btree_iter) -> bkey_s_c;
}
unsafe extern "C" {
    pub fn bch2_btree_iter_peek_prev_min(arg1: *mut btree_iter, arg2: bpos) -> bkey_s_c;
}
unsafe extern "C" {
    #[link_name = "bch2_btree_iter_peek_prev__extern"]
    pub fn bch2_btree_iter_peek_prev(iter: *mut btree_iter) -> bkey_s_c;
}
unsafe extern "C" {
    pub fn bch2_btree_iter_prev(arg1: *mut btree_iter) -> bkey_s_c;
}
unsafe extern "C" {
    pub fn bch2_btree_iter_peek_slot(arg1: *mut btree_iter) -> bkey_s_c;
}
unsafe extern "C" {
    pub fn bch2_btree_iter_next_slot(arg1: *mut btree_iter) -> bkey_s_c;
}
unsafe extern "C" {
    pub fn bch2_btree_iter_prev_slot(arg1: *mut btree_iter) -> bkey_s_c;
}
unsafe extern "C" {
    pub fn bch2_btree_iter_advance(arg1: *mut btree_iter) -> bool;
}
unsafe extern "C" {
    pub fn bch2_btree_iter_rewind(arg1: *mut btree_iter) -> bool;
}
unsafe extern "C" {
    #[link_name = "__bch2_btree_iter_set_pos__extern"]
    pub fn __bch2_btree_iter_set_pos(iter: *mut btree_iter, new_pos: bpos);
}
unsafe extern "C" {
    #[link_name = "bch2_btree_iter_set_pos__extern"]
    pub fn bch2_btree_iter_set_pos(iter: *mut btree_iter, new_pos: bpos);
}
unsafe extern "C" {
    #[link_name = "bch2_btree_iter_set_pos_to_extent_start__extern"]
    pub fn bch2_btree_iter_set_pos_to_extent_start(iter: *mut btree_iter);
}
unsafe extern "C" {
    #[link_name = "bch2_btree_iter_set_snapshot__extern"]
    pub fn bch2_btree_iter_set_snapshot(iter: *mut btree_iter, snapshot: u32_);
}
unsafe extern "C" {
    pub fn bch2_trans_iter_exit(arg1: *mut btree_iter);
}
unsafe extern "C" {
    #[link_name = "bch2_btree_iter_flags__extern"]
    pub fn bch2_btree_iter_flags(
        trans: *mut btree_trans,
        btree_id: ::std::os::raw::c_uint,
        level: ::std::os::raw::c_uint,
        flags: btree_iter_update_trigger_flags,
    ) -> btree_iter_update_trigger_flags;
}
unsafe extern "C" {
    #[link_name = "bch2_trans_iter_init_common__extern"]
    pub fn bch2_trans_iter_init_common(
        trans: *mut btree_trans,
        iter: *mut btree_iter,
        btree: btree_id,
        pos: bpos,
        locks_want: ::std::os::raw::c_uint,
        depth: ::std::os::raw::c_uint,
        flags: btree_iter_update_trigger_flags,
        ip: ::std::os::raw::c_ulong,
    );
}
unsafe extern "C" {
    pub fn bch2_trans_iter_init_outlined(
        arg1: *mut btree_trans,
        arg2: *mut btree_iter,
        arg3: btree_id,
        arg4: bpos,
        arg5: btree_iter_update_trigger_flags,
        ip: ::std::os::raw::c_ulong,
    );
}
unsafe extern "C" {
    #[link_name = "__bch2_trans_iter_init__extern"]
    pub fn __bch2_trans_iter_init(
        trans: *mut btree_trans,
        iter: *mut btree_iter,
        btree: btree_id,
        pos: bpos,
        flags: btree_iter_update_trigger_flags,
    );
}
unsafe extern "C" {
    #[link_name = "bch2_trans_iter_init__extern"]
    pub fn bch2_trans_iter_init(
        trans: *mut btree_trans,
        iter: *mut btree_iter,
        btree: btree_id,
        pos: bpos,
        flags: btree_iter_update_trigger_flags,
    );
}
unsafe extern "C" {
    pub fn bch2_trans_copy_iter(arg1: *mut btree_iter, arg2: *mut btree_iter);
}
unsafe extern "C" {
    pub fn __bch2_trans_node_iter_init(
        arg1: *mut btree_trans,
        arg2: *mut btree_iter,
        arg3: btree_id,
        arg4: bpos,
        arg5: ::std::os::raw::c_uint,
        arg6: ::std::os::raw::c_uint,
        arg7: btree_iter_update_trigger_flags,
    );
}
unsafe extern "C" {
    #[link_name = "bch2_trans_node_iter_init__extern"]
    pub fn bch2_trans_node_iter_init(
        trans: *mut btree_trans,
        iter: *mut btree_iter,
        btree: btree_id,
        pos: bpos,
        locks_want: ::std::os::raw::c_uint,
        depth: ::std::os::raw::c_uint,
        flags: btree_iter_update_trigger_flags,
    );
}
unsafe extern "C" {
    pub fn bch2_set_btree_iter_dontneed(arg1: *mut btree_iter);
}
unsafe extern "C" {
    pub fn __bch2_trans_kmalloc(
        arg1: *mut btree_trans,
        arg2: usize,
        arg3: ::std::os::raw::c_ulong,
    ) -> *mut ::std::os::raw::c_void;
}
unsafe extern "C" {
    #[link_name = "bch2_trans_kmalloc_trace__extern"]
    pub fn bch2_trans_kmalloc_trace(
        trans: *mut btree_trans,
        size: usize,
        ip: ::std::os::raw::c_ulong,
    );
}
unsafe extern "C" {
    #[link_name = "bch2_trans_kmalloc_nomemzero_ip__extern"]
    pub fn bch2_trans_kmalloc_nomemzero_ip(
        trans: *mut btree_trans,
        size: usize,
        ip: ::std::os::raw::c_ulong,
    ) -> *mut ::std::os::raw::c_void;
}
unsafe extern "C" {
    #[link_name = "bch2_trans_kmalloc_ip__extern"]
    pub fn bch2_trans_kmalloc_ip(
        trans: *mut btree_trans,
        size: usize,
        ip: ::std::os::raw::c_ulong,
    ) -> *mut ::std::os::raw::c_void;
}
unsafe extern "C" {
    /** bch2_trans_kmalloc - allocate memory for use by the current transaction

 Must be called after bch2_trans_begin, which on second and further calls
 frees all memory allocated in this transaction*/
    #[link_name = "bch2_trans_kmalloc__extern"]
    pub fn bch2_trans_kmalloc(
        trans: *mut btree_trans,
        size: usize,
    ) -> *mut ::std::os::raw::c_void;
}
unsafe extern "C" {
    #[link_name = "bch2_trans_kmalloc_nomemzero__extern"]
    pub fn bch2_trans_kmalloc_nomemzero(
        trans: *mut btree_trans,
        size: usize,
    ) -> *mut ::std::os::raw::c_void;
}
unsafe extern "C" {
    #[link_name = "__bch2_bkey_get_typed__extern"]
    pub fn __bch2_bkey_get_typed(
        iter: *mut btree_iter,
        type_: bch_bkey_type,
    ) -> bkey_s_c;
}
unsafe extern "C" {
    #[link_name = "__bch2_bkey_get_val_typed__extern"]
    pub fn __bch2_bkey_get_val_typed(
        trans: *mut btree_trans,
        btree: btree_id,
        pos: bpos,
        flags: btree_iter_update_trigger_flags,
        type_: bch_bkey_type,
        val_size: ::std::os::raw::c_uint,
        val: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_trans_begin(arg1: *mut btree_trans) -> u32_;
}
unsafe extern "C" {
    #[link_name = "bch2_btree_iter_peek_prev_type__extern"]
    pub fn bch2_btree_iter_peek_prev_type(
        iter: *mut btree_iter,
        flags: btree_iter_update_trigger_flags,
    ) -> bkey_s_c;
}
unsafe extern "C" {
    #[link_name = "bch2_btree_iter_peek_type__extern"]
    pub fn bch2_btree_iter_peek_type(
        iter: *mut btree_iter,
        flags: btree_iter_update_trigger_flags,
    ) -> bkey_s_c;
}
unsafe extern "C" {
    #[link_name = "bch2_btree_iter_peek_max_type__extern"]
    pub fn bch2_btree_iter_peek_max_type(
        iter: *mut btree_iter,
        end: bpos,
        flags: btree_iter_update_trigger_flags,
    ) -> bkey_s_c;
}
unsafe extern "C" {
    pub fn __bch2_btree_trans_too_many_iters(
        arg1: *mut btree_trans,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_btree_iter_peek_and_restart_outlined(arg1: *mut btree_iter) -> bkey_s_c;
}
unsafe extern "C" {
    pub fn bch2_btree_iter_peek_root(
        arg1: *mut btree_trans,
        arg2: *mut btree_iter,
        arg3: btree_id,
        arg4: ::std::os::raw::c_uint,
    ) -> bkey_s_c;
}
unsafe extern "C" {
    pub fn __bch2_trans_get(
        arg1: *mut bch_fs,
        arg2: ::std::os::raw::c_uint,
    ) -> *mut btree_trans;
}
unsafe extern "C" {
    pub fn bch2_trans_put(arg1: *mut btree_trans);
}
unsafe extern "C" {
    pub fn bch2_current_has_btree_trans(arg1: *mut bch_fs) -> bool;
}
unsafe extern "C" {
    pub static mut bch2_btree_transaction_fns: [*const ::std::os::raw::c_char; 128usize];
}
unsafe extern "C" {
    pub fn bch2_trans_get_fn_idx(
        arg1: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_uint;
}
unsafe extern "C" {
    pub fn bch2_btree_trans_to_text(arg1: *mut printbuf, arg2: *mut btree_trans);
}
unsafe extern "C" {
    pub fn bch2_fs_btree_iter_exit(arg1: *mut bch_fs);
}
unsafe extern "C" {
    pub fn bch2_fs_btree_iter_init_early(arg1: *mut bch_fs);
}
unsafe extern "C" {
    pub fn bch2_fs_btree_iter_init(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_checksum_mergeable__extern"]
    pub fn bch2_checksum_mergeable(type_: ::std::os::raw::c_uint) -> bool;
}
unsafe extern "C" {
    pub fn bch2_checksum_merge(
        arg1: ::std::os::raw::c_uint,
        arg2: bch_csum,
        arg3: bch_csum,
        arg4: usize,
    ) -> bch_csum;
}
unsafe extern "C" {
    pub fn bch2_checksum(
        arg1: *mut bch_fs,
        arg2: ::std::os::raw::c_uint,
        arg3: nonce,
        arg4: *const ::std::os::raw::c_void,
        arg5: usize,
    ) -> bch_csum;
}
unsafe extern "C" {
    #[link_name = "bch2_csum_to_text__extern"]
    pub fn bch2_csum_to_text(out: *mut printbuf, type_: bch_csum_type, csum: bch_csum);
}
unsafe extern "C" {
    #[link_name = "bch2_csum_err_msg__extern"]
    pub fn bch2_csum_err_msg(
        out: *mut printbuf,
        type_: bch_csum_type,
        expected: bch_csum,
        got: bch_csum,
    );
}
unsafe extern "C" {
    pub fn bch2_chacha20(
        arg1: *const bch_key,
        arg2: nonce,
        arg3: *mut ::std::os::raw::c_void,
        arg4: usize,
    );
}
unsafe extern "C" {
    pub fn bch2_request_key(
        arg1: *mut bch_sb,
        arg2: *mut bch_key,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_revoke_key(arg1: *mut bch_sb) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_encrypt(
        arg1: *mut bch_fs,
        arg2: ::std::os::raw::c_uint,
        arg3: nonce,
        data: *mut ::std::os::raw::c_void,
        arg4: usize,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_checksum_bio(
        arg1: *mut bch_fs,
        arg2: ::std::os::raw::c_uint,
        arg3: nonce,
        arg4: *mut bio,
    ) -> bch_csum;
}
unsafe extern "C" {
    pub fn bch2_rechecksum_bio(
        arg1: *mut bch_fs,
        arg2: *mut bio,
        arg3: bversion,
        arg4: bch_extent_crc_unpacked,
        arg5: *mut bch_extent_crc_unpacked,
        arg6: *mut bch_extent_crc_unpacked,
        arg7: ::std::os::raw::c_uint,
        arg8: ::std::os::raw::c_uint,
        arg9: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn __bch2_encrypt_bio(
        arg1: *mut bch_fs,
        arg2: ::std::os::raw::c_uint,
        arg3: nonce,
        arg4: *mut bio,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_encrypt_bio__extern"]
    pub fn bch2_encrypt_bio(
        c: *mut bch_fs,
        type_: ::std::os::raw::c_uint,
        nonce: nonce,
        bio: *mut bio,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub static bch_sb_field_ops_crypt: bch_sb_field_ops;
}
unsafe extern "C" {
    pub fn bch2_decrypt_sb_key(
        arg1: *mut bch_fs,
        arg2: *mut bch_sb_field_crypt,
        arg3: *mut bch_key,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_fs_encryption_exit(arg1: *mut bch_fs);
}
unsafe extern "C" {
    pub fn bch2_fs_encryption_init(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_csum_opt_to_type__extern"]
    pub fn bch2_csum_opt_to_type(type_: bch_csum_opt, data: bool) -> bch_csum_type;
}
unsafe extern "C" {
    #[link_name = "bch2_data_checksum_type__extern"]
    pub fn bch2_data_checksum_type(
        c: *mut bch_fs,
        opts: bch_inode_opts,
    ) -> bch_csum_type;
}
unsafe extern "C" {
    #[link_name = "bch2_data_checksum_type_rb__extern"]
    pub fn bch2_data_checksum_type_rb(
        c: *mut bch_fs,
        opts: bch_extent_reconcile,
    ) -> bch_csum_type;
}
unsafe extern "C" {
    #[link_name = "bch2_meta_checksum_type__extern"]
    pub fn bch2_meta_checksum_type(c: *mut bch_fs) -> bch_csum_type;
}
unsafe extern "C" {
    #[link_name = "bch2_checksum_type_valid__extern"]
    pub fn bch2_checksum_type_valid(
        c: *const bch_fs,
        type_: ::std::os::raw::c_uint,
    ) -> bool;
}
unsafe extern "C" {
    #[link_name = "bch2_crc_cmp__extern"]
    pub fn bch2_crc_cmp(l: bch_csum, r: bch_csum) -> bool;
}
unsafe extern "C" {
    #[link_name = "bch2_key_is_encrypted__extern"]
    pub fn bch2_key_is_encrypted(key: *mut bch_encrypted_key) -> bool;
}
unsafe extern "C" {
    #[link_name = "__bch2_sb_key_nonce__extern"]
    pub fn __bch2_sb_key_nonce(sb: *mut bch_sb) -> nonce;
}
unsafe extern "C" {
    #[link_name = "bch2_sb_key_nonce__extern"]
    pub fn bch2_sb_key_nonce(c: *mut bch_fs) -> nonce;
}
unsafe extern "C" {
    pub fn bch2_extent_fallocate(
        arg1: *mut btree_trans,
        arg2: subvol_inum,
        arg3: *mut btree_iter,
        arg4: u64_,
        arg5: bch_inode_opts,
        arg6: *mut s64,
        arg7: write_point_specifier,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_fpunch_snapshot(
        arg1: *mut btree_trans,
        arg2: bpos,
        arg3: bpos,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_fpunch_at(
        arg1: *mut btree_trans,
        arg2: *mut btree_iter,
        arg3: subvol_inum,
        arg4: u64_,
        arg5: *mut s64,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_fpunch(
        c: *mut bch_fs,
        arg1: subvol_inum,
        arg2: u64_,
        arg3: u64_,
        arg4: *mut s64,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_logged_op_truncate_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: bkey_s_c,
    );
}
unsafe extern "C" {
    pub fn bch2_resume_logged_op_truncate(
        arg1: *mut btree_trans,
        arg2: *mut bkey_i,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_truncate(
        arg1: *mut bch_fs,
        arg2: subvol_inum,
        arg3: u64_,
        arg4: *mut u64_,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_logged_op_finsert_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: bkey_s_c,
    );
}
unsafe extern "C" {
    pub fn bch2_resume_logged_op_finsert(
        arg1: *mut btree_trans,
        arg2: *mut bkey_i,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_fcollapse_finsert(
        arg1: *mut bch_fs,
        arg2: subvol_inum,
        arg3: u64_,
        arg4: u64_,
        arg5: bool,
        arg6: *mut s64,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_dev_usage_read_fast(arg1: *mut bch_dev, arg2: *mut bch_dev_usage);
}
unsafe extern "C" {
    #[link_name = "bch2_dev_usage_read__extern"]
    pub fn bch2_dev_usage_read(ca: *mut bch_dev) -> bch_dev_usage;
}
unsafe extern "C" {
    pub fn bch2_dev_usage_full_read_fast(
        arg1: *mut bch_dev,
        arg2: *mut bch_dev_usage_full,
    );
}
unsafe extern "C" {
    #[link_name = "bch2_dev_usage_full_read__extern"]
    pub fn bch2_dev_usage_full_read(ca: *mut bch_dev) -> bch_dev_usage_full;
}
unsafe extern "C" {
    pub fn bch2_dev_usage_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_dev,
        arg3: *mut bch_dev_usage_full,
    );
}
unsafe extern "C" {
    #[link_name = "bch2_dev_buckets_reserved__extern"]
    pub fn bch2_dev_buckets_reserved(ca: *mut bch_dev, watermark: bch_watermark) -> u64_;
}
unsafe extern "C" {
    pub fn bch2_fs_usage_read_short(arg1: *mut bch_fs) -> bch_fs_usage_short;
}
unsafe extern "C" {
    pub fn bch2_bucket_ref_update(
        arg1: *mut btree_trans,
        arg2: *mut bch_dev,
        arg3: bkey_s_c,
        arg4: *const bch_extent_ptr,
        arg5: s64,
        arg6: bch_data_type,
        arg7: u8_,
        arg8: u8_,
        arg9: *mut u32_,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_check_fix_ptrs(
        arg1: *mut btree_trans,
        arg2: *mut btree_iter,
        arg3: btree_id,
        arg4: ::std::os::raw::c_uint,
        arg5: bkey_s_c,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_trigger_extent(
        arg1: *mut btree_trans,
        arg2: btree_trigger_op,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_trigger_reservation(
        arg1: *mut btree_trans,
        arg2: btree_trigger_op,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_trans_account_disk_usage_change(arg1: *mut btree_trans);
}
unsafe extern "C" {
    pub fn bch2_trans_mark_metadata_bucket(
        arg1: *mut btree_trans,
        arg2: *mut bch_dev,
        arg3: u64_,
        arg4: bch_data_type,
        arg5: ::std::os::raw::c_uint,
        arg6: btree_iter_update_trigger_flags,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_trans_mark_dev_sb(
        arg1: *mut bch_fs,
        arg2: *mut bch_dev,
        arg3: btree_iter_update_trigger_flags,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_trans_mark_dev_sbs_flags(
        arg1: *mut bch_fs,
        arg2: btree_iter_update_trigger_flags,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_trans_mark_dev_sbs(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_is_superblock_bucket(arg1: *mut bch_dev, arg2: u64_) -> bool;
}
unsafe extern "C" {
    #[link_name = "bch2_data_type_str__extern"]
    pub fn bch2_data_type_str(type_: bch_data_type) -> *const ::std::os::raw::c_char;
}
unsafe extern "C" {
    #[link_name = "bch2_disk_reservation_put__extern"]
    pub fn bch2_disk_reservation_put(c: *mut bch_fs, res: *mut disk_reservation);
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_reservation_flags {
    BCH_DISK_RESERVATION_NOFAIL = 1,
    BCH_DISK_RESERVATION_PARTIAL = 2,
}
unsafe extern "C" {
    pub fn __bch2_disk_reservation_add(
        arg1: *mut bch_fs,
        arg2: *mut disk_reservation,
        arg3: u64_,
        arg4: bch_reservation_flags,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_disk_reservation_add__extern"]
    pub fn bch2_disk_reservation_add(
        c: *mut bch_fs,
        res: *mut disk_reservation,
        sectors: u64_,
        flags: bch_reservation_flags,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_disk_reservation_init__extern"]
    pub fn bch2_disk_reservation_init(
        c: *mut bch_fs,
        nr_replicas: ::std::os::raw::c_uint,
    ) -> disk_reservation;
}
unsafe extern "C" {
    #[link_name = "bch2_disk_reservation_get__extern"]
    pub fn bch2_disk_reservation_get(
        c: *mut bch_fs,
        res: *mut disk_reservation,
        sectors: u64_,
        nr_replicas: ::std::os::raw::c_uint,
        flags: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_buckets_nouse_free(arg1: *mut bch_fs);
}
unsafe extern "C" {
    pub fn bch2_buckets_nouse_alloc(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_bucket_nouse__extern"]
    pub fn bch2_bucket_nouse(ca: *mut bch_dev, bucket: u64_) -> bool;
}
unsafe extern "C" {
    pub fn bch2_dev_buckets_resize(
        arg1: *mut bch_fs,
        arg2: *mut bch_dev,
        arg3: u64_,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_dev_buckets_free(arg1: *mut bch_dev);
}
unsafe extern "C" {
    pub fn bch2_dev_buckets_alloc(
        arg1: *mut bch_fs,
        arg2: *mut bch_dev,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_bbpos_to_text__extern"]
    pub fn bch2_bbpos_to_text(out: *mut printbuf, pos: bbpos);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bkey_buf {
    pub k: *mut bkey_i,
    pub onstack: [u64_; 12usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_buf"][::std::mem::size_of::<bkey_buf>() - 104usize];
    ["Alignment of bkey_buf"][::std::mem::align_of::<bkey_buf>() - 8usize];
    ["Offset of field: bkey_buf::k"][::std::mem::offset_of!(bkey_buf, k) - 0usize];
    [
        "Offset of field: bkey_buf::onstack",
    ][::std::mem::offset_of!(bkey_buf, onstack) - 8usize];
};
impl Default for bkey_buf {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C" {
    #[link_name = "bch2_bkey_buf_realloc_noprof__extern"]
    pub fn bch2_bkey_buf_realloc_noprof(
        s: *mut bkey_buf,
        u64s: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_bkey_buf_reassemble_noprof__extern"]
    pub fn bch2_bkey_buf_reassemble_noprof(
        s: *mut bkey_buf,
        k: bkey_s_c,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_bkey_buf_copy_noprof__extern"]
    pub fn bch2_bkey_buf_copy_noprof(
        s: *mut bkey_buf,
        src: *mut bkey_i,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_bkey_buf_unpack_noprof__extern"]
    pub fn bch2_bkey_buf_unpack_noprof(
        s: *mut bkey_buf,
        b: *mut btree,
        src: *mut bkey_packed,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_bkey_buf_init__extern"]
    pub fn bch2_bkey_buf_init(s: *mut bkey_buf);
}
unsafe extern "C" {
    #[link_name = "bch2_bkey_buf_exit__extern"]
    pub fn bch2_bkey_buf_exit(s: *mut bkey_buf);
}
unsafe extern "C" {
    #[link_name = "bch2_journal_add_entry_noreservation__extern"]
    pub fn bch2_journal_add_entry_noreservation(
        buf: *mut journal_buf,
        u64s: usize,
    ) -> *mut jset_entry;
}
unsafe extern "C" {
    #[link_name = "bch2_journal_add_entry__extern"]
    pub fn bch2_journal_add_entry(
        j: *mut journal,
        res: *mut journal_res,
        type_: ::std::os::raw::c_uint,
        id: btree_id,
        level: ::std::os::raw::c_uint,
        u64s: ::std::os::raw::c_uint,
    ) -> *mut jset_entry;
}
unsafe extern "C" {
    pub fn bch2_journal_entry_close(arg1: *mut journal) -> bool;
}
unsafe extern "C" {
    pub fn bch2_journal_do_writes_locked(arg1: *mut journal);
}
unsafe extern "C" {
    pub fn bch2_journal_do_writes(arg1: *mut journal);
}
unsafe extern "C" {
    pub fn bch2_journal_buf_put_final(arg1: *mut journal, arg2: u64_);
}
unsafe extern "C" {
    #[link_name = "__bch2_journal_buf_put__extern"]
    pub fn __bch2_journal_buf_put(j: *mut journal, seq: u64_);
}
unsafe extern "C" {
    #[link_name = "bch2_journal_buf_put__extern"]
    pub fn bch2_journal_buf_put(j: *mut journal, seq: u64_);
}
unsafe extern "C" {
    #[link_name = "bch2_journal_res_put__extern"]
    pub fn bch2_journal_res_put(j: *mut journal, res: *mut journal_res);
}
unsafe extern "C" {
    pub fn bch2_journal_res_get_slowpath(
        arg1: *mut journal,
        arg2: *mut journal_res,
        arg3: ::std::os::raw::c_uint,
        arg4: *mut btree_trans,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_journal_res_get__extern"]
    pub fn bch2_journal_res_get(
        j: *mut journal,
        res: *mut journal_res,
        u64s: ::std::os::raw::c_uint,
        flags: ::std::os::raw::c_uint,
        trans: *mut btree_trans,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_journal_quiesce(arg1: *mut journal);
}
unsafe extern "C" {
    pub fn bch2_journal_shutdown_quiesce(arg1: *mut journal);
}
unsafe extern "C" {
    pub fn bch2_journal_write_work(arg1: *mut work_struct);
}
unsafe extern "C" {
    pub fn bch2_journal_entry_res_resize(
        arg1: *mut journal,
        arg2: *mut journal_entry_res,
        arg3: ::std::os::raw::c_uint,
    );
}
unsafe extern "C" {
    pub fn bch2_journal_flush_seq_async(
        arg1: *mut journal,
        arg2: u64_,
        arg3: ::std::os::raw::c_uint,
        arg4: *mut closure,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_journal_flush_async(
        arg1: *mut journal,
        arg2: ::std::os::raw::c_uint,
        arg3: *mut closure,
    );
}
unsafe extern "C" {
    pub fn bch2_journal_flush_seq(
        arg1: *mut journal,
        arg2: u64_,
        arg3: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_journal_flush(arg1: *mut journal) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_journal_advance_rewind_seq(arg1: *mut journal, arg2: u64_);
}
unsafe extern "C" {
    pub fn bch2_journal_add_rewind_range(
        arg1: *mut bch_fs,
        arg2: u64_,
        arg3: u64_,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_journal_noflush_seq(arg1: *mut journal, arg2: u64_, arg3: u64_) -> bool;
}
unsafe extern "C" {
    pub fn __bch2_journal_meta(arg1: *mut journal) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_journal_meta(arg1: *mut journal) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_journal_halt_locked(arg1: *mut journal);
}
unsafe extern "C" {
    pub fn bch2_journal_halt(arg1: *mut journal);
}
unsafe extern "C" {
    #[link_name = "bch2_journal_error__extern"]
    pub fn bch2_journal_error(j: *mut journal) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_journal_unblock(arg1: *mut journal);
}
unsafe extern "C" {
    pub fn bch2_journal_block(arg1: *mut journal);
}
unsafe extern "C" {
    pub fn bch2_next_write_buffer_flush_journal_buf(
        arg1: *mut journal,
        arg2: u64_,
        arg3: *mut bool,
    ) -> *mut journal_buf;
}
unsafe extern "C" {
    pub fn __bch2_journal_debug_to_text(arg1: *mut printbuf, arg2: *mut journal);
}
unsafe extern "C" {
    pub fn bch2_journal_debug_to_text(arg1: *mut printbuf, arg2: *mut journal);
}
unsafe extern "C" {
    pub fn bch2_snapshot_tree_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: bkey_s_c,
    );
}
unsafe extern "C" {
    pub fn bch2_snapshot_tree_validate(
        arg1: *mut bch_fs,
        arg2: bkey_s_c,
        arg3: bkey_validate_context,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn __bch2_snapshot_tree_create(
        arg1: *mut btree_trans,
    ) -> *mut bkey_i_snapshot_tree;
}
unsafe extern "C" {
    pub fn bch2_snapshot_tree_lookup(
        arg1: *mut btree_trans,
        arg2: u32_,
        arg3: *mut bch_snapshot_tree,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_snapshot_to_text(arg1: *mut printbuf, arg2: *const bch_snapshot);
}
unsafe extern "C" {
    pub fn bch2_snapshot_key_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: bkey_s_c,
    );
}
unsafe extern "C" {
    pub fn bch2_snapshot_validate(
        arg1: *mut bch_fs,
        arg2: bkey_s_c,
        arg3: bkey_validate_context,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_mark_snapshot(
        arg1: *mut btree_trans,
        arg2: btree_trigger_op,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_snapshot_tree_keys_to_text(
        arg1: *mut printbuf,
        arg2: *mut btree_trans,
        arg3: u32_,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_check_snapshot_needs_deletion(
        arg1: *mut btree_trans,
        arg2: bkey_s_c,
        arg3: *mut u32_,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_snapshot_t_mut(arg1: *mut bch_fs, arg2: u32_) -> *mut snapshot_t;
}
unsafe extern "C" {
    #[link_name = "bch2_snapshot_tree__extern"]
    pub fn bch2_snapshot_tree(c: *mut bch_fs, id: u32_) -> u32_;
}
unsafe extern "C" {
    #[link_name = "bch2_snapshots_same_tree__extern"]
    pub fn bch2_snapshots_same_tree(c: *mut bch_fs, id1: u32_, id2: u32_) -> bool;
}
unsafe extern "C" {
    #[link_name = "__bch2_snapshot_parent_early__extern"]
    pub fn __bch2_snapshot_parent_early(c: *mut bch_fs, id: u32_) -> u32_;
}
unsafe extern "C" {
    #[link_name = "bch2_snapshot_parent_early__extern"]
    pub fn bch2_snapshot_parent_early(c: *mut bch_fs, id: u32_) -> u32_;
}
unsafe extern "C" {
    #[link_name = "__bch2_snapshot_parent__extern"]
    pub fn __bch2_snapshot_parent(
        c: *mut bch_fs,
        t: *mut snapshot_table,
        id: u32_,
    ) -> u32_;
}
unsafe extern "C" {
    #[link_name = "bch2_snapshot_parent__extern"]
    pub fn bch2_snapshot_parent(c: *mut bch_fs, id: u32_) -> u32_;
}
unsafe extern "C" {
    #[link_name = "bch2_snapshot_nth_parent__extern"]
    pub fn bch2_snapshot_nth_parent(c: *mut bch_fs, id: u32_, n: u32_) -> u32_;
}
unsafe extern "C" {
    pub fn bch2_snapshot_skiplist_get(arg1: *mut bch_fs, arg2: u32_) -> u32_;
}
unsafe extern "C" {
    #[link_name = "bch2_snapshot_root__extern"]
    pub fn bch2_snapshot_root(c: *mut bch_fs, id: u32_) -> u32_;
}
unsafe extern "C" {
    #[link_name = "__bch2_snapshot_exists__extern"]
    pub fn __bch2_snapshot_exists(t: *mut snapshot_table, id: u32_) -> bool;
}
unsafe extern "C" {
    #[link_name = "bch2_snapshot_exists__extern"]
    pub fn bch2_snapshot_exists(c: *mut bch_fs, id: u32_) -> bool;
}
unsafe extern "C" {
    #[link_name = "bch2_snapshot_is_internal_node__extern"]
    pub fn bch2_snapshot_is_internal_node(
        c: *mut bch_fs,
        id: u32_,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_snapshot_is_leaf__extern"]
    pub fn bch2_snapshot_is_leaf(c: *mut bch_fs, id: u32_) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_snapshot_depth__extern"]
    pub fn bch2_snapshot_depth(c: *mut bch_fs, parent: u32_) -> u32_;
}
unsafe extern "C" {
    #[link_name = "bch2_snapshot_live_descendent__extern"]
    pub fn bch2_snapshot_live_descendent(c: *mut bch_fs, id: u32_) -> u32_;
}
unsafe extern "C" {
    pub fn __bch2_snapshot_is_ancestor(
        arg1: *mut btree_trans,
        arg2: u32_,
        arg3: u32_,
    ) -> bool;
}
unsafe extern "C" {
    #[link_name = "bch2_snapshot_is_ancestor__extern"]
    pub fn bch2_snapshot_is_ancestor(
        trans: *mut btree_trans,
        id: u32_,
        ancestor: u32_,
    ) -> bool;
}
unsafe extern "C" {
    pub fn bch2_snapshot_is_ancestor_early(
        arg1: *mut bch_fs,
        arg2: u32_,
        arg3: u32_,
    ) -> bool;
}
unsafe extern "C" {
    #[link_name = "bch2_snapshot_has_children__extern"]
    pub fn bch2_snapshot_has_children(c: *mut bch_fs, id: u32_) -> bool;
}
unsafe extern "C" {
    pub fn bch2_snapshot_id_list_to_text(
        arg1: *mut printbuf,
        arg2: *mut snapshot_id_list,
    );
}
unsafe extern "C" {
    pub fn __bch2_snapshot_tree_next(
        arg1: *mut bch_fs,
        arg2: *mut snapshot_table,
        arg3: u32_,
        arg4: *mut ::std::os::raw::c_uint,
    ) -> u32_;
}
unsafe extern "C" {
    pub fn bch2_snapshot_tree_next(
        arg1: *mut bch_fs,
        arg2: u32_,
        arg3: *mut ::std::os::raw::c_uint,
    ) -> u32_;
}
unsafe extern "C" {
    pub fn bch2_snapshot_lookup(
        trans: *mut btree_trans,
        id: u32_,
        s: *mut bch_snapshot,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_snapshot_get_subvol(
        arg1: *mut btree_trans,
        arg2: u32_,
        arg3: *mut bch_subvolume,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_snapshot_node_create(
        arg1: *mut btree_trans,
        arg2: u32_,
        arg3: *mut u32_,
        arg4: *mut u32_,
        arg5: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_check_snapshot_trees(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_check_snapshots_trans(arg1: *mut btree_trans) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_check_snapshots(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_reconstruct_snapshots(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn __bch2_check_key_has_snapshot(
        arg1: *mut btree_trans,
        arg2: *mut btree_iter,
        arg3: bkey_s_c,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_check_key_has_snapshot__extern"]
    pub fn bch2_check_key_has_snapshot(
        trans: *mut btree_trans,
        iter: *mut btree_iter,
        k: bkey_s_c,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn __bch2_get_snapshot_overwrites(
        arg1: *mut btree_trans,
        arg2: btree_id,
        arg3: bpos,
        arg4: *mut snapshot_id_list,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_get_snapshot_overwrites__extern"]
    pub fn bch2_get_snapshot_overwrites(
        trans: *mut btree_trans,
        btree: btree_id,
        pos: bpos,
        s: *mut snapshot_id_list,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_snapshot_node_set_deleted(
        arg1: *mut btree_trans,
        arg2: u32_,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn __bch2_key_has_snapshot_overwrites(
        arg1: *mut btree_trans,
        arg2: btree_id,
        arg3: bpos,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_key_has_snapshot_overwrites__extern"]
    pub fn bch2_key_has_snapshot_overwrites(
        trans: *mut btree_trans,
        id: btree_id,
        pos: bpos,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn __bch2_delete_dead_snapshots(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_delete_dead_snapshots(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_delete_dead_snapshots_work(arg1: *mut work_struct);
}
unsafe extern "C" {
    pub fn bch2_delete_dead_snapshots_async(arg1: *mut bch_fs);
}
unsafe extern "C" {
    pub fn bch2_snapshot_delete_status_to_text(arg1: *mut printbuf, arg2: *mut bch_fs);
}
unsafe extern "C" {
    pub fn bch2_delete_dead_interior_snapshots(
        arg1: *mut bch_fs,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_snapshots_read(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_fs_snapshots_exit(arg1: *mut bch_fs);
}
unsafe extern "C" {
    pub fn bch2_fs_snapshots_init_early(arg1: *mut bch_fs);
}
unsafe extern "C" {
    pub fn bch2_fs_snapshots_init(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_btree_node_prep_for_write(
        arg1: *mut btree_trans,
        arg2: *mut btree_path,
        arg3: *mut btree,
    );
}
unsafe extern "C" {
    pub fn bch2_btree_bset_insert_key(
        arg1: *mut btree_trans,
        arg2: *mut btree_path,
        arg3: *mut btree,
        arg4: *mut btree_node_iter,
        arg5: *mut bkey_i,
    ) -> bool;
}
unsafe extern "C" {
    pub fn bch2_btree_node_flush0(
        arg1: *mut journal,
        arg2: *mut journal_entry_pin,
        arg3: u64_,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_btree_node_flush1(
        arg1: *mut journal,
        arg2: *mut journal_entry_pin,
        arg3: u64_,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_btree_add_journal_pin(arg1: *mut bch_fs, arg2: *mut btree, arg3: u64_);
}
unsafe extern "C" {
    pub fn bch2_btree_insert_key_leaf(
        arg1: *mut btree_trans,
        arg2: *mut btree_path,
        arg3: *mut bkey_i,
        arg4: u64_,
    );
}
impl bch_trans_commit_flags {
    pub const BCH_TRANS_COMMIT_no_enospc: bch_trans_commit_flags = bch_trans_commit_flags(
        16,
    );
    pub const BCH_TRANS_COMMIT_no_check_rw: bch_trans_commit_flags = bch_trans_commit_flags(
        32,
    );
    pub const BCH_TRANS_COMMIT_no_journal_res: bch_trans_commit_flags = bch_trans_commit_flags(
        64,
    );
    pub const BCH_TRANS_COMMIT_no_skip_noops: bch_trans_commit_flags = bch_trans_commit_flags(
        128,
    );
    pub const BCH_TRANS_COMMIT_journal_reclaim: bch_trans_commit_flags = bch_trans_commit_flags(
        256,
    );
    pub const BCH_TRANS_COMMIT_journal_replay: bch_trans_commit_flags = bch_trans_commit_flags(
        512,
    );
    pub const BCH_TRANS_COMMIT_skip_accounting_apply: bch_trans_commit_flags = bch_trans_commit_flags(
        1024,
    );
}
impl ::std::ops::BitOr<bch_trans_commit_flags> for bch_trans_commit_flags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        bch_trans_commit_flags(self.0 | other.0)
    }
}
impl ::std::ops::BitOrAssign for bch_trans_commit_flags {
    #[inline]
    fn bitor_assign(&mut self, rhs: bch_trans_commit_flags) {
        self.0 |= rhs.0;
    }
}
impl ::std::ops::BitAnd<bch_trans_commit_flags> for bch_trans_commit_flags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        bch_trans_commit_flags(self.0 & other.0)
    }
}
impl ::std::ops::BitAndAssign for bch_trans_commit_flags {
    #[inline]
    fn bitand_assign(&mut self, rhs: bch_trans_commit_flags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct bch_trans_commit_flags(pub ::std::os::raw::c_uint);
unsafe extern "C" {
    pub fn bch2_trans_commit_flags_to_text(
        arg1: *mut printbuf,
        arg2: bch_trans_commit_flags,
    );
}
unsafe extern "C" {
    pub fn bch2_btree_delete_at(
        arg1: *mut btree_trans,
        arg2: *mut btree_iter,
        arg3: btree_iter_update_trigger_flags,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_btree_delete(
        arg1: *mut btree_trans,
        arg2: btree_id,
        arg3: bpos,
        arg4: btree_iter_update_trigger_flags,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_btree_insert_nonextent(
        arg1: *mut btree_trans,
        arg2: btree_id,
        arg3: *mut bkey_i,
        arg4: ::std::os::raw::c_uint,
        arg5: btree_iter_update_trigger_flags,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_btree_insert_trans(
        arg1: *mut btree_trans,
        arg2: btree_id,
        arg3: *mut bkey_i,
        arg4: btree_iter_update_trigger_flags,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_btree_insert(
        arg1: *mut bch_fs,
        arg2: btree_id,
        arg3: *mut bkey_i,
        arg4: *mut disk_reservation,
        arg5: bch_trans_commit_flags,
        arg6: btree_iter_update_trigger_flags,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_btree_delete_range_trans(
        arg1: *mut btree_trans,
        arg2: btree_id,
        arg3: bpos,
        arg4: bpos,
        arg5: btree_iter_update_trigger_flags,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_btree_delete_range(
        arg1: *mut bch_fs,
        arg2: btree_id,
        arg3: bpos,
        arg4: bpos,
        arg5: btree_iter_update_trigger_flags,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_btree_bit_mod_iter(
        arg1: *mut btree_trans,
        arg2: *mut btree_iter,
        arg3: bool,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_btree_bit_mod(
        arg1: *mut btree_trans,
        arg2: btree_id,
        arg3: bpos,
        arg4: bool,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_btree_bit_mod_buffered(
        arg1: *mut btree_trans,
        arg2: btree_id,
        arg3: bpos,
        arg4: bool,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_btree_delete_at_buffered__extern"]
    pub fn bch2_btree_delete_at_buffered(
        trans: *mut btree_trans,
        btree: btree_id,
        pos: bpos,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn __bch2_insert_snapshot_whiteouts(
        arg1: *mut btree_trans,
        arg2: btree_id,
        arg3: bpos,
        arg4: *mut snapshot_id_list,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_insert_snapshot_whiteouts__extern"]
    pub fn bch2_insert_snapshot_whiteouts(
        trans: *mut btree_trans,
        btree: btree_id,
        old_pos: bpos,
        new_pos: bpos,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_trans_update_extent_overwrite(
        arg1: *mut btree_trans,
        arg2: *mut btree_iter,
        arg3: btree_iter_update_trigger_flags,
        arg4: bkey_s_c,
        arg5: bkey_s_c,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_bkey_get_empty_slot(
        arg1: *mut btree_trans,
        arg2: *mut btree_iter,
        arg3: btree_id,
        arg4: bpos,
        arg5: bpos,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_trans_update_ip(
        arg1: *mut btree_trans,
        arg2: *mut btree_iter,
        arg3: *mut bkey_i,
        arg4: ::std::os::raw::c_uint,
        arg5: btree_iter_update_trigger_flags,
        arg6: ::std::os::raw::c_ulong,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_trigger_get_mutable_new(
        arg1: *mut btree_trans,
        arg2: btree_trigger_op,
        needed_u64s: ::std::os::raw::c_uint,
        arg3: *mut bkey_s,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_trans_update_buf__extern"]
    pub fn bch2_trans_update_buf(
        trans: *mut btree_trans,
        iter: *mut btree_iter,
        k: *mut bkey_i,
        k_buf_u64s: ::std::os::raw::c_uint,
        flags: btree_iter_update_trigger_flags,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_trans_update__extern"]
    pub fn bch2_trans_update(
        trans: *mut btree_trans,
        iter: *mut btree_iter,
        k: *mut bkey_i,
        flags: btree_iter_update_trigger_flags,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn __bch2_trans_subbuf_alloc(
        arg1: *mut btree_trans,
        arg2: *mut btree_trans_subbuf,
        arg3: ::std::os::raw::c_uint,
        arg4: ulong,
    ) -> *mut ::std::os::raw::c_void;
}
unsafe extern "C" {
    #[link_name = "bch2_trans_subbuf_reserve__extern"]
    pub fn bch2_trans_subbuf_reserve(
        trans: *mut btree_trans,
        buf: *mut btree_trans_subbuf,
        u64s: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_trans_subbuf_alloc_ip__extern"]
    pub fn bch2_trans_subbuf_alloc_ip(
        trans: *mut btree_trans,
        buf: *mut btree_trans_subbuf,
        u64s: ::std::os::raw::c_uint,
        ip: ulong,
    ) -> *mut ::std::os::raw::c_void;
}
unsafe extern "C" {
    #[link_name = "bch2_trans_subbuf_alloc__extern"]
    pub fn bch2_trans_subbuf_alloc(
        trans: *mut btree_trans,
        buf: *mut btree_trans_subbuf,
        u64s: ::std::os::raw::c_uint,
    ) -> *mut ::std::os::raw::c_void;
}
unsafe extern "C" {
    #[link_name = "bch2_trans_jset_entry_alloc_ip__extern"]
    pub fn bch2_trans_jset_entry_alloc_ip(
        trans: *mut btree_trans,
        u64s: ::std::os::raw::c_uint,
        ip: ulong,
    ) -> *mut jset_entry;
}
unsafe extern "C" {
    #[link_name = "bch2_trans_jset_entry_alloc__extern"]
    pub fn bch2_trans_jset_entry_alloc(
        trans: *mut btree_trans,
        u64s: ::std::os::raw::c_uint,
    ) -> *mut jset_entry;
}
unsafe extern "C" {
    pub fn bch2_btree_insert_clone_trans(
        arg1: *mut btree_trans,
        arg2: btree_id,
        arg3: *mut bkey_i,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_btree_write_buffer_insert_err(
        arg1: *mut bch_fs,
        arg2: btree_id,
        arg3: *mut bkey_i,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_btree_write_buffer_insert_checks__extern"]
    pub fn bch2_btree_write_buffer_insert_checks(
        c: *mut bch_fs,
        btree: btree_id,
        k: *mut bkey_i,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_trans_update_buffered__extern"]
    pub fn bch2_trans_update_buffered(
        trans: *mut btree_trans,
        btree: btree_id,
        k: *mut bkey_i,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_trans_commit_hook(
        arg1: *mut btree_trans,
        arg2: *mut btree_trans_commit_hook,
    );
}
unsafe extern "C" {
    pub fn __bch2_trans_commit(
        arg1: *mut btree_trans,
        arg2: bch_trans_commit_flags,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_trans_log_str(
        arg1: *mut btree_trans,
        arg2: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_trans_log_msg(
        arg1: *mut btree_trans,
        arg2: *mut printbuf,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_trans_log_bkey(
        arg1: *mut btree_trans,
        arg2: btree_id,
        arg3: ::std::os::raw::c_uint,
        arg4: *mut bkey_i,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_fs_log_msg(
        arg1: *mut bch_fs,
        arg2: *const ::std::os::raw::c_char,
        ...
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_journal_log_msg(
        arg1: *mut bch_fs,
        arg2: *const ::std::os::raw::c_char,
        ...
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_trans_has_updates__extern"]
    pub fn bch2_trans_has_updates(trans: *mut btree_trans) -> bool;
}
unsafe extern "C" {
    #[link_name = "bch2_trans_reset_updates__extern"]
    pub fn bch2_trans_reset_updates(trans: *mut btree_trans);
}
unsafe extern "C" {
    /** bch2_trans_commit - insert keys at given iterator positions

 This is main entry point for btree updates.

 Return values:
 -EROFS: filesystem read only
 -EIO: journal or btree node IO error*/
    #[link_name = "bch2_trans_commit__extern"]
    pub fn bch2_trans_commit(
        trans: *mut btree_trans,
        disk_res: *mut disk_reservation,
        journal_seq: *mut u64_,
        flags: bch_trans_commit_flags,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_trans_commit_lazy__extern"]
    pub fn bch2_trans_commit_lazy(
        trans: *mut btree_trans,
        disk_res: *mut disk_reservation,
        journal_seq: *mut u64_,
        flags: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "__bch2_bkey_make_mut_noupdate__extern"]
    pub fn __bch2_bkey_make_mut_noupdate(
        trans: *mut btree_trans,
        k: bkey_s_c,
        type_: ::std::os::raw::c_uint,
        min_bytes: ::std::os::raw::c_uint,
    ) -> *mut bkey_i;
}
unsafe extern "C" {
    #[link_name = "bch2_bkey_make_mut_noupdate__extern"]
    pub fn bch2_bkey_make_mut_noupdate(
        trans: *mut btree_trans,
        k: bkey_s_c,
    ) -> *mut bkey_i;
}
unsafe extern "C" {
    #[link_name = "__bch2_bkey_make_mut__extern"]
    pub fn __bch2_bkey_make_mut(
        trans: *mut btree_trans,
        iter: *mut btree_iter,
        k: *mut bkey_s_c,
        flags: btree_iter_update_trigger_flags,
        type_: ::std::os::raw::c_uint,
        min_bytes: ::std::os::raw::c_uint,
    ) -> *mut bkey_i;
}
unsafe extern "C" {
    #[link_name = "bch2_bkey_make_mut__extern"]
    pub fn bch2_bkey_make_mut(
        trans: *mut btree_trans,
        iter: *mut btree_iter,
        k: *mut bkey_s_c,
        flags: btree_iter_update_trigger_flags,
    ) -> *mut bkey_i;
}
unsafe extern "C" {
    #[link_name = "__bch2_bkey_get_mut_noupdate__extern"]
    pub fn __bch2_bkey_get_mut_noupdate(
        iter: *mut btree_iter,
        type_: ::std::os::raw::c_uint,
        min_bytes: ::std::os::raw::c_uint,
    ) -> *mut bkey_i;
}
unsafe extern "C" {
    #[link_name = "bch2_bkey_get_mut_noupdate__extern"]
    pub fn bch2_bkey_get_mut_noupdate(iter: *mut btree_iter) -> *mut bkey_i;
}
unsafe extern "C" {
    #[link_name = "__bch2_bkey_get_mut__extern"]
    pub fn __bch2_bkey_get_mut(
        trans: *mut btree_trans,
        btree: btree_id,
        pos: bpos,
        flags: btree_iter_update_trigger_flags,
        type_: ::std::os::raw::c_uint,
        min_bytes: ::std::os::raw::c_uint,
    ) -> *mut bkey_i;
}
unsafe extern "C" {
    #[link_name = "bch2_bkey_get_mut_minsize__extern"]
    pub fn bch2_bkey_get_mut_minsize(
        trans: *mut btree_trans,
        btree_id: ::std::os::raw::c_uint,
        pos: bpos,
        flags: btree_iter_update_trigger_flags,
        min_bytes: ::std::os::raw::c_uint,
    ) -> *mut bkey_i;
}
unsafe extern "C" {
    #[link_name = "bch2_bkey_get_mut__extern"]
    pub fn bch2_bkey_get_mut(
        trans: *mut btree_trans,
        btree_id: ::std::os::raw::c_uint,
        pos: bpos,
        flags: btree_iter_update_trigger_flags,
    ) -> *mut bkey_i;
}
unsafe extern "C" {
    #[link_name = "__bch2_bkey_alloc__extern"]
    pub fn __bch2_bkey_alloc(
        trans: *mut btree_trans,
        iter: *mut btree_iter,
        flags: btree_iter_update_trigger_flags,
        type_: ::std::os::raw::c_uint,
        val_size: ::std::os::raw::c_uint,
    ) -> *mut bkey_i;
}
unsafe extern "C" {
    pub fn bch2_reflink_p_validate(
        arg1: *mut bch_fs,
        arg2: bkey_s_c,
        arg3: bkey_validate_context,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_reflink_p_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: bkey_s_c,
    );
}
unsafe extern "C" {
    pub fn bch2_reflink_p_merge(arg1: *mut bch_fs, arg2: bkey_s, arg3: bkey_s_c) -> bool;
}
unsafe extern "C" {
    pub fn bch2_trigger_reflink_p(
        arg1: *mut btree_trans,
        arg2: btree_trigger_op,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_reflink_p_check_repair(
        arg1: *mut btree_trans,
        arg2: *mut btree_iter,
        arg3: btree_id,
        arg4: ::std::os::raw::c_uint,
        arg5: bkey_s_c,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_reflink_v_validate(
        arg1: *mut bch_fs,
        arg2: bkey_s_c,
        arg3: bkey_validate_context,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_reflink_v_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: bkey_s_c,
    );
}
unsafe extern "C" {
    pub fn bch2_trigger_reflink_v(
        arg1: *mut btree_trans,
        arg2: btree_trigger_op,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_indirect_inline_data_validate(
        arg1: *mut bch_fs,
        arg2: bkey_s_c,
        arg3: bkey_validate_context,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_indirect_inline_data_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: bkey_s_c,
    );
}
unsafe extern "C" {
    pub fn bch2_trigger_indirect_inline_data(
        arg1: *mut btree_trans,
        arg2: btree_trigger_op,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_lookup_indirect_extent(
        arg1: *mut btree_trans,
        arg2: *mut btree_iter,
        arg3: *mut s64,
        arg4: bkey_s_c_reflink_p,
        arg5: bool,
        arg6: ::std::os::raw::c_uint,
    ) -> bkey_s_c;
}
unsafe extern "C" {
    pub fn bch2_make_extent_indirect(
        arg1: *mut btree_trans,
        arg2: *mut btree_iter,
        arg3: *mut bkey_i,
        arg4: bool,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_remap_range(
        arg1: *mut bch_fs,
        arg2: subvol_inum,
        arg3: u64_,
        arg4: subvol_inum,
        arg5: u64_,
        arg6: u64_,
        arg7: u64_,
        arg8: *mut s64,
        arg9: bool,
    ) -> s64;
}
unsafe extern "C" {
    pub fn bch2_gc_reflink_done(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_gc_reflink_start(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_dev_congested_to_text(arg1: *mut printbuf, arg2: *mut bch_dev);
}
#[repr(C)]
pub struct bch_read_err_report {
    pub lock: mutex,
    pub errors: u32_,
    pub msg: printbuf,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_read_err_report",
    ][::std::mem::size_of::<bch_read_err_report>() - 88usize];
    [
        "Alignment of bch_read_err_report",
    ][::std::mem::align_of::<bch_read_err_report>() - 8usize];
    [
        "Offset of field: bch_read_err_report::lock",
    ][::std::mem::offset_of!(bch_read_err_report, lock) - 0usize];
    [
        "Offset of field: bch_read_err_report::errors",
    ][::std::mem::offset_of!(bch_read_err_report, errors) - 40usize];
    [
        "Offset of field: bch_read_err_report::msg",
    ][::std::mem::offset_of!(bch_read_err_report, msg) - 48usize];
};
impl Default for bch_read_err_report {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bch_read_bio {
    pub c: *mut bch_fs,
    pub ca: *mut bch_dev,
    pub start_time: u64_,
    pub submit_time: u64_,
    pub __bindgen_anon_1: bch_read_bio__bindgen_ty_1,
    pub bvec_iter: bvec_iter,
    pub offset_into_extent: ::std::os::raw::c_uint,
    pub flags: u16_,
    pub __bindgen_anon_2: bch_read_bio__bindgen_ty_2,
    pub ret: s16,
    pub pick: extent_ptr_decoded,
    pub subvol: u32_,
    pub read_pos: bpos,
    pub data_btree: btree_id,
    pub data_pos: bpos,
    pub version: bversion,
    pub opts: bch_inode_opts,
    pub failed: *mut bch_io_failures,
    pub err_report: *mut bch_read_err_report,
    pub work: work_struct,
    pub bio: bio,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bch_read_bio__bindgen_ty_1 {
    pub parent: *mut bch_read_bio,
    pub end_io: bio_end_io_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_read_bio__bindgen_ty_1",
    ][::std::mem::size_of::<bch_read_bio__bindgen_ty_1>() - 8usize];
    [
        "Alignment of bch_read_bio__bindgen_ty_1",
    ][::std::mem::align_of::<bch_read_bio__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bch_read_bio__bindgen_ty_1::parent",
    ][::std::mem::offset_of!(bch_read_bio__bindgen_ty_1, parent) - 0usize];
    [
        "Offset of field: bch_read_bio__bindgen_ty_1::end_io",
    ][::std::mem::offset_of!(bch_read_bio__bindgen_ty_1, end_io) - 0usize];
};
impl Default for bch_read_bio__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bch_read_bio__bindgen_ty_2 {
    pub __bindgen_anon_1: bch_read_bio__bindgen_ty_2__bindgen_ty_1,
    pub _state: u16_,
}
#[repr(C)]
#[repr(align(2))]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_read_bio__bindgen_ty_2__bindgen_ty_1 {
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_read_bio__bindgen_ty_2__bindgen_ty_1",
    ][::std::mem::size_of::<bch_read_bio__bindgen_ty_2__bindgen_ty_1>() - 2usize];
    [
        "Alignment of bch_read_bio__bindgen_ty_2__bindgen_ty_1",
    ][::std::mem::align_of::<bch_read_bio__bindgen_ty_2__bindgen_ty_1>() - 2usize];
};
impl bch_read_bio__bindgen_ty_2__bindgen_ty_1 {
    #[inline]
    pub fn data_update(&self) -> u16_ {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u16) }
    }
    #[inline]
    pub fn set_data_update(&mut self, val: u16_) {
        unsafe {
            let val: u16 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn data_update_raw(this: *const Self) -> u16_ {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8)
                    as u16,
            )
        }
    }
    #[inline]
    pub unsafe fn set_data_update_raw(this: *mut Self, val: u16_) {
        unsafe {
            let val: u16 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn data_update_verify_decompress(&self) -> u16_ {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u16) }
    }
    #[inline]
    pub fn set_data_update_verify_decompress(&mut self, val: u16_) {
        unsafe {
            let val: u16 = ::std::mem::transmute(val);
            self._bitfield_1.set(1usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn data_update_verify_decompress_raw(this: *const Self) -> u16_ {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 1usize, 1u8)
                    as u16,
            )
        }
    }
    #[inline]
    pub unsafe fn set_data_update_verify_decompress_raw(this: *mut Self, val: u16_) {
        unsafe {
            let val: u16 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                1usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn promote(&self) -> u16_ {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u16) }
    }
    #[inline]
    pub fn set_promote(&mut self, val: u16_) {
        unsafe {
            let val: u16 = ::std::mem::transmute(val);
            self._bitfield_1.set(2usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn promote_raw(this: *const Self) -> u16_ {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 2usize, 1u8)
                    as u16,
            )
        }
    }
    #[inline]
    pub unsafe fn set_promote_raw(this: *mut Self, val: u16_) {
        unsafe {
            let val: u16 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                2usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn bounce(&self) -> u16_ {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u16) }
    }
    #[inline]
    pub fn set_bounce(&mut self, val: u16_) {
        unsafe {
            let val: u16 = ::std::mem::transmute(val);
            self._bitfield_1.set(3usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn bounce_raw(this: *const Self) -> u16_ {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 3usize, 1u8)
                    as u16,
            )
        }
    }
    #[inline]
    pub unsafe fn set_bounce_raw(this: *mut Self, val: u16_) {
        unsafe {
            let val: u16 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                3usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn split(&self) -> u16_ {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u16) }
    }
    #[inline]
    pub fn set_split(&mut self, val: u16_) {
        unsafe {
            let val: u16 = ::std::mem::transmute(val);
            self._bitfield_1.set(4usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn split_raw(this: *const Self) -> u16_ {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 4usize, 1u8)
                    as u16,
            )
        }
    }
    #[inline]
    pub unsafe fn set_split_raw(this: *mut Self, val: u16_) {
        unsafe {
            let val: u16 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                4usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn narrow_crcs(&self) -> u16_ {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u16) }
    }
    #[inline]
    pub fn set_narrow_crcs(&mut self, val: u16_) {
        unsafe {
            let val: u16 = ::std::mem::transmute(val);
            self._bitfield_1.set(5usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn narrow_crcs_raw(this: *const Self) -> u16_ {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 5usize, 1u8)
                    as u16,
            )
        }
    }
    #[inline]
    pub unsafe fn set_narrow_crcs_raw(this: *mut Self, val: u16_) {
        unsafe {
            let val: u16 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                5usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn saw_error(&self) -> u16_ {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u16) }
    }
    #[inline]
    pub fn set_saw_error(&mut self, val: u16_) {
        unsafe {
            let val: u16 = ::std::mem::transmute(val);
            self._bitfield_1.set(6usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn saw_error_raw(this: *const Self) -> u16_ {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 6usize, 1u8)
                    as u16,
            )
        }
    }
    #[inline]
    pub unsafe fn set_saw_error_raw(this: *mut Self, val: u16_) {
        unsafe {
            let val: u16 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                6usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn self_healing(&self) -> u16_ {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u16) }
    }
    #[inline]
    pub fn set_self_healing(&mut self, val: u16_) {
        unsafe {
            let val: u16 = ::std::mem::transmute(val);
            self._bitfield_1.set(7usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn self_healing_raw(this: *const Self) -> u16_ {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 7usize, 1u8)
                    as u16,
            )
        }
    }
    #[inline]
    pub unsafe fn set_self_healing_raw(this: *mut Self, val: u16_) {
        unsafe {
            let val: u16 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                7usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn context(&self) -> u16_ {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 2u8) as u16) }
    }
    #[inline]
    pub fn set_context(&mut self, val: u16_) {
        unsafe {
            let val: u16 = ::std::mem::transmute(val);
            self._bitfield_1.set(8usize, 2u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn context_raw(this: *const Self) -> u16_ {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 8usize, 2u8)
                    as u16,
            )
        }
    }
    #[inline]
    pub unsafe fn set_context_raw(this: *mut Self, val: u16_) {
        unsafe {
            let val: u16 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                8usize,
                2u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        data_update: u16_,
        data_update_verify_decompress: u16_,
        promote: u16_,
        bounce: u16_,
        split: u16_,
        narrow_crcs: u16_,
        saw_error: u16_,
        self_healing: u16_,
        context: u16_,
    ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                1u8,
                {
                    let data_update: u16 = unsafe { ::std::mem::transmute(data_update) };
                    data_update as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                1usize,
                1u8,
                {
                    let data_update_verify_decompress: u16 = unsafe {
                        ::std::mem::transmute(data_update_verify_decompress)
                    };
                    data_update_verify_decompress as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                2usize,
                1u8,
                {
                    let promote: u16 = unsafe { ::std::mem::transmute(promote) };
                    promote as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                3usize,
                1u8,
                {
                    let bounce: u16 = unsafe { ::std::mem::transmute(bounce) };
                    bounce as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                4usize,
                1u8,
                {
                    let split: u16 = unsafe { ::std::mem::transmute(split) };
                    split as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                5usize,
                1u8,
                {
                    let narrow_crcs: u16 = unsafe { ::std::mem::transmute(narrow_crcs) };
                    narrow_crcs as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                6usize,
                1u8,
                {
                    let saw_error: u16 = unsafe { ::std::mem::transmute(saw_error) };
                    saw_error as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                7usize,
                1u8,
                {
                    let self_healing: u16 = unsafe {
                        ::std::mem::transmute(self_healing)
                    };
                    self_healing as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                8usize,
                2u8,
                {
                    let context: u16 = unsafe { ::std::mem::transmute(context) };
                    context as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_read_bio__bindgen_ty_2",
    ][::std::mem::size_of::<bch_read_bio__bindgen_ty_2>() - 2usize];
    [
        "Alignment of bch_read_bio__bindgen_ty_2",
    ][::std::mem::align_of::<bch_read_bio__bindgen_ty_2>() - 2usize];
    [
        "Offset of field: bch_read_bio__bindgen_ty_2::_state",
    ][::std::mem::offset_of!(bch_read_bio__bindgen_ty_2, _state) - 0usize];
};
impl Default for bch_read_bio__bindgen_ty_2 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_read_bio"][::std::mem::size_of::<bch_read_bio>() - 392usize];
    ["Alignment of bch_read_bio"][::std::mem::align_of::<bch_read_bio>() - 8usize];
    [
        "Offset of field: bch_read_bio::c",
    ][::std::mem::offset_of!(bch_read_bio, c) - 0usize];
    [
        "Offset of field: bch_read_bio::ca",
    ][::std::mem::offset_of!(bch_read_bio, ca) - 8usize];
    [
        "Offset of field: bch_read_bio::start_time",
    ][::std::mem::offset_of!(bch_read_bio, start_time) - 16usize];
    [
        "Offset of field: bch_read_bio::submit_time",
    ][::std::mem::offset_of!(bch_read_bio, submit_time) - 24usize];
    [
        "Offset of field: bch_read_bio::bvec_iter",
    ][::std::mem::offset_of!(bch_read_bio, bvec_iter) - 40usize];
    [
        "Offset of field: bch_read_bio::offset_into_extent",
    ][::std::mem::offset_of!(bch_read_bio, offset_into_extent) - 64usize];
    [
        "Offset of field: bch_read_bio::flags",
    ][::std::mem::offset_of!(bch_read_bio, flags) - 68usize];
    [
        "Offset of field: bch_read_bio::ret",
    ][::std::mem::offset_of!(bch_read_bio, ret) - 72usize];
    [
        "Offset of field: bch_read_bio::pick",
    ][::std::mem::offset_of!(bch_read_bio, pick) - 80usize];
    [
        "Offset of field: bch_read_bio::subvol",
    ][::std::mem::offset_of!(bch_read_bio, subvol) - 144usize];
    [
        "Offset of field: bch_read_bio::read_pos",
    ][::std::mem::offset_of!(bch_read_bio, read_pos) - 148usize];
    [
        "Offset of field: bch_read_bio::data_btree",
    ][::std::mem::offset_of!(bch_read_bio, data_btree) - 168usize];
    [
        "Offset of field: bch_read_bio::data_pos",
    ][::std::mem::offset_of!(bch_read_bio, data_pos) - 172usize];
    [
        "Offset of field: bch_read_bio::version",
    ][::std::mem::offset_of!(bch_read_bio, version) - 192usize];
    [
        "Offset of field: bch_read_bio::opts",
    ][::std::mem::offset_of!(bch_read_bio, opts) - 208usize];
    [
        "Offset of field: bch_read_bio::failed",
    ][::std::mem::offset_of!(bch_read_bio, failed) - 240usize];
    [
        "Offset of field: bch_read_bio::err_report",
    ][::std::mem::offset_of!(bch_read_bio, err_report) - 248usize];
    [
        "Offset of field: bch_read_bio::work",
    ][::std::mem::offset_of!(bch_read_bio, work) - 256usize];
    [
        "Offset of field: bch_read_bio::bio",
    ][::std::mem::offset_of!(bch_read_bio, bio) - 288usize];
};
impl Default for bch_read_bio {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C" {
    #[link_name = "bch2_read_indirect_extent__extern"]
    pub fn bch2_read_indirect_extent(
        trans: *mut btree_trans,
        data_btree: *mut btree_id,
        offset_into_extent: *mut s64,
        extent: *mut bkey_buf,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_read_err_msg_trans(
        arg1: *mut btree_trans,
        arg2: *mut printbuf,
        arg3: *mut bch_read_bio,
        arg4: bpos,
    );
}
unsafe extern "C" {
    pub fn __bch2_read_extent(
        arg1: *mut btree_trans,
        arg2: *mut bch_read_bio,
        arg3: bvec_iter,
        arg4: bpos,
        arg5: btree_id,
        arg6: bkey_s_c,
        arg7: ::std::os::raw::c_uint,
        arg8: *mut bch_io_failures,
        arg9: bch_read_flags,
        arg10: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_read_extent__extern"]
    pub fn bch2_read_extent(
        trans: *mut btree_trans,
        rbio: *mut bch_read_bio,
        read_pos: bpos,
        data_btree: btree_id,
        k: bkey_s_c,
        offset_into_extent: ::std::os::raw::c_uint,
        flags: bch_read_flags,
    );
}
unsafe extern "C" {
    pub fn bch2_read(
        arg1: *mut btree_trans,
        arg2: *mut bch_read_bio,
        arg3: bvec_iter,
        arg4: subvol_inum,
        arg5: *mut bch_io_failures,
        arg6: *mut bkey_buf,
        arg7: bch_read_flags,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_promote_op_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: *mut promote_op,
    );
}
unsafe extern "C" {
    pub fn bch2_read_bio_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: *mut bch_read_bio,
    );
}
unsafe extern "C" {
    pub fn bch2_fs_io_read_exit(arg1: *mut bch_fs);
}
unsafe extern "C" {
    pub fn bch2_fs_io_read_init(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
impl bch_write_flags {
    pub const BCH_WRITE_alloc_nowait: bch_write_flags = bch_write_flags(1);
    pub const BCH_WRITE_cached: bch_write_flags = bch_write_flags(2);
    pub const BCH_WRITE_data_encoded: bch_write_flags = bch_write_flags(4);
    pub const BCH_WRITE_pages_stable: bch_write_flags = bch_write_flags(8);
    pub const BCH_WRITE_pages_owned: bch_write_flags = bch_write_flags(16);
    pub const BCH_WRITE_only_specified_devs: bch_write_flags = bch_write_flags(32);
    pub const BCH_WRITE_must_ec: bch_write_flags = bch_write_flags(64);
    pub const BCH_WRITE_wrote_data_inline: bch_write_flags = bch_write_flags(128);
    pub const BCH_WRITE_check_enospc: bch_write_flags = bch_write_flags(256);
    pub const BCH_WRITE_sync: bch_write_flags = bch_write_flags(512);
    pub const BCH_WRITE_move: bch_write_flags = bch_write_flags(1024);
    pub const BCH_WRITE_in_worker: bch_write_flags = bch_write_flags(2048);
    pub const BCH_WRITE_submitted: bch_write_flags = bch_write_flags(4096);
    pub const BCH_WRITE_convert_unwritten: bch_write_flags = bch_write_flags(8192);
}
impl ::std::ops::BitOr<bch_write_flags> for bch_write_flags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        bch_write_flags(self.0 | other.0)
    }
}
impl ::std::ops::BitOrAssign for bch_write_flags {
    #[inline]
    fn bitor_assign(&mut self, rhs: bch_write_flags) {
        self.0 |= rhs.0;
    }
}
impl ::std::ops::BitAnd<bch_write_flags> for bch_write_flags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        bch_write_flags(self.0 & other.0)
    }
}
impl ::std::ops::BitAndAssign for bch_write_flags {
    #[inline]
    fn bitand_assign(&mut self, rhs: bch_write_flags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct bch_write_flags(pub ::std::os::raw::c_uint);
#[repr(C)]
pub struct bch_write_bio {
    pub __bindgen_anon_1: bch_write_bio__bindgen_ty_1,
    pub bio: bio,
}
#[repr(C)]
pub struct bch_write_bio__bindgen_ty_1 {
    pub __bindgen_anon_1: __BindgenUnionField<bch_write_bio__bindgen_ty_1__bindgen_ty_1>,
    pub wbio: __BindgenUnionField<bch_write_bio__bindgen_ty_1__bindgen_ty_2>,
    pub bindgen_union_field: [u64; 18usize],
}
#[repr(C)]
#[derive(Debug)]
pub struct bch_write_bio__bindgen_ty_1__bindgen_ty_1 {
    pub c: *mut bch_fs,
    pub parent: *mut bch_write_bio,
    pub ca: *mut bch_dev,
    pub submit_time: u64_,
    pub inode_offset: u64_,
    pub nocow_bucket: u64_,
    pub failed: bch_io_failures,
    pub dev: u8_,
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
    pub __bindgen_padding_0: [u16; 3usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_write_bio__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bch_write_bio__bindgen_ty_1__bindgen_ty_1>() - 144usize];
    [
        "Alignment of bch_write_bio__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bch_write_bio__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bch_write_bio__bindgen_ty_1__bindgen_ty_1::c",
    ][::std::mem::offset_of!(bch_write_bio__bindgen_ty_1__bindgen_ty_1, c) - 0usize];
    [
        "Offset of field: bch_write_bio__bindgen_ty_1__bindgen_ty_1::parent",
    ][::std::mem::offset_of!(bch_write_bio__bindgen_ty_1__bindgen_ty_1, parent)
        - 8usize];
    [
        "Offset of field: bch_write_bio__bindgen_ty_1__bindgen_ty_1::ca",
    ][::std::mem::offset_of!(bch_write_bio__bindgen_ty_1__bindgen_ty_1, ca) - 16usize];
    [
        "Offset of field: bch_write_bio__bindgen_ty_1__bindgen_ty_1::submit_time",
    ][::std::mem::offset_of!(bch_write_bio__bindgen_ty_1__bindgen_ty_1, submit_time)
        - 24usize];
    [
        "Offset of field: bch_write_bio__bindgen_ty_1__bindgen_ty_1::inode_offset",
    ][::std::mem::offset_of!(bch_write_bio__bindgen_ty_1__bindgen_ty_1, inode_offset)
        - 32usize];
    [
        "Offset of field: bch_write_bio__bindgen_ty_1__bindgen_ty_1::nocow_bucket",
    ][::std::mem::offset_of!(bch_write_bio__bindgen_ty_1__bindgen_ty_1, nocow_bucket)
        - 40usize];
    [
        "Offset of field: bch_write_bio__bindgen_ty_1__bindgen_ty_1::failed",
    ][::std::mem::offset_of!(bch_write_bio__bindgen_ty_1__bindgen_ty_1, failed)
        - 48usize];
    [
        "Offset of field: bch_write_bio__bindgen_ty_1__bindgen_ty_1::dev",
    ][::std::mem::offset_of!(bch_write_bio__bindgen_ty_1__bindgen_ty_1, dev) - 136usize];
};
impl Default for bch_write_bio__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl bch_write_bio__bindgen_ty_1__bindgen_ty_1 {
    #[inline]
    pub fn split(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_split(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn split_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_split_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn bounce(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_bounce(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(1usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn bounce_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 1usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_bounce_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                1usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn put_bio(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_put_bio(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(2usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn put_bio_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 2usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_put_bio_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                2usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn nocow(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_nocow(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(3usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn nocow_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 3usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_nocow_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                3usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn used_mempool(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_used_mempool(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(4usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn used_mempool_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 4usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_used_mempool_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                4usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn first_btree_write(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_first_btree_write(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(5usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn first_btree_write_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 5usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_first_btree_write_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                5usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        split: ::std::os::raw::c_uint,
        bounce: ::std::os::raw::c_uint,
        put_bio: ::std::os::raw::c_uint,
        nocow: ::std::os::raw::c_uint,
        used_mempool: ::std::os::raw::c_uint,
        first_btree_write: ::std::os::raw::c_uint,
    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                1u8,
                {
                    let split: u32 = unsafe { ::std::mem::transmute(split) };
                    split as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                1usize,
                1u8,
                {
                    let bounce: u32 = unsafe { ::std::mem::transmute(bounce) };
                    bounce as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                2usize,
                1u8,
                {
                    let put_bio: u32 = unsafe { ::std::mem::transmute(put_bio) };
                    put_bio as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                3usize,
                1u8,
                {
                    let nocow: u32 = unsafe { ::std::mem::transmute(nocow) };
                    nocow as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                4usize,
                1u8,
                {
                    let used_mempool: u32 = unsafe {
                        ::std::mem::transmute(used_mempool)
                    };
                    used_mempool as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                5usize,
                1u8,
                {
                    let first_btree_write: u32 = unsafe {
                        ::std::mem::transmute(first_btree_write)
                    };
                    first_btree_write as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Debug)]
pub struct bch_write_bio__bindgen_ty_1__bindgen_ty_2 {
    pub c: *mut bch_fs,
    pub parent: *mut bch_write_bio,
    pub ca: *mut bch_dev,
    pub submit_time: u64_,
    pub inode_offset: u64_,
    pub nocow_bucket: u64_,
    pub failed: bch_io_failures,
    pub dev: u8_,
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
    pub __bindgen_padding_0: [u16; 3usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_write_bio__bindgen_ty_1__bindgen_ty_2",
    ][::std::mem::size_of::<bch_write_bio__bindgen_ty_1__bindgen_ty_2>() - 144usize];
    [
        "Alignment of bch_write_bio__bindgen_ty_1__bindgen_ty_2",
    ][::std::mem::align_of::<bch_write_bio__bindgen_ty_1__bindgen_ty_2>() - 8usize];
    [
        "Offset of field: bch_write_bio__bindgen_ty_1__bindgen_ty_2::c",
    ][::std::mem::offset_of!(bch_write_bio__bindgen_ty_1__bindgen_ty_2, c) - 0usize];
    [
        "Offset of field: bch_write_bio__bindgen_ty_1__bindgen_ty_2::parent",
    ][::std::mem::offset_of!(bch_write_bio__bindgen_ty_1__bindgen_ty_2, parent)
        - 8usize];
    [
        "Offset of field: bch_write_bio__bindgen_ty_1__bindgen_ty_2::ca",
    ][::std::mem::offset_of!(bch_write_bio__bindgen_ty_1__bindgen_ty_2, ca) - 16usize];
    [
        "Offset of field: bch_write_bio__bindgen_ty_1__bindgen_ty_2::submit_time",
    ][::std::mem::offset_of!(bch_write_bio__bindgen_ty_1__bindgen_ty_2, submit_time)
        - 24usize];
    [
        "Offset of field: bch_write_bio__bindgen_ty_1__bindgen_ty_2::inode_offset",
    ][::std::mem::offset_of!(bch_write_bio__bindgen_ty_1__bindgen_ty_2, inode_offset)
        - 32usize];
    [
        "Offset of field: bch_write_bio__bindgen_ty_1__bindgen_ty_2::nocow_bucket",
    ][::std::mem::offset_of!(bch_write_bio__bindgen_ty_1__bindgen_ty_2, nocow_bucket)
        - 40usize];
    [
        "Offset of field: bch_write_bio__bindgen_ty_1__bindgen_ty_2::failed",
    ][::std::mem::offset_of!(bch_write_bio__bindgen_ty_1__bindgen_ty_2, failed)
        - 48usize];
    [
        "Offset of field: bch_write_bio__bindgen_ty_1__bindgen_ty_2::dev",
    ][::std::mem::offset_of!(bch_write_bio__bindgen_ty_1__bindgen_ty_2, dev) - 136usize];
};
impl Default for bch_write_bio__bindgen_ty_1__bindgen_ty_2 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl bch_write_bio__bindgen_ty_1__bindgen_ty_2 {
    #[inline]
    pub fn split(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_split(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn split_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_split_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn bounce(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_bounce(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(1usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn bounce_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 1usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_bounce_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                1usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn put_bio(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_put_bio(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(2usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn put_bio_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 2usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_put_bio_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                2usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn nocow(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_nocow(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(3usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn nocow_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 3usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_nocow_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                3usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn used_mempool(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_used_mempool(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(4usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn used_mempool_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 4usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_used_mempool_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                4usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn first_btree_write(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_first_btree_write(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(5usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn first_btree_write_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 5usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_first_btree_write_raw(
        this: *mut Self,
        val: ::std::os::raw::c_uint,
    ) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                5usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        split: ::std::os::raw::c_uint,
        bounce: ::std::os::raw::c_uint,
        put_bio: ::std::os::raw::c_uint,
        nocow: ::std::os::raw::c_uint,
        used_mempool: ::std::os::raw::c_uint,
        first_btree_write: ::std::os::raw::c_uint,
    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                1u8,
                {
                    let split: u32 = unsafe { ::std::mem::transmute(split) };
                    split as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                1usize,
                1u8,
                {
                    let bounce: u32 = unsafe { ::std::mem::transmute(bounce) };
                    bounce as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                2usize,
                1u8,
                {
                    let put_bio: u32 = unsafe { ::std::mem::transmute(put_bio) };
                    put_bio as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                3usize,
                1u8,
                {
                    let nocow: u32 = unsafe { ::std::mem::transmute(nocow) };
                    nocow as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                4usize,
                1u8,
                {
                    let used_mempool: u32 = unsafe {
                        ::std::mem::transmute(used_mempool)
                    };
                    used_mempool as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                5usize,
                1u8,
                {
                    let first_btree_write: u32 = unsafe {
                        ::std::mem::transmute(first_btree_write)
                    };
                    first_btree_write as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_write_bio__bindgen_ty_1",
    ][::std::mem::size_of::<bch_write_bio__bindgen_ty_1>() - 144usize];
    [
        "Alignment of bch_write_bio__bindgen_ty_1",
    ][::std::mem::align_of::<bch_write_bio__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bch_write_bio__bindgen_ty_1::wbio",
    ][::std::mem::offset_of!(bch_write_bio__bindgen_ty_1, wbio) - 0usize];
};
impl Default for bch_write_bio__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_write_bio"][::std::mem::size_of::<bch_write_bio>() - 248usize];
    ["Alignment of bch_write_bio"][::std::mem::align_of::<bch_write_bio>() - 8usize];
    [
        "Offset of field: bch_write_bio::bio",
    ][::std::mem::offset_of!(bch_write_bio, bio) - 144usize];
};
impl Default for bch_write_bio {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct bch_write_op {
    pub cl: closure,
    pub c: *mut bch_fs,
    pub end_io: ::std::option::Option<unsafe extern "C" fn(arg1: *mut bch_write_op)>,
    pub start_time: u64_,
    pub written: ::std::os::raw::c_uint,
    pub flags: u16_,
    pub error: s16,
    pub io_error: u8_,
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
    pub devs_have: bch_devs_list,
    pub target: u16_,
    pub nonce: u16_,
    pub opts: bch_inode_opts,
    pub subvol: u32_,
    pub pos: bpos,
    pub version: bversion,
    pub crc: bch_extent_crc_unpacked,
    pub write_point: write_point_specifier,
    pub wp: *mut write_point,
    pub wp_list: cds_list_head,
    pub res: disk_reservation,
    pub open_buckets: open_buckets,
    pub new_i_size: u64_,
    pub i_sectors_delta: s64,
    pub insert_keys: keylist,
    pub inline_keys: [u64_; 92usize],
    pub devs_need_flush: *mut bch_devs_mask,
    pub wbio: bch_write_bio,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_write_op"][::std::mem::size_of::<bch_write_op>() - 1336usize];
    ["Alignment of bch_write_op"][::std::mem::align_of::<bch_write_op>() - 8usize];
    [
        "Offset of field: bch_write_op::cl",
    ][::std::mem::offset_of!(bch_write_op, cl) - 0usize];
    [
        "Offset of field: bch_write_op::c",
    ][::std::mem::offset_of!(bch_write_op, c) - 48usize];
    [
        "Offset of field: bch_write_op::end_io",
    ][::std::mem::offset_of!(bch_write_op, end_io) - 56usize];
    [
        "Offset of field: bch_write_op::start_time",
    ][::std::mem::offset_of!(bch_write_op, start_time) - 64usize];
    [
        "Offset of field: bch_write_op::written",
    ][::std::mem::offset_of!(bch_write_op, written) - 72usize];
    [
        "Offset of field: bch_write_op::flags",
    ][::std::mem::offset_of!(bch_write_op, flags) - 76usize];
    [
        "Offset of field: bch_write_op::error",
    ][::std::mem::offset_of!(bch_write_op, error) - 78usize];
    [
        "Offset of field: bch_write_op::io_error",
    ][::std::mem::offset_of!(bch_write_op, io_error) - 80usize];
    [
        "Offset of field: bch_write_op::devs_have",
    ][::std::mem::offset_of!(bch_write_op, devs_have) - 84usize];
    [
        "Offset of field: bch_write_op::target",
    ][::std::mem::offset_of!(bch_write_op, target) - 102usize];
    [
        "Offset of field: bch_write_op::nonce",
    ][::std::mem::offset_of!(bch_write_op, nonce) - 104usize];
    [
        "Offset of field: bch_write_op::opts",
    ][::std::mem::offset_of!(bch_write_op, opts) - 112usize];
    [
        "Offset of field: bch_write_op::subvol",
    ][::std::mem::offset_of!(bch_write_op, subvol) - 144usize];
    [
        "Offset of field: bch_write_op::pos",
    ][::std::mem::offset_of!(bch_write_op, pos) - 148usize];
    [
        "Offset of field: bch_write_op::version",
    ][::std::mem::offset_of!(bch_write_op, version) - 168usize];
    [
        "Offset of field: bch_write_op::crc",
    ][::std::mem::offset_of!(bch_write_op, crc) - 184usize];
    [
        "Offset of field: bch_write_op::write_point",
    ][::std::mem::offset_of!(bch_write_op, write_point) - 224usize];
    [
        "Offset of field: bch_write_op::wp",
    ][::std::mem::offset_of!(bch_write_op, wp) - 232usize];
    [
        "Offset of field: bch_write_op::wp_list",
    ][::std::mem::offset_of!(bch_write_op, wp_list) - 240usize];
    [
        "Offset of field: bch_write_op::res",
    ][::std::mem::offset_of!(bch_write_op, res) - 256usize];
    [
        "Offset of field: bch_write_op::open_buckets",
    ][::std::mem::offset_of!(bch_write_op, open_buckets) - 272usize];
    [
        "Offset of field: bch_write_op::new_i_size",
    ][::std::mem::offset_of!(bch_write_op, new_i_size) - 312usize];
    [
        "Offset of field: bch_write_op::i_sectors_delta",
    ][::std::mem::offset_of!(bch_write_op, i_sectors_delta) - 320usize];
    [
        "Offset of field: bch_write_op::insert_keys",
    ][::std::mem::offset_of!(bch_write_op, insert_keys) - 328usize];
    [
        "Offset of field: bch_write_op::inline_keys",
    ][::std::mem::offset_of!(bch_write_op, inline_keys) - 344usize];
    [
        "Offset of field: bch_write_op::devs_need_flush",
    ][::std::mem::offset_of!(bch_write_op, devs_need_flush) - 1080usize];
    [
        "Offset of field: bch_write_op::wbio",
    ][::std::mem::offset_of!(bch_write_op, wbio) - 1088usize];
};
impl Default for bch_write_op {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl bch_write_op {
    #[inline]
    pub fn compression_opt(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
    }
    #[inline]
    pub fn set_compression_opt(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 8u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn compression_opt_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 3usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 8u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_compression_opt_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 3usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                8u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn csum_type(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 4u8) as u32) }
    }
    #[inline]
    pub fn set_csum_type(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(8usize, 4u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn csum_type_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 3usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 8usize, 4u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_csum_type_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 3usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                8usize,
                4u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn nr_replicas(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 4u8) as u32) }
    }
    #[inline]
    pub fn set_nr_replicas(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(12usize, 4u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn nr_replicas_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 3usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 12usize, 4u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_nr_replicas_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 3usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                12usize,
                4u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn watermark(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 3u8) as u32) }
    }
    #[inline]
    pub fn set_watermark(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(16usize, 3u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn watermark_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 3usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 16usize, 3u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_watermark_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 3usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                16usize,
                3u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn incompressible(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_incompressible(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(19usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn incompressible_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 3usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 19usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_incompressible_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 3usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                19usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn stripe_waited(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_stripe_waited(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(20usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn stripe_waited_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 3usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 20usize, 1u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_stripe_waited_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 3usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                20usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        compression_opt: ::std::os::raw::c_uint,
        csum_type: ::std::os::raw::c_uint,
        nr_replicas: ::std::os::raw::c_uint,
        watermark: ::std::os::raw::c_uint,
        incompressible: ::std::os::raw::c_uint,
        stripe_waited: ::std::os::raw::c_uint,
    ) -> __BindgenBitfieldUnit<[u8; 3usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                8u8,
                {
                    let compression_opt: u32 = unsafe {
                        ::std::mem::transmute(compression_opt)
                    };
                    compression_opt as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                8usize,
                4u8,
                {
                    let csum_type: u32 = unsafe { ::std::mem::transmute(csum_type) };
                    csum_type as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                12usize,
                4u8,
                {
                    let nr_replicas: u32 = unsafe { ::std::mem::transmute(nr_replicas) };
                    nr_replicas as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                16usize,
                3u8,
                {
                    let watermark: u32 = unsafe { ::std::mem::transmute(watermark) };
                    watermark as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                19usize,
                1u8,
                {
                    let incompressible: u32 = unsafe {
                        ::std::mem::transmute(incompressible)
                    };
                    incompressible as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                20usize,
                1u8,
                {
                    let stripe_waited: u32 = unsafe {
                        ::std::mem::transmute(stripe_waited)
                    };
                    stripe_waited as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_data_update_types {
    BCH_DATA_UPDATE_other = 0,
    BCH_DATA_UPDATE_copygc = 1,
    BCH_DATA_UPDATE_reconcile = 2,
    BCH_DATA_UPDATE_promote = 3,
    BCH_DATA_UPDATE_self_heal = 4,
    BCH_DATA_UPDATE_scrub = 5,
    BCH_DATA_UPDATE_scrub_no_repair = 6,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct data_update_opts {
    pub type_: bch_data_update_types,
    pub ptrs_io_error: u8_,
    pub ptrs_kill: u8_,
    pub ptrs_kill_ec: u8_,
    pub extra_replicas: u8_,
    pub target: u16_,
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
    pub read_dev: ::std::os::raw::c_uint,
    pub read_flags: bch_read_flags,
    pub write_flags: bch_write_flags,
    pub commit_flags: bch_trans_commit_flags,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of data_update_opts"][::std::mem::size_of::<data_update_opts>() - 28usize];
    [
        "Alignment of data_update_opts",
    ][::std::mem::align_of::<data_update_opts>() - 4usize];
    [
        "Offset of field: data_update_opts::type_",
    ][::std::mem::offset_of!(data_update_opts, type_) - 0usize];
    [
        "Offset of field: data_update_opts::ptrs_io_error",
    ][::std::mem::offset_of!(data_update_opts, ptrs_io_error) - 4usize];
    [
        "Offset of field: data_update_opts::ptrs_kill",
    ][::std::mem::offset_of!(data_update_opts, ptrs_kill) - 5usize];
    [
        "Offset of field: data_update_opts::ptrs_kill_ec",
    ][::std::mem::offset_of!(data_update_opts, ptrs_kill_ec) - 6usize];
    [
        "Offset of field: data_update_opts::extra_replicas",
    ][::std::mem::offset_of!(data_update_opts, extra_replicas) - 7usize];
    [
        "Offset of field: data_update_opts::target",
    ][::std::mem::offset_of!(data_update_opts, target) - 8usize];
    [
        "Offset of field: data_update_opts::read_dev",
    ][::std::mem::offset_of!(data_update_opts, read_dev) - 12usize];
    [
        "Offset of field: data_update_opts::read_flags",
    ][::std::mem::offset_of!(data_update_opts, read_flags) - 16usize];
    [
        "Offset of field: data_update_opts::write_flags",
    ][::std::mem::offset_of!(data_update_opts, write_flags) - 20usize];
    [
        "Offset of field: data_update_opts::commit_flags",
    ][::std::mem::offset_of!(data_update_opts, commit_flags) - 24usize];
};
impl Default for data_update_opts {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl data_update_opts {
    #[inline]
    pub fn no_devs_have(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_no_devs_have(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn no_devs_have_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_no_devs_have_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn checksum_paranoia(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_checksum_paranoia(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(1usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn checksum_paranoia_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 1usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_checksum_paranoia_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                1usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        no_devs_have: bool,
        checksum_paranoia: bool,
    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                1u8,
                {
                    let no_devs_have: u8 = unsafe {
                        ::std::mem::transmute(no_devs_have)
                    };
                    no_devs_have as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                1usize,
                1u8,
                {
                    let checksum_paranoia: u8 = unsafe {
                        ::std::mem::transmute(checksum_paranoia)
                    };
                    checksum_paranoia as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
pub struct data_update {
    pub rcu: rcu_head,
    pub btree_id: btree_id,
    pub k: bkey_buf,
    pub opts: data_update_opts,
    pub on_hashtable: bool,
    pub read_done: bool,
    pub cas: [*mut bch_dev; 16usize],
    pub hash: rhlist_head,
    pub pos: bbpos,
    pub read_list: cds_list_head,
    pub io_list: cds_list_head,
    pub io_seq: u64_,
    pub b: *mut move_bucket,
    pub ctxt: *mut moving_context,
    pub stats: *mut bch_move_stats,
    pub rbio: bch_read_bio,
    pub op: bch_write_op,
    pub bvecs: *mut bio_vec,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of data_update"][::std::mem::size_of::<data_update>() - 2128usize];
    ["Alignment of data_update"][::std::mem::align_of::<data_update>() - 8usize];
    [
        "Offset of field: data_update::rcu",
    ][::std::mem::offset_of!(data_update, rcu) - 0usize];
    [
        "Offset of field: data_update::btree_id",
    ][::std::mem::offset_of!(data_update, btree_id) - 16usize];
    [
        "Offset of field: data_update::k",
    ][::std::mem::offset_of!(data_update, k) - 24usize];
    [
        "Offset of field: data_update::opts",
    ][::std::mem::offset_of!(data_update, opts) - 128usize];
    [
        "Offset of field: data_update::on_hashtable",
    ][::std::mem::offset_of!(data_update, on_hashtable) - 156usize];
    [
        "Offset of field: data_update::read_done",
    ][::std::mem::offset_of!(data_update, read_done) - 157usize];
    [
        "Offset of field: data_update::cas",
    ][::std::mem::offset_of!(data_update, cas) - 160usize];
    [
        "Offset of field: data_update::hash",
    ][::std::mem::offset_of!(data_update, hash) - 288usize];
    [
        "Offset of field: data_update::pos",
    ][::std::mem::offset_of!(data_update, pos) - 304usize];
    [
        "Offset of field: data_update::read_list",
    ][::std::mem::offset_of!(data_update, read_list) - 328usize];
    [
        "Offset of field: data_update::io_list",
    ][::std::mem::offset_of!(data_update, io_list) - 344usize];
    [
        "Offset of field: data_update::io_seq",
    ][::std::mem::offset_of!(data_update, io_seq) - 360usize];
    [
        "Offset of field: data_update::b",
    ][::std::mem::offset_of!(data_update, b) - 368usize];
    [
        "Offset of field: data_update::ctxt",
    ][::std::mem::offset_of!(data_update, ctxt) - 376usize];
    [
        "Offset of field: data_update::stats",
    ][::std::mem::offset_of!(data_update, stats) - 384usize];
    [
        "Offset of field: data_update::rbio",
    ][::std::mem::offset_of!(data_update, rbio) - 392usize];
    [
        "Offset of field: data_update::op",
    ][::std::mem::offset_of!(data_update, op) - 784usize];
    [
        "Offset of field: data_update::bvecs",
    ][::std::mem::offset_of!(data_update, bvecs) - 2120usize];
};
impl Default for data_update {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct promote_op {
    pub start_time: u64_,
    pub cpu: ::std::os::raw::c_int,
    pub work: work_struct,
    pub write: data_update,
    pub bi_inline_vecs: __IncompleteArrayField<bio_vec>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of promote_op"][::std::mem::size_of::<promote_op>() - 2176usize];
    ["Alignment of promote_op"][::std::mem::align_of::<promote_op>() - 8usize];
    [
        "Offset of field: promote_op::start_time",
    ][::std::mem::offset_of!(promote_op, start_time) - 0usize];
    [
        "Offset of field: promote_op::cpu",
    ][::std::mem::offset_of!(promote_op, cpu) - 8usize];
    [
        "Offset of field: promote_op::work",
    ][::std::mem::offset_of!(promote_op, work) - 16usize];
    [
        "Offset of field: promote_op::write",
    ][::std::mem::offset_of!(promote_op, write) - 48usize];
    [
        "Offset of field: promote_op::bi_inline_vecs",
    ][::std::mem::offset_of!(promote_op, bi_inline_vecs) - 2176usize];
};
impl Default for promote_op {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C" {
    pub fn bch2_data_update_opts_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: *mut bch_inode_opts,
        arg4: *mut data_update_opts,
    );
}
unsafe extern "C" {
    pub fn bch2_data_update_to_text(arg1: *mut printbuf, arg2: *mut data_update);
}
unsafe extern "C" {
    pub fn bch2_data_update_inflight_to_text(
        arg1: *mut printbuf,
        arg2: *mut data_update,
    );
}
unsafe extern "C" {
    pub fn bch2_data_update_in_flight(
        arg1: *mut bch_fs,
        arg2: *mut bbpos,
        arg3: bch_data_update_types,
    ) -> bool;
}
unsafe extern "C" {
    pub fn bch2_data_update_index_update(
        arg1: *mut bch_write_op,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_data_update_read_done(arg1: *mut data_update);
}
unsafe extern "C" {
    pub fn bch2_can_do_data_update(
        arg1: *mut btree_trans,
        arg2: *mut bch_inode_opts,
        arg3: *mut data_update_opts,
        arg4: bkey_s_c,
        arg5: *mut printbuf,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_data_update_ec_alloc_failed(arg1: *mut data_update);
}
unsafe extern "C" {
    pub fn bch2_data_update_exit(arg1: *mut data_update, arg2: ::std::os::raw::c_int);
}
unsafe extern "C" {
    pub fn bch2_data_update_init(
        arg1: *mut btree_trans,
        arg2: *mut btree_iter,
        arg3: *mut moving_context,
        arg4: *mut data_update,
        arg5: write_point_specifier,
        arg6: *mut bch_inode_opts,
        arg7: data_update_opts,
        arg8: btree_id,
        arg9: bkey_s_c,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_fs_data_update_exit(arg1: *mut bch_fs);
}
unsafe extern "C" {
    pub fn bch2_fs_data_update_init(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct moving_context {
    pub trans: *mut btree_trans,
    pub list: cds_list_head,
    pub fn_: *mut ::std::os::raw::c_void,
    pub rate: *mut bch_ratelimit,
    pub stats: *mut bch_move_stats,
    pub wp: write_point_specifier,
    pub wait_on_copygc: bool,
    pub cl: closure,
    pub lock: mutex,
    pub reads: cds_list_head,
    pub ios: cds_list_head,
    pub io_seq: u64_,
    pub read_sectors: atomic_t,
    pub write_sectors: atomic_t,
    pub read_ios: atomic_t,
    pub write_ios: atomic_t,
    pub wait: wait_queue_head_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of moving_context"][::std::mem::size_of::<moving_context>() - 264usize];
    ["Alignment of moving_context"][::std::mem::align_of::<moving_context>() - 8usize];
    [
        "Offset of field: moving_context::trans",
    ][::std::mem::offset_of!(moving_context, trans) - 0usize];
    [
        "Offset of field: moving_context::list",
    ][::std::mem::offset_of!(moving_context, list) - 8usize];
    [
        "Offset of field: moving_context::fn_",
    ][::std::mem::offset_of!(moving_context, fn_) - 24usize];
    [
        "Offset of field: moving_context::rate",
    ][::std::mem::offset_of!(moving_context, rate) - 32usize];
    [
        "Offset of field: moving_context::stats",
    ][::std::mem::offset_of!(moving_context, stats) - 40usize];
    [
        "Offset of field: moving_context::wp",
    ][::std::mem::offset_of!(moving_context, wp) - 48usize];
    [
        "Offset of field: moving_context::wait_on_copygc",
    ][::std::mem::offset_of!(moving_context, wait_on_copygc) - 56usize];
    [
        "Offset of field: moving_context::cl",
    ][::std::mem::offset_of!(moving_context, cl) - 64usize];
    [
        "Offset of field: moving_context::lock",
    ][::std::mem::offset_of!(moving_context, lock) - 112usize];
    [
        "Offset of field: moving_context::reads",
    ][::std::mem::offset_of!(moving_context, reads) - 152usize];
    [
        "Offset of field: moving_context::ios",
    ][::std::mem::offset_of!(moving_context, ios) - 168usize];
    [
        "Offset of field: moving_context::io_seq",
    ][::std::mem::offset_of!(moving_context, io_seq) - 184usize];
    [
        "Offset of field: moving_context::read_sectors",
    ][::std::mem::offset_of!(moving_context, read_sectors) - 192usize];
    [
        "Offset of field: moving_context::write_sectors",
    ][::std::mem::offset_of!(moving_context, write_sectors) - 196usize];
    [
        "Offset of field: moving_context::read_ios",
    ][::std::mem::offset_of!(moving_context, read_ios) - 200usize];
    [
        "Offset of field: moving_context::write_ios",
    ][::std::mem::offset_of!(moving_context, write_ios) - 204usize];
    [
        "Offset of field: moving_context::wait",
    ][::std::mem::offset_of!(moving_context, wait) - 208usize];
};
impl Default for moving_context {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type move_pred_fn = ::std::option::Option<
    unsafe extern "C" fn(
        arg1: *mut btree_trans,
        arg2: *mut ::std::os::raw::c_void,
        arg3: btree_id,
        arg4: bkey_s_c,
        arg5: *mut bch_inode_opts,
        arg6: *mut data_update_opts,
    ) -> ::std::os::raw::c_int,
>;
unsafe extern "C" {
    pub static bch2_data_ops_strs: [*const ::std::os::raw::c_char; 0usize];
}
unsafe extern "C" {
    pub fn bch2_moving_ctxt_exit(arg1: *mut moving_context);
}
unsafe extern "C" {
    pub fn bch2_moving_ctxt_init(
        arg1: *mut moving_context,
        arg2: *mut bch_fs,
        arg3: *mut bch_ratelimit,
        arg4: *mut bch_move_stats,
        arg5: write_point_specifier,
        arg6: bool,
    );
}
unsafe extern "C" {
    pub fn bch2_moving_ctxt_next_pending_write(
        arg1: *mut moving_context,
    ) -> *mut data_update;
}
unsafe extern "C" {
    pub fn bch2_moving_ctxt_do_pending_writes(arg1: *mut moving_context);
}
unsafe extern "C" {
    pub fn bch2_moving_ctxt_flush_all(arg1: *mut moving_context);
}
unsafe extern "C" {
    pub fn bch2_move_ctxt_wait_for_io(arg1: *mut moving_context);
}
unsafe extern "C" {
    pub fn bch2_move_ratelimit(arg1: *mut moving_context) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_move_extent(
        arg1: *mut moving_context,
        arg2: *mut move_bucket,
        arg3: *mut bch_inode_opts,
        arg4: *mut data_update_opts,
        arg5: *mut btree_iter,
        arg6: ::std::os::raw::c_uint,
        arg7: bkey_s_c,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_move_data_btree(
        arg1: *mut moving_context,
        arg2: bpos,
        arg3: bpos,
        arg4: move_pred_fn,
        arg5: *mut ::std::os::raw::c_void,
        arg6: btree_id,
        arg7: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_move_data_phys(
        arg1: *mut bch_fs,
        arg2: ::std::os::raw::c_uint,
        arg3: u64_,
        arg4: u64_,
        arg5: ::std::os::raw::c_uint,
        arg6: *mut bch_ratelimit,
        arg7: *mut bch_move_stats,
        arg8: write_point_specifier,
        arg9: bool,
        arg10: move_pred_fn,
        arg11: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_evacuate_data(
        arg1: *mut moving_context,
        arg2: ::std::os::raw::c_uint,
        arg3: u64_,
        arg4: u64_,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_evacuate_ec_orphan(
        arg1: *mut moving_context,
        arg2: u64_,
        arg3: ::std::os::raw::c_uint,
        arg4: u64_,
        arg5: u64_,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_evacuate_bucket(
        arg1: *mut moving_context,
        arg2: *mut move_bucket,
        arg3: bpos,
        arg4: ::std::os::raw::c_int,
        arg5: data_update_opts,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_scrub_journal(
        arg1: *mut bch_fs,
        arg2: *mut u64_,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_scrub_journal_do_repairs(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_data_job(
        arg1: *mut bch_fs,
        arg2: *mut bch_move_stats,
        arg3: *mut bch_ioctl_data,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_move_stats_to_text(arg1: *mut printbuf, arg2: *mut bch_move_stats);
}
unsafe extern "C" {
    pub fn bch2_move_stats_exit(arg1: *mut bch_move_stats, arg2: *mut bch_fs);
}
unsafe extern "C" {
    pub fn bch2_move_stats_init(
        arg1: *mut bch_move_stats,
        arg2: *const ::std::os::raw::c_char,
    );
}
unsafe extern "C" {
    pub fn bch2_fs_moving_ctxts_to_text(arg1: *mut printbuf, arg2: *mut bch_fs);
}
unsafe extern "C" {
    pub fn bch2_fs_move_exit(arg1: *mut bch_fs);
}
unsafe extern "C" {
    pub fn bch2_fs_move_init(arg1: *mut bch_fs);
}
unsafe extern "C" {
    pub fn bch2_btree_node_ondisk_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: *const btree,
    );
}
unsafe extern "C" {
    #[link_name = "bch2_fs_debug_exit__extern"]
    pub fn bch2_fs_debug_exit(c: *mut bch_fs);
}
unsafe extern "C" {
    #[link_name = "bch2_fs_debug_init__extern"]
    pub fn bch2_fs_debug_init(c: *mut bch_fs);
}
unsafe extern "C" {
    #[link_name = "bch2_debug_exit__extern"]
    pub fn bch2_debug_exit();
}
unsafe extern "C" {
    #[link_name = "bch2_debug_init__extern"]
    pub fn bch2_debug_init() -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_devs_list_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: *mut bch_devs_list,
    );
}
unsafe extern "C" {
    pub fn bch2_dev_to_fs(arg1: dev_t) -> *mut bch_fs;
}
unsafe extern "C" {
    pub fn bch2_dev_in_fs(
        arg1: *mut bch_sb_handle,
        arg2: *mut bch_sb_handle,
        arg3: *mut bch_opts,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_dev_io_ref_stop(arg1: *mut bch_dev, arg2: ::std::os::raw::c_int);
}
unsafe extern "C" {
    pub fn bch2_dev_unlink(arg1: *mut bch_dev);
}
unsafe extern "C" {
    pub fn bch2_dev_free(arg1: *mut bch_dev);
}
unsafe extern "C" {
    pub fn __bch2_dev_offline(arg1: *mut bch_fs, arg2: *mut bch_dev);
}
unsafe extern "C" {
    pub fn bch2_dev_sysfs_online(
        arg1: *mut bch_fs,
        arg2: *mut bch_dev,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_dev_alloc(
        arg1: *mut bch_fs,
        arg2: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_dev_attach_bdev(
        arg1: *mut bch_fs,
        arg2: *mut bch_sb_handle,
        arg3: *mut printbuf,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_dev_state_allowed(
        arg1: *mut bch_fs,
        arg2: *mut bch_dev,
        arg3: bch_member_state,
        arg4: ::std::os::raw::c_int,
        arg5: *mut printbuf,
    ) -> bool;
}
unsafe extern "C" {
    pub fn __bch2_dev_set_state(
        arg1: *mut bch_fs,
        arg2: *mut bch_dev,
        arg3: bch_member_state,
        arg4: ::std::os::raw::c_int,
        arg5: *mut printbuf,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_dev_set_state(
        arg1: *mut bch_fs,
        arg2: *mut bch_dev,
        arg3: bch_member_state,
        arg4: ::std::os::raw::c_int,
        arg5: *mut printbuf,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_dev_add_initialize(
        arg1: *mut bch_fs,
        arg2: *mut bch_dev,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_dev_remove(
        arg1: *mut bch_fs,
        arg2: *mut bch_dev,
        arg3: ::std::os::raw::c_int,
        arg4: *mut printbuf,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_dev_add(
        arg1: *mut bch_fs,
        arg2: *const ::std::os::raw::c_char,
        arg3: *mut printbuf,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_dev_online(
        arg1: *mut bch_fs,
        arg2: *const ::std::os::raw::c_char,
        arg3: *mut printbuf,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_dev_offline(
        arg1: *mut bch_fs,
        arg2: *mut bch_dev,
        arg3: ::std::os::raw::c_int,
        arg4: *mut printbuf,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_dev_resize(
        arg1: *mut bch_fs,
        arg2: *mut bch_dev,
        arg3: u64_,
        arg4: *mut printbuf,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn __bch2_dev_resize_alloc(
        arg1: *mut bch_dev,
        arg2: u64_,
        arg3: u64_,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_dev_lookup(
        arg1: *mut bch_fs,
        arg2: *const ::std::os::raw::c_char,
    ) -> *mut bch_dev;
}
unsafe extern "C" {
    pub static bch2_sb_handle_bdev_ops: blk_holder_ops;
}
unsafe extern "C" {
    pub static bch2_sb_error_strs: [*const ::std::os::raw::c_char; 0usize];
}
unsafe extern "C" {
    pub fn bch2_sb_error_id_to_text(arg1: *mut printbuf, arg2: bch_sb_error_id);
}
unsafe extern "C" {
    pub fn bch2_fs_errors_to_text(arg1: *mut printbuf, arg2: *mut bch_fs);
}
unsafe extern "C" {
    pub static bch_sb_field_ops_errors: bch_sb_field_ops;
}
unsafe extern "C" {
    pub fn bch2_sb_error_count(arg1: *mut bch_fs, arg2: bch_sb_error_id);
}
unsafe extern "C" {
    pub fn bch2_sb_errors_from_cpu(arg1: *mut bch_fs);
}
unsafe extern "C" {
    pub fn bch2_sb_errors_to_cpu(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn __bch2_inconsistent_error(arg1: *mut bch_fs, arg2: *mut printbuf) -> bool;
}
unsafe extern "C" {
    pub fn bch2_inconsistent_error(arg1: *mut bch_fs) -> bool;
}
unsafe extern "C" {
    pub fn bch2_fs_inconsistent(
        arg1: *mut bch_fs,
        arg2: *const ::std::os::raw::c_char,
        ...
    ) -> bool;
}
unsafe extern "C" {
    pub fn bch2_trans_inconsistent(
        arg1: *mut btree_trans,
        arg2: *const ::std::os::raw::c_char,
        ...
    ) -> bool;
}
unsafe extern "C" {
    pub fn __bch2_topology_error(
        arg1: *mut bch_fs,
        arg2: *mut printbuf,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_fs_topology_error(
        arg1: *mut bch_fs,
        arg2: *const ::std::os::raw::c_char,
        ...
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn __bch2_count_fsck_err(
        arg1: *mut bch_fs,
        arg2: bch_sb_error_id,
        arg3: *mut printbuf,
    ) -> bool;
}
unsafe extern "C" {
    pub fn bch2_fsck_err_opt(
        arg1: *mut bch_fs,
        arg2: bch_fsck_flags,
        arg3: bch_sb_error_id,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn __bch2_fsck_err(
        arg1: *mut bch_fs,
        arg2: *mut btree_trans,
        arg3: bch_fsck_flags,
        arg4: bch_sb_error_id,
        arg5: *const ::std::os::raw::c_char,
        ...
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_flush_fsck_errs(arg1: *mut bch_fs);
}
unsafe extern "C" {
    pub fn bch2_free_fsck_errs(arg1: *mut bch_fs);
}
unsafe extern "C" {
    pub fn __bch2_bkey_fsck_err(
        arg1: *mut bch_fs,
        arg2: bkey_s_c,
        from: bkey_validate_context,
        arg3: bch_sb_error_id,
        arg4: *const ::std::os::raw::c_char,
        ...
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_fatal_error(
        c: *mut bch_fs,
        func: *const ::std::os::raw::c_char,
        fmt: *const ::std::os::raw::c_char,
        ...
    );
}
unsafe extern "C" {
    pub fn bch2_io_error_work(arg1: *mut work_struct);
}
unsafe extern "C" {
    pub fn bch2_io_error(arg1: *mut bch_dev, arg2: bch_member_error_type);
}
unsafe extern "C" {
    pub fn bch2_latency_acct(
        arg1: *mut bch_dev,
        arg2: u64_,
        arg3: ::std::os::raw::c_int,
    );
}
unsafe extern "C" {
    #[link_name = "bch2_account_io_success_fail__extern"]
    pub fn bch2_account_io_success_fail(
        ca: *mut bch_dev,
        type_: bch_member_error_type,
        success: bool,
    );
}
unsafe extern "C" {
    #[link_name = "bch2_account_io_completion__extern"]
    pub fn bch2_account_io_completion(
        ca: *mut bch_dev,
        type_: bch_member_error_type,
        submit_time: u64_,
        success: bool,
    );
}
unsafe extern "C" {
    pub fn bch2_inum_offset_err_msg_trans_norestart(
        arg1: *mut btree_trans,
        arg2: *mut printbuf,
        arg3: u32_,
        arg4: bpos,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_inum_offset_err_msg_trans(
        arg1: *mut btree_trans,
        arg2: *mut printbuf,
        arg3: u32_,
        arg4: bpos,
    );
}
unsafe extern "C" {
    pub fn bch2_fs_errors_exit(arg1: *mut bch_fs);
}
unsafe extern "C" {
    pub fn bch2_fs_errors_init_early(arg1: *mut bch_fs);
}
unsafe extern "C" {
    pub fn bch2_fs_errors_init(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub static bch2_fs_flag_strs: [*const ::std::os::raw::c_char; 0usize];
}
unsafe extern "C" {
    pub static bch2_write_refs: [*const ::std::os::raw::c_char; 0usize];
}
unsafe extern "C" {
    pub static bch2_dev_read_refs: [*const ::std::os::raw::c_char; 0usize];
}
unsafe extern "C" {
    pub static bch2_dev_write_refs: [*const ::std::os::raw::c_char; 0usize];
}
unsafe extern "C" {
    pub static mut bch2_fs_list: cds_list_head;
}
unsafe extern "C" {
    pub static mut bch2_fs_list_lock: mutex;
}
unsafe extern "C" {
    pub fn __bch2_uuid_to_fs(uuid: __uuid_t) -> *mut bch_fs;
}
unsafe extern "C" {
    pub fn bch2_uuid_to_fs(arg1: __uuid_t) -> *mut bch_fs;
}
unsafe extern "C" {
    pub fn bch2_fs_emergency_read_only(arg1: *mut bch_fs, arg2: *mut printbuf) -> bool;
}
unsafe extern "C" {
    pub fn bch2_fs_emergency_read_only_locked(
        arg1: *mut bch_fs,
        out: *mut printbuf,
    ) -> bool;
}
unsafe extern "C" {
    pub fn bch2_fs_read_only(arg1: *mut bch_fs);
}
unsafe extern "C" {
    pub fn bch2_fs_read_write(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_fs_read_write_early(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_fs_init_rw(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_fs_resize_on_mount(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_missing_devs_to_text(arg1: *mut printbuf, arg2: *mut bch_fs);
}
unsafe extern "C" {
    pub fn bch2_fs_start(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_fs_stop(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_fs_exit(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_fs_open(arg1: *mut darray_const_str, arg2: *mut bch_opts) -> *mut bch_fs;
}
unsafe extern "C" {
    pub static bch2_recovery_passes: [*const ::std::os::raw::c_char; 0usize];
}
unsafe extern "C" {
    pub static bch_sb_field_ops_recovery_passes: bch_sb_field_ops;
}
unsafe extern "C" {
    pub fn bch2_recovery_passes_to_stable(v: u64_) -> u64_;
}
unsafe extern "C" {
    pub fn bch2_recovery_passes_from_stable(v: u64_) -> u64_;
}
unsafe extern "C" {
    pub fn bch2_fsck_recovery_passes() -> u64_;
}
unsafe extern "C" {
    pub fn bch2_recovery_pass_set_no_ratelimit(
        arg1: *mut bch_fs,
        arg2: bch_recovery_pass,
    );
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_run_recovery_pass_flags {
    RUN_RECOVERY_PASS_nopersistent = 1,
    RUN_RECOVERY_PASS_ratelimit = 2,
}
unsafe extern "C" {
    #[link_name = "bch2_recovery_cancelled__extern"]
    pub fn bch2_recovery_cancelled(c: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_recovery_pass_want_ratelimit(
        arg1: *mut bch_fs,
        arg2: bch_recovery_pass,
        arg3: ::std::os::raw::c_uint,
    ) -> bool;
}
unsafe extern "C" {
    pub fn __bch2_run_explicit_recovery_pass(
        arg1: *mut bch_fs,
        arg2: *mut printbuf,
        arg3: bch_recovery_pass,
        arg4: bch_run_recovery_pass_flags,
        arg5: *mut bool,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_run_explicit_recovery_pass(
        arg1: *mut bch_fs,
        arg2: *mut printbuf,
        arg3: bch_recovery_pass,
        arg4: bch_run_recovery_pass_flags,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_require_recovery_pass(
        arg1: *mut bch_fs,
        arg2: *mut printbuf,
        arg3: bch_recovery_pass,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_recovery_passes_match(arg1: ::std::os::raw::c_uint) -> u64_;
}
unsafe extern "C" {
    pub fn bch2_run_async_recovery_passes(arg1: *mut bch_fs);
}
unsafe extern "C" {
    pub fn bch2_run_recovery_passes(
        arg1: *mut bch_fs,
        arg2: u64_,
        arg3: bool,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_run_recovery_passes_startup(
        arg1: *mut bch_fs,
        arg2: bch_recovery_pass,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_recovery_pass_status_to_text(arg1: *mut printbuf, arg2: *mut bch_fs);
}
unsafe extern "C" {
    pub fn bch2_fs_recovery_passes_init(arg1: *mut bch_fs);
}
unsafe extern "C" {
    pub static bch2_inode_opts: [*const ::std::os::raw::c_char; 0usize];
}
unsafe extern "C" {
    pub fn bch2_inode_validate(
        arg1: *mut bch_fs,
        arg2: bkey_s_c,
        arg3: bkey_validate_context,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_inode_v2_validate(
        arg1: *mut bch_fs,
        arg2: bkey_s_c,
        arg3: bkey_validate_context,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_inode_v3_validate(
        arg1: *mut bch_fs,
        arg2: bkey_s_c,
        arg3: bkey_validate_context,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_inode_to_text(arg1: *mut printbuf, arg2: *mut bch_fs, arg3: bkey_s_c);
}
unsafe extern "C" {
    pub fn __bch2_inode_has_child_snapshots(
        arg1: *mut btree_trans,
        arg2: bpos,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_inode_has_child_snapshots__extern"]
    pub fn bch2_inode_has_child_snapshots(
        trans: *mut btree_trans,
        pos: bpos,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_trigger_inode(
        arg1: *mut btree_trans,
        arg2: btree_trigger_op,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_inode_generation_validate(
        arg1: *mut bch_fs,
        arg2: bkey_s_c,
        arg3: bkey_validate_context,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_inode_generation_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: bkey_s_c,
    );
}
unsafe extern "C" {
    pub fn bch2_inode_alloc_cursor_validate(
        arg1: *mut bch_fs,
        arg2: bkey_s_c,
        arg3: bkey_validate_context,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_inode_alloc_cursor_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: bkey_s_c,
    );
}
pub type u96 = u64_;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bch_inode_unpacked {
    pub bi_inum: u64_,
    pub bi_snapshot: u32_,
    pub bi_journal_seq: u64_,
    pub bi_hash_seed: __le64,
    pub bi_size: u64_,
    pub bi_sectors: u64_,
    pub bi_version: u64_,
    pub bi_flags: u32_,
    pub bi_mode: u16_,
    pub bi_atime: u96,
    pub bi_ctime: u96,
    pub bi_mtime: u96,
    pub bi_otime: u96,
    pub bi_uid: u32_,
    pub bi_gid: u32_,
    pub bi_nlink: u32_,
    pub bi_generation: u32_,
    pub bi_dev: u32_,
    pub bi_data_checksum: u8_,
    pub bi_compression: u8_,
    pub bi_project: u32_,
    pub bi_background_compression: u8_,
    pub bi_data_replicas: u8_,
    pub bi_promote_target: u16_,
    pub bi_foreground_target: u16_,
    pub bi_background_target: u16_,
    pub bi_erasure_code: u16_,
    pub bi_fields_set: u16_,
    pub bi_dir: u64_,
    pub bi_dir_offset: u64_,
    pub bi_subvol: u32_,
    pub bi_parent_subvol: u32_,
    pub bi_nocow: u8_,
    pub bi_depth: u32_,
    pub bi_inodes_32bit: u8_,
    pub bi_casefold: u8_,
    pub bi_unused_ec_max_data_blocks: u8_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_inode_unpacked",
    ][::std::mem::size_of::<bch_inode_unpacked>() - 176usize];
    [
        "Alignment of bch_inode_unpacked",
    ][::std::mem::align_of::<bch_inode_unpacked>() - 8usize];
    [
        "Offset of field: bch_inode_unpacked::bi_inum",
    ][::std::mem::offset_of!(bch_inode_unpacked, bi_inum) - 0usize];
    [
        "Offset of field: bch_inode_unpacked::bi_snapshot",
    ][::std::mem::offset_of!(bch_inode_unpacked, bi_snapshot) - 8usize];
    [
        "Offset of field: bch_inode_unpacked::bi_journal_seq",
    ][::std::mem::offset_of!(bch_inode_unpacked, bi_journal_seq) - 16usize];
    [
        "Offset of field: bch_inode_unpacked::bi_hash_seed",
    ][::std::mem::offset_of!(bch_inode_unpacked, bi_hash_seed) - 24usize];
    [
        "Offset of field: bch_inode_unpacked::bi_size",
    ][::std::mem::offset_of!(bch_inode_unpacked, bi_size) - 32usize];
    [
        "Offset of field: bch_inode_unpacked::bi_sectors",
    ][::std::mem::offset_of!(bch_inode_unpacked, bi_sectors) - 40usize];
    [
        "Offset of field: bch_inode_unpacked::bi_version",
    ][::std::mem::offset_of!(bch_inode_unpacked, bi_version) - 48usize];
    [
        "Offset of field: bch_inode_unpacked::bi_flags",
    ][::std::mem::offset_of!(bch_inode_unpacked, bi_flags) - 56usize];
    [
        "Offset of field: bch_inode_unpacked::bi_mode",
    ][::std::mem::offset_of!(bch_inode_unpacked, bi_mode) - 60usize];
    [
        "Offset of field: bch_inode_unpacked::bi_atime",
    ][::std::mem::offset_of!(bch_inode_unpacked, bi_atime) - 64usize];
    [
        "Offset of field: bch_inode_unpacked::bi_ctime",
    ][::std::mem::offset_of!(bch_inode_unpacked, bi_ctime) - 72usize];
    [
        "Offset of field: bch_inode_unpacked::bi_mtime",
    ][::std::mem::offset_of!(bch_inode_unpacked, bi_mtime) - 80usize];
    [
        "Offset of field: bch_inode_unpacked::bi_otime",
    ][::std::mem::offset_of!(bch_inode_unpacked, bi_otime) - 88usize];
    [
        "Offset of field: bch_inode_unpacked::bi_uid",
    ][::std::mem::offset_of!(bch_inode_unpacked, bi_uid) - 96usize];
    [
        "Offset of field: bch_inode_unpacked::bi_gid",
    ][::std::mem::offset_of!(bch_inode_unpacked, bi_gid) - 100usize];
    [
        "Offset of field: bch_inode_unpacked::bi_nlink",
    ][::std::mem::offset_of!(bch_inode_unpacked, bi_nlink) - 104usize];
    [
        "Offset of field: bch_inode_unpacked::bi_generation",
    ][::std::mem::offset_of!(bch_inode_unpacked, bi_generation) - 108usize];
    [
        "Offset of field: bch_inode_unpacked::bi_dev",
    ][::std::mem::offset_of!(bch_inode_unpacked, bi_dev) - 112usize];
    [
        "Offset of field: bch_inode_unpacked::bi_data_checksum",
    ][::std::mem::offset_of!(bch_inode_unpacked, bi_data_checksum) - 116usize];
    [
        "Offset of field: bch_inode_unpacked::bi_compression",
    ][::std::mem::offset_of!(bch_inode_unpacked, bi_compression) - 117usize];
    [
        "Offset of field: bch_inode_unpacked::bi_project",
    ][::std::mem::offset_of!(bch_inode_unpacked, bi_project) - 120usize];
    [
        "Offset of field: bch_inode_unpacked::bi_background_compression",
    ][::std::mem::offset_of!(bch_inode_unpacked, bi_background_compression) - 124usize];
    [
        "Offset of field: bch_inode_unpacked::bi_data_replicas",
    ][::std::mem::offset_of!(bch_inode_unpacked, bi_data_replicas) - 125usize];
    [
        "Offset of field: bch_inode_unpacked::bi_promote_target",
    ][::std::mem::offset_of!(bch_inode_unpacked, bi_promote_target) - 126usize];
    [
        "Offset of field: bch_inode_unpacked::bi_foreground_target",
    ][::std::mem::offset_of!(bch_inode_unpacked, bi_foreground_target) - 128usize];
    [
        "Offset of field: bch_inode_unpacked::bi_background_target",
    ][::std::mem::offset_of!(bch_inode_unpacked, bi_background_target) - 130usize];
    [
        "Offset of field: bch_inode_unpacked::bi_erasure_code",
    ][::std::mem::offset_of!(bch_inode_unpacked, bi_erasure_code) - 132usize];
    [
        "Offset of field: bch_inode_unpacked::bi_fields_set",
    ][::std::mem::offset_of!(bch_inode_unpacked, bi_fields_set) - 134usize];
    [
        "Offset of field: bch_inode_unpacked::bi_dir",
    ][::std::mem::offset_of!(bch_inode_unpacked, bi_dir) - 136usize];
    [
        "Offset of field: bch_inode_unpacked::bi_dir_offset",
    ][::std::mem::offset_of!(bch_inode_unpacked, bi_dir_offset) - 144usize];
    [
        "Offset of field: bch_inode_unpacked::bi_subvol",
    ][::std::mem::offset_of!(bch_inode_unpacked, bi_subvol) - 152usize];
    [
        "Offset of field: bch_inode_unpacked::bi_parent_subvol",
    ][::std::mem::offset_of!(bch_inode_unpacked, bi_parent_subvol) - 156usize];
    [
        "Offset of field: bch_inode_unpacked::bi_nocow",
    ][::std::mem::offset_of!(bch_inode_unpacked, bi_nocow) - 160usize];
    [
        "Offset of field: bch_inode_unpacked::bi_depth",
    ][::std::mem::offset_of!(bch_inode_unpacked, bi_depth) - 164usize];
    [
        "Offset of field: bch_inode_unpacked::bi_inodes_32bit",
    ][::std::mem::offset_of!(bch_inode_unpacked, bi_inodes_32bit) - 168usize];
    [
        "Offset of field: bch_inode_unpacked::bi_casefold",
    ][::std::mem::offset_of!(bch_inode_unpacked, bi_casefold) - 169usize];
    [
        "Offset of field: bch_inode_unpacked::bi_unused_ec_max_data_blocks",
    ][::std::mem::offset_of!(bch_inode_unpacked, bi_unused_ec_max_data_blocks)
        - 170usize];
};
#[repr(C)]
pub struct bkey_inode_buf {
    pub inode: bkey_i_inode_v3,
    pub _pad: [u8_; 342usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bkey_inode_buf"][::std::mem::size_of::<bkey_inode_buf>() - 432usize];
    ["Alignment of bkey_inode_buf"][::std::mem::align_of::<bkey_inode_buf>() - 8usize];
    [
        "Offset of field: bkey_inode_buf::inode",
    ][::std::mem::offset_of!(bkey_inode_buf, inode) - 0usize];
    [
        "Offset of field: bkey_inode_buf::_pad",
    ][::std::mem::offset_of!(bkey_inode_buf, _pad) - 88usize];
};
impl Default for bkey_inode_buf {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C" {
    pub fn bch2_inode_pack(arg1: *mut bkey_inode_buf, arg2: *const bch_inode_unpacked);
}
unsafe extern "C" {
    pub fn bch2_inode_unpack(
        arg1: bkey_s_c,
        arg2: *mut bch_inode_unpacked,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_inode_to_v3(arg1: *mut btree_trans, arg2: *mut bkey_i) -> *mut bkey_i;
}
unsafe extern "C" {
    pub fn bch2_inode_unpacked_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_inode_unpacked,
    );
}
unsafe extern "C" {
    pub fn __bch2_inode_peek(
        arg1: *mut btree_trans,
        arg2: *mut btree_iter,
        arg3: *mut bch_inode_unpacked,
        arg4: subvol_inum,
        arg5: ::std::os::raw::c_uint,
        arg6: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_inode_peek_nowarn__extern"]
    pub fn bch2_inode_peek_nowarn(
        trans: *mut btree_trans,
        iter: *mut btree_iter,
        inode: *mut bch_inode_unpacked,
        inum: subvol_inum,
        flags: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_inode_find_by_inum_snapshot(
        arg1: *mut btree_trans,
        arg2: u64_,
        arg3: u32_,
        arg4: *mut bch_inode_unpacked,
        arg5: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn __bch2_inode_find_by_inum_trans(
        arg1: *mut btree_trans,
        arg2: subvol_inum,
        arg3: *mut bch_inode_unpacked,
        arg4: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_inode_find_by_inum_nowarn_trans__extern"]
    pub fn bch2_inode_find_by_inum_nowarn_trans(
        trans: *mut btree_trans,
        inum: subvol_inum,
        inode: *mut bch_inode_unpacked,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_inode_find_by_inum(
        arg1: *mut bch_fs,
        arg2: subvol_inum,
        arg3: *mut bch_inode_unpacked,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_inode_find_oldest_snapshot(
        trans: *mut btree_trans,
        inum: u64_,
        snapshot: u32_,
        root: *mut bch_inode_unpacked,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_inode_write_flags(
        arg1: *mut btree_trans,
        arg2: *mut btree_iter,
        arg3: *mut bch_inode_unpacked,
        arg4: btree_iter_update_trigger_flags,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_inode_write__extern"]
    pub fn bch2_inode_write(
        trans: *mut btree_trans,
        iter: *mut btree_iter,
        inode: *mut bch_inode_unpacked,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn __bch2_fsck_write_inode(
        arg1: *mut btree_trans,
        arg2: *mut bch_inode_unpacked,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_fsck_write_inode(
        arg1: *mut btree_trans,
        arg2: *mut bch_inode_unpacked,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_inode_init_early(arg1: *mut bch_fs, arg2: *mut bch_inode_unpacked);
}
unsafe extern "C" {
    pub fn bch2_inode_init_late(
        arg1: *mut bch_fs,
        arg2: *mut bch_inode_unpacked,
        arg3: u64_,
        arg4: uid_t,
        arg5: gid_t,
        arg6: umode_t,
        arg7: dev_t,
        arg8: *mut bch_inode_unpacked,
    );
}
unsafe extern "C" {
    pub fn bch2_inode_init(
        arg1: *mut bch_fs,
        arg2: *mut bch_inode_unpacked,
        arg3: uid_t,
        arg4: gid_t,
        arg5: umode_t,
        arg6: dev_t,
        arg7: *mut bch_inode_unpacked,
    );
}
unsafe extern "C" {
    pub fn bch2_inode_create(
        arg1: *mut btree_trans,
        arg2: *mut btree_iter,
        arg3: *mut bch_inode_unpacked,
        arg4: u32_,
        arg5: u64_,
        arg6: bool,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_inode_rm(arg1: *mut bch_fs, arg2: subvol_inum) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_inode_opt_set__extern"]
    pub fn bch2_inode_opt_set(inode: *mut bch_inode_unpacked, id: inode_opt_id, v: u64_);
}
unsafe extern "C" {
    #[link_name = "bch2_inode_opt_get__extern"]
    pub fn bch2_inode_opt_get(inode: *mut bch_inode_unpacked, id: inode_opt_id) -> u64_;
}
unsafe extern "C" {
    #[link_name = "bch2_inode_flags__extern"]
    pub fn bch2_inode_flags(k: bkey_s_c) -> u32_;
}
unsafe extern "C" {
    #[link_name = "bch2_inode_casefold__extern"]
    pub fn bch2_inode_casefold(c: *mut bch_fs, bi: *const bch_inode_unpacked) -> bool;
}
unsafe extern "C" {
    #[link_name = "bch2_inode_has_backpointer__extern"]
    pub fn bch2_inode_has_backpointer(bi: *const bch_inode_unpacked) -> bool;
}
unsafe extern "C" {
    #[link_name = "bch2_inode_nlink_get__extern"]
    pub fn bch2_inode_nlink_get(bi: *mut bch_inode_unpacked) -> ::std::os::raw::c_uint;
}
unsafe extern "C" {
    #[link_name = "bch2_inode_nlink_set__extern"]
    pub fn bch2_inode_nlink_set(
        bi: *mut bch_inode_unpacked,
        nlink: ::std::os::raw::c_uint,
    );
}
unsafe extern "C" {
    pub fn bch2_inode_nlink_inc(arg1: *mut bch_inode_unpacked) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_inode_nlink_dec(arg1: *mut btree_trans, arg2: *mut bch_inode_unpacked);
}
unsafe extern "C" {
    pub fn bch2_inode_opts_to_opts(arg1: *mut bch_inode_unpacked) -> bch_opts;
}
unsafe extern "C" {
    pub fn bch2_inode_opts_get_inode(
        arg1: *mut bch_fs,
        arg2: *mut bch_inode_unpacked,
        arg3: *mut bch_inode_opts,
    );
}
unsafe extern "C" {
    pub fn bch2_inode_set_casefold(
        arg1: *mut btree_trans,
        arg2: subvol_inum,
        arg3: *mut bch_inode_unpacked,
        arg4: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_extent_reconcile_validate(
        arg1: *mut bch_fs,
        arg2: bkey_s_c,
        arg3: bkey_validate_context,
        arg4: *const bch_extent_reconcile,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_bkey_get_reconcile_bp_pos(arg1: *const bch_fs, arg2: bkey_s_c) -> bpos;
}
unsafe extern "C" {
    pub fn bch2_bkey_set_reconcile_bp(
        arg1: *const bch_fs,
        arg2: bkey_s,
        arg3: ::std::os::raw::c_uint,
        arg4: u64_,
    );
}
unsafe extern "C" {
    pub fn bch2_extent_rebalance_v1_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: *const bch_extent_rebalance_v1,
    );
}
unsafe extern "C" {
    pub fn bch2_extent_reconcile_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: *const bch_extent_reconcile,
    );
}
unsafe extern "C" {
    pub fn bch2_bkey_reconcile_opts(
        arg1: *const bch_fs,
        arg2: bkey_s_c,
    ) -> *const bch_extent_reconcile;
}
unsafe extern "C" {
    pub fn bch2_bkey_reconcile_work_id(
        arg1: *const bch_fs,
        arg2: bkey_s_c,
    ) -> reconcile_work_id;
}
unsafe extern "C" {
    pub fn __bch2_trigger_extent_reconcile(
        arg1: *mut btree_trans,
        arg2: btree_trigger_op,
        arg3: *const bch_extent_reconcile,
        arg4: *const bch_extent_reconcile,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_trigger_extent_reconcile__extern"]
    pub fn bch2_trigger_extent_reconcile(
        trans: *mut btree_trans,
        op: btree_trigger_op,
    ) -> ::std::os::raw::c_int;
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum set_needs_reconcile_ctx {
    SET_NEEDS_RECONCILE_opt_change = 0,
    SET_NEEDS_RECONCILE_opt_change_indirect = 1,
    SET_NEEDS_RECONCILE_foreground = 2,
    SET_NEEDS_RECONCILE_other = 3,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct snapshot_io_opts_entry {
    pub snapshot: u32_,
    pub io_opts: bch_inode_opts,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of snapshot_io_opts_entry",
    ][::std::mem::size_of::<snapshot_io_opts_entry>() - 40usize];
    [
        "Alignment of snapshot_io_opts_entry",
    ][::std::mem::align_of::<snapshot_io_opts_entry>() - 8usize];
    [
        "Offset of field: snapshot_io_opts_entry::snapshot",
    ][::std::mem::offset_of!(snapshot_io_opts_entry, snapshot) - 0usize];
    [
        "Offset of field: snapshot_io_opts_entry::io_opts",
    ][::std::mem::offset_of!(snapshot_io_opts_entry, io_opts) - 8usize];
};
#[repr(C)]
#[derive(Debug)]
pub struct per_snapshot_io_opts {
    pub cur_inum: u64_,
    pub metadata: bool,
    pub fs_scan_cookie: bool,
    pub inum_scan_cookie: bool,
    pub dev_cookie: bch_devs_mask,
    pub fs_io_opts: bch_inode_opts,
    pub d: per_snapshot_io_opts__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug)]
pub struct per_snapshot_io_opts__bindgen_ty_1 {
    pub nr: usize,
    pub size: usize,
    pub data: *mut snapshot_io_opts_entry,
    pub preallocated: __IncompleteArrayField<snapshot_io_opts_entry>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of per_snapshot_io_opts__bindgen_ty_1",
    ][::std::mem::size_of::<per_snapshot_io_opts__bindgen_ty_1>() - 24usize];
    [
        "Alignment of per_snapshot_io_opts__bindgen_ty_1",
    ][::std::mem::align_of::<per_snapshot_io_opts__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: per_snapshot_io_opts__bindgen_ty_1::nr",
    ][::std::mem::offset_of!(per_snapshot_io_opts__bindgen_ty_1, nr) - 0usize];
    [
        "Offset of field: per_snapshot_io_opts__bindgen_ty_1::size",
    ][::std::mem::offset_of!(per_snapshot_io_opts__bindgen_ty_1, size) - 8usize];
    [
        "Offset of field: per_snapshot_io_opts__bindgen_ty_1::data",
    ][::std::mem::offset_of!(per_snapshot_io_opts__bindgen_ty_1, data) - 16usize];
    [
        "Offset of field: per_snapshot_io_opts__bindgen_ty_1::preallocated",
    ][::std::mem::offset_of!(per_snapshot_io_opts__bindgen_ty_1, preallocated)
        - 24usize];
};
impl Default for per_snapshot_io_opts__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of per_snapshot_io_opts",
    ][::std::mem::size_of::<per_snapshot_io_opts>() - 80usize];
    [
        "Alignment of per_snapshot_io_opts",
    ][::std::mem::align_of::<per_snapshot_io_opts>() - 8usize];
    [
        "Offset of field: per_snapshot_io_opts::cur_inum",
    ][::std::mem::offset_of!(per_snapshot_io_opts, cur_inum) - 0usize];
    [
        "Offset of field: per_snapshot_io_opts::metadata",
    ][::std::mem::offset_of!(per_snapshot_io_opts, metadata) - 8usize];
    [
        "Offset of field: per_snapshot_io_opts::fs_scan_cookie",
    ][::std::mem::offset_of!(per_snapshot_io_opts, fs_scan_cookie) - 9usize];
    [
        "Offset of field: per_snapshot_io_opts::inum_scan_cookie",
    ][::std::mem::offset_of!(per_snapshot_io_opts, inum_scan_cookie) - 10usize];
    [
        "Offset of field: per_snapshot_io_opts::dev_cookie",
    ][::std::mem::offset_of!(per_snapshot_io_opts, dev_cookie) - 16usize];
    [
        "Offset of field: per_snapshot_io_opts::fs_io_opts",
    ][::std::mem::offset_of!(per_snapshot_io_opts, fs_io_opts) - 24usize];
    [
        "Offset of field: per_snapshot_io_opts::d",
    ][::std::mem::offset_of!(per_snapshot_io_opts, d) - 56usize];
};
impl Default for per_snapshot_io_opts {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C" {
    pub fn bch2_bkey_get_io_opts(
        arg1: *mut btree_trans,
        arg2: *mut per_snapshot_io_opts,
        arg3: bkey_s_c,
        opts: *mut bch_inode_opts,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_update_reconcile_opts(
        arg1: *mut btree_trans,
        arg2: *mut per_snapshot_io_opts,
        arg3: *mut bch_inode_opts,
        arg4: *mut btree_iter,
        level: ::std::os::raw::c_uint,
        arg5: bkey_s_c,
        arg6: set_needs_reconcile_ctx,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_bkey_set_needs_reconcile(
        arg1: *mut btree_trans,
        arg2: *mut per_snapshot_io_opts,
        arg3: *mut bch_inode_opts,
        arg4: bkey_s,
        arg5: ::std::os::raw::c_uint,
        arg6: set_needs_reconcile_ctx,
        arg7: u32_,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_extent_trigger_set_needs_reconcile(
        arg1: *mut btree_trans,
        arg2: *mut btree_trigger_op,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_inode_reconcile_opts_get__extern"]
    pub fn bch2_inode_reconcile_opts_get(
        c: *mut bch_fs,
        inode: *mut bch_inode_unpacked,
    ) -> bch_extent_reconcile;
}
unsafe extern "C" {
    pub fn bch2_inode_rm_snapshot(
        arg1: *mut btree_trans,
        arg2: u64_,
        arg3: u32_,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_delete_dead_inodes(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_kill_i_generation_keys(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_check_subvols(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_check_subvol_children(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_subvolume_validate(
        arg1: *mut bch_fs,
        arg2: bkey_s_c,
        arg3: bkey_validate_context,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_subvolume_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: bkey_s_c,
    );
}
unsafe extern "C" {
    pub fn bch2_subvolume_trigger(
        arg1: *mut btree_trans,
        arg2: btree_trigger_op,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_subvol_has_children(
        arg1: *mut btree_trans,
        arg2: u32_,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_subvolume_get(
        arg1: *mut btree_trans,
        arg2: ::std::os::raw::c_uint,
        arg3: bool,
        arg4: *mut bch_subvolume,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn __bch2_subvolume_get_snapshot(
        arg1: *mut btree_trans,
        arg2: u32_,
        arg3: *mut u32_,
        arg4: bool,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_subvolume_get_snapshot(
        arg1: *mut btree_trans,
        arg2: u32_,
        arg3: *mut u32_,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_subvol_is_ro_trans(
        arg1: *mut btree_trans,
        arg2: u32_,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_subvol_is_ro(arg1: *mut bch_fs, arg2: u32_) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_btree_iter_peek_in_subvolume_max_type__extern"]
    pub fn bch2_btree_iter_peek_in_subvolume_max_type(
        iter: *mut btree_iter,
        end: bpos,
        subvolid: u32_,
        flags: ::std::os::raw::c_uint,
    ) -> bkey_s_c;
}
unsafe extern "C" {
    pub fn bch2_subvolume_unlink(
        arg1: *mut btree_trans,
        arg2: u32_,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_subvolume_create(
        arg1: *mut btree_trans,
        arg2: u64_,
        arg3: u32_,
        arg4: u32_,
        arg5: *mut u32_,
        arg6: *mut u32_,
        arg7: bool,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_initialize_subvolumes(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_fs_upgrade_for_subvolumes(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_fs_subvolumes_init_early(arg1: *mut bch_fs);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _SIPHASH_CTX {
    pub v: [u64_; 4usize],
    pub buf: [u8_; 8usize],
    pub bytes: u32_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of _SIPHASH_CTX"][::std::mem::size_of::<_SIPHASH_CTX>() - 48usize];
    ["Alignment of _SIPHASH_CTX"][::std::mem::align_of::<_SIPHASH_CTX>() - 8usize];
    [
        "Offset of field: _SIPHASH_CTX::v",
    ][::std::mem::offset_of!(_SIPHASH_CTX, v) - 0usize];
    [
        "Offset of field: _SIPHASH_CTX::buf",
    ][::std::mem::offset_of!(_SIPHASH_CTX, buf) - 32usize];
    [
        "Offset of field: _SIPHASH_CTX::bytes",
    ][::std::mem::offset_of!(_SIPHASH_CTX, bytes) - 40usize];
};
pub type SIPHASH_CTX = _SIPHASH_CTX;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct SIPHASH_KEY {
    pub k0: __le64,
    pub k1: __le64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of SIPHASH_KEY"][::std::mem::size_of::<SIPHASH_KEY>() - 16usize];
    ["Alignment of SIPHASH_KEY"][::std::mem::align_of::<SIPHASH_KEY>() - 8usize];
    [
        "Offset of field: SIPHASH_KEY::k0",
    ][::std::mem::offset_of!(SIPHASH_KEY, k0) - 0usize];
    [
        "Offset of field: SIPHASH_KEY::k1",
    ][::std::mem::offset_of!(SIPHASH_KEY, k1) - 8usize];
};
unsafe extern "C" {
    pub fn bch2_install_fatal_signal_handlers();
}
unsafe extern "C" {
    pub fn read_file_str(
        arg1: ::std::os::raw::c_int,
        arg2: *const ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_char;
}
unsafe extern "C" {
    pub fn read_file_u64(
        arg1: ::std::os::raw::c_int,
        arg2: *const ::std::os::raw::c_char,
    ) -> u64_;
}
unsafe extern "C" {
    pub fn ask_yn() -> bool;
}
unsafe extern "C" {
    #[link_name = "bch2_str_hash_opt_to_type__extern"]
    pub fn bch2_str_hash_opt_to_type(
        c: *mut bch_fs,
        opt: bch_str_hash_opts,
    ) -> bch_str_hash_type;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bch_hash_info {
    pub inum_snapshot: u32_,
    pub type_: u8_,
    pub is_31bit: bool,
    pub cf_encoding: *mut unicode_map,
    pub siphash_key: SIPHASH_KEY,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_hash_info"][::std::mem::size_of::<bch_hash_info>() - 32usize];
    ["Alignment of bch_hash_info"][::std::mem::align_of::<bch_hash_info>() - 8usize];
    [
        "Offset of field: bch_hash_info::inum_snapshot",
    ][::std::mem::offset_of!(bch_hash_info, inum_snapshot) - 0usize];
    [
        "Offset of field: bch_hash_info::type_",
    ][::std::mem::offset_of!(bch_hash_info, type_) - 4usize];
    [
        "Offset of field: bch_hash_info::is_31bit",
    ][::std::mem::offset_of!(bch_hash_info, is_31bit) - 5usize];
    [
        "Offset of field: bch_hash_info::cf_encoding",
    ][::std::mem::offset_of!(bch_hash_info, cf_encoding) - 8usize];
    [
        "Offset of field: bch_hash_info::siphash_key",
    ][::std::mem::offset_of!(bch_hash_info, siphash_key) - 16usize];
};
impl Default for bch_hash_info {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C" {
    pub fn bch2_hash_info_init(
        arg1: *mut bch_fs,
        arg2: *const bch_inode_unpacked,
        arg3: *mut bch_hash_info,
    ) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bch_str_hash_ctx {
    pub __bindgen_anon_1: bch_str_hash_ctx__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bch_str_hash_ctx__bindgen_ty_1 {
    pub bch_crc32c: u32_,
    pub crc64: u64_,
    pub siphash: SIPHASH_CTX,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_str_hash_ctx__bindgen_ty_1",
    ][::std::mem::size_of::<bch_str_hash_ctx__bindgen_ty_1>() - 48usize];
    [
        "Alignment of bch_str_hash_ctx__bindgen_ty_1",
    ][::std::mem::align_of::<bch_str_hash_ctx__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bch_str_hash_ctx__bindgen_ty_1::bch_crc32c",
    ][::std::mem::offset_of!(bch_str_hash_ctx__bindgen_ty_1, bch_crc32c) - 0usize];
    [
        "Offset of field: bch_str_hash_ctx__bindgen_ty_1::crc64",
    ][::std::mem::offset_of!(bch_str_hash_ctx__bindgen_ty_1, crc64) - 0usize];
    [
        "Offset of field: bch_str_hash_ctx__bindgen_ty_1::siphash",
    ][::std::mem::offset_of!(bch_str_hash_ctx__bindgen_ty_1, siphash) - 0usize];
};
impl Default for bch_str_hash_ctx__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_str_hash_ctx"][::std::mem::size_of::<bch_str_hash_ctx>() - 48usize];
    [
        "Alignment of bch_str_hash_ctx",
    ][::std::mem::align_of::<bch_str_hash_ctx>() - 8usize];
};
impl Default for bch_str_hash_ctx {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C" {
    #[link_name = "bch2_str_hash_init__extern"]
    pub fn bch2_str_hash_init(ctx: *mut bch_str_hash_ctx, info: *const bch_hash_info);
}
unsafe extern "C" {
    #[link_name = "bch2_str_hash_update__extern"]
    pub fn bch2_str_hash_update(
        ctx: *mut bch_str_hash_ctx,
        info: *const bch_hash_info,
        data: *const ::std::os::raw::c_void,
        len: usize,
    );
}
unsafe extern "C" {
    #[link_name = "__bch2_str_hash_end__extern"]
    pub fn __bch2_str_hash_end(
        ctx: *mut bch_str_hash_ctx,
        info: *const bch_hash_info,
    ) -> u64_;
}
unsafe extern "C" {
    #[link_name = "bch2_str_hash_end__extern"]
    pub fn bch2_str_hash_end(
        ctx: *mut bch_str_hash_ctx,
        info: *const bch_hash_info,
        maybe_31bit: bool,
    ) -> u64_;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bch_hash_desc {
    pub btree_id: btree_id,
    pub key_type: u8_,
    pub hash_key: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *const bch_hash_info,
            arg2: *const ::std::os::raw::c_void,
        ) -> u64_,
    >,
    pub hash_bkey: ::std::option::Option<
        unsafe extern "C" fn(arg1: *const bch_hash_info, arg2: bkey_s_c) -> u64_,
    >,
    pub cmp_key: ::std::option::Option<
        unsafe extern "C" fn(arg1: bkey_s_c, arg2: *const ::std::os::raw::c_void) -> bool,
    >,
    pub cmp_bkey: ::std::option::Option<
        unsafe extern "C" fn(arg1: bkey_s_c, arg2: bkey_s_c) -> bool,
    >,
    pub is_visible: ::std::option::Option<
        unsafe extern "C" fn(inum: subvol_inum, arg1: bkey_s_c) -> bool,
    >,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_hash_desc"][::std::mem::size_of::<bch_hash_desc>() - 48usize];
    ["Alignment of bch_hash_desc"][::std::mem::align_of::<bch_hash_desc>() - 8usize];
    [
        "Offset of field: bch_hash_desc::btree_id",
    ][::std::mem::offset_of!(bch_hash_desc, btree_id) - 0usize];
    [
        "Offset of field: bch_hash_desc::key_type",
    ][::std::mem::offset_of!(bch_hash_desc, key_type) - 4usize];
    [
        "Offset of field: bch_hash_desc::hash_key",
    ][::std::mem::offset_of!(bch_hash_desc, hash_key) - 8usize];
    [
        "Offset of field: bch_hash_desc::hash_bkey",
    ][::std::mem::offset_of!(bch_hash_desc, hash_bkey) - 16usize];
    [
        "Offset of field: bch_hash_desc::cmp_key",
    ][::std::mem::offset_of!(bch_hash_desc, cmp_key) - 24usize];
    [
        "Offset of field: bch_hash_desc::cmp_bkey",
    ][::std::mem::offset_of!(bch_hash_desc, cmp_bkey) - 32usize];
    [
        "Offset of field: bch_hash_desc::is_visible",
    ][::std::mem::offset_of!(bch_hash_desc, is_visible) - 40usize];
};
impl Default for bch_hash_desc {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C" {
    #[link_name = "bch2_hash_lookup_in_snapshot__extern"]
    pub fn bch2_hash_lookup_in_snapshot(
        trans: *mut btree_trans,
        iter: *mut btree_iter,
        desc: bch_hash_desc,
        info: *const bch_hash_info,
        inum: subvol_inum,
        key: *const ::std::os::raw::c_void,
        flags: btree_iter_update_trigger_flags,
        snapshot: u32_,
    ) -> bkey_s_c;
}
unsafe extern "C" {
    #[link_name = "bch2_hash_lookup__extern"]
    pub fn bch2_hash_lookup(
        trans: *mut btree_trans,
        iter: *mut btree_iter,
        desc: bch_hash_desc,
        info: *const bch_hash_info,
        inum: subvol_inum,
        key: *const ::std::os::raw::c_void,
        flags: btree_iter_update_trigger_flags,
    ) -> bkey_s_c;
}
unsafe extern "C" {
    #[link_name = "bch2_hash_hole__extern"]
    pub fn bch2_hash_hole(
        trans: *mut btree_trans,
        iter: *mut btree_iter,
        desc: bch_hash_desc,
        info: *const bch_hash_info,
        inum: subvol_inum,
        key: *const ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_hash_needs_whiteout__extern"]
    pub fn bch2_hash_needs_whiteout(
        trans: *mut btree_trans,
        desc: bch_hash_desc,
        info: *const bch_hash_info,
        start: *mut btree_iter,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_hash_set_or_get_in_snapshot__extern"]
    pub fn bch2_hash_set_or_get_in_snapshot(
        trans: *mut btree_trans,
        iter: *mut btree_iter,
        desc: bch_hash_desc,
        info: *const bch_hash_info,
        inum: subvol_inum,
        snapshot: u32_,
        insert: *mut bkey_i,
        flags: btree_iter_update_trigger_flags,
    ) -> bkey_s_c;
}
unsafe extern "C" {
    #[link_name = "bch2_hash_set_in_snapshot__extern"]
    pub fn bch2_hash_set_in_snapshot(
        trans: *mut btree_trans,
        desc: bch_hash_desc,
        info: *const bch_hash_info,
        inum: subvol_inum,
        snapshot: u32_,
        insert: *mut bkey_i,
        flags: btree_iter_update_trigger_flags,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_hash_set__extern"]
    pub fn bch2_hash_set(
        trans: *mut btree_trans,
        desc: bch_hash_desc,
        info: *const bch_hash_info,
        inum: subvol_inum,
        insert: *mut bkey_i,
        flags: btree_iter_update_trigger_flags,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_hash_delete_at__extern"]
    pub fn bch2_hash_delete_at(
        trans: *mut btree_trans,
        desc: bch_hash_desc,
        info: *const bch_hash_info,
        iter: *mut btree_iter,
        flags: btree_iter_update_trigger_flags,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_hash_delete__extern"]
    pub fn bch2_hash_delete(
        trans: *mut btree_trans,
        desc: bch_hash_desc,
        info: *const bch_hash_info,
        inum: subvol_inum,
        key: *const ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_repair_inode_hash_info(
        arg1: *mut btree_trans,
        arg2: *mut bch_inode_unpacked,
        arg3: *mut bch_inode_unpacked,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn __bch2_str_hash_check_key(
        arg1: *mut btree_trans,
        arg2: *mut snapshots_seen,
        arg3: *const bch_hash_desc,
        arg4: *mut bch_hash_info,
        arg5: bkey_s_c,
        arg6: *mut bool,
        arg7: *mut bool,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_str_hash_check_key__extern"]
    pub fn bch2_str_hash_check_key(
        trans: *mut btree_trans,
        s: *mut snapshots_seen,
        desc: *const bch_hash_desc,
        hash_info: *mut bch_hash_info,
        hash_k: bkey_s_c,
        updated_before_k_pos: *mut bool,
        repaired_inode: *mut bool,
    ) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug)]
pub struct snapshots_seen {
    pub pos: bpos,
    pub ids: snapshot_id_list,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of snapshots_seen"][::std::mem::size_of::<snapshots_seen>() - 48usize];
    ["Alignment of snapshots_seen"][::std::mem::align_of::<snapshots_seen>() - 8usize];
    [
        "Offset of field: snapshots_seen::pos",
    ][::std::mem::offset_of!(snapshots_seen, pos) - 0usize];
    [
        "Offset of field: snapshots_seen::ids",
    ][::std::mem::offset_of!(snapshots_seen, ids) - 24usize];
};
impl Default for snapshots_seen {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C" {
    pub fn bch2_snapshots_seen_update(
        arg1: *mut bch_fs,
        arg2: *mut snapshots_seen,
        arg3: btree_id,
        arg4: bpos,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_key_visible_in_snapshot(
        arg1: *mut btree_trans,
        arg2: *mut snapshots_seen,
        arg3: u32_,
        arg4: u32_,
    ) -> bool;
}
unsafe extern "C" {
    pub fn bch2_ref_visible(
        arg1: *mut btree_trans,
        arg2: *mut snapshots_seen,
        arg3: u32_,
        arg4: u32_,
    ) -> bool;
}
unsafe extern "C" {
    pub fn bch2_ref_visible2(
        arg1: *mut btree_trans,
        arg2: u32_,
        arg3: *mut snapshots_seen,
        arg4: u32_,
        arg5: *mut snapshots_seen,
    ) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct inode_walker_entry {
    pub inode: bch_inode_unpacked,
    pub whiteout: bool,
    pub count: u64_,
    pub i_size: u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of inode_walker_entry",
    ][::std::mem::size_of::<inode_walker_entry>() - 200usize];
    [
        "Alignment of inode_walker_entry",
    ][::std::mem::align_of::<inode_walker_entry>() - 8usize];
    [
        "Offset of field: inode_walker_entry::inode",
    ][::std::mem::offset_of!(inode_walker_entry, inode) - 0usize];
    [
        "Offset of field: inode_walker_entry::whiteout",
    ][::std::mem::offset_of!(inode_walker_entry, whiteout) - 176usize];
    [
        "Offset of field: inode_walker_entry::count",
    ][::std::mem::offset_of!(inode_walker_entry, count) - 184usize];
    [
        "Offset of field: inode_walker_entry::i_size",
    ][::std::mem::offset_of!(inode_walker_entry, i_size) - 192usize];
};
#[repr(C)]
#[derive(Debug)]
pub struct inode_walker {
    pub first_this_inode: bool,
    pub have_inodes: bool,
    pub recalculate_sums: bool,
    pub last_pos: bpos,
    pub inodes: inode_walker__bindgen_ty_1,
    pub deletes: snapshot_id_list,
}
#[repr(C)]
#[derive(Debug)]
pub struct inode_walker__bindgen_ty_1 {
    pub nr: usize,
    pub size: usize,
    pub data: *mut inode_walker_entry,
    pub preallocated: __IncompleteArrayField<inode_walker_entry>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of inode_walker__bindgen_ty_1",
    ][::std::mem::size_of::<inode_walker__bindgen_ty_1>() - 24usize];
    [
        "Alignment of inode_walker__bindgen_ty_1",
    ][::std::mem::align_of::<inode_walker__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: inode_walker__bindgen_ty_1::nr",
    ][::std::mem::offset_of!(inode_walker__bindgen_ty_1, nr) - 0usize];
    [
        "Offset of field: inode_walker__bindgen_ty_1::size",
    ][::std::mem::offset_of!(inode_walker__bindgen_ty_1, size) - 8usize];
    [
        "Offset of field: inode_walker__bindgen_ty_1::data",
    ][::std::mem::offset_of!(inode_walker__bindgen_ty_1, data) - 16usize];
    [
        "Offset of field: inode_walker__bindgen_ty_1::preallocated",
    ][::std::mem::offset_of!(inode_walker__bindgen_ty_1, preallocated) - 24usize];
};
impl Default for inode_walker__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of inode_walker"][::std::mem::size_of::<inode_walker>() - 72usize];
    ["Alignment of inode_walker"][::std::mem::align_of::<inode_walker>() - 8usize];
    [
        "Offset of field: inode_walker::first_this_inode",
    ][::std::mem::offset_of!(inode_walker, first_this_inode) - 0usize];
    [
        "Offset of field: inode_walker::have_inodes",
    ][::std::mem::offset_of!(inode_walker, have_inodes) - 1usize];
    [
        "Offset of field: inode_walker::recalculate_sums",
    ][::std::mem::offset_of!(inode_walker, recalculate_sums) - 2usize];
    [
        "Offset of field: inode_walker::last_pos",
    ][::std::mem::offset_of!(inode_walker, last_pos) - 4usize];
    [
        "Offset of field: inode_walker::inodes",
    ][::std::mem::offset_of!(inode_walker, inodes) - 24usize];
    [
        "Offset of field: inode_walker::deletes",
    ][::std::mem::offset_of!(inode_walker, deletes) - 48usize];
};
impl Default for inode_walker {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C" {
    pub fn bch2_walk_inode(
        arg1: *mut btree_trans,
        arg2: *mut inode_walker,
        arg3: bkey_s_c,
    ) -> *mut inode_walker_entry;
}
unsafe extern "C" {
    pub fn bch2_dirent_inode_mismatch_msg(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: bkey_s_c_dirent,
        arg4: *mut bch_inode_unpacked,
    );
}
unsafe extern "C" {
    pub fn bch2_reattach_inode(
        arg1: *mut btree_trans,
        arg2: *mut bch_inode_unpacked,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_fsck_update_backpointers(
        arg1: *mut btree_trans,
        arg2: *mut snapshots_seen,
        arg3: bch_hash_desc,
        arg4: *mut bch_hash_info,
        arg5: *mut bkey_i,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_check_key_has_inode(
        arg1: *mut btree_trans,
        arg2: *mut btree_iter,
        arg3: *mut inode_walker,
        arg4: *mut inode_walker_entry,
        arg5: bkey_s_c,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_check_inodes(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_check_extents(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_check_indirect_extents(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_check_dirents(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_check_xattrs(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_check_root(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_check_subvolume_structure(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_check_unreachable_inodes(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_check_directory_structure(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_check_nlinks(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_fix_reflink_p(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_fs_fsck_errcode(
        arg1: *mut bch_fs,
        arg2: *mut printbuf,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_ioctl_fsck_offline(
        arg1: *mut bch_ioctl_fsck_offline,
    ) -> ::std::os::raw::c_long;
}
unsafe extern "C" {
    pub fn bch2_ioctl_fsck_online(
        arg1: *mut bch_fs,
        arg2: bch_ioctl_fsck_online,
    ) -> ::std::os::raw::c_long;
}
unsafe extern "C" {
    pub static bch2_dirent_hash_desc: bch_hash_desc;
}
unsafe extern "C" {
    pub fn bch2_dirent_validate(
        arg1: *mut bch_fs,
        arg2: bkey_s_c,
        arg3: bkey_validate_context,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_dirent_to_text(arg1: *mut printbuf, arg2: *mut bch_fs, arg3: bkey_s_c);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bch_inode_info {
    _unused: [u8; 0],
}
unsafe extern "C" {
    #[link_name = "bch2_casefold__extern"]
    pub fn bch2_casefold(
        trans: *mut btree_trans,
        info: *const bch_hash_info,
        str_: *const qstr,
        out_cf: *mut qstr,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_maybe_casefold__extern"]
    pub fn bch2_maybe_casefold(
        trans: *mut btree_trans,
        info: *const bch_hash_info,
        str_: *const qstr,
        out_cf: *mut qstr,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_dirent_get_name(arg1: bkey_s_c_dirent) -> qstr;
}
unsafe extern "C" {
    pub fn bch2_dirent_read_target(
        arg1: *mut btree_trans,
        arg2: subvol_inum,
        arg3: bkey_s_c_dirent,
        arg4: *mut subvol_inum,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_dirent_init_name(
        arg1: *mut bch_fs,
        arg2: *mut bkey_i_dirent,
        arg3: *const bch_hash_info,
        arg4: *const qstr,
        arg5: *const qstr,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_dirent_create_key(
        arg1: *mut btree_trans,
        arg2: *const bch_hash_info,
        arg3: subvol_inum,
        arg4: u8_,
        arg5: *const qstr,
        arg6: *const qstr,
        arg7: u64_,
    ) -> *mut bkey_i_dirent;
}
unsafe extern "C" {
    pub fn bch2_dirent_create_snapshot(
        arg1: *mut btree_trans,
        arg2: u32_,
        arg3: u64_,
        arg4: u32_,
        arg5: *const bch_hash_info,
        arg6: u8_,
        arg7: *const qstr,
        arg8: u64_,
        arg9: *mut u64_,
        arg10: btree_iter_update_trigger_flags,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_dirent_create(
        arg1: *mut btree_trans,
        arg2: subvol_inum,
        arg3: *const bch_hash_info,
        arg4: u8_,
        arg5: *const qstr,
        arg6: u64_,
        arg7: *mut u64_,
        arg8: btree_iter_update_trigger_flags,
    ) -> ::std::os::raw::c_int;
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_rename_mode {
    BCH_RENAME = 0,
    BCH_RENAME_OVERWRITE = 1,
    BCH_RENAME_EXCHANGE = 2,
}
unsafe extern "C" {
    pub fn bch2_dirent_rename(
        arg1: *mut btree_trans,
        arg2: subvol_inum,
        arg3: *mut bch_hash_info,
        arg4: subvol_inum,
        arg5: *mut bch_hash_info,
        arg6: *const qstr,
        arg7: *mut subvol_inum,
        arg8: *mut u64_,
        arg9: *const qstr,
        arg10: *mut subvol_inum,
        arg11: *mut u64_,
        arg12: bch_rename_mode,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_dirent_lookup_trans(
        arg1: *mut btree_trans,
        arg2: *mut btree_iter,
        arg3: subvol_inum,
        arg4: *const bch_hash_info,
        arg5: *const qstr,
        arg6: *mut subvol_inum,
        arg7: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_dirent_lookup(
        arg1: *mut bch_fs,
        arg2: subvol_inum,
        arg3: *const bch_hash_info,
        arg4: *const qstr,
        arg5: *mut subvol_inum,
    ) -> u64_;
}
unsafe extern "C" {
    pub fn bch2_empty_dir_snapshot(
        arg1: *mut btree_trans,
        arg2: u64_,
        arg3: u32_,
        arg4: u32_,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_empty_dir_trans(
        arg1: *mut btree_trans,
        arg2: subvol_inum,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_readdir(
        arg1: *mut bch_fs,
        arg2: subvol_inum,
        arg3: *mut bch_hash_info,
        arg4: *mut dir_context,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_fsck_remove_dirent(
        arg1: *mut btree_trans,
        arg2: bpos,
    ) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct posix_acl {
    _unused: [u8; 0],
}
unsafe extern "C" {
    pub fn bch2_create_trans(
        arg1: *mut btree_trans,
        arg2: subvol_inum,
        arg3: *mut bch_inode_unpacked,
        arg4: *mut bch_inode_unpacked,
        arg5: *const qstr,
        arg6: uid_t,
        arg7: gid_t,
        arg8: umode_t,
        arg9: dev_t,
        arg10: *mut posix_acl,
        arg11: *mut posix_acl,
        arg12: subvol_inum,
        arg13: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_link_trans(
        arg1: *mut btree_trans,
        arg2: subvol_inum,
        arg3: *mut bch_inode_unpacked,
        arg4: subvol_inum,
        arg5: *mut bch_inode_unpacked,
        arg6: *const qstr,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_unlink_trans(
        arg1: *mut btree_trans,
        arg2: subvol_inum,
        arg3: *mut bch_inode_unpacked,
        arg4: subvol_inum,
        arg5: *mut bch_inode_unpacked,
        arg6: *const qstr,
        arg7: bool,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_rename_trans(
        arg1: *mut btree_trans,
        arg2: subvol_inum,
        arg3: *mut bch_inode_unpacked,
        arg4: subvol_inum,
        arg5: *mut bch_inode_unpacked,
        arg6: *mut bch_inode_unpacked,
        arg7: *mut bch_inode_unpacked,
        arg8: *const qstr,
        arg9: *const qstr,
        arg10: bch_rename_mode,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_reinherit_attrs(
        arg1: *mut bch_inode_unpacked,
        arg2: *mut bch_inode_unpacked,
    ) -> bool;
}
unsafe extern "C" {
    pub fn bch2_inum_to_path(
        arg1: *mut btree_trans,
        arg2: subvol_inum,
        arg3: *mut printbuf,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_inum_to_path_in_subvol(
        arg1: *mut btree_trans,
        arg2: subvol_inum,
        arg3: u32_,
        arg4: ::std::os::raw::c_uint,
        arg5: *mut printbuf,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_inum_snapshot_to_path(
        arg1: *mut btree_trans,
        arg2: u64_,
        arg3: u32_,
        arg4: *mut snapshot_id_list,
        arg5: *mut printbuf,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn __bch2_check_dirent_target(
        arg1: *mut btree_trans,
        arg2: *mut btree_iter,
        arg3: bkey_s_c_dirent,
        arg4: *mut bch_inode_unpacked,
        arg5: bool,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_check_dirent_target__extern"]
    pub fn bch2_check_dirent_target(
        trans: *mut btree_trans,
        dirent_iter: *mut btree_iter,
        d: bkey_s_c_dirent,
        target: *mut bch_inode_unpacked,
        in_fsck: bool,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_maybe_propagate_has_case_insensitive(
        arg1: *mut btree_trans,
        arg2: subvol_inum,
        arg3: *mut bch_inode_unpacked,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_check_inode_has_case_insensitive(
        arg1: *mut btree_trans,
        arg2: *mut bch_inode_unpacked,
        arg3: *mut snapshot_id_list,
        arg4: *mut bool,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub static bch2_xattr_hash_desc: bch_hash_desc;
}
unsafe extern "C" {
    pub fn bch2_xattr_validate(
        arg1: *mut bch_fs,
        arg2: bkey_s_c,
        arg3: bkey_validate_context,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_xattr_to_text(arg1: *mut printbuf, arg2: *mut bch_fs, arg3: bkey_s_c);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct xattr_handler {
    _unused: [u8; 0],
}
unsafe extern "C" {
    pub fn bch2_xattr_set(
        arg1: *mut btree_trans,
        arg2: subvol_inum,
        arg3: *mut bch_inode_unpacked,
        arg4: *const ::std::os::raw::c_char,
        arg5: *const ::std::os::raw::c_void,
        arg6: usize,
        arg7: ::std::os::raw::c_int,
        arg8: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_xattr_list(
        arg1: *mut dentry,
        arg2: *mut ::std::os::raw::c_char,
        arg3: usize,
    ) -> isize;
}
unsafe extern "C" {
    pub static bch2_xattr_handlers: [*const xattr_handler; 0usize];
}
unsafe extern "C" {
    #[link_name = "bch2_u64s_neg__extern"]
    pub fn bch2_u64s_neg(v: *mut u64_, nr: ::std::os::raw::c_uint);
}
unsafe extern "C" {
    #[link_name = "bch2_accounting_counters__extern"]
    pub fn bch2_accounting_counters(k: *const bkey) -> ::std::os::raw::c_uint;
}
unsafe extern "C" {
    #[link_name = "bch2_accounting_neg__extern"]
    pub fn bch2_accounting_neg(a: bkey_s_accounting);
}
unsafe extern "C" {
    #[link_name = "bch2_accounting_key_is_zero__extern"]
    pub fn bch2_accounting_key_is_zero(a: bkey_s_c_accounting) -> bool;
}
unsafe extern "C" {
    #[link_name = "bch2_accounting_accumulate__extern"]
    pub fn bch2_accounting_accumulate(
        dst: *mut bkey_i_accounting,
        src: bkey_s_c_accounting,
    );
}
unsafe extern "C" {
    pub fn __bch2_accounting_maybe_kill(arg1: *mut bch_fs, pos: bpos);
}
unsafe extern "C" {
    #[link_name = "bch2_accounting_accumulate_maybe_kill__extern"]
    pub fn bch2_accounting_accumulate_maybe_kill(
        c: *mut bch_fs,
        dst: *mut bkey_i_accounting,
        src: bkey_s_c_accounting,
    );
}
unsafe extern "C" {
    #[link_name = "bpos_to_disk_accounting_pos__extern"]
    pub fn bpos_to_disk_accounting_pos(acc: *mut disk_accounting_pos, p: bpos);
}
unsafe extern "C" {
    pub fn bch2_disk_accounting_mod(
        arg1: *mut btree_trans,
        arg2: *mut disk_accounting_pos,
        arg3: *mut s64,
        arg4: ::std::os::raw::c_uint,
        arg5: bool,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_mod_dev_cached_sectors(
        arg1: *mut btree_trans,
        arg2: ::std::os::raw::c_uint,
        arg3: s64,
        arg4: bool,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_accounting_validate(
        arg1: *mut bch_fs,
        arg2: bkey_s_c,
        arg3: bkey_validate_context,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_accounting_key_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: *mut disk_accounting_pos,
    );
}
unsafe extern "C" {
    pub fn bch2_accounting_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: bkey_s_c,
    );
}
unsafe extern "C" {
    pub fn bch2_accounting_swab(arg1: *const bch_fs, arg2: bkey_s);
}
unsafe extern "C" {
    pub fn bch2_accounting_update_sb(arg1: *mut btree_trans) -> ::std::os::raw::c_int;
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum bch_accounting_mode {
    BCH_ACCOUNTING_normal = 0,
    BCH_ACCOUNTING_gc = 1,
    BCH_ACCOUNTING_read = 2,
}
unsafe extern "C" {
    pub fn bch2_accounting_mem_insert(
        arg1: *mut bch_fs,
        arg2: bkey_s_c_accounting,
        arg3: bch_accounting_mode,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_accounting_mem_insert_locked(
        arg1: *mut bch_fs,
        arg2: bkey_s_c_accounting,
        arg3: bch_accounting_mode,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_accounting_mem_gc(arg1: *mut bch_fs);
}
unsafe extern "C" {
    #[link_name = "bch2_accounting_is_mem__extern"]
    pub fn bch2_accounting_is_mem(acc: *mut disk_accounting_pos) -> bool;
}
unsafe extern "C" {
    #[link_name = "bch2_bkey_is_accounting_mem__extern"]
    pub fn bch2_bkey_is_accounting_mem(k: *mut bkey) -> bool;
}
unsafe extern "C" {
    #[link_name = "bch2_accounting_mem_mod_locked__extern"]
    pub fn bch2_accounting_mem_mod_locked(
        trans: *mut btree_trans,
        a: bkey_s_c_accounting,
        mode: bch_accounting_mode,
        write_locked: bool,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_accounting_mem_add__extern"]
    pub fn bch2_accounting_mem_add(
        trans: *mut btree_trans,
        a: bkey_s_c_accounting,
        gc: bool,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_accounting_mem_read_counters__extern"]
    pub fn bch2_accounting_mem_read_counters(
        acc: *mut bch_accounting_mem,
        idx: ::std::os::raw::c_uint,
        v: *mut u64_,
        nr: ::std::os::raw::c_uint,
        gc: bool,
    );
}
unsafe extern "C" {
    #[link_name = "bch2_accounting_mem_read__extern"]
    pub fn bch2_accounting_mem_read(
        c: *mut bch_fs,
        p: bpos,
        v: *mut u64_,
        nr: ::std::os::raw::c_uint,
    );
}
unsafe extern "C" {
    #[link_name = "bch2_accounting_trans_commit_hook__extern"]
    pub fn bch2_accounting_trans_commit_hook(
        trans: *mut btree_trans,
        a: *mut bkey_i_accounting,
        commit_flags: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_accounting_trans_commit_revert__extern"]
    pub fn bch2_accounting_trans_commit_revert(
        trans: *mut btree_trans,
        a_i: *mut bkey_i_accounting,
        commit_flags: ::std::os::raw::c_uint,
    );
}
unsafe extern "C" {
    pub fn bch2_fs_replicas_usage_read(
        arg1: *mut bch_fs,
        arg2: *mut darray_char,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_fs_accounting_read(
        arg1: *mut bch_fs,
        arg2: *mut darray_char,
        arg3: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_fs_accounting_read_key(
        arg1: *mut btree_trans,
        arg2: *mut disk_accounting_pos,
        arg3: *mut u64_,
        arg4: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_gc_accounting_start(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_gc_accounting_done(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_accounting_read(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_dev_usage_remove(
        arg1: *mut bch_fs,
        arg2: *mut bch_dev,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_dev_usage_init(arg1: *mut bch_dev, arg2: bool) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_verify_accounting_clean(c: *mut bch_fs);
}
unsafe extern "C" {
    pub fn bch2_accounting_gc_free(arg1: *mut bch_fs);
}
unsafe extern "C" {
    pub fn bch2_fs_accounting_exit(arg1: *mut bch_fs);
}
unsafe extern "C" {
    #[link_name = "bch2_dev_bucket_exists__extern"]
    pub fn bch2_dev_bucket_exists(c: *mut bch_fs, pos: bpos) -> bool;
}
unsafe extern "C" {
    #[link_name = "bch2_bucket_sectors_total__extern"]
    pub fn bch2_bucket_sectors_total(a: bch_alloc_v4) -> s64;
}
unsafe extern "C" {
    #[link_name = "bch2_bucket_sectors_dirty__extern"]
    pub fn bch2_bucket_sectors_dirty(a: bch_alloc_v4) -> s64;
}
unsafe extern "C" {
    #[link_name = "bch2_bucket_sectors__extern"]
    pub fn bch2_bucket_sectors(a: bch_alloc_v4) -> s64;
}
unsafe extern "C" {
    #[link_name = "bch2_bucket_sectors_fragmented__extern"]
    pub fn bch2_bucket_sectors_fragmented(ca: *mut bch_dev, a: bch_alloc_v4) -> s64;
}
unsafe extern "C" {
    #[link_name = "bch2_bucket_sectors_unstriped__extern"]
    pub fn bch2_bucket_sectors_unstriped(a: bch_alloc_v4) -> s64;
}
unsafe extern "C" {
    pub fn bch2_trans_start_alloc_update_noupdate(
        arg1: *mut btree_trans,
        arg2: *mut btree_iter,
        arg3: bpos,
    ) -> *mut bkey_i_alloc_v4;
}
unsafe extern "C" {
    pub fn bch2_trans_start_alloc_update(
        arg1: *mut btree_trans,
        arg2: bpos,
        arg3: btree_iter_update_trigger_flags,
    ) -> *mut bkey_i_alloc_v4;
}
unsafe extern "C" {
    pub fn __bch2_alloc_to_v4(arg1: bkey_s_c, arg2: *mut bch_alloc_v4);
}
unsafe extern "C" {
    #[link_name = "bch2_alloc_to_v4__extern"]
    pub fn bch2_alloc_to_v4(
        k: bkey_s_c,
        convert: *mut bch_alloc_v4,
    ) -> *const bch_alloc_v4;
}
unsafe extern "C" {
    pub fn bch2_alloc_to_v4_mut(
        arg1: *mut btree_trans,
        arg2: bkey_s_c,
    ) -> *mut bkey_i_alloc_v4;
}
unsafe extern "C" {
    pub fn bch2_bucket_io_time_reset(
        arg1: *mut btree_trans,
        arg2: ::std::os::raw::c_uint,
        arg3: usize,
        arg4: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_alloc_v1_validate(
        arg1: *mut bch_fs,
        arg2: bkey_s_c,
        arg3: bkey_validate_context,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_alloc_v2_validate(
        arg1: *mut bch_fs,
        arg2: bkey_s_c,
        arg3: bkey_validate_context,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_alloc_v3_validate(
        arg1: *mut bch_fs,
        arg2: bkey_s_c,
        arg3: bkey_validate_context,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_alloc_v4_validate(
        arg1: *mut bch_fs,
        arg2: bkey_s_c,
        arg3: bkey_validate_context,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_alloc_v4_swab(arg1: *const bch_fs, arg2: bkey_s);
}
unsafe extern "C" {
    pub fn bch2_alloc_to_text(arg1: *mut printbuf, arg2: *mut bch_fs, arg3: bkey_s_c);
}
unsafe extern "C" {
    pub fn bch2_alloc_v4_to_text(arg1: *mut printbuf, arg2: *mut bch_fs, arg3: bkey_s_c);
}
unsafe extern "C" {
    pub fn bch2_bucket_gens_validate(
        arg1: *mut bch_fs,
        arg2: bkey_s_c,
        arg3: bkey_validate_context,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_bucket_gens_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: bkey_s_c,
    );
}
unsafe extern "C" {
    pub fn bch2_bucket_gens_init(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_alloc_read(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_bucket_do_freespace_index(
        arg1: *mut btree_trans,
        arg2: *mut bch_dev,
        arg3: bkey_s_c,
        arg4: *const bch_alloc_v4,
        arg5: bool,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_alloc_key_to_dev_counters(
        arg1: *mut btree_trans,
        arg2: *mut bch_dev,
        arg3: *const bch_alloc_v4,
        arg4: *const bch_alloc_v4,
        arg5: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_trigger_alloc(
        arg1: *mut btree_trans,
        arg2: btree_trigger_op,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_dev_remove_alloc(
        arg1: *mut bch_fs,
        arg2: *mut bch_dev,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_recalc_capacity(arg1: *mut bch_fs);
}
unsafe extern "C" {
    pub fn bch2_fs_ra_pages(arg1: *mut bch_fs) -> ::std::os::raw::c_ulong;
}
unsafe extern "C" {
    pub fn bch2_min_rw_member_capacity(arg1: *mut bch_fs) -> u64_;
}
unsafe extern "C" {
    pub fn bch2_dev_allocator_set_rw(arg1: *mut bch_fs, arg2: *mut bch_dev, arg3: bool);
}
unsafe extern "C" {
    pub fn bch2_dev_allocator_remove(arg1: *mut bch_fs, arg2: *mut bch_dev);
}
unsafe extern "C" {
    pub fn bch2_dev_allocator_add(arg1: *mut bch_fs, arg2: *mut bch_dev);
}
unsafe extern "C" {
    pub fn bch2_fs_allocator_background_init(arg1: *mut bch_fs);
}
unsafe extern "C" {
    pub fn bch2_fs_capacity_exit(arg1: *mut bch_fs);
}
unsafe extern "C" {
    pub fn bch2_fs_capacity_init(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_bio_free_pages_pool(arg1: *mut bch_fs, arg2: *mut bio);
}
unsafe extern "C" {
    pub fn bch2_bio_alloc_pages_pool(
        arg1: *mut bch_fs,
        arg2: *mut bio,
        arg3: ::std::os::raw::c_uint,
        arg4: usize,
    );
}
unsafe extern "C" {
    pub fn bch2_submit_wbio_replicas(
        arg1: *mut bch_write_bio,
        arg2: *mut bch_fs,
        arg3: bch_data_type,
        arg4: *const bkey_i,
        arg5: bool,
        arg6: *mut *mut bch_dev,
    );
}
unsafe extern "C" {
    pub fn bch2_write_op_error(
        op: *mut bch_write_op,
        arg1: bool,
        arg2: u64_,
        arg3: *const ::std::os::raw::c_char,
        ...
    );
}
unsafe extern "C" {
    pub fn bch2_sum_sector_overwrites(
        arg1: *mut btree_trans,
        arg2: *mut btree_iter,
        arg3: *mut bkey_i,
        arg4: *mut bool,
        arg5: *mut s64,
        arg6: *mut s64,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_extent_update(
        arg1: *mut btree_trans,
        arg2: subvol_inum,
        arg3: *mut btree_iter,
        arg4: *mut bkey_i,
        arg5: ::std::os::raw::c_uint,
        arg6: *mut disk_reservation,
        arg7: u64_,
        arg8: *mut s64,
        arg9: bool,
        arg10: u32_,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bch2_write_op_init__extern"]
    pub fn bch2_write_op_init(
        op: *mut bch_write_op,
        c: *mut bch_fs,
        opts: bch_inode_opts,
    );
}
unsafe extern "C" {
    pub fn bch2_write(ws: *mut work_struct);
}
unsafe extern "C" {
    pub fn bch2_write_point_do_index_updates(arg1: *mut work_struct);
}
unsafe extern "C" {
    pub static bch2_write_flags: [*const ::std::os::raw::c_char; 0usize];
}
unsafe extern "C" {
    pub fn __bch2_write_op_to_text(arg1: *mut printbuf, arg2: *mut bch_write_op);
}
unsafe extern "C" {
    pub fn bch2_write_op_to_text(arg1: *mut printbuf, arg2: *mut bch_write_op);
}
unsafe extern "C" {
    pub fn bch2_fs_io_write_exit(arg1: *mut bch_fs);
}
unsafe extern "C" {
    pub fn bch2_fs_io_write_init(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_set_nr_journal_buckets(
        arg1: *mut bch_fs,
        arg2: *mut bch_dev,
        arg3: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_dev_journal_bucket_delete(
        arg1: *mut bch_dev,
        arg2: u64_,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_dev_journal_alloc(
        arg1: *mut bch_dev,
        arg2: bool,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_fs_journal_alloc(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_dev_journal_stop(arg1: *mut journal, arg2: *mut bch_dev);
}
unsafe extern "C" {
    pub fn bch2_fs_journal_stop(arg1: *mut journal);
}
unsafe extern "C" {
    pub fn bch2_fs_journal_start(
        arg1: *mut journal,
        arg2: journal_start_info,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_journal_set_replay_done(arg1: *mut journal);
}
unsafe extern "C" {
    pub fn bch2_dev_journal_exit(arg1: *mut bch_dev);
}
unsafe extern "C" {
    pub fn bch2_dev_journal_init_early(arg1: *mut bch_dev);
}
unsafe extern "C" {
    pub fn bch2_dev_journal_init(
        arg1: *mut bch_dev,
        arg2: *mut bch_sb,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_fs_journal_exit(arg1: *mut journal);
}
unsafe extern "C" {
    pub fn bch2_fs_journal_init_early(arg1: *mut journal);
}
unsafe extern "C" {
    pub fn bch2_fs_journal_init(arg1: *mut journal) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_journal_dev_buckets_available(
        arg1: *mut journal,
        arg2: *mut journal_device,
        arg3: journal_space_from,
    ) -> ::std::os::raw::c_uint;
}
unsafe extern "C" {
    pub fn bch2_journal_set_watermark(arg1: *mut journal);
}
unsafe extern "C" {
    pub fn bch2_journal_space_available(arg1: *mut journal);
}
unsafe extern "C" {
    pub fn bch2_journal_update_last_seq(arg1: *mut journal);
}
#[repr(C)]
#[derive(Default, Copy, Clone)]
pub struct replicas_entry_refs {
    pub nr_refs: ::std::os::raw::c_uint,
    pub replicas: bch_replicas_padded,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of replicas_entry_refs",
    ][::std::mem::size_of::<replicas_entry_refs>() - 24usize];
    [
        "Alignment of replicas_entry_refs",
    ][::std::mem::align_of::<replicas_entry_refs>() - 4usize];
    [
        "Offset of field: replicas_entry_refs::nr_refs",
    ][::std::mem::offset_of!(replicas_entry_refs, nr_refs) - 0usize];
    [
        "Offset of field: replicas_entry_refs::replicas",
    ][::std::mem::offset_of!(replicas_entry_refs, replicas) - 4usize];
};
#[repr(C)]
#[derive(Copy, Clone)]
pub struct darray_replicas_entry_refs {
    pub nr: usize,
    pub size: usize,
    pub data: *mut replicas_entry_refs,
    pub preallocated: [replicas_entry_refs; 16usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of darray_replicas_entry_refs",
    ][::std::mem::size_of::<darray_replicas_entry_refs>() - 408usize];
    [
        "Alignment of darray_replicas_entry_refs",
    ][::std::mem::align_of::<darray_replicas_entry_refs>() - 8usize];
    [
        "Offset of field: darray_replicas_entry_refs::nr",
    ][::std::mem::offset_of!(darray_replicas_entry_refs, nr) - 0usize];
    [
        "Offset of field: darray_replicas_entry_refs::size",
    ][::std::mem::offset_of!(darray_replicas_entry_refs, size) - 8usize];
    [
        "Offset of field: darray_replicas_entry_refs::data",
    ][::std::mem::offset_of!(darray_replicas_entry_refs, data) - 16usize];
    [
        "Offset of field: darray_replicas_entry_refs::preallocated",
    ][::std::mem::offset_of!(darray_replicas_entry_refs, preallocated) - 24usize];
};
impl Default for darray_replicas_entry_refs {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C" {
    pub fn bch2_journal_update_last_seq_ondisk(
        arg1: *mut journal,
        arg2: u64_,
        arg3: *mut darray_replicas_entry_refs,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "__bch2_journal_pin_put__extern"]
    pub fn __bch2_journal_pin_put(j: *mut journal, seq: u64_) -> bool;
}
unsafe extern "C" {
    pub fn bch2_journal_replay_pins_put(arg1: *mut journal, arg2: u64_);
}
unsafe extern "C" {
    pub fn bch2_journal_pin_drop(arg1: *mut journal, arg2: *mut journal_entry_pin);
}
unsafe extern "C" {
    pub fn bch2_journal_pin_set(
        arg1: *mut journal,
        arg2: u64_,
        arg3: *mut journal_entry_pin,
        arg4: journal_pin_flush_fn,
    );
}
unsafe extern "C" {
    #[link_name = "bch2_journal_pin_add__extern"]
    pub fn bch2_journal_pin_add(
        j: *mut journal,
        seq: u64_,
        pin: *mut journal_entry_pin,
        flush_fn: journal_pin_flush_fn,
    );
}
unsafe extern "C" {
    pub fn bch2_journal_pin_copy(
        arg1: *mut journal,
        arg2: *mut journal_entry_pin,
        arg3: *mut journal_entry_pin,
        arg4: journal_pin_flush_fn,
    );
}
unsafe extern "C" {
    #[link_name = "bch2_journal_pin_update__extern"]
    pub fn bch2_journal_pin_update(
        j: *mut journal,
        seq: u64_,
        pin: *mut journal_entry_pin,
        flush_fn: journal_pin_flush_fn,
    );
}
unsafe extern "C" {
    pub fn bch2_journal_pin_flush(arg1: *mut journal, arg2: *mut journal_entry_pin);
}
unsafe extern "C" {
    pub fn bch2_journal_discard_work(arg1: *mut work_struct);
}
unsafe extern "C" {
    pub fn bch2_journal_do_discards(arg1: *mut journal);
}
unsafe extern "C" {
    pub fn bch2_journal_reclaim(arg1: *mut journal) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_journal_reclaim_stop(arg1: *mut journal);
}
unsafe extern "C" {
    pub fn bch2_journal_reclaim_start(arg1: *mut journal) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_journal_flush_pins(arg1: *mut journal, arg2: u64_) -> bool;
}
unsafe extern "C" {
    #[link_name = "bch2_journal_flush_all_pins__extern"]
    pub fn bch2_journal_flush_all_pins(j: *mut journal) -> bool;
}
unsafe extern "C" {
    #[link_name = "bch2_journal_flush_outstanding_pins__extern"]
    pub fn bch2_journal_flush_outstanding_pins(j: *mut journal) -> bool;
}
unsafe extern "C" {
    pub fn bch2_journal_flush_device_pins(
        arg1: *mut journal,
        arg2: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_journal_pins_to_text(arg1: *mut printbuf, arg2: *mut journal);
}
unsafe extern "C" {
    pub fn bch2_journal_seq_pins_to_text(
        arg1: *mut printbuf,
        arg2: *mut journal,
        arg3: *mut u64_,
    ) -> bool;
}
unsafe extern "C" {
    pub fn bch2_journal_reclaim_to_text(arg1: *mut printbuf, arg2: *mut journal);
}
unsafe extern "C" {
    pub fn bch2_journal_pos_from_member_info_set(arg1: *mut bch_fs);
}
unsafe extern "C" {
    pub fn bch2_journal_pos_from_member_info_resume(arg1: *mut bch_fs);
}
unsafe extern "C" {
    pub fn bch2_journal_ptrs_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: *mut journal_replay,
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct u64_range {
    pub start: u64_,
    pub end: u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of u64_range"][::std::mem::size_of::<u64_range>() - 16usize];
    ["Alignment of u64_range"][::std::mem::align_of::<u64_range>() - 8usize];
    [
        "Offset of field: u64_range::start",
    ][::std::mem::offset_of!(u64_range, start) - 0usize];
    ["Offset of field: u64_range::end"][::std::mem::offset_of!(u64_range, end) - 8usize];
};
unsafe extern "C" {
    pub fn bch2_journal_entry_missing_range(
        arg1: *mut bch_fs,
        arg2: u64_,
        arg3: u64_,
    ) -> u64_range;
}
unsafe extern "C" {
    pub fn bch2_journal_seq_datetime_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: u64_,
    );
}
unsafe extern "C" {
    pub fn bch2_journal_reread_for_rewind(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_journal_read(
        arg1: *mut bch_fs,
        arg2: *mut journal_start_info,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_journal_seq_next_blacklisted(arg1: *mut bch_fs, arg2: u64_) -> u64_;
}
unsafe extern "C" {
    pub fn bch2_journal_seq_next_nonblacklisted(arg1: *mut bch_fs, arg2: u64_) -> u64_;
}
unsafe extern "C" {
    pub fn bch2_journal_seq_is_blacklisted(
        arg1: *mut bch_fs,
        arg2: u64_,
        arg3: bool,
    ) -> bool;
}
unsafe extern "C" {
    pub fn bch2_journal_last_blacklisted_seq(arg1: *mut bch_fs) -> u64_;
}
unsafe extern "C" {
    pub fn bch2_journal_seq_blacklist_add(
        c: *mut bch_fs,
        arg1: u64_,
        arg2: u64_,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_blacklist_table_initialize(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub static bch_sb_field_ops_journal_seq_blacklist: bch_sb_field_ops;
}
unsafe extern "C" {
    pub fn bch2_blacklist_entries_gc(arg1: *mut bch_fs) -> bool;
}
unsafe extern "C" {
    pub fn bch2_journal_entry_err_msg(
        arg1: *mut printbuf,
        arg2: u32_,
        arg3: *mut jset,
        arg4: *mut jset_entry,
    );
}
unsafe extern "C" {
    pub fn bch2_journal_entry_validate(
        arg1: *mut bch_fs,
        arg2: *mut jset,
        arg3: *mut jset_entry,
        arg4: ::std::os::raw::c_uint,
        arg5: ::std::os::raw::c_int,
        arg6: bkey_validate_context,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_journal_entry_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: *mut jset_entry,
    );
}
unsafe extern "C" {
    pub fn bch2_jset_validate(
        arg1: *mut bch_fs,
        arg2: *mut bch_dev,
        arg3: *mut jset,
        arg4: u64_,
        arg5: bch_validate_flags,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_jset_validate_early(
        arg1: *mut bch_fs,
        arg2: *mut bch_dev,
        arg3: *mut jset,
        arg4: u64_,
        arg5: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub static bch_sb_field_ops_disk_groups: bch_sb_field_ops;
}
unsafe extern "C" {
    pub fn bch2_target_to_mask(
        arg1: *mut bch_fs,
        arg2: ::std::os::raw::c_uint,
    ) -> *const bch_devs_mask;
}
unsafe extern "C" {
    #[link_name = "bch2_target_accepts_data__extern"]
    pub fn bch2_target_accepts_data(
        c: *mut bch_fs,
        data_type: bch_data_type,
        target: u16_,
    ) -> bool;
}
unsafe extern "C" {
    pub fn bch2_dev_in_target_rcu(
        arg1: *mut bch_fs,
        arg2: ::std::os::raw::c_uint,
        arg3: ::std::os::raw::c_uint,
    ) -> bool;
}
unsafe extern "C" {
    #[link_name = "bch2_dev_in_target__extern"]
    pub fn bch2_dev_in_target(
        c: *mut bch_fs,
        dev: ::std::os::raw::c_uint,
        target: ::std::os::raw::c_uint,
    ) -> bool;
}
unsafe extern "C" {
    pub fn bch2_disk_path_find(
        arg1: *mut bch_sb_handle,
        arg2: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_disk_path_find_or_create(
        arg1: *mut bch_sb_handle,
        arg2: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_disk_path_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: ::std::os::raw::c_uint,
    );
}
unsafe extern "C" {
    pub fn bch2_disk_path_to_text_sb(
        arg1: *mut printbuf,
        arg2: *mut bch_sb,
        arg3: ::std::os::raw::c_uint,
    );
}
unsafe extern "C" {
    pub fn bch2_target_to_text(
        out: *mut printbuf,
        arg1: *mut bch_fs,
        arg2: ::std::os::raw::c_uint,
    );
}
unsafe extern "C" {
    pub fn bch2_opt_target_parse(
        arg1: *mut bch_fs,
        arg2: *const ::std::os::raw::c_char,
        arg3: *mut u64_,
        arg4: *mut printbuf,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_opt_target_to_text(
        arg1: *mut printbuf,
        arg2: *mut bch_fs,
        arg3: *mut bch_sb,
        arg4: u64_,
    );
}
unsafe extern "C" {
    pub fn bch2_sb_disk_groups_to_cpu(arg1: *mut bch_fs) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn __bch2_dev_group_set(
        arg1: *mut bch_fs,
        arg2: *mut bch_dev,
        arg3: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_dev_group_set(
        arg1: *mut bch_fs,
        arg2: *mut bch_dev,
        arg3: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn bch2_sb_validate_disk_groups(
        arg1: *mut bch_sb,
        arg2: *mut bch_sb_field,
    ) -> *const ::std::os::raw::c_char;
}
unsafe extern "C" {
    pub fn bch2_disk_groups_to_text(arg1: *mut printbuf, arg2: *mut bch_fs);
}
unsafe extern "C" {
    pub fn read_passphrase(
        arg1: *const ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_char;
}
unsafe extern "C" {
    pub fn derive_passphrase(
        arg1: *mut bch_sb_field_crypt,
        arg2: *const ::std::os::raw::c_char,
    ) -> bch_key;
}
unsafe extern "C" {
    pub fn bch2_sb_is_encrypted(arg1: *mut bch_sb) -> bool;
}
unsafe extern "C" {
    pub fn bch2_passphrase_check(
        arg1: *mut bch_sb,
        arg2: *const ::std::os::raw::c_char,
        arg3: *mut bch_key,
        arg4: *mut bch_encrypted_key,
    ) -> bool;
}
unsafe extern "C" {
    pub fn bch2_add_key(
        arg1: *mut bch_sb,
        arg2: *const ::std::os::raw::c_char,
        arg3: *const ::std::os::raw::c_char,
        arg4: *const ::std::os::raw::c_char,
    ) -> bool;
}
unsafe extern "C" {
    pub fn bch_sb_crypt_init(
        sb: *mut bch_sb,
        arg1: *mut bch_sb_field_crypt,
        arg2: *const ::std::os::raw::c_char,
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bch_opt_strs {
    pub __bindgen_anon_1: bch_opt_strs__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bch_opt_strs__bindgen_ty_1 {
    pub by_id: [*mut ::std::os::raw::c_char; 88usize],
    pub __bindgen_anon_1: bch_opt_strs__bindgen_ty_1__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bch_opt_strs__bindgen_ty_1__bindgen_ty_1 {
    pub block_size: *mut ::std::os::raw::c_char,
    pub btree_node_size: *mut ::std::os::raw::c_char,
    pub errors: *mut ::std::os::raw::c_char,
    pub write_error_timeout: *mut ::std::os::raw::c_char,
    pub metadata_replicas: *mut ::std::os::raw::c_char,
    pub data_replicas: *mut ::std::os::raw::c_char,
    pub encoded_extent_max: *mut ::std::os::raw::c_char,
    pub metadata_checksum: *mut ::std::os::raw::c_char,
    pub data_checksum: *mut ::std::os::raw::c_char,
    pub checksum_err_retry_nr: *mut ::std::os::raw::c_char,
    pub compression: *mut ::std::os::raw::c_char,
    pub background_compression: *mut ::std::os::raw::c_char,
    pub str_hash: *mut ::std::os::raw::c_char,
    pub metadata_target: *mut ::std::os::raw::c_char,
    pub foreground_target: *mut ::std::os::raw::c_char,
    pub background_target: *mut ::std::os::raw::c_char,
    pub promote_target: *mut ::std::os::raw::c_char,
    pub erasure_code: *mut ::std::os::raw::c_char,
    pub ec_max_data_blocks: *mut ::std::os::raw::c_char,
    pub casefold: *mut ::std::os::raw::c_char,
    pub casefold_disabled: *mut ::std::os::raw::c_char,
    pub inodes_32bit: *mut ::std::os::raw::c_char,
    pub shard_inode_numbers_bits: *mut ::std::os::raw::c_char,
    pub btree_node_mem_ptr_optimization: *mut ::std::os::raw::c_char,
    pub gc_reserve_percent: *mut ::std::os::raw::c_char,
    pub gc_reserve_bytes: *mut ::std::os::raw::c_char,
    pub root_reserve_percent: *mut ::std::os::raw::c_char,
    pub wide_macs: *mut ::std::os::raw::c_char,
    pub inline_data: *mut ::std::os::raw::c_char,
    pub promote_whole_extents: *mut ::std::os::raw::c_char,
    pub acl: *mut ::std::os::raw::c_char,
    pub usrquota: *mut ::std::os::raw::c_char,
    pub grpquota: *mut ::std::os::raw::c_char,
    pub prjquota: *mut ::std::os::raw::c_char,
    pub degraded: *mut ::std::os::raw::c_char,
    pub mount_trusts_udev: *mut ::std::os::raw::c_char,
    pub no_splitbrain_check: *mut ::std::os::raw::c_char,
    pub no_version_check: *mut ::std::os::raw::c_char,
    pub verbose: *mut ::std::os::raw::c_char,
    pub journal_flush_delay: *mut ::std::os::raw::c_char,
    pub journal_flush_disabled: *mut ::std::os::raw::c_char,
    pub journal_reclaim_delay: *mut ::std::os::raw::c_char,
    pub writeback_timeout: *mut ::std::os::raw::c_char,
    pub move_bytes_in_flight: *mut ::std::os::raw::c_char,
    pub move_ios_in_flight: *mut ::std::os::raw::c_char,
    pub fsck: *mut ::std::os::raw::c_char,
    pub fsck_memory_usage_percent: *mut ::std::os::raw::c_char,
    pub fix_errors: *mut ::std::os::raw::c_char,
    pub ratelimit_errors: *mut ::std::os::raw::c_char,
    pub nochanges: *mut ::std::os::raw::c_char,
    pub norecovery: *mut ::std::os::raw::c_char,
    pub journal_rewind: *mut ::std::os::raw::c_char,
    pub journal_rewind_discard_buffer_percent: *mut ::std::os::raw::c_char,
    pub scrub_recent_journal_entries: *mut ::std::os::raw::c_char,
    pub scrub_journal_max_rewind_secs: *mut ::std::os::raw::c_char,
    pub recovery_passes: *mut ::std::os::raw::c_char,
    pub recovery_passes_exclude: *mut ::std::os::raw::c_char,
    pub recovery_pass_last: *mut ::std::os::raw::c_char,
    pub retain_recovery_info: *mut ::std::os::raw::c_char,
    pub read_entire_journal: *mut ::std::os::raw::c_char,
    pub read_journal_only: *mut ::std::os::raw::c_char,
    pub journal_transaction_names: *mut ::std::os::raw::c_char,
    pub allocator_stuck_timeout: *mut ::std::os::raw::c_char,
    pub noexcl: *mut ::std::os::raw::c_char,
    pub direct_io: *mut ::std::os::raw::c_char,
    pub sb: *mut ::std::os::raw::c_char,
    pub read_only: *mut ::std::os::raw::c_char,
    pub nostart: *mut ::std::os::raw::c_char,
    pub dangerously_reconstruct_alloc: *mut ::std::os::raw::c_char,
    pub version_upgrade: *mut ::std::os::raw::c_char,
    pub stdio: *mut ::std::os::raw::c_char,
    pub project: *mut ::std::os::raw::c_char,
    pub nocow: *mut ::std::os::raw::c_char,
    pub nocow_enabled: *mut ::std::os::raw::c_char,
    pub copygc_enabled: *mut ::std::os::raw::c_char,
    pub reconcile_enabled: *mut ::std::os::raw::c_char,
    pub reconcile_on_ac_only: *mut ::std::os::raw::c_char,
    pub auto_snapshot_deletion: *mut ::std::os::raw::c_char,
    pub no_data_io: *mut ::std::os::raw::c_char,
    pub state: *mut ::std::os::raw::c_char,
    pub bucket_size: *mut ::std::os::raw::c_char,
    pub durability: *mut ::std::os::raw::c_char,
    pub data_allowed: *mut ::std::os::raw::c_char,
    pub discard: *mut ::std::os::raw::c_char,
    pub rotational: *mut ::std::os::raw::c_char,
    pub btree_node_prefetch: *mut ::std::os::raw::c_char,
    pub dev_readahead: *mut ::std::os::raw::c_char,
    pub ec_stripe_buf_limit: *mut ::std::os::raw::c_char,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_opt_strs__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bch_opt_strs__bindgen_ty_1__bindgen_ty_1>() - 704usize];
    [
        "Alignment of bch_opt_strs__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bch_opt_strs__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::block_size",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, block_size)
        - 0usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::btree_node_size",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, btree_node_size)
        - 8usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::errors",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, errors)
        - 16usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::write_error_timeout",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, write_error_timeout
    ) - 24usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::metadata_replicas",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, metadata_replicas)
        - 32usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::data_replicas",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, data_replicas)
        - 40usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::encoded_extent_max",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, encoded_extent_max
    ) - 48usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::metadata_checksum",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, metadata_checksum)
        - 56usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::data_checksum",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, data_checksum)
        - 64usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::checksum_err_retry_nr",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, checksum_err_retry_nr
    ) - 72usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::compression",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, compression)
        - 80usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::background_compression",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, background_compression
    ) - 88usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::str_hash",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, str_hash)
        - 96usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::metadata_target",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, metadata_target)
        - 104usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::foreground_target",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, foreground_target)
        - 112usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::background_target",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, background_target)
        - 120usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::promote_target",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, promote_target)
        - 128usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::erasure_code",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, erasure_code)
        - 136usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::ec_max_data_blocks",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, ec_max_data_blocks
    ) - 144usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::casefold",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, casefold)
        - 152usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::casefold_disabled",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, casefold_disabled)
        - 160usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::inodes_32bit",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, inodes_32bit)
        - 168usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::shard_inode_numbers_bits",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, shard_inode_numbers_bits
    ) - 176usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::btree_node_mem_ptr_optimization",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, btree_node_mem_ptr_optimization
    ) - 184usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::gc_reserve_percent",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, gc_reserve_percent
    ) - 192usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::gc_reserve_bytes",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, gc_reserve_bytes)
        - 200usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::root_reserve_percent",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, root_reserve_percent
    ) - 208usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::wide_macs",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, wide_macs)
        - 216usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::inline_data",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, inline_data)
        - 224usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::promote_whole_extents",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, promote_whole_extents
    ) - 232usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::acl",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, acl) - 240usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::usrquota",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, usrquota)
        - 248usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::grpquota",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, grpquota)
        - 256usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::prjquota",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, prjquota)
        - 264usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::degraded",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, degraded)
        - 272usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::mount_trusts_udev",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, mount_trusts_udev)
        - 280usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::no_splitbrain_check",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, no_splitbrain_check
    ) - 288usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::no_version_check",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, no_version_check)
        - 296usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::verbose",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, verbose)
        - 304usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::journal_flush_delay",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, journal_flush_delay
    ) - 312usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::journal_flush_disabled",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, journal_flush_disabled
    ) - 320usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::journal_reclaim_delay",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, journal_reclaim_delay
    ) - 328usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::writeback_timeout",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, writeback_timeout)
        - 336usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::move_bytes_in_flight",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, move_bytes_in_flight
    ) - 344usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::move_ios_in_flight",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, move_ios_in_flight
    ) - 352usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::fsck",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, fsck) - 360usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::fsck_memory_usage_percent",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, fsck_memory_usage_percent
    ) - 368usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::fix_errors",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, fix_errors)
        - 376usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::ratelimit_errors",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, ratelimit_errors)
        - 384usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::nochanges",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, nochanges)
        - 392usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::norecovery",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, norecovery)
        - 400usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::journal_rewind",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, journal_rewind)
        - 408usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::journal_rewind_discard_buffer_percent",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, journal_rewind_discard_buffer_percent
    ) - 416usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::scrub_recent_journal_entries",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, scrub_recent_journal_entries
    ) - 424usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::scrub_journal_max_rewind_secs",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, scrub_journal_max_rewind_secs
    ) - 432usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::recovery_passes",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, recovery_passes)
        - 440usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::recovery_passes_exclude",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, recovery_passes_exclude
    ) - 448usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::recovery_pass_last",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, recovery_pass_last
    ) - 456usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::retain_recovery_info",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, retain_recovery_info
    ) - 464usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::read_entire_journal",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, read_entire_journal
    ) - 472usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::read_journal_only",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, read_journal_only)
        - 480usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::journal_transaction_names",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, journal_transaction_names
    ) - 488usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::allocator_stuck_timeout",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, allocator_stuck_timeout
    ) - 496usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::noexcl",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, noexcl)
        - 504usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::direct_io",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, direct_io)
        - 512usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::sb",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, sb) - 520usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::read_only",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, read_only)
        - 528usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::nostart",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, nostart)
        - 536usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::dangerously_reconstruct_alloc",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, dangerously_reconstruct_alloc
    ) - 544usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::version_upgrade",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, version_upgrade)
        - 552usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::stdio",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, stdio)
        - 560usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::project",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, project)
        - 568usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::nocow",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, nocow)
        - 576usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::nocow_enabled",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, nocow_enabled)
        - 584usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::copygc_enabled",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, copygc_enabled)
        - 592usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::reconcile_enabled",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, reconcile_enabled)
        - 600usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::reconcile_on_ac_only",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, reconcile_on_ac_only
    ) - 608usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::auto_snapshot_deletion",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, auto_snapshot_deletion
    ) - 616usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::no_data_io",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, no_data_io)
        - 624usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::state",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, state)
        - 632usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::bucket_size",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, bucket_size)
        - 640usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::durability",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, durability)
        - 648usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::data_allowed",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, data_allowed)
        - 656usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::discard",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, discard)
        - 664usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::rotational",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, rotational)
        - 672usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::btree_node_prefetch",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, btree_node_prefetch
    ) - 680usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::dev_readahead",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, dev_readahead)
        - 688usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::ec_stripe_buf_limit",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, ec_stripe_buf_limit
    ) - 696usize];
};
impl Default for bch_opt_strs__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_opt_strs__bindgen_ty_1",
    ][::std::mem::size_of::<bch_opt_strs__bindgen_ty_1>() - 704usize];
    [
        "Alignment of bch_opt_strs__bindgen_ty_1",
    ][::std::mem::align_of::<bch_opt_strs__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1::by_id",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1, by_id) - 0usize];
};
impl Default for bch_opt_strs__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_opt_strs"][::std::mem::size_of::<bch_opt_strs>() - 704usize];
    ["Alignment of bch_opt_strs"][::std::mem::align_of::<bch_opt_strs>() - 8usize];
};
impl Default for bch_opt_strs {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C" {
    pub fn bch2_opt_strs_free(arg1: *mut bch_opt_strs);
}
unsafe extern "C" {
    pub fn bch2_parse_opts(arg1: bch_opt_strs) -> bch_opts;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct format_opts {
    pub label: *mut ::std::os::raw::c_char,
    pub uuid: __uuid_t,
    pub version: ::std::os::raw::c_uint,
    pub superblock_size: ::std::os::raw::c_uint,
    pub encrypted: bool,
    pub passphrase_file: *mut ::std::os::raw::c_char,
    pub passphrase: *mut ::std::os::raw::c_char,
    pub source: *mut ::std::os::raw::c_char,
    pub no_sb_at_end: bool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of format_opts"][::std::mem::size_of::<format_opts>() - 72usize];
    ["Alignment of format_opts"][::std::mem::align_of::<format_opts>() - 8usize];
    [
        "Offset of field: format_opts::label",
    ][::std::mem::offset_of!(format_opts, label) - 0usize];
    [
        "Offset of field: format_opts::uuid",
    ][::std::mem::offset_of!(format_opts, uuid) - 8usize];
    [
        "Offset of field: format_opts::version",
    ][::std::mem::offset_of!(format_opts, version) - 24usize];
    [
        "Offset of field: format_opts::superblock_size",
    ][::std::mem::offset_of!(format_opts, superblock_size) - 28usize];
    [
        "Offset of field: format_opts::encrypted",
    ][::std::mem::offset_of!(format_opts, encrypted) - 32usize];
    [
        "Offset of field: format_opts::passphrase_file",
    ][::std::mem::offset_of!(format_opts, passphrase_file) - 40usize];
    [
        "Offset of field: format_opts::passphrase",
    ][::std::mem::offset_of!(format_opts, passphrase) - 48usize];
    [
        "Offset of field: format_opts::source",
    ][::std::mem::offset_of!(format_opts, source) - 56usize];
    [
        "Offset of field: format_opts::no_sb_at_end",
    ][::std::mem::offset_of!(format_opts, no_sb_at_end) - 64usize];
};
impl Default for format_opts {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dev_opts {
    pub file: *mut file,
    pub bdev: *mut block_device,
    pub path: *const ::std::os::raw::c_char,
    pub sb_offset: u64_,
    pub sb_end: u64_,
    pub nbuckets: u64_,
    pub fs_size: u64_,
    pub label: *const ::std::os::raw::c_char,
    pub opts: bch_opts,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of dev_opts"][::std::mem::size_of::<dev_opts>() - 296usize];
    ["Alignment of dev_opts"][::std::mem::align_of::<dev_opts>() - 8usize];
    ["Offset of field: dev_opts::file"][::std::mem::offset_of!(dev_opts, file) - 0usize];
    ["Offset of field: dev_opts::bdev"][::std::mem::offset_of!(dev_opts, bdev) - 8usize];
    [
        "Offset of field: dev_opts::path",
    ][::std::mem::offset_of!(dev_opts, path) - 16usize];
    [
        "Offset of field: dev_opts::sb_offset",
    ][::std::mem::offset_of!(dev_opts, sb_offset) - 24usize];
    [
        "Offset of field: dev_opts::sb_end",
    ][::std::mem::offset_of!(dev_opts, sb_end) - 32usize];
    [
        "Offset of field: dev_opts::nbuckets",
    ][::std::mem::offset_of!(dev_opts, nbuckets) - 40usize];
    [
        "Offset of field: dev_opts::fs_size",
    ][::std::mem::offset_of!(dev_opts, fs_size) - 48usize];
    [
        "Offset of field: dev_opts::label",
    ][::std::mem::offset_of!(dev_opts, label) - 56usize];
    [
        "Offset of field: dev_opts::opts",
    ][::std::mem::offset_of!(dev_opts, opts) - 64usize];
};
impl Default for dev_opts {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C" {
    /** Initializes the RAID system.

 You must call this function before any other.

 The RAID system is initialized in the RAID_MODE_CAUCHY mode.*/
    pub fn raid_init();
}
unsafe extern "C" {
    pub fn rust_csum_vstruct_sb(sb: *mut bch_sb) -> bch_csum;
}
unsafe extern "C" {
    pub fn rust_strip_alloc_do(c: *mut bch_fs);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rust_journal_entries {
    pub entries: *mut *mut journal_replay,
    pub nr: usize,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of rust_journal_entries",
    ][::std::mem::size_of::<rust_journal_entries>() - 16usize];
    [
        "Alignment of rust_journal_entries",
    ][::std::mem::align_of::<rust_journal_entries>() - 8usize];
    [
        "Offset of field: rust_journal_entries::entries",
    ][::std::mem::offset_of!(rust_journal_entries, entries) - 0usize];
    [
        "Offset of field: rust_journal_entries::nr",
    ][::std::mem::offset_of!(rust_journal_entries, nr) - 8usize];
};
impl Default for rust_journal_entries {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C" {
    pub fn rust_collect_journal_entries(c: *mut bch_fs) -> rust_journal_entries;
}
unsafe extern "C" {
    pub fn rust_get_next_online_dev(
        c: *mut bch_fs,
        ca: *mut bch_dev,
        ref_idx: ::std::os::raw::c_uint,
    ) -> *mut bch_dev;
}
unsafe extern "C" {
    pub fn rust_put_online_dev_ref(ca: *mut bch_dev, ref_idx: ::std::os::raw::c_uint);
}
unsafe extern "C" {
    pub fn rust_jset_decrypt(c: *mut bch_fs, j: *mut jset) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn rust_bset_decrypt(
        c: *mut bch_fs,
        i: *mut bset,
        offset: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn rust_set_bit(nr: ::std::os::raw::c_ulong, addr: *mut ::std::os::raw::c_ulong);
}
unsafe extern "C" {
    pub fn rust_dev_tryget_noerror(
        c: *mut bch_fs,
        dev: ::std::os::raw::c_uint,
    ) -> *mut bch_dev;
}
unsafe extern "C" {
    pub fn rust_dev_put(ca: *mut bch_dev);
}
unsafe extern "C" {
    pub fn rust_write_submit(
        c: *mut bch_fs,
        op: *mut bch_write_op,
        bvecs: *mut bio_vec,
        nr_bvecs: ::std::os::raw::c_uint,
        buf: *const ::std::os::raw::c_void,
        len: usize,
        inum: __u64,
        offset: __u64,
        subvol: __u32,
        replicas: __u32,
        new_i_size: __u64,
        end_io: ::std::option::Option<unsafe extern "C" fn(arg1: *mut bch_write_op)>,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn rust_read_submit(
        c: *mut bch_fs,
        rbio: *mut bch_read_bio,
        bvecs: *mut bio_vec,
        nr_bvecs: ::std::os::raw::c_uint,
        buf: *mut ::std::os::raw::c_void,
        len: usize,
        offset: __u64,
        opts: bch_inode_opts,
        inum: subvol_inum,
        endio: bio_end_io_t,
    );
}
unsafe extern "C" {
    pub fn rust_link_data(
        c: *mut bch_fs,
        dst_inum: __u64,
        sectors_delta: *mut __s64,
        logical: __u64,
        physical: __u64,
        length: __u64,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn rust_accounting_mem_read(
        c: *mut bch_fs,
        p: bpos,
        v: *mut __u64,
        nr: ::std::os::raw::c_uint,
    );
}
unsafe extern "C" {
    pub fn rust_fuse_ensure_current();
}
unsafe extern "C" {
    pub fn rust_fuse_rcu_register();
}
unsafe extern "C" {
    pub fn rust_fuse_rcu_unregister();
}
unsafe extern "C" {
    pub fn rust_block_bytes(c: *mut bch_fs) -> u32_;
}
unsafe extern "C" {
    pub fn rust_inode_nlink_get(bi: *mut bch_inode_unpacked) -> u32_;
}
unsafe extern "C" {
    pub fn rust_bch2_time_to_timespec(c: *mut bch_fs, time: s64) -> timespec;
}
unsafe extern "C" {
    pub fn rust_timespec_to_bch2_time(c: *mut bch_fs, ts: timespec) -> s64;
}
unsafe extern "C" {
    pub fn rust_bch2_current_time(c: *mut bch_fs) -> s64;
}
unsafe extern "C" {
    pub fn rust_fuse_lookup(
        c: *mut bch_fs,
        dir: subvol_inum,
        name: *const ::std::os::raw::c_uchar,
        name_len: ::std::os::raw::c_uint,
        inum_out: *mut subvol_inum,
        inode_out: *mut bch_inode_unpacked,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn rust_fuse_create(
        c: *mut bch_fs,
        dir: subvol_inum,
        name: *const ::std::os::raw::c_uchar,
        name_len: ::std::os::raw::c_uint,
        mode: u16_,
        rdev: u64_,
        new_inode: *mut bch_inode_unpacked,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn rust_fuse_unlink(
        c: *mut bch_fs,
        dir: subvol_inum,
        name: *const ::std::os::raw::c_uchar,
        name_len: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn rust_fuse_rename(
        c: *mut bch_fs,
        src_dir: subvol_inum,
        src_name: *const ::std::os::raw::c_uchar,
        src_len: ::std::os::raw::c_uint,
        dst_dir: subvol_inum,
        dst_name: *const ::std::os::raw::c_uchar,
        dst_len: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn rust_fuse_link(
        c: *mut bch_fs,
        inum: subvol_inum,
        newparent: subvol_inum,
        name: *const ::std::os::raw::c_uchar,
        name_len: ::std::os::raw::c_uint,
        inode_out: *mut bch_inode_unpacked,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn rust_fuse_setattr(
        c: *mut bch_fs,
        inum: subvol_inum,
        inode_out: *mut bch_inode_unpacked,
        set_mode: ::std::os::raw::c_int,
        mode: u16_,
        set_uid: ::std::os::raw::c_int,
        uid: u32_,
        set_gid: ::std::os::raw::c_int,
        gid: u32_,
        set_size: ::std::os::raw::c_int,
        size: u64_,
        atime_flag: ::std::os::raw::c_int,
        atime: s64,
        mtime_flag: ::std::os::raw::c_int,
        mtime: s64,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn rust_fuse_update_inode_after_write(
        c: *mut bch_fs,
        inum: subvol_inum,
    ) -> ::std::os::raw::c_int;
}
pub type rust_fuse_filldir_fn = ::std::option::Option<
    unsafe extern "C" fn(
        ctx: *mut ::std::os::raw::c_void,
        name: *const ::std::os::raw::c_char,
        name_len: ::std::os::raw::c_uint,
        ino: u64_,
        type_: ::std::os::raw::c_uint,
        pos: u64_,
    ) -> ::std::os::raw::c_int,
>;
unsafe extern "C" {
    pub fn rust_fuse_readdir(
        c: *mut bch_fs,
        dir: subvol_inum,
        pos: u64_,
        ctx: *mut ::std::os::raw::c_void,
        filldir: rust_fuse_filldir_fn,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn rust_bch2_fs_usage_read_short(c: *mut bch_fs) -> bch_fs_usage_short;
}
unsafe extern "C" {
    pub fn rust_fuse_count_inodes(c: *mut bch_fs, nr_inodes: *mut u64_);
}
pub const BLK_OPEN_READ: blk_mode_t = 1;
pub const BLK_OPEN_WRITE: blk_mode_t = 2;
pub const BLK_OPEN_EXCL: blk_mode_t = 4;
pub const BLK_OPEN_CREAT: blk_mode_t = 64;
pub type __builtin_va_list = [__va_list_tag; 1usize];
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __va_list_tag {
    pub gp_offset: ::std::os::raw::c_uint,
    pub fp_offset: ::std::os::raw::c_uint,
    pub overflow_arg_area: *mut ::std::os::raw::c_void,
    pub reg_save_area: *mut ::std::os::raw::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of __va_list_tag"][::std::mem::size_of::<__va_list_tag>() - 24usize];
    ["Alignment of __va_list_tag"][::std::mem::align_of::<__va_list_tag>() - 8usize];
    [
        "Offset of field: __va_list_tag::gp_offset",
    ][::std::mem::offset_of!(__va_list_tag, gp_offset) - 0usize];
    [
        "Offset of field: __va_list_tag::fp_offset",
    ][::std::mem::offset_of!(__va_list_tag, fp_offset) - 4usize];
    [
        "Offset of field: __va_list_tag::overflow_arg_area",
    ][::std::mem::offset_of!(__va_list_tag, overflow_arg_area) - 8usize];
    [
        "Offset of field: __va_list_tag::reg_save_area",
    ][::std::mem::offset_of!(__va_list_tag, reg_save_area) - 16usize];
};
impl Default for __va_list_tag {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct kobj_ns_type_operations {
    pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct device {
    pub _address: u8,
}
