bindings.rs

/* automatically generated by rust-bindgen 0.69.4

See instructions from: https://rust-lang.github.io/rust-bindgen/print.html
  Download LLVM from: https://releases.llvm.org/download.html
  ADD LIBCLANG_PATH to environment

  bindgen.exe `
   .\include\hax_interface.h `
   -o platform\crosvm\hypervisor\src\haxm\haxm_sys\bindings.rs `
   --with-derive-default `
   -- -DHAX_TESTS=1

  The HAX_TESTS macro definition prevents the inlude file from including
  anything that's only needed by the kernel.

  I also had to remove some align tags for structs that live within packed
  structs, there's a bindgen bug for this:
  https://github.com/rust-lang/rust-bindgen/issues/1538

  I removed the align attr. from:
    - segment_desc_t__bindgen_ty_1__bindgen_ty_1
 */
#![allow(clippy::undocumented_unsafe_blocks)]

#[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]
    pub fn get_bit(&self, index: usize) -> bool {
        debug_assert!(index / 8 < self.storage.as_ref().len());
        let byte_index = index / 8;
        let byte = self.storage.as_ref()[byte_index];
        let bit_index = if cfg!(target_endian = "big") {
            7 - (index % 8)
        } else {
            index % 8
        };
        let mask = 1 << bit_index;
        byte & mask == mask
    }
    #[inline]
    pub fn set_bit(&mut self, index: usize, val: bool) {
        debug_assert!(index / 8 < self.storage.as_ref().len());
        let byte_index = index / 8;
        let byte = &mut self.storage.as_mut()[byte_index];
        let bit_index = if cfg!(target_endian = "big") {
            7 - (index % 8)
        } else {
            index % 8
        };
        let mask = 1 << bit_index;
        if val {
            *byte |= mask;
        } else {
            *byte &= !mask;
        }
    }
    #[inline]
    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
        debug_assert!(bit_width <= 64);
        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
        debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
        let mut val = 0;
        for i in 0..(bit_width as usize) {
            if self.get_bit(i + bit_offset) {
                let index = if cfg!(target_endian = "big") {
                    bit_width as usize - 1 - i
                } else {
                    i
                };
                val |= 1 << index;
            }
        }
        val
    }
    #[inline]
    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
        debug_assert!(bit_width <= 64);
        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
        debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
        for i in 0..(bit_width as usize) {
            let mask = 1 << i;
            let val_bit_is_set = val & mask == mask;
            let index = if cfg!(target_endian = "big") {
                bit_width as usize - 1 - i
            } else {
                i
            };
            self.set_bit(index + bit_offset, val_bit_is_set);
        }
    }
}
#[repr(C)]
#[derive(Default)]
pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
impl<T> __IncompleteArrayField<T> {
    #[inline]
    pub const fn new() -> Self {
        __IncompleteArrayField(::std::marker::PhantomData, [])
    }
    #[inline]
    pub fn as_ptr(&self) -> *const T {
        self as *const _ as *const T
    }
    #[inline]
    pub fn as_mut_ptr(&mut self) -> *mut T {
        self as *mut _ as *mut T
    }
    #[inline]
    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
        ::std::slice::from_raw_parts(self.as_ptr(), len)
    }
    #[inline]
    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
    }
}
impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        fmt.write_str("__IncompleteArrayField")
    }
}
pub const _VCRT_COMPILER_PREPROCESSOR: u32 = 1;
pub const _SAL_VERSION: u32 = 20;
pub const __SAL_H_VERSION: u32 = 180000000;
pub const _USE_DECLSPECS_FOR_SAL: u32 = 0;
pub const _USE_ATTRIBUTES_FOR_SAL: u32 = 0;
pub const _CRT_PACKING: u32 = 8;
pub const _HAS_EXCEPTIONS: u32 = 1;
pub const _STL_LANG: u32 = 0;
pub const _HAS_CXX17: u32 = 0;
pub const _HAS_CXX20: u32 = 0;
pub const _HAS_CXX23: u32 = 0;
pub const _HAS_NODISCARD: u32 = 0;
pub const WCHAR_MIN: u32 = 0;
pub const WCHAR_MAX: u32 = 65535;
pub const WINT_MIN: u32 = 0;
pub const WINT_MAX: u32 = 65535;
pub const HAX_PAGE_SIZE: u32 = 4096;
pub const HAX_PAGE_SHIFT: u32 = 12;
pub const HAX_PAGE_MASK: u32 = 4095;
pub const HAX_MAX_MSR_ARRAY: u32 = 32;
pub const HAX_IO_OUT: u32 = 0;
pub const HAX_IO_IN: u32 = 1;
pub const HAX_PAGEFAULT_ACC_R: u32 = 1;
pub const HAX_PAGEFAULT_ACC_W: u32 = 2;
pub const HAX_PAGEFAULT_ACC_X: u32 = 4;
pub const HAX_PAGEFAULT_PERM_R: u32 = 16;
pub const HAX_PAGEFAULT_PERM_W: u32 = 32;
pub const HAX_PAGEFAULT_PERM_X: u32 = 64;
pub const HAX_CAP_STATUS_WORKING: u32 = 1;
pub const HAX_CAP_MEMQUOTA: u32 = 2;
pub const HAX_CAP_WORKSTATUS_MASK: u32 = 1;
pub const HAX_CAP_FAILREASON_VT: u32 = 1;
pub const HAX_CAP_FAILREASON_NX: u32 = 2;
pub const HAX_CAP_EPT: u32 = 1;
pub const HAX_CAP_FASTMMIO: u32 = 2;
pub const HAX_CAP_UG: u32 = 4;
pub const HAX_CAP_64BIT_RAMBLOCK: u32 = 8;
pub const HAX_CAP_64BIT_SETRAM: u32 = 16;
pub const HAX_CAP_TUNNEL_PAGE: u32 = 32;
pub const HAX_CAP_RAM_PROTECTION: u32 = 64;
pub const HAX_CAP_DEBUG: u32 = 128;
pub const HAX_CAP_IMPLICIT_RAMBLOCK: u32 = 256;
pub const HAX_CAP_CPUID: u32 = 512;
pub const HAX_CAP_VM_LOG: u32 = 1024;
pub const HAX_RAM_INFO_ROM: u32 = 1;
pub const HAX_RAM_INFO_UNPIN: u32 = 32;
pub const HAX_RAM_INFO_STANDALONE: u32 = 64;
pub const HAX_RAM_INFO_INVALID: u32 = 128;
pub const HAX_RAM_PERM_NONE: u32 = 0;
pub const HAX_RAM_PERM_RWX: u32 = 7;
pub const HAX_RAM_PERM_MASK: u32 = 7;
pub const HAX_DEBUG_ENABLE: u32 = 1;
pub const HAX_DEBUG_STEP: u32 = 2;
pub const HAX_DEBUG_USE_SW_BP: u32 = 4;
pub const HAX_DEBUG_USE_HW_BP: u32 = 8;
pub const HAX_MAX_CPUID_ENTRIES: u32 = 64;
pub const HAX_DEVICE_APIC: u32 = 1;
pub type va_list = *mut ::std::os::raw::c_char;
extern "C" {
    pub fn __va_start(arg1: *mut *mut ::std::os::raw::c_char, ...);
}
pub type __vcrt_bool = bool;
pub type wchar_t = ::std::os::raw::c_ushort;
extern "C" {
    pub fn __security_init_cookie();
}
extern "C" {
    pub fn __security_check_cookie(_StackCookie: usize);
}
extern "C" {
    pub fn __report_gsfailure(_StackCookie: usize) -> !;
}
extern "C" {
    pub static mut __security_cookie: usize;
}
pub type int_least8_t = ::std::os::raw::c_schar;
pub type int_least16_t = ::std::os::raw::c_short;
pub type int_least32_t = ::std::os::raw::c_int;
pub type int_least64_t = ::std::os::raw::c_longlong;
pub type uint_least8_t = ::std::os::raw::c_uchar;
pub type uint_least16_t = ::std::os::raw::c_ushort;
pub type uint_least32_t = ::std::os::raw::c_uint;
pub type uint_least64_t = ::std::os::raw::c_ulonglong;
pub type int_fast8_t = ::std::os::raw::c_schar;
pub type int_fast16_t = ::std::os::raw::c_int;
pub type int_fast32_t = ::std::os::raw::c_int;
pub type int_fast64_t = ::std::os::raw::c_longlong;
pub type uint_fast8_t = ::std::os::raw::c_uchar;
pub type uint_fast16_t = ::std::os::raw::c_uint;
pub type uint_fast32_t = ::std::os::raw::c_uint;
pub type uint_fast64_t = ::std::os::raw::c_ulonglong;
pub type intmax_t = ::std::os::raw::c_longlong;
pub type uintmax_t = ::std::os::raw::c_ulonglong;
pub type hax_pa_t = u64;
pub type hax_pfn_t = u64;
pub type hax_paddr_t = u64;
pub type hax_vaddr_t = u64;
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union interruptibility_state_t {
    pub raw: u32,
    pub __bindgen_anon_1: interruptibility_state_t__bindgen_ty_1,
    pub pad: u64,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct interruptibility_state_t__bindgen_ty_1 {
    pub _bitfield_align_1: [u32; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
}
#[test]
fn bindgen_test_layout_interruptibility_state_t__bindgen_ty_1() {
    assert_eq!(
        ::std::mem::size_of::<interruptibility_state_t__bindgen_ty_1>(),
        4usize,
        concat!(
            "Size of: ",
            stringify!(interruptibility_state_t__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<interruptibility_state_t__bindgen_ty_1>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(interruptibility_state_t__bindgen_ty_1)
        )
    );
}
impl interruptibility_state_t__bindgen_ty_1 {
    #[inline]
    pub fn sti_blocking(&self) -> u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_sti_blocking(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn movss_blocking(&self) -> u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_movss_blocking(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(1usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn smi_blocking(&self) -> u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_smi_blocking(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(2usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn nmi_blocking(&self) -> u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_nmi_blocking(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(3usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn reserved(&self) -> u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 28u8) as u32) }
    }
    #[inline]
    pub fn set_reserved(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(4usize, 28u8, val as u64)
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        sti_blocking: u32,
        movss_blocking: u32,
        smi_blocking: u32,
        nmi_blocking: u32,
        reserved: u32,
    ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
        __bindgen_bitfield_unit.set(0usize, 1u8, {
            let sti_blocking: u32 = unsafe { ::std::mem::transmute(sti_blocking) };
            sti_blocking as u64
        });
        __bindgen_bitfield_unit.set(1usize, 1u8, {
            let movss_blocking: u32 = unsafe { ::std::mem::transmute(movss_blocking) };
            movss_blocking as u64
        });
        __bindgen_bitfield_unit.set(2usize, 1u8, {
            let smi_blocking: u32 = unsafe { ::std::mem::transmute(smi_blocking) };
            smi_blocking as u64
        });
        __bindgen_bitfield_unit.set(3usize, 1u8, {
            let nmi_blocking: u32 = unsafe { ::std::mem::transmute(nmi_blocking) };
            nmi_blocking as u64
        });
        __bindgen_bitfield_unit.set(4usize, 28u8, {
            let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
            reserved as u64
        });
        __bindgen_bitfield_unit
    }
}
#[test]
fn bindgen_test_layout_interruptibility_state_t() {
    const UNINIT: ::std::mem::MaybeUninit<interruptibility_state_t> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<interruptibility_state_t>(),
        8usize,
        concat!("Size of: ", stringify!(interruptibility_state_t))
    );
    assert_eq!(
        ::std::mem::align_of::<interruptibility_state_t>(),
        1usize,
        concat!("Alignment of ", stringify!(interruptibility_state_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).raw) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(interruptibility_state_t),
            "::",
            stringify!(raw)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pad) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(interruptibility_state_t),
            "::",
            stringify!(pad)
        )
    );
}
impl Default for interruptibility_state_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, packed)]
#[derive(Copy, Clone)]
pub struct segment_desc_t {
    pub selector: u16,
    pub dummy: u16,
    pub limit: u32,
    pub base: u64,
    pub __bindgen_anon_1: segment_desc_t__bindgen_ty_1,
    pub ipad: u32,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union segment_desc_t__bindgen_ty_1 {
    pub __bindgen_anon_1: segment_desc_t__bindgen_ty_1__bindgen_ty_1,
    pub ar: u32,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct segment_desc_t__bindgen_ty_1__bindgen_ty_1 {
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
}
#[test]
fn bindgen_test_layout_segment_desc_t__bindgen_ty_1__bindgen_ty_1() {
    assert_eq!(
        ::std::mem::size_of::<segment_desc_t__bindgen_ty_1__bindgen_ty_1>(),
        4usize,
        concat!(
            "Size of: ",
            stringify!(segment_desc_t__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<segment_desc_t__bindgen_ty_1__bindgen_ty_1>(),
        1usize,
        concat!(
            "Alignment of ",
            stringify!(segment_desc_t__bindgen_ty_1__bindgen_ty_1)
        )
    );
}
impl segment_desc_t__bindgen_ty_1__bindgen_ty_1 {
    #[inline]
    pub fn type_(&self) -> u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) }
    }
    #[inline]
    pub fn set_type(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 4u8, val as u64)
        }
    }
    #[inline]
    pub fn desc(&self) -> u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_desc(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(4usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn dpl(&self) -> u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 2u8) as u32) }
    }
    #[inline]
    pub fn set_dpl(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(5usize, 2u8, val as u64)
        }
    }
    #[inline]
    pub fn present(&self) -> u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_present(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(7usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn available(&self) -> u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_available(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(12usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn long_mode(&self) -> u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_long_mode(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(13usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn operand_size(&self) -> u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_operand_size(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(14usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn granularity(&self) -> u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_granularity(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(15usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn null(&self) -> u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_null(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(16usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        type_: u32,
        desc: u32,
        dpl: u32,
        present: u32,
        available: u32,
        long_mode: u32,
        operand_size: u32,
        granularity: u32,
        null: u32,
    ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
        __bindgen_bitfield_unit.set(0usize, 4u8, {
            let type_: u32 = unsafe { ::std::mem::transmute(type_) };
            type_ as u64
        });
        __bindgen_bitfield_unit.set(4usize, 1u8, {
            let desc: u32 = unsafe { ::std::mem::transmute(desc) };
            desc as u64
        });
        __bindgen_bitfield_unit.set(5usize, 2u8, {
            let dpl: u32 = unsafe { ::std::mem::transmute(dpl) };
            dpl as u64
        });
        __bindgen_bitfield_unit.set(7usize, 1u8, {
            let present: u32 = unsafe { ::std::mem::transmute(present) };
            present as u64
        });
        __bindgen_bitfield_unit.set(12usize, 1u8, {
            let available: u32 = unsafe { ::std::mem::transmute(available) };
            available as u64
        });
        __bindgen_bitfield_unit.set(13usize, 1u8, {
            let long_mode: u32 = unsafe { ::std::mem::transmute(long_mode) };
            long_mode as u64
        });
        __bindgen_bitfield_unit.set(14usize, 1u8, {
            let operand_size: u32 = unsafe { ::std::mem::transmute(operand_size) };
            operand_size as u64
        });
        __bindgen_bitfield_unit.set(15usize, 1u8, {
            let granularity: u32 = unsafe { ::std::mem::transmute(granularity) };
            granularity as u64
        });
        __bindgen_bitfield_unit.set(16usize, 1u8, {
            let null: u32 = unsafe { ::std::mem::transmute(null) };
            null as u64
        });
        __bindgen_bitfield_unit
    }
}
#[test]
fn bindgen_test_layout_segment_desc_t__bindgen_ty_1() {
    const UNINIT: ::std::mem::MaybeUninit<segment_desc_t__bindgen_ty_1> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<segment_desc_t__bindgen_ty_1>(),
        4usize,
        concat!("Size of: ", stringify!(segment_desc_t__bindgen_ty_1))
    );
    assert_eq!(
        ::std::mem::align_of::<segment_desc_t__bindgen_ty_1>(),
        4usize,
        concat!("Alignment of ", stringify!(segment_desc_t__bindgen_ty_1))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ar) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(segment_desc_t__bindgen_ty_1),
            "::",
            stringify!(ar)
        )
    );
}
impl Default for segment_desc_t__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()
        }
    }
}
#[test]
fn bindgen_test_layout_segment_desc_t() {
    const UNINIT: ::std::mem::MaybeUninit<segment_desc_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<segment_desc_t>(),
        24usize,
        concat!("Size of: ", stringify!(segment_desc_t))
    );
    assert_eq!(
        ::std::mem::align_of::<segment_desc_t>(),
        1usize,
        concat!("Alignment of ", stringify!(segment_desc_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).selector) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(segment_desc_t),
            "::",
            stringify!(selector)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dummy) as usize - ptr as usize },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(segment_desc_t),
            "::",
            stringify!(dummy)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).limit) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(segment_desc_t),
            "::",
            stringify!(limit)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).base) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(segment_desc_t),
            "::",
            stringify!(base)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ipad) as usize - ptr as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(segment_desc_t),
            "::",
            stringify!(ipad)
        )
    );
}
impl Default for segment_desc_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, packed)]
#[derive(Copy, Clone)]
pub struct vcpu_state_t {
    pub __bindgen_anon_1: vcpu_state_t__bindgen_ty_1,
    pub __bindgen_anon_2: vcpu_state_t__bindgen_ty_2,
    pub __bindgen_anon_3: vcpu_state_t__bindgen_ty_3,
    pub cs: segment_desc_t,
    pub ss: segment_desc_t,
    pub ds: segment_desc_t,
    pub es: segment_desc_t,
    pub fs: segment_desc_t,
    pub gs: segment_desc_t,
    pub ldt: segment_desc_t,
    pub tr: segment_desc_t,
    pub gdt: segment_desc_t,
    pub idt: segment_desc_t,
    pub cr0: u64,
    pub cr2: u64,
    pub cr3: u64,
    pub cr4: u64,
    pub dr0: u64,
    pub dr1: u64,
    pub dr2: u64,
    pub dr3: u64,
    pub dr6: u64,
    pub dr7: u64,
    pub pde: u64,
    pub efer: u32,
    pub sysenter_cs: u32,
    pub sysenter_eip: u64,
    pub sysenter_esp: u64,
    pub activity_state: u32,
    pub pad: u32,
    pub interruptibility_state: interruptibility_state_t,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union vcpu_state_t__bindgen_ty_1 {
    pub regs: [u64; 16usize],
    pub __bindgen_anon_1: vcpu_state_t__bindgen_ty_1__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct vcpu_state_t__bindgen_ty_1__bindgen_ty_1 {
    pub __bindgen_anon_1: vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
    pub __bindgen_anon_2: vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2,
    pub __bindgen_anon_3: vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_3,
    pub __bindgen_anon_4: vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_4,
    pub __bindgen_anon_5: vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_5,
    pub __bindgen_anon_6: vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_6,
    pub __bindgen_anon_7: vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_7,
    pub __bindgen_anon_8: vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_8,
    pub r8: u64,
    pub r9: u64,
    pub r10: u64,
    pub r11: u64,
    pub r12: u64,
    pub r13: u64,
    pub r14: u64,
    pub r15: u64,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
    pub __bindgen_anon_1: vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
    pub ax: u16,
    pub eax: u32,
    pub rax: u64,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
    pub al: u8,
    pub ah: u8,
}
#[test]
fn bindgen_test_layout_vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1() {
    const UNINIT: ::std::mem::MaybeUninit<
        vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
    > = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1>(
        ),
        2usize,
        concat!(
            "Size of: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1>(
        ),
        1usize,
        concat!(
            "Alignment of ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).al) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(al)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ah) as usize - ptr as usize },
        1usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(ah)
        )
    );
}
#[test]
fn bindgen_test_layout_vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1() {
    const UNINIT: ::std::mem::MaybeUninit<vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ax) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(ax)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).eax) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(eax)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rax) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(rax)
        )
    );
}
impl Default for vcpu_state_t__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()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2 {
    pub __bindgen_anon_1: vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1,
    pub cx: u16,
    pub ecx: u32,
    pub rcx: u64,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1 {
    pub cl: u8,
    pub ch: u8,
}
#[test]
fn bindgen_test_layout_vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1() {
    const UNINIT: ::std::mem::MaybeUninit<
        vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1,
    > = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1>(
        ),
        2usize,
        concat!(
            "Size of: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1>(
        ),
        1usize,
        concat!(
            "Alignment of ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).cl) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1),
            "::",
            stringify!(cl)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ch) as usize - ptr as usize },
        1usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1),
            "::",
            stringify!(ch)
        )
    );
}
#[test]
fn bindgen_test_layout_vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2() {
    const UNINIT: ::std::mem::MaybeUninit<vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).cx) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2),
            "::",
            stringify!(cx)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ecx) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2),
            "::",
            stringify!(ecx)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rcx) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2),
            "::",
            stringify!(rcx)
        )
    );
}
impl Default for vcpu_state_t__bindgen_ty_1__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()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_3 {
    pub __bindgen_anon_1: vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_3__bindgen_ty_1,
    pub dx: u16,
    pub edx: u32,
    pub rdx: u64,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_3__bindgen_ty_1 {
    pub dl: u8,
    pub dh: u8,
}
#[test]
fn bindgen_test_layout_vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_3__bindgen_ty_1() {
    const UNINIT: ::std::mem::MaybeUninit<
        vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_3__bindgen_ty_1,
    > = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_3__bindgen_ty_1>(
        ),
        2usize,
        concat!(
            "Size of: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_3__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_3__bindgen_ty_1>(
        ),
        1usize,
        concat!(
            "Alignment of ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_3__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dl) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_3__bindgen_ty_1),
            "::",
            stringify!(dl)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dh) as usize - ptr as usize },
        1usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_3__bindgen_ty_1),
            "::",
            stringify!(dh)
        )
    );
}
#[test]
fn bindgen_test_layout_vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_3() {
    const UNINIT: ::std::mem::MaybeUninit<vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_3> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_3>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_3)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_3>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_3)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dx) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_3),
            "::",
            stringify!(dx)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).edx) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_3),
            "::",
            stringify!(edx)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rdx) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_3),
            "::",
            stringify!(rdx)
        )
    );
}
impl Default for vcpu_state_t__bindgen_ty_1__bindgen_ty_1__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(Copy, Clone)]
pub union vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_4 {
    pub __bindgen_anon_1: vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_4__bindgen_ty_1,
    pub bx: u16,
    pub ebx: u32,
    pub rbx: u64,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_4__bindgen_ty_1 {
    pub bl: u8,
    pub bh: u8,
}
#[test]
fn bindgen_test_layout_vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_4__bindgen_ty_1() {
    const UNINIT: ::std::mem::MaybeUninit<
        vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_4__bindgen_ty_1,
    > = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_4__bindgen_ty_1>(
        ),
        2usize,
        concat!(
            "Size of: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_4__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_4__bindgen_ty_1>(
        ),
        1usize,
        concat!(
            "Alignment of ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_4__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bl) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_4__bindgen_ty_1),
            "::",
            stringify!(bl)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bh) as usize - ptr as usize },
        1usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_4__bindgen_ty_1),
            "::",
            stringify!(bh)
        )
    );
}
#[test]
fn bindgen_test_layout_vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_4() {
    const UNINIT: ::std::mem::MaybeUninit<vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_4> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_4>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_4)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_4>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_4)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bx) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_4),
            "::",
            stringify!(bx)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ebx) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_4),
            "::",
            stringify!(ebx)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rbx) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_4),
            "::",
            stringify!(rbx)
        )
    );
}
impl Default for vcpu_state_t__bindgen_ty_1__bindgen_ty_1__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()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_5 {
    pub sp: u16,
    pub esp: u32,
    pub rsp: u64,
}
#[test]
fn bindgen_test_layout_vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_5() {
    const UNINIT: ::std::mem::MaybeUninit<vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_5> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_5>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_5)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_5>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_5)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).sp) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_5),
            "::",
            stringify!(sp)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).esp) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_5),
            "::",
            stringify!(esp)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rsp) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_5),
            "::",
            stringify!(rsp)
        )
    );
}
impl Default for vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_5 {
    fn default() -> Self {
        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 vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_6 {
    pub bp: u16,
    pub ebp: u32,
    pub rbp: u64,
}
#[test]
fn bindgen_test_layout_vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_6() {
    const UNINIT: ::std::mem::MaybeUninit<vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_6> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_6>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_6)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_6>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_6)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bp) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_6),
            "::",
            stringify!(bp)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ebp) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_6),
            "::",
            stringify!(ebp)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rbp) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_6),
            "::",
            stringify!(rbp)
        )
    );
}
impl Default for vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_6 {
    fn default() -> Self {
        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 vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_7 {
    pub si: u16,
    pub esi: u32,
    pub rsi: u64,
}
#[test]
fn bindgen_test_layout_vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_7() {
    const UNINIT: ::std::mem::MaybeUninit<vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_7> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_7>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_7)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_7>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_7)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).si) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_7),
            "::",
            stringify!(si)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).esi) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_7),
            "::",
            stringify!(esi)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rsi) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_7),
            "::",
            stringify!(rsi)
        )
    );
}
impl Default for vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_7 {
    fn default() -> Self {
        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 vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_8 {
    pub di: u16,
    pub edi: u32,
    pub rdi: u64,
}
#[test]
fn bindgen_test_layout_vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_8() {
    const UNINIT: ::std::mem::MaybeUninit<vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_8> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_8>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_8)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_8>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_8)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).di) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_8),
            "::",
            stringify!(di)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).edi) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_8),
            "::",
            stringify!(edi)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rdi) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_8),
            "::",
            stringify!(rdi)
        )
    );
}
impl Default for vcpu_state_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_8 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[test]
fn bindgen_test_layout_vcpu_state_t__bindgen_ty_1__bindgen_ty_1() {
    const UNINIT: ::std::mem::MaybeUninit<vcpu_state_t__bindgen_ty_1__bindgen_ty_1> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<vcpu_state_t__bindgen_ty_1__bindgen_ty_1>(),
        128usize,
        concat!(
            "Size of: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<vcpu_state_t__bindgen_ty_1__bindgen_ty_1>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).r8) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(r8)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).r9) as usize - ptr as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(r9)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).r10) as usize - ptr as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(r10)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).r11) as usize - ptr as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(r11)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).r12) as usize - ptr as usize },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(r12)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).r13) as usize - ptr as usize },
        104usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(r13)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).r14) as usize - ptr as usize },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(r14)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).r15) as usize - ptr as usize },
        120usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(r15)
        )
    );
}
impl Default for vcpu_state_t__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()
        }
    }
}
#[test]
fn bindgen_test_layout_vcpu_state_t__bindgen_ty_1() {
    const UNINIT: ::std::mem::MaybeUninit<vcpu_state_t__bindgen_ty_1> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<vcpu_state_t__bindgen_ty_1>(),
        128usize,
        concat!("Size of: ", stringify!(vcpu_state_t__bindgen_ty_1))
    );
    assert_eq!(
        ::std::mem::align_of::<vcpu_state_t__bindgen_ty_1>(),
        8usize,
        concat!("Alignment of ", stringify!(vcpu_state_t__bindgen_ty_1))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).regs) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_1),
            "::",
            stringify!(regs)
        )
    );
}
impl Default for vcpu_state_t__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 vcpu_state_t__bindgen_ty_2 {
    pub eip: u32,
    pub rip: u64,
}
#[test]
fn bindgen_test_layout_vcpu_state_t__bindgen_ty_2() {
    const UNINIT: ::std::mem::MaybeUninit<vcpu_state_t__bindgen_ty_2> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<vcpu_state_t__bindgen_ty_2>(),
        8usize,
        concat!("Size of: ", stringify!(vcpu_state_t__bindgen_ty_2))
    );
    assert_eq!(
        ::std::mem::align_of::<vcpu_state_t__bindgen_ty_2>(),
        8usize,
        concat!("Alignment of ", stringify!(vcpu_state_t__bindgen_ty_2))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).eip) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_2),
            "::",
            stringify!(eip)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rip) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_2),
            "::",
            stringify!(rip)
        )
    );
}
impl Default for vcpu_state_t__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(Copy, Clone)]
pub union vcpu_state_t__bindgen_ty_3 {
    pub eflags: u32,
    pub rflags: u64,
}
#[test]
fn bindgen_test_layout_vcpu_state_t__bindgen_ty_3() {
    const UNINIT: ::std::mem::MaybeUninit<vcpu_state_t__bindgen_ty_3> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<vcpu_state_t__bindgen_ty_3>(),
        8usize,
        concat!("Size of: ", stringify!(vcpu_state_t__bindgen_ty_3))
    );
    assert_eq!(
        ::std::mem::align_of::<vcpu_state_t__bindgen_ty_3>(),
        8usize,
        concat!("Alignment of ", stringify!(vcpu_state_t__bindgen_ty_3))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).eflags) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_3),
            "::",
            stringify!(eflags)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rflags) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t__bindgen_ty_3),
            "::",
            stringify!(rflags)
        )
    );
}
impl Default for vcpu_state_t__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()
        }
    }
}
#[test]
fn bindgen_test_layout_vcpu_state_t() {
    const UNINIT: ::std::mem::MaybeUninit<vcpu_state_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<vcpu_state_t>(),
        512usize,
        concat!("Size of: ", stringify!(vcpu_state_t))
    );
    assert_eq!(
        ::std::mem::align_of::<vcpu_state_t>(),
        1usize,
        concat!("Alignment of ", stringify!(vcpu_state_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).cs) as usize - ptr as usize },
        144usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t),
            "::",
            stringify!(cs)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ss) as usize - ptr as usize },
        168usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t),
            "::",
            stringify!(ss)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ds) as usize - ptr as usize },
        192usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t),
            "::",
            stringify!(ds)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).es) as usize - ptr as usize },
        216usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t),
            "::",
            stringify!(es)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fs) as usize - ptr as usize },
        240usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t),
            "::",
            stringify!(fs)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).gs) as usize - ptr as usize },
        264usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t),
            "::",
            stringify!(gs)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ldt) as usize - ptr as usize },
        288usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t),
            "::",
            stringify!(ldt)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).tr) as usize - ptr as usize },
        312usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t),
            "::",
            stringify!(tr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).gdt) as usize - ptr as usize },
        336usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t),
            "::",
            stringify!(gdt)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).idt) as usize - ptr as usize },
        360usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t),
            "::",
            stringify!(idt)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).cr0) as usize - ptr as usize },
        384usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t),
            "::",
            stringify!(cr0)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).cr2) as usize - ptr as usize },
        392usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t),
            "::",
            stringify!(cr2)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).cr3) as usize - ptr as usize },
        400usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t),
            "::",
            stringify!(cr3)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).cr4) as usize - ptr as usize },
        408usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t),
            "::",
            stringify!(cr4)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dr0) as usize - ptr as usize },
        416usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t),
            "::",
            stringify!(dr0)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dr1) as usize - ptr as usize },
        424usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t),
            "::",
            stringify!(dr1)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dr2) as usize - ptr as usize },
        432usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t),
            "::",
            stringify!(dr2)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dr3) as usize - ptr as usize },
        440usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t),
            "::",
            stringify!(dr3)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dr6) as usize - ptr as usize },
        448usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t),
            "::",
            stringify!(dr6)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dr7) as usize - ptr as usize },
        456usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t),
            "::",
            stringify!(dr7)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pde) as usize - ptr as usize },
        464usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t),
            "::",
            stringify!(pde)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).efer) as usize - ptr as usize },
        472usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t),
            "::",
            stringify!(efer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).sysenter_cs) as usize - ptr as usize },
        476usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t),
            "::",
            stringify!(sysenter_cs)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).sysenter_eip) as usize - ptr as usize },
        480usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t),
            "::",
            stringify!(sysenter_eip)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).sysenter_esp) as usize - ptr as usize },
        488usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t),
            "::",
            stringify!(sysenter_esp)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).activity_state) as usize - ptr as usize },
        496usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t),
            "::",
            stringify!(activity_state)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pad) as usize - ptr as usize },
        500usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t),
            "::",
            stringify!(pad)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).interruptibility_state) as usize - ptr as usize },
        504usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_state_t),
            "::",
            stringify!(interruptibility_state)
        )
    );
}
impl Default for vcpu_state_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()
        }
    }
}
extern "C" {
    pub fn dump();
}
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct vmx_msr {
    pub entry: u64,
    pub value: u64,
}
#[test]
fn bindgen_test_layout_vmx_msr() {
    const UNINIT: ::std::mem::MaybeUninit<vmx_msr> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<vmx_msr>(),
        16usize,
        concat!("Size of: ", stringify!(vmx_msr))
    );
    assert_eq!(
        ::std::mem::align_of::<vmx_msr>(),
        1usize,
        concat!("Alignment of ", stringify!(vmx_msr))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).entry) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(vmx_msr),
            "::",
            stringify!(entry)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(vmx_msr),
            "::",
            stringify!(value)
        )
    );
}
#[repr(C)]
#[repr(align(16))]
#[derive(Copy, Clone)]
pub struct fx_layout {
    pub fcw: u16,
    pub fsw: u16,
    pub ftw: u8,
    pub res1: u8,
    pub fop: u16,
    pub __bindgen_anon_1: fx_layout__bindgen_ty_1,
    pub __bindgen_anon_2: fx_layout__bindgen_ty_2,
    pub mxcsr: u32,
    pub mxcsr_mask: u32,
    pub st_mm: [[u8; 16usize]; 8usize],
    pub mmx_1: [[u8; 16usize]; 8usize],
    pub mmx_2: [[u8; 16usize]; 8usize],
    pub pad: [u8; 96usize],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union fx_layout__bindgen_ty_1 {
    pub __bindgen_anon_1: fx_layout__bindgen_ty_1__bindgen_ty_1,
    pub fpu_ip: u64,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct fx_layout__bindgen_ty_1__bindgen_ty_1 {
    pub fip: u32,
    pub fcs: u16,
    pub res2: u16,
}
#[test]
fn bindgen_test_layout_fx_layout__bindgen_ty_1__bindgen_ty_1() {
    const UNINIT: ::std::mem::MaybeUninit<fx_layout__bindgen_ty_1__bindgen_ty_1> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<fx_layout__bindgen_ty_1__bindgen_ty_1>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(fx_layout__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<fx_layout__bindgen_ty_1__bindgen_ty_1>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(fx_layout__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fip) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(fx_layout__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(fip)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fcs) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(fx_layout__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(fcs)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).res2) as usize - ptr as usize },
        6usize,
        concat!(
            "Offset of field: ",
            stringify!(fx_layout__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(res2)
        )
    );
}
#[test]
fn bindgen_test_layout_fx_layout__bindgen_ty_1() {
    const UNINIT: ::std::mem::MaybeUninit<fx_layout__bindgen_ty_1> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<fx_layout__bindgen_ty_1>(),
        8usize,
        concat!("Size of: ", stringify!(fx_layout__bindgen_ty_1))
    );
    assert_eq!(
        ::std::mem::align_of::<fx_layout__bindgen_ty_1>(),
        8usize,
        concat!("Alignment of ", stringify!(fx_layout__bindgen_ty_1))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fpu_ip) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(fx_layout__bindgen_ty_1),
            "::",
            stringify!(fpu_ip)
        )
    );
}
impl Default for fx_layout__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 fx_layout__bindgen_ty_2 {
    pub __bindgen_anon_1: fx_layout__bindgen_ty_2__bindgen_ty_1,
    pub fpu_dp: u64,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct fx_layout__bindgen_ty_2__bindgen_ty_1 {
    pub fdp: u32,
    pub fds: u16,
    pub res3: u16,
}
#[test]
fn bindgen_test_layout_fx_layout__bindgen_ty_2__bindgen_ty_1() {
    const UNINIT: ::std::mem::MaybeUninit<fx_layout__bindgen_ty_2__bindgen_ty_1> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<fx_layout__bindgen_ty_2__bindgen_ty_1>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(fx_layout__bindgen_ty_2__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<fx_layout__bindgen_ty_2__bindgen_ty_1>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(fx_layout__bindgen_ty_2__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fdp) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(fx_layout__bindgen_ty_2__bindgen_ty_1),
            "::",
            stringify!(fdp)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fds) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(fx_layout__bindgen_ty_2__bindgen_ty_1),
            "::",
            stringify!(fds)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).res3) as usize - ptr as usize },
        6usize,
        concat!(
            "Offset of field: ",
            stringify!(fx_layout__bindgen_ty_2__bindgen_ty_1),
            "::",
            stringify!(res3)
        )
    );
}
#[test]
fn bindgen_test_layout_fx_layout__bindgen_ty_2() {
    const UNINIT: ::std::mem::MaybeUninit<fx_layout__bindgen_ty_2> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<fx_layout__bindgen_ty_2>(),
        8usize,
        concat!("Size of: ", stringify!(fx_layout__bindgen_ty_2))
    );
    assert_eq!(
        ::std::mem::align_of::<fx_layout__bindgen_ty_2>(),
        8usize,
        concat!("Alignment of ", stringify!(fx_layout__bindgen_ty_2))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fpu_dp) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(fx_layout__bindgen_ty_2),
            "::",
            stringify!(fpu_dp)
        )
    );
}
impl Default for fx_layout__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()
        }
    }
}
#[test]
fn bindgen_test_layout_fx_layout() {
    const UNINIT: ::std::mem::MaybeUninit<fx_layout> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<fx_layout>(),
        512usize,
        concat!("Size of: ", stringify!(fx_layout))
    );
    assert_eq!(
        ::std::mem::align_of::<fx_layout>(),
        16usize,
        concat!("Alignment of ", stringify!(fx_layout))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fcw) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(fx_layout),
            "::",
            stringify!(fcw)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fsw) as usize - ptr as usize },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(fx_layout),
            "::",
            stringify!(fsw)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ftw) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(fx_layout),
            "::",
            stringify!(ftw)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).res1) as usize - ptr as usize },
        5usize,
        concat!(
            "Offset of field: ",
            stringify!(fx_layout),
            "::",
            stringify!(res1)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fop) as usize - ptr as usize },
        6usize,
        concat!(
            "Offset of field: ",
            stringify!(fx_layout),
            "::",
            stringify!(fop)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mxcsr) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(fx_layout),
            "::",
            stringify!(mxcsr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mxcsr_mask) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(fx_layout),
            "::",
            stringify!(mxcsr_mask)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).st_mm) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(fx_layout),
            "::",
            stringify!(st_mm)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mmx_1) as usize - ptr as usize },
        160usize,
        concat!(
            "Offset of field: ",
            stringify!(fx_layout),
            "::",
            stringify!(mmx_1)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mmx_2) as usize - ptr as usize },
        288usize,
        concat!(
            "Offset of field: ",
            stringify!(fx_layout),
            "::",
            stringify!(mmx_2)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pad) as usize - ptr as usize },
        416usize,
        concat!(
            "Offset of field: ",
            stringify!(fx_layout),
            "::",
            stringify!(pad)
        )
    );
}
impl Default for fx_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, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct hax_msr_data {
    pub nr_msr: u16,
    pub done: u16,
    pub pad: [u16; 2usize],
    pub entries: [vmx_msr; 32usize],
}
#[test]
fn bindgen_test_layout_hax_msr_data() {
    const UNINIT: ::std::mem::MaybeUninit<hax_msr_data> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<hax_msr_data>(),
        520usize,
        concat!("Size of: ", stringify!(hax_msr_data))
    );
    assert_eq!(
        ::std::mem::align_of::<hax_msr_data>(),
        1usize,
        concat!("Alignment of ", stringify!(hax_msr_data))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nr_msr) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_msr_data),
            "::",
            stringify!(nr_msr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).done) as usize - ptr as usize },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_msr_data),
            "::",
            stringify!(done)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pad) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_msr_data),
            "::",
            stringify!(pad)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).entries) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_msr_data),
            "::",
            stringify!(entries)
        )
    );
}
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_UNKNOWN: vcpu_panic_reason = 0;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_VMCS_LOAD_FAILED_IN_VMX_EXECUTE:
    vcpu_panic_reason = 1;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_VMCS_LOAD_FAILED_IN_VMX_VMWRITE:
    vcpu_panic_reason = 2;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_VMCS_LOAD_FAILED_WHILE_VCPU_PREPARE:
    vcpu_panic_reason = 3;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_VMCS_LOAD_FAILED_IN_VCPU_PREPARE:
    vcpu_panic_reason = 4;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_VMCS_LOAD_FAILED_WHILE_VCPU_VMREAD_ALL:
    vcpu_panic_reason = 5;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_VMCS_LOAD_FAILED_WHILE_EXIT_CR_ACCESS:
    vcpu_panic_reason = 6;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_VMCS_LOAD_FAILED_WHILE_CLTS: vcpu_panic_reason =
    7;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_VMCS_LOAD_FAILED_WHILE_LMSW: vcpu_panic_reason =
    8;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_VMCS_LOAD_FAILED_ON_VCPU_SET_REGS:
    vcpu_panic_reason = 9;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_VMCS_LOAD_FAILED_IN_VMREAD: vcpu_panic_reason =
    10;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_VMCS_PUT_FAILED_WHILE_VCPU_VMREAD_ALL:
    vcpu_panic_reason = 11;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_VMCS_PUT_FAILED_IN_VMX_VMWRITE:
    vcpu_panic_reason = 12;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_VMCS_PUT_FAILED_WHILE_EXIT_CR_ACCESS:
    vcpu_panic_reason = 13;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_VMCS_PUT_FAILED_WHILE_CLTS: vcpu_panic_reason =
    14;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_VMCS_PUT_FAILED_WHILE_LMSW: vcpu_panic_reason =
    15;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_VMCS_PUT_FAILED_ON_VCPU_SET_REGS:
    vcpu_panic_reason = 16;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_VMCS_PUT_FAILED_IN_VMREAD: vcpu_panic_reason = 17;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_PUT_VMCS_FAILED: vcpu_panic_reason = 18;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_PUT_VMCS_FAILED_BEFORE_VMEXIT: vcpu_panic_reason =
    19;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_READ_GUEST_VIRTUAL_ERROR: vcpu_panic_reason = 20;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_READ_GUEST_VIRTUAL_ERROR_IN_STRING_IO:
    vcpu_panic_reason = 21;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_WRITE_GUEST_VIRTUAL_ERROR: vcpu_panic_reason = 22;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_WRITE_GUEST_VIRTUAL_FAILED: vcpu_panic_reason =
    23;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_IO_POST_UNEXPECTED_PAGE_FAULT: vcpu_panic_reason =
    24;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_MMIO_FETCH_INSTRUCTION_FAILED: vcpu_panic_reason =
    25;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_EM_DECODE_INS_FAILED: vcpu_panic_reason = 26;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_EM_EMULATE_INS_FAILED: vcpu_panic_reason = 27;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_EM_EMULATE_INS_FAILED_IN_VCPU_EXECUTE:
    vcpu_panic_reason = 28;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_VCPU_READ_GPR_INVALID_REGISTER_INDEX:
    vcpu_panic_reason = 29;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_VCPU_WRITE_GPR_INVALID_REGISTER_INDEX:
    vcpu_panic_reason = 30;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_TRIPLE_FAULT: vcpu_panic_reason = 31;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_INVALID_GUEST_STATE: vcpu_panic_reason = 32;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_PAGE_FAULT_WHILE_EPT_IS_ENABLED:
    vcpu_panic_reason = 33;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_MACHINE_CHECK: vcpu_panic_reason = 34;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_DOUBLE_FAULT: vcpu_panic_reason = 35;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_FAILED_TO_RELOAD_PDPT_FOR_EPT_PAE_MODE:
    vcpu_panic_reason = 36;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_64_BIT_GUEST_NOT_ALLOWED_ON_32_BIT_HOST:
    vcpu_panic_reason = 37;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_UNEXPECTED_EPT_MISCONFIGURATION:
    vcpu_panic_reason = 38;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_INCORRECT_EPT_SETTING: vcpu_panic_reason = 39;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_EPT_HANDLE_ACCESS_VIOLATION_RETURNED_ERROR:
    vcpu_panic_reason = 40;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_UNHANDLED_VMX_VMEXIT_REASON: vcpu_panic_reason =
    41;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_AMD_UNIMPLEMENTED: vcpu_panic_reason = 42;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_RVI_HANDLE_ACCESS_VIOLATION_RETURNED_EEXIST:
    vcpu_panic_reason = 43;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_ATTEMPTED_TO_USE_UNSET_NRIP: vcpu_panic_reason =
    44;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_ATTEMPTED_TO_USE_UNSET_EXIT_GPA:
    vcpu_panic_reason = 45;
pub const vcpu_panic_reason_HAX_VCPU_PANIC_REASON_ILLEGAL_GUEST_WRITE_TO_IA32_EFER_SVME:
    vcpu_panic_reason = 46;
pub type vcpu_panic_reason = ::std::os::raw::c_int;
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct hax_tunnel {
    pub exit_reason: u32,
    pub pad0: u32,
    pub exit_status: u32,
    pub user_event_pending: u32,
    pub ready_for_interrupt_injection: ::std::os::raw::c_int,
    pub request_interrupt_window: ::std::os::raw::c_int,
    pub __bindgen_anon_1: hax_tunnel__bindgen_ty_1,
    pub apic_base: u64,
    pub vcpu_panic_reason: u32,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union hax_tunnel__bindgen_ty_1 {
    pub io: hax_tunnel__bindgen_ty_1__bindgen_ty_1,
    pub mmio: hax_tunnel__bindgen_ty_1__bindgen_ty_2,
    pub pagefault: hax_tunnel__bindgen_ty_1__bindgen_ty_3,
    pub debug: hax_tunnel__bindgen_ty_1__bindgen_ty_4,
    pub eoi: hax_tunnel__bindgen_ty_1__bindgen_ty_5,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct hax_tunnel__bindgen_ty_1__bindgen_ty_1 {
    pub direction: u8,
    pub df: u8,
    pub size: u16,
    pub port: u16,
    pub count: u16,
    pub flags: u8,
    pub pad0: u8,
    pub pad1: u16,
    pub pad2: u32,
    pub vaddr: hax_vaddr_t,
}
#[test]
fn bindgen_test_layout_hax_tunnel__bindgen_ty_1__bindgen_ty_1() {
    const UNINIT: ::std::mem::MaybeUninit<hax_tunnel__bindgen_ty_1__bindgen_ty_1> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<hax_tunnel__bindgen_ty_1__bindgen_ty_1>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(hax_tunnel__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<hax_tunnel__bindgen_ty_1__bindgen_ty_1>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(hax_tunnel__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).direction) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_tunnel__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(direction)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).df) as usize - ptr as usize },
        1usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_tunnel__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(df)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_tunnel__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).port) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_tunnel__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(port)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).count) as usize - ptr as usize },
        6usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_tunnel__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(count)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_tunnel__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(flags)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pad0) as usize - ptr as usize },
        9usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_tunnel__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(pad0)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pad1) as usize - ptr as usize },
        10usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_tunnel__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(pad1)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pad2) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_tunnel__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(pad2)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).vaddr) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_tunnel__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(vaddr)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct hax_tunnel__bindgen_ty_1__bindgen_ty_2 {
    pub gla: hax_paddr_t,
}
#[test]
fn bindgen_test_layout_hax_tunnel__bindgen_ty_1__bindgen_ty_2() {
    const UNINIT: ::std::mem::MaybeUninit<hax_tunnel__bindgen_ty_1__bindgen_ty_2> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<hax_tunnel__bindgen_ty_1__bindgen_ty_2>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(hax_tunnel__bindgen_ty_1__bindgen_ty_2)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<hax_tunnel__bindgen_ty_1__bindgen_ty_2>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(hax_tunnel__bindgen_ty_1__bindgen_ty_2)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).gla) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_tunnel__bindgen_ty_1__bindgen_ty_2),
            "::",
            stringify!(gla)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct hax_tunnel__bindgen_ty_1__bindgen_ty_3 {
    pub gpa: hax_paddr_t,
    pub flags: u32,
    pub reserved1: u32,
    pub reserved2: u64,
}
#[test]
fn bindgen_test_layout_hax_tunnel__bindgen_ty_1__bindgen_ty_3() {
    const UNINIT: ::std::mem::MaybeUninit<hax_tunnel__bindgen_ty_1__bindgen_ty_3> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<hax_tunnel__bindgen_ty_1__bindgen_ty_3>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(hax_tunnel__bindgen_ty_1__bindgen_ty_3)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<hax_tunnel__bindgen_ty_1__bindgen_ty_3>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(hax_tunnel__bindgen_ty_1__bindgen_ty_3)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).gpa) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_tunnel__bindgen_ty_1__bindgen_ty_3),
            "::",
            stringify!(gpa)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_tunnel__bindgen_ty_1__bindgen_ty_3),
            "::",
            stringify!(flags)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_tunnel__bindgen_ty_1__bindgen_ty_3),
            "::",
            stringify!(reserved1)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_tunnel__bindgen_ty_1__bindgen_ty_3),
            "::",
            stringify!(reserved2)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct hax_tunnel__bindgen_ty_1__bindgen_ty_4 {
    pub rip: u64,
    pub dr6: u64,
    pub dr7: u64,
}
#[test]
fn bindgen_test_layout_hax_tunnel__bindgen_ty_1__bindgen_ty_4() {
    const UNINIT: ::std::mem::MaybeUninit<hax_tunnel__bindgen_ty_1__bindgen_ty_4> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<hax_tunnel__bindgen_ty_1__bindgen_ty_4>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(hax_tunnel__bindgen_ty_1__bindgen_ty_4)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<hax_tunnel__bindgen_ty_1__bindgen_ty_4>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(hax_tunnel__bindgen_ty_1__bindgen_ty_4)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rip) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_tunnel__bindgen_ty_1__bindgen_ty_4),
            "::",
            stringify!(rip)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dr6) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_tunnel__bindgen_ty_1__bindgen_ty_4),
            "::",
            stringify!(dr6)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dr7) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_tunnel__bindgen_ty_1__bindgen_ty_4),
            "::",
            stringify!(dr7)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct hax_tunnel__bindgen_ty_1__bindgen_ty_5 {
    pub vector: u8,
}
#[test]
fn bindgen_test_layout_hax_tunnel__bindgen_ty_1__bindgen_ty_5() {
    const UNINIT: ::std::mem::MaybeUninit<hax_tunnel__bindgen_ty_1__bindgen_ty_5> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<hax_tunnel__bindgen_ty_1__bindgen_ty_5>(),
        1usize,
        concat!(
            "Size of: ",
            stringify!(hax_tunnel__bindgen_ty_1__bindgen_ty_5)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<hax_tunnel__bindgen_ty_1__bindgen_ty_5>(),
        1usize,
        concat!(
            "Alignment of ",
            stringify!(hax_tunnel__bindgen_ty_1__bindgen_ty_5)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).vector) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_tunnel__bindgen_ty_1__bindgen_ty_5),
            "::",
            stringify!(vector)
        )
    );
}
#[test]
fn bindgen_test_layout_hax_tunnel__bindgen_ty_1() {
    const UNINIT: ::std::mem::MaybeUninit<hax_tunnel__bindgen_ty_1> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<hax_tunnel__bindgen_ty_1>(),
        24usize,
        concat!("Size of: ", stringify!(hax_tunnel__bindgen_ty_1))
    );
    assert_eq!(
        ::std::mem::align_of::<hax_tunnel__bindgen_ty_1>(),
        8usize,
        concat!("Alignment of ", stringify!(hax_tunnel__bindgen_ty_1))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).io) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_tunnel__bindgen_ty_1),
            "::",
            stringify!(io)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mmio) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_tunnel__bindgen_ty_1),
            "::",
            stringify!(mmio)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pagefault) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_tunnel__bindgen_ty_1),
            "::",
            stringify!(pagefault)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).debug) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_tunnel__bindgen_ty_1),
            "::",
            stringify!(debug)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).eoi) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_tunnel__bindgen_ty_1),
            "::",
            stringify!(eoi)
        )
    );
}
impl Default for hax_tunnel__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()
        }
    }
}
#[test]
fn bindgen_test_layout_hax_tunnel() {
    const UNINIT: ::std::mem::MaybeUninit<hax_tunnel> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<hax_tunnel>(),
        60usize,
        concat!("Size of: ", stringify!(hax_tunnel))
    );
    assert_eq!(
        ::std::mem::align_of::<hax_tunnel>(),
        1usize,
        concat!("Alignment of ", stringify!(hax_tunnel))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).exit_reason) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_tunnel),
            "::",
            stringify!(exit_reason)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pad0) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_tunnel),
            "::",
            stringify!(pad0)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).exit_status) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_tunnel),
            "::",
            stringify!(exit_status)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).user_event_pending) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_tunnel),
            "::",
            stringify!(user_event_pending)
        )
    );
    assert_eq!(
        unsafe {
            ::std::ptr::addr_of!((*ptr).ready_for_interrupt_injection) as usize - ptr as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_tunnel),
            "::",
            stringify!(ready_for_interrupt_injection)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).request_interrupt_window) as usize - ptr as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_tunnel),
            "::",
            stringify!(request_interrupt_window)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).apic_base) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_tunnel),
            "::",
            stringify!(apic_base)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).vcpu_panic_reason) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_tunnel),
            "::",
            stringify!(vcpu_panic_reason)
        )
    );
}
impl Default for hax_tunnel {
    fn default() -> Self {
        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)]
#[derive(Copy, Clone)]
pub struct hax_fastmmio {
    pub gpa: hax_paddr_t,
    pub __bindgen_anon_1: hax_fastmmio__bindgen_ty_1,
    pub size: u8,
    pub direction: u8,
    pub reg_index: u16,
    pub pad0: u32,
    pub cr0: u64,
    pub cr2: u64,
    pub cr3: u64,
    pub cr4: u64,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union hax_fastmmio__bindgen_ty_1 {
    pub value: u64,
    pub gpa2: hax_paddr_t,
}
#[test]
fn bindgen_test_layout_hax_fastmmio__bindgen_ty_1() {
    const UNINIT: ::std::mem::MaybeUninit<hax_fastmmio__bindgen_ty_1> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<hax_fastmmio__bindgen_ty_1>(),
        8usize,
        concat!("Size of: ", stringify!(hax_fastmmio__bindgen_ty_1))
    );
    assert_eq!(
        ::std::mem::align_of::<hax_fastmmio__bindgen_ty_1>(),
        8usize,
        concat!("Alignment of ", stringify!(hax_fastmmio__bindgen_ty_1))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_fastmmio__bindgen_ty_1),
            "::",
            stringify!(value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).gpa2) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_fastmmio__bindgen_ty_1),
            "::",
            stringify!(gpa2)
        )
    );
}
impl Default for hax_fastmmio__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()
        }
    }
}
#[test]
fn bindgen_test_layout_hax_fastmmio() {
    const UNINIT: ::std::mem::MaybeUninit<hax_fastmmio> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<hax_fastmmio>(),
        56usize,
        concat!("Size of: ", stringify!(hax_fastmmio))
    );
    assert_eq!(
        ::std::mem::align_of::<hax_fastmmio>(),
        1usize,
        concat!("Alignment of ", stringify!(hax_fastmmio))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).gpa) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_fastmmio),
            "::",
            stringify!(gpa)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_fastmmio),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).direction) as usize - ptr as usize },
        17usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_fastmmio),
            "::",
            stringify!(direction)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).reg_index) as usize - ptr as usize },
        18usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_fastmmio),
            "::",
            stringify!(reg_index)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pad0) as usize - ptr as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_fastmmio),
            "::",
            stringify!(pad0)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).cr0) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_fastmmio),
            "::",
            stringify!(cr0)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).cr2) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_fastmmio),
            "::",
            stringify!(cr2)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).cr3) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_fastmmio),
            "::",
            stringify!(cr3)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).cr4) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_fastmmio),
            "::",
            stringify!(cr4)
        )
    );
}
impl Default for hax_fastmmio {
    fn default() -> Self {
        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)]
#[derive(Debug, Default, Copy, Clone)]
pub struct hax_module_version {
    pub compat_version: u32,
    pub cur_version: u32,
}
#[test]
fn bindgen_test_layout_hax_module_version() {
    const UNINIT: ::std::mem::MaybeUninit<hax_module_version> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<hax_module_version>(),
        8usize,
        concat!("Size of: ", stringify!(hax_module_version))
    );
    assert_eq!(
        ::std::mem::align_of::<hax_module_version>(),
        1usize,
        concat!("Alignment of ", stringify!(hax_module_version))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).compat_version) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_module_version),
            "::",
            stringify!(compat_version)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).cur_version) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_module_version),
            "::",
            stringify!(cur_version)
        )
    );
}
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct hax_capabilityinfo {
    pub wstatus: u16,
    pub winfo: u16,
    pub win_refcount: u32,
    pub mem_quota: u64,
}
#[test]
fn bindgen_test_layout_hax_capabilityinfo() {
    const UNINIT: ::std::mem::MaybeUninit<hax_capabilityinfo> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<hax_capabilityinfo>(),
        16usize,
        concat!("Size of: ", stringify!(hax_capabilityinfo))
    );
    assert_eq!(
        ::std::mem::align_of::<hax_capabilityinfo>(),
        1usize,
        concat!("Alignment of ", stringify!(hax_capabilityinfo))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).wstatus) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_capabilityinfo),
            "::",
            stringify!(wstatus)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).winfo) as usize - ptr as usize },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_capabilityinfo),
            "::",
            stringify!(winfo)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).win_refcount) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_capabilityinfo),
            "::",
            stringify!(win_refcount)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mem_quota) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_capabilityinfo),
            "::",
            stringify!(mem_quota)
        )
    );
}
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct hax_tunnel_info {
    pub va: u64,
    pub io_va: u64,
    pub size: u16,
    pub pad: [u16; 3usize],
}
#[test]
fn bindgen_test_layout_hax_tunnel_info() {
    const UNINIT: ::std::mem::MaybeUninit<hax_tunnel_info> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<hax_tunnel_info>(),
        24usize,
        concat!("Size of: ", stringify!(hax_tunnel_info))
    );
    assert_eq!(
        ::std::mem::align_of::<hax_tunnel_info>(),
        1usize,
        concat!("Alignment of ", stringify!(hax_tunnel_info))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).va) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_tunnel_info),
            "::",
            stringify!(va)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).io_va) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_tunnel_info),
            "::",
            stringify!(io_va)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_tunnel_info),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pad) as usize - ptr as usize },
        18usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_tunnel_info),
            "::",
            stringify!(pad)
        )
    );
}
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct hax_set_memlimit {
    pub enable_memlimit: u8,
    pub pad: [u8; 7usize],
    pub memory_limit: u64,
}
#[test]
fn bindgen_test_layout_hax_set_memlimit() {
    const UNINIT: ::std::mem::MaybeUninit<hax_set_memlimit> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<hax_set_memlimit>(),
        16usize,
        concat!("Size of: ", stringify!(hax_set_memlimit))
    );
    assert_eq!(
        ::std::mem::align_of::<hax_set_memlimit>(),
        1usize,
        concat!("Alignment of ", stringify!(hax_set_memlimit))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).enable_memlimit) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_set_memlimit),
            "::",
            stringify!(enable_memlimit)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pad) as usize - ptr as usize },
        1usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_set_memlimit),
            "::",
            stringify!(pad)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).memory_limit) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_set_memlimit),
            "::",
            stringify!(memory_limit)
        )
    );
}
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct hax_alloc_ram_info {
    pub size: u32,
    pub pad: u32,
    pub va: u64,
}
#[test]
fn bindgen_test_layout_hax_alloc_ram_info() {
    const UNINIT: ::std::mem::MaybeUninit<hax_alloc_ram_info> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<hax_alloc_ram_info>(),
        16usize,
        concat!("Size of: ", stringify!(hax_alloc_ram_info))
    );
    assert_eq!(
        ::std::mem::align_of::<hax_alloc_ram_info>(),
        1usize,
        concat!("Alignment of ", stringify!(hax_alloc_ram_info))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_alloc_ram_info),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pad) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_alloc_ram_info),
            "::",
            stringify!(pad)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).va) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_alloc_ram_info),
            "::",
            stringify!(va)
        )
    );
}
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct hax_ramblock_info {
    pub start_va: u64,
    pub size: u64,
    pub reserved: u64,
}
#[test]
fn bindgen_test_layout_hax_ramblock_info() {
    const UNINIT: ::std::mem::MaybeUninit<hax_ramblock_info> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<hax_ramblock_info>(),
        24usize,
        concat!("Size of: ", stringify!(hax_ramblock_info))
    );
    assert_eq!(
        ::std::mem::align_of::<hax_ramblock_info>(),
        1usize,
        concat!("Alignment of ", stringify!(hax_ramblock_info))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).start_va) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_ramblock_info),
            "::",
            stringify!(start_va)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_ramblock_info),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_ramblock_info),
            "::",
            stringify!(reserved)
        )
    );
}
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct hax_set_ram_info {
    pub pa_start: u64,
    pub size: u32,
    pub flags: u8,
    pub pad: [u8; 3usize],
    pub va: u64,
}
#[test]
fn bindgen_test_layout_hax_set_ram_info() {
    const UNINIT: ::std::mem::MaybeUninit<hax_set_ram_info> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<hax_set_ram_info>(),
        24usize,
        concat!("Size of: ", stringify!(hax_set_ram_info))
    );
    assert_eq!(
        ::std::mem::align_of::<hax_set_ram_info>(),
        1usize,
        concat!("Alignment of ", stringify!(hax_set_ram_info))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pa_start) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_set_ram_info),
            "::",
            stringify!(pa_start)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_set_ram_info),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_set_ram_info),
            "::",
            stringify!(flags)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pad) as usize - ptr as usize },
        13usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_set_ram_info),
            "::",
            stringify!(pad)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).va) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_set_ram_info),
            "::",
            stringify!(va)
        )
    );
}
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct hax_set_ram_info2 {
    pub pa_start: u64,
    pub size: u64,
    pub va: u64,
    pub flags: u32,
    pub reserved1: u32,
    pub reserved2: u64,
}
#[test]
fn bindgen_test_layout_hax_set_ram_info2() {
    const UNINIT: ::std::mem::MaybeUninit<hax_set_ram_info2> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<hax_set_ram_info2>(),
        40usize,
        concat!("Size of: ", stringify!(hax_set_ram_info2))
    );
    assert_eq!(
        ::std::mem::align_of::<hax_set_ram_info2>(),
        1usize,
        concat!("Alignment of ", stringify!(hax_set_ram_info2))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pa_start) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_set_ram_info2),
            "::",
            stringify!(pa_start)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_set_ram_info2),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).va) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_set_ram_info2),
            "::",
            stringify!(va)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_set_ram_info2),
            "::",
            stringify!(flags)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_set_ram_info2),
            "::",
            stringify!(reserved1)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_set_ram_info2),
            "::",
            stringify!(reserved2)
        )
    );
}
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct hax_protect_ram_info {
    pub pa_start: u64,
    pub size: u64,
    pub flags: u32,
    pub reserved: u32,
}
#[test]
fn bindgen_test_layout_hax_protect_ram_info() {
    const UNINIT: ::std::mem::MaybeUninit<hax_protect_ram_info> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<hax_protect_ram_info>(),
        24usize,
        concat!("Size of: ", stringify!(hax_protect_ram_info))
    );
    assert_eq!(
        ::std::mem::align_of::<hax_protect_ram_info>(),
        1usize,
        concat!("Alignment of ", stringify!(hax_protect_ram_info))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pa_start) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_protect_ram_info),
            "::",
            stringify!(pa_start)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_protect_ram_info),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_protect_ram_info),
            "::",
            stringify!(flags)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_protect_ram_info),
            "::",
            stringify!(reserved)
        )
    );
}
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct hax_qemu_version {
    pub cur_version: u32,
    pub least_version: u32,
}
#[test]
fn bindgen_test_layout_hax_qemu_version() {
    const UNINIT: ::std::mem::MaybeUninit<hax_qemu_version> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<hax_qemu_version>(),
        8usize,
        concat!("Size of: ", stringify!(hax_qemu_version))
    );
    assert_eq!(
        ::std::mem::align_of::<hax_qemu_version>(),
        1usize,
        concat!("Alignment of ", stringify!(hax_qemu_version))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).cur_version) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_qemu_version),
            "::",
            stringify!(cur_version)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).least_version) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_qemu_version),
            "::",
            stringify!(least_version)
        )
    );
}
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct hax_debug_t {
    pub control: u32,
    pub reserved: u32,
    pub dr: [u64; 8usize],
}
#[test]
fn bindgen_test_layout_hax_debug_t() {
    const UNINIT: ::std::mem::MaybeUninit<hax_debug_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<hax_debug_t>(),
        72usize,
        concat!("Size of: ", stringify!(hax_debug_t))
    );
    assert_eq!(
        ::std::mem::align_of::<hax_debug_t>(),
        1usize,
        concat!("Alignment of ", stringify!(hax_debug_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).control) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_debug_t),
            "::",
            stringify!(control)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_debug_t),
            "::",
            stringify!(reserved)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dr) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_debug_t),
            "::",
            stringify!(dr)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct hax_cpuid_entry {
    pub function: u32,
    pub index: u32,
    pub flags: u32,
    pub eax: u32,
    pub ebx: u32,
    pub ecx: u32,
    pub edx: u32,
    pub pad: [u32; 3usize],
}
#[test]
fn bindgen_test_layout_hax_cpuid_entry() {
    const UNINIT: ::std::mem::MaybeUninit<hax_cpuid_entry> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<hax_cpuid_entry>(),
        40usize,
        concat!("Size of: ", stringify!(hax_cpuid_entry))
    );
    assert_eq!(
        ::std::mem::align_of::<hax_cpuid_entry>(),
        4usize,
        concat!("Alignment of ", stringify!(hax_cpuid_entry))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).function) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_cpuid_entry),
            "::",
            stringify!(function)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).index) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_cpuid_entry),
            "::",
            stringify!(index)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_cpuid_entry),
            "::",
            stringify!(flags)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).eax) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_cpuid_entry),
            "::",
            stringify!(eax)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ebx) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_cpuid_entry),
            "::",
            stringify!(ebx)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ecx) as usize - ptr as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_cpuid_entry),
            "::",
            stringify!(ecx)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).edx) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_cpuid_entry),
            "::",
            stringify!(edx)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pad) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_cpuid_entry),
            "::",
            stringify!(pad)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct hax_cpuid {
    pub total: u32,
    pub pad: u32,
    pub entries: __IncompleteArrayField<hax_cpuid_entry>,
}
#[test]
fn bindgen_test_layout_hax_cpuid() {
    const UNINIT: ::std::mem::MaybeUninit<hax_cpuid> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<hax_cpuid>(),
        8usize,
        concat!("Size of: ", stringify!(hax_cpuid))
    );
    assert_eq!(
        ::std::mem::align_of::<hax_cpuid>(),
        4usize,
        concat!("Alignment of ", stringify!(hax_cpuid))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).total) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_cpuid),
            "::",
            stringify!(total)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pad) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_cpuid),
            "::",
            stringify!(pad)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).entries) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_cpuid),
            "::",
            stringify!(entries)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct hax_log_file {
    pub path: [wchar_t; 2048usize],
}
#[test]
fn bindgen_test_layout_hax_log_file() {
    const UNINIT: ::std::mem::MaybeUninit<hax_log_file> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<hax_log_file>(),
        4096usize,
        concat!("Size of: ", stringify!(hax_log_file))
    );
    assert_eq!(
        ::std::mem::align_of::<hax_log_file>(),
        2usize,
        concat!("Alignment of ", stringify!(hax_log_file))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).path) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_log_file),
            "::",
            stringify!(path)
        )
    );
}
impl Default for hax_log_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, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct hax_create_device_info {
    pub type_: u32,
    pub flags: u32,
    pub size: u32,
}
#[test]
fn bindgen_test_layout_hax_create_device_info() {
    const UNINIT: ::std::mem::MaybeUninit<hax_create_device_info> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<hax_create_device_info>(),
        12usize,
        concat!("Size of: ", stringify!(hax_create_device_info))
    );
    assert_eq!(
        ::std::mem::align_of::<hax_create_device_info>(),
        1usize,
        concat!("Alignment of ", stringify!(hax_create_device_info))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_create_device_info),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_create_device_info),
            "::",
            stringify!(flags)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_create_device_info),
            "::",
            stringify!(size)
        )
    );
}
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct hax_msi {
    pub vector: u8,
    pub dest_id: u8,
    pub dest_mode: u8,
    pub trigger_mode: u8,
    pub delivery_mode: u8,
    pub level: u8,
}
#[test]
fn bindgen_test_layout_hax_msi() {
    const UNINIT: ::std::mem::MaybeUninit<hax_msi> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<hax_msi>(),
        6usize,
        concat!("Size of: ", stringify!(hax_msi))
    );
    assert_eq!(
        ::std::mem::align_of::<hax_msi>(),
        1usize,
        concat!("Alignment of ", stringify!(hax_msi))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).vector) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_msi),
            "::",
            stringify!(vector)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dest_id) as usize - ptr as usize },
        1usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_msi),
            "::",
            stringify!(dest_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dest_mode) as usize - ptr as usize },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_msi),
            "::",
            stringify!(dest_mode)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).trigger_mode) as usize - ptr as usize },
        3usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_msi),
            "::",
            stringify!(trigger_mode)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).delivery_mode) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_msi),
            "::",
            stringify!(delivery_mode)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).level) as usize - ptr as usize },
        5usize,
        concat!(
            "Offset of field: ",
            stringify!(hax_msi),
            "::",
            stringify!(level)
        )
    );
}