xen-sys 0.0.0-pre2

/* automatically generated by rust-bindgen 0.59.1 */

pub const true_: u32 = 1;
pub const false_: u32 = 0;
pub const __bool_true_false_are_defined: u32 = 1;
pub const INVALID_PADDR: i32 = -1;
pub const PRIpaddr: &'static [u8; 6usize] = b"016lx\0";
pub const PRIregister: &'static [u8; 6usize] = b"016lx\0";
pub const INT8_MIN: i32 = -128;
pub const INT16_MIN: i32 = -32768;
pub const INT32_MIN: i32 = -2147483648;
pub const INT8_MAX: u32 = 127;
pub const INT16_MAX: u32 = 32767;
pub const INT32_MAX: u32 = 2147483647;
pub const UINT8_MAX: u32 = 255;
pub const UINT16_MAX: u32 = 65535;
pub const UINT32_MAX: u32 = 4294967295;
pub const UINT_MAX: i32 = -1;
pub const ULONG_MAX: i32 = -1;
pub const __XEN_LATEST_INTERFACE_VERSION__: u32 = 265728;
pub const __XEN_INTERFACE_VERSION__: u32 = 0;
pub const XEN_HYPERCALL_TAG: u32 = 3745;
pub const XEN_LEGACY_MAX_VCPUS: u32 = 1;
pub const __HYPERVISOR_set_trap_table: u32 = 0;
pub const __HYPERVISOR_mmu_update: u32 = 1;
pub const __HYPERVISOR_set_gdt: u32 = 2;
pub const __HYPERVISOR_stack_switch: u32 = 3;
pub const __HYPERVISOR_set_callbacks: u32 = 4;
pub const __HYPERVISOR_fpu_taskswitch: u32 = 5;
pub const __HYPERVISOR_sched_op_compat: u32 = 6;
pub const __HYPERVISOR_platform_op: u32 = 7;
pub const __HYPERVISOR_set_debugreg: u32 = 8;
pub const __HYPERVISOR_get_debugreg: u32 = 9;
pub const __HYPERVISOR_update_descriptor: u32 = 10;
pub const __HYPERVISOR_memory_op: u32 = 12;
pub const __HYPERVISOR_multicall: u32 = 13;
pub const __HYPERVISOR_update_va_mapping: u32 = 14;
pub const __HYPERVISOR_set_timer_op: u32 = 15;
pub const __HYPERVISOR_event_channel_op_compat: u32 = 16;
pub const __HYPERVISOR_xen_version: u32 = 17;
pub const __HYPERVISOR_console_io: u32 = 18;
pub const __HYPERVISOR_physdev_op_compat: u32 = 19;
pub const __HYPERVISOR_grant_table_op: u32 = 20;
pub const __HYPERVISOR_vm_assist: u32 = 21;
pub const __HYPERVISOR_update_va_mapping_otherdomain: u32 = 22;
pub const __HYPERVISOR_iret: u32 = 23;
pub const __HYPERVISOR_vcpu_op: u32 = 24;
pub const __HYPERVISOR_set_segment_base: u32 = 25;
pub const __HYPERVISOR_mmuext_op: u32 = 26;
pub const __HYPERVISOR_xsm_op: u32 = 27;
pub const __HYPERVISOR_nmi_op: u32 = 28;
pub const __HYPERVISOR_sched_op: u32 = 29;
pub const __HYPERVISOR_callback_op: u32 = 30;
pub const __HYPERVISOR_xenoprof_op: u32 = 31;
pub const __HYPERVISOR_event_channel_op: u32 = 32;
pub const __HYPERVISOR_physdev_op: u32 = 33;
pub const __HYPERVISOR_hvm_op: u32 = 34;
pub const __HYPERVISOR_sysctl: u32 = 35;
pub const __HYPERVISOR_domctl: u32 = 36;
pub const __HYPERVISOR_kexec_op: u32 = 37;
pub const __HYPERVISOR_tmem_op: u32 = 38;
pub const __HYPERVISOR_argo_op: u32 = 39;
pub const __HYPERVISOR_xenpmu_op: u32 = 40;
pub const __HYPERVISOR_dm_op: u32 = 41;
pub const __HYPERVISOR_hypfs_op: u32 = 42;
pub const __HYPERVISOR_arch_0: u32 = 48;
pub const __HYPERVISOR_arch_1: u32 = 49;
pub const __HYPERVISOR_arch_2: u32 = 50;
pub const __HYPERVISOR_arch_3: u32 = 51;
pub const __HYPERVISOR_arch_4: u32 = 52;
pub const __HYPERVISOR_arch_5: u32 = 53;
pub const __HYPERVISOR_arch_6: u32 = 54;
pub const __HYPERVISOR_arch_7: u32 = 55;
pub const __HYPERVISOR_dom0_op: u32 = 7;
pub const VIRQ_TIMER: u32 = 0;
pub const VIRQ_DEBUG: u32 = 1;
pub const VIRQ_CONSOLE: u32 = 2;
pub const VIRQ_DOM_EXC: u32 = 3;
pub const VIRQ_TBUF: u32 = 4;
pub const VIRQ_DEBUGGER: u32 = 6;
pub const VIRQ_XENOPROF: u32 = 7;
pub const VIRQ_CON_RING: u32 = 8;
pub const VIRQ_PCPU_STATE: u32 = 9;
pub const VIRQ_MEM_EVENT: u32 = 10;
pub const VIRQ_ARGO: u32 = 11;
pub const VIRQ_ENOMEM: u32 = 12;
pub const VIRQ_XENPMU: u32 = 13;
pub const VIRQ_ARCH_0: u32 = 16;
pub const VIRQ_ARCH_1: u32 = 17;
pub const VIRQ_ARCH_2: u32 = 18;
pub const VIRQ_ARCH_3: u32 = 19;
pub const VIRQ_ARCH_4: u32 = 20;
pub const VIRQ_ARCH_5: u32 = 21;
pub const VIRQ_ARCH_6: u32 = 22;
pub const VIRQ_ARCH_7: u32 = 23;
pub const NR_VIRQS: u32 = 24;
pub const MMU_NORMAL_PT_UPDATE: u32 = 0;
pub const MMU_MACHPHYS_UPDATE: u32 = 1;
pub const MMU_PT_UPDATE_PRESERVE_AD: u32 = 2;
pub const MMU_PT_UPDATE_NO_TRANSLATE: u32 = 3;
pub const MMUEXT_PIN_L1_TABLE: u32 = 0;
pub const MMUEXT_PIN_L2_TABLE: u32 = 1;
pub const MMUEXT_PIN_L3_TABLE: u32 = 2;
pub const MMUEXT_PIN_L4_TABLE: u32 = 3;
pub const MMUEXT_UNPIN_TABLE: u32 = 4;
pub const MMUEXT_NEW_BASEPTR: u32 = 5;
pub const MMUEXT_TLB_FLUSH_LOCAL: u32 = 6;
pub const MMUEXT_INVLPG_LOCAL: u32 = 7;
pub const MMUEXT_TLB_FLUSH_MULTI: u32 = 8;
pub const MMUEXT_INVLPG_MULTI: u32 = 9;
pub const MMUEXT_TLB_FLUSH_ALL: u32 = 10;
pub const MMUEXT_INVLPG_ALL: u32 = 11;
pub const MMUEXT_FLUSH_CACHE: u32 = 12;
pub const MMUEXT_SET_LDT: u32 = 13;
pub const MMUEXT_NEW_USER_BASEPTR: u32 = 15;
pub const MMUEXT_CLEAR_PAGE: u32 = 16;
pub const MMUEXT_COPY_PAGE: u32 = 17;
pub const MMUEXT_FLUSH_CACHE_GLOBAL: u32 = 18;
pub const MMUEXT_MARK_SUPER: u32 = 19;
pub const MMUEXT_UNMARK_SUPER: u32 = 20;
pub const CONSOLEIO_write: u32 = 0;
pub const CONSOLEIO_read: u32 = 1;
pub const VMASST_CMD_enable: u32 = 0;
pub const VMASST_CMD_disable: u32 = 1;
pub const VMASST_TYPE_4gb_segments: u32 = 0;
pub const VMASST_TYPE_4gb_segments_notify: u32 = 1;
pub const VMASST_TYPE_writable_pagetables: u32 = 2;
pub const VMASST_TYPE_pae_extended_cr3: u32 = 3;
pub const VMASST_TYPE_architectural_iopl: u32 = 4;
pub const VMASST_TYPE_runstate_update_flag: u32 = 5;
pub const VMASST_TYPE_m2p_strict: u32 = 32;
pub const MAX_VMASST_TYPE: u32 = 3;
pub const XEN_PVCLOCK_TSC_STABLE_BIT: u32 = 1;
pub const XEN_PVCLOCK_GUEST_STOPPED: u32 = 2;
pub const SIF_PRIVILEGED: u32 = 1;
pub const SIF_INITDOMAIN: u32 = 2;
pub const SIF_MULTIBOOT_MOD: u32 = 4;
pub const SIF_MOD_START_PFN: u32 = 8;
pub const SIF_VIRT_P2M_4TOOLS: u32 = 16;
pub const SIF_PM_MASK: u32 = 65280;
pub const XEN_VGATYPE_TEXT_MODE_3: u32 = 3;
pub const XEN_VGATYPE_VESA_LFB: u32 = 35;
pub const XEN_VGATYPE_EFI_LFB: u32 = 112;
pub const EVTCHNOP_bind_interdomain: u32 = 0;
pub const EVTCHNOP_bind_virq: u32 = 1;
pub const EVTCHNOP_bind_pirq: u32 = 2;
pub const EVTCHNOP_close: u32 = 3;
pub const EVTCHNOP_send: u32 = 4;
pub const EVTCHNOP_status: u32 = 5;
pub const EVTCHNOP_alloc_unbound: u32 = 6;
pub const EVTCHNOP_bind_ipi: u32 = 7;
pub const EVTCHNOP_bind_vcpu: u32 = 8;
pub const EVTCHNOP_unmask: u32 = 9;
pub const EVTCHNOP_reset: u32 = 10;
pub const EVTCHNOP_init_control: u32 = 11;
pub const EVTCHNOP_expand_array: u32 = 12;
pub const EVTCHNOP_set_priority: u32 = 13;
pub const BIND_PIRQ__WILL_SHARE: u32 = 1;
pub const EVTCHNSTAT_closed: u32 = 0;
pub const EVTCHNSTAT_unbound: u32 = 1;
pub const EVTCHNSTAT_interdomain: u32 = 2;
pub const EVTCHNSTAT_pirq: u32 = 3;
pub const EVTCHNSTAT_virq: u32 = 4;
pub const EVTCHNSTAT_ipi: u32 = 5;
pub const EVTCHN_FIFO_PRIORITY_MAX: u32 = 0;
pub const EVTCHN_FIFO_PRIORITY_DEFAULT: u32 = 7;
pub const EVTCHN_FIFO_PRIORITY_MIN: u32 = 15;
pub const EVTCHN_FIFO_MAX_QUEUES: u32 = 16;
pub const EVTCHN_FIFO_PENDING: u32 = 31;
pub const EVTCHN_FIFO_MASKED: u32 = 30;
pub const EVTCHN_FIFO_LINKED: u32 = 29;
pub const EVTCHN_FIFO_BUSY: u32 = 28;
pub const EVTCHN_FIFO_LINK_BITS: u32 = 17;
pub const EVTCHN_FIFO_LINK_MASK: u32 = 131071;
pub const EVTCHN_FIFO_NR_CHANNELS: u32 = 131072;
pub const SCHEDOP_yield: u32 = 0;
pub const SCHEDOP_block: u32 = 1;
pub const SCHEDOP_shutdown: u32 = 2;
pub const SCHEDOP_poll: u32 = 3;
pub const SCHEDOP_remote_shutdown: u32 = 4;
pub const SCHEDOP_shutdown_code: u32 = 5;
pub const SCHEDOP_watchdog: u32 = 6;
pub const SCHEDOP_pin_override: u32 = 7;
pub const SHUTDOWN_poweroff: u32 = 0;
pub const SHUTDOWN_reboot: u32 = 1;
pub const SHUTDOWN_suspend: u32 = 2;
pub const SHUTDOWN_crash: u32 = 3;
pub const SHUTDOWN_watchdog: u32 = 4;
pub const SHUTDOWN_soft_reset: u32 = 5;
pub const SHUTDOWN_MAX: u32 = 5;
pub const XEN_ELFNOTE_INFO: u32 = 0;
pub const XEN_ELFNOTE_ENTRY: u32 = 1;
pub const XEN_ELFNOTE_HYPERCALL_PAGE: u32 = 2;
pub const XEN_ELFNOTE_VIRT_BASE: u32 = 3;
pub const XEN_ELFNOTE_PADDR_OFFSET: u32 = 4;
pub const XEN_ELFNOTE_XEN_VERSION: u32 = 5;
pub const XEN_ELFNOTE_GUEST_OS: u32 = 6;
pub const XEN_ELFNOTE_GUEST_VERSION: u32 = 7;
pub const XEN_ELFNOTE_LOADER: u32 = 8;
pub const XEN_ELFNOTE_PAE_MODE: u32 = 9;
pub const XEN_ELFNOTE_FEATURES: u32 = 10;
pub const XEN_ELFNOTE_BSD_SYMTAB: u32 = 11;
pub const XEN_ELFNOTE_HV_START_LOW: u32 = 12;
pub const XEN_ELFNOTE_L1_MFN_VALID: u32 = 13;
pub const XEN_ELFNOTE_SUSPEND_CANCEL: u32 = 14;
pub const XEN_ELFNOTE_INIT_P2M: u32 = 15;
pub const XEN_ELFNOTE_MOD_START_PFN: u32 = 16;
pub const XEN_ELFNOTE_SUPPORTED_FEATURES: u32 = 17;
pub const XEN_ELFNOTE_PHYS32_ENTRY: u32 = 18;
pub const XEN_ELFNOTE_MAX: u32 = 18;
pub const XEN_ELFNOTE_CRASH_INFO: u32 = 16777217;
pub const XEN_ELFNOTE_CRASH_REGS: u32 = 16777218;
pub const XEN_ELFNOTE_DUMPCORE_NONE: u32 = 33554432;
pub const XEN_ELFNOTE_DUMPCORE_HEADER: u32 = 33554433;
pub const XEN_ELFNOTE_DUMPCORE_XEN_VERSION: u32 = 33554434;
pub const XEN_ELFNOTE_DUMPCORE_FORMAT_VERSION: u32 = 33554435;
pub type __s8 = cty::c_schar;
pub type __u8 = cty::c_uchar;
pub type __s16 = cty::c_short;
pub type __u16 = cty::c_ushort;
pub type __s32 = cty::c_int;
pub type __u32 = cty::c_uint;
pub type __s64 = cty::c_long;
pub type __u64 = cty::c_ulong;
pub type s8 = cty::c_schar;
pub type u8_ = cty::c_uchar;
pub type s16 = cty::c_short;
pub type u16_ = cty::c_ushort;
pub type s32 = cty::c_int;
pub type u32_ = cty::c_uint;
pub type s64 = cty::c_long;
pub type u64_ = cty::c_ulong;
pub type vaddr_t = u64_;
pub type paddr_t = u64_;
pub type register_t = u64_;
pub type size_t = cty::c_ulong;
pub type ssize_t = cty::c_long;
pub type __le16 = __u16;
pub type __be16 = __u16;
pub type __le32 = __u32;
pub type __be32 = __u32;
pub type __le64 = __u64;
pub type __be64 = __u64;
pub type bool_t = bool;
pub type xen_pfn_t = u64;
pub type xen_ulong_t = u64;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct arch_vcpu_info {}
#[test]
fn bindgen_test_layout_arch_vcpu_info() {
    assert_eq!(
        ::core::mem::size_of::<arch_vcpu_info>(),
        0usize,
        concat!("Size of: ", stringify!(arch_vcpu_info))
    );
    assert_eq!(
        ::core::mem::align_of::<arch_vcpu_info>(),
        1usize,
        concat!("Alignment of ", stringify!(arch_vcpu_info))
    );
}
pub type arch_vcpu_info_t = arch_vcpu_info;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct arch_shared_info {}
#[test]
fn bindgen_test_layout_arch_shared_info() {
    assert_eq!(
        ::core::mem::size_of::<arch_shared_info>(),
        0usize,
        concat!("Size of: ", stringify!(arch_shared_info))
    );
    assert_eq!(
        ::core::mem::align_of::<arch_shared_info>(),
        1usize,
        concat!("Alignment of ", stringify!(arch_shared_info))
    );
}
pub type arch_shared_info_t = arch_shared_info;
pub type xen_callback_t = u64;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct xen_pmu_arch {
    pub dummy: u8,
}
#[test]
fn bindgen_test_layout_xen_pmu_arch() {
    assert_eq!(
        ::core::mem::size_of::<xen_pmu_arch>(),
        1usize,
        concat!("Size of: ", stringify!(xen_pmu_arch))
    );
    assert_eq!(
        ::core::mem::align_of::<xen_pmu_arch>(),
        1usize,
        concat!("Alignment of ", stringify!(xen_pmu_arch))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<xen_pmu_arch>())).dummy as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(xen_pmu_arch),
            "::",
            stringify!(dummy)
        )
    );
}
pub type xen_pmu_arch_t = xen_pmu_arch;
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_char {
    pub p: *mut cty::c_char,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_char() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_char>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_char))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_char>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_char))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_char>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_char),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_char>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_char),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_char {
    pub p: *mut cty::c_char,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_char() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_char>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_64_char))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_char>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_64_char))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_64_char>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_char),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_64_char>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_char),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_const_char {
    pub p: *const cty::c_char,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_const_char() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_const_char>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_const_char))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_const_char>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_const_char))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_const_char>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_char),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_const_char>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_char),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_const_char {
    pub p: *const cty::c_char,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_const_char() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_const_char>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_64_const_char))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_const_char>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_64_const_char))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_64_const_char>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_char),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_64_const_char>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_char),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_uchar {
    pub p: *mut cty::c_uchar,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_uchar() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_uchar>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_uchar))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_uchar>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_uchar))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_uchar>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_uchar),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_uchar>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_uchar),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_uchar {
    pub p: *mut cty::c_uchar,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_uchar() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_uchar>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_64_uchar))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_uchar>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_64_uchar))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_64_uchar>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_uchar),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_64_uchar>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_uchar),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_const_uchar {
    pub p: *const cty::c_uchar,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_const_uchar() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_const_uchar>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_const_uchar))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_const_uchar>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_const_uchar))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_const_uchar>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_uchar),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_const_uchar>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_uchar),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_const_uchar {
    pub p: *const cty::c_uchar,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_const_uchar() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_const_uchar>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_64_const_uchar))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_const_uchar>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_64_const_uchar))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_const_uchar>())).p as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_uchar),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_const_uchar>())).q as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_uchar),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_int {
    pub p: *mut cty::c_int,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_int() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_int>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_int))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_int>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_int))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_int>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_int),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_int>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_int),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_int {
    pub p: *mut cty::c_int,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_int() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_int>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_64_int))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_int>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_64_int))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_64_int>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_int),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_64_int>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_int),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_const_int {
    pub p: *const cty::c_int,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_const_int() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_const_int>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_const_int))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_const_int>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_const_int))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_const_int>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_int),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_const_int>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_int),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_const_int {
    pub p: *const cty::c_int,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_const_int() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_const_int>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_64_const_int))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_const_int>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_64_const_int))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_64_const_int>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_int),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_64_const_int>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_int),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_uint {
    pub p: *mut cty::c_uint,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_uint() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_uint>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_uint))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_uint>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_uint))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_uint>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_uint),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_uint>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_uint),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_uint {
    pub p: *mut cty::c_uint,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_uint() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_uint>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_64_uint))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_uint>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_64_uint))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_64_uint>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_uint),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_64_uint>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_uint),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_const_uint {
    pub p: *const cty::c_uint,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_const_uint() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_const_uint>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_const_uint))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_const_uint>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_const_uint))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_const_uint>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_uint),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_const_uint>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_uint),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_const_uint {
    pub p: *const cty::c_uint,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_const_uint() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_const_uint>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_64_const_uint))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_const_uint>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_64_const_uint))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_64_const_uint>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_uint),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_64_const_uint>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_uint),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_long {
    pub p: *mut cty::c_long,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_long() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_long>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_long))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_long>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_long))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_long>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_long),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_long>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_long),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_long {
    pub p: *mut cty::c_long,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_long() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_long>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_64_long))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_long>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_64_long))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_64_long>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_long),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_64_long>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_long),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_const_long {
    pub p: *const cty::c_long,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_const_long() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_const_long>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_const_long))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_const_long>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_const_long))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_const_long>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_long),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_const_long>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_long),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_const_long {
    pub p: *const cty::c_long,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_const_long() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_const_long>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_64_const_long))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_const_long>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_64_const_long))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_64_const_long>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_long),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_64_const_long>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_long),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_ulong {
    pub p: *mut cty::c_ulong,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_ulong() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_ulong>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_ulong))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_ulong>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_ulong))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_ulong>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_ulong),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_ulong>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_ulong),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_ulong {
    pub p: *mut cty::c_ulong,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_ulong() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_ulong>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_64_ulong))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_ulong>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_64_ulong))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_64_ulong>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_ulong),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_64_ulong>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_ulong),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_const_ulong {
    pub p: *const cty::c_ulong,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_const_ulong() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_const_ulong>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_const_ulong))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_const_ulong>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_const_ulong))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_const_ulong>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_ulong),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_const_ulong>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_ulong),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_const_ulong {
    pub p: *const cty::c_ulong,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_const_ulong() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_const_ulong>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_64_const_ulong))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_const_ulong>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_64_const_ulong))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_const_ulong>())).p as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_ulong),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_const_ulong>())).q as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_ulong),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_void {
    pub p: *mut cty::c_void,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_void() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_void>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_void))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_void>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_void))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_void>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_void),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_void>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_void),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_void {
    pub p: *mut cty::c_void,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_void() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_void>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_64_void))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_void>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_64_void))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_64_void>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_void),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_64_void>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_void),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_const_void {
    pub p: *const cty::c_void,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_const_void() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_const_void>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_const_void))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_const_void>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_const_void))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_const_void>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_void),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_const_void>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_void),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_const_void {
    pub p: *const cty::c_void,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_const_void() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_const_void>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_64_const_void))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_const_void>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_64_const_void))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_64_const_void>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_void),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_64_const_void>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_void),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_uint64_t {
    pub p: *mut u64,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_uint64_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_uint64_t>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_uint64_t))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_uint64_t>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_uint64_t))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_uint64_t>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_uint64_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_uint64_t>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_uint64_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_uint64_t {
    pub p: *mut u64,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_uint64_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_uint64_t>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_64_uint64_t))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_uint64_t>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_64_uint64_t))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_64_uint64_t>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_uint64_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_64_uint64_t>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_uint64_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_const_uint64_t {
    pub p: *const u64,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_const_uint64_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_const_uint64_t>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_const_uint64_t))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_const_uint64_t>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_const_uint64_t))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_const_uint64_t>())).p as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_uint64_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_const_uint64_t>())).q as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_uint64_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_const_uint64_t {
    pub p: *const u64,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_const_uint64_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_const_uint64_t>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_64_const_uint64_t))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_const_uint64_t>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(__guest_handle_64_const_uint64_t)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_const_uint64_t>())).p as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_uint64_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_const_uint64_t>())).q as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_uint64_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_xen_pfn_t {
    pub p: *mut xen_pfn_t,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_xen_pfn_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_xen_pfn_t>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_xen_pfn_t))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_xen_pfn_t>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_xen_pfn_t))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_xen_pfn_t>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_xen_pfn_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_xen_pfn_t>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_xen_pfn_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_xen_pfn_t {
    pub p: *mut xen_pfn_t,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_xen_pfn_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_xen_pfn_t>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_64_xen_pfn_t))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_xen_pfn_t>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_64_xen_pfn_t))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_64_xen_pfn_t>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_xen_pfn_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_64_xen_pfn_t>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_xen_pfn_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_const_xen_pfn_t {
    pub p: *const xen_pfn_t,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_const_xen_pfn_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_const_xen_pfn_t>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_const_xen_pfn_t))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_const_xen_pfn_t>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_const_xen_pfn_t))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_const_xen_pfn_t>())).p as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_xen_pfn_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_const_xen_pfn_t>())).q as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_xen_pfn_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_const_xen_pfn_t {
    pub p: *const xen_pfn_t,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_const_xen_pfn_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_const_xen_pfn_t>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_64_const_xen_pfn_t))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_const_xen_pfn_t>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(__guest_handle_64_const_xen_pfn_t)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_const_xen_pfn_t>())).p as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_xen_pfn_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_const_xen_pfn_t>())).q as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_xen_pfn_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_xen_ulong_t {
    pub p: *mut xen_ulong_t,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_xen_ulong_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_xen_ulong_t>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_xen_ulong_t))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_xen_ulong_t>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_xen_ulong_t))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_xen_ulong_t>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_xen_ulong_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_xen_ulong_t>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_xen_ulong_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_xen_ulong_t {
    pub p: *mut xen_ulong_t,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_xen_ulong_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_xen_ulong_t>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_64_xen_ulong_t))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_xen_ulong_t>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_64_xen_ulong_t))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_xen_ulong_t>())).p as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_xen_ulong_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_xen_ulong_t>())).q as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_xen_ulong_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_const_xen_ulong_t {
    pub p: *const xen_ulong_t,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_const_xen_ulong_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_const_xen_ulong_t>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_const_xen_ulong_t))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_const_xen_ulong_t>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(__guest_handle_const_xen_ulong_t)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_const_xen_ulong_t>())).p as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_xen_ulong_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_const_xen_ulong_t>())).q as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_xen_ulong_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_const_xen_ulong_t {
    pub p: *const xen_ulong_t,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_const_xen_ulong_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_const_xen_ulong_t>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_64_const_xen_ulong_t))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_const_xen_ulong_t>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(__guest_handle_64_const_xen_ulong_t)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_const_xen_ulong_t>())).p as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_xen_ulong_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_const_xen_ulong_t>())).q as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_xen_ulong_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct mmuext_op {
    pub cmd: cty::c_uint,
    pub arg1: mmuext_op__bindgen_ty_1,
    pub arg2: mmuext_op__bindgen_ty_2,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union mmuext_op__bindgen_ty_1 {
    pub mfn: xen_pfn_t,
    pub linear_addr: cty::c_ulong,
}
#[test]
fn bindgen_test_layout_mmuext_op__bindgen_ty_1() {
    assert_eq!(
        ::core::mem::size_of::<mmuext_op__bindgen_ty_1>(),
        8usize,
        concat!("Size of: ", stringify!(mmuext_op__bindgen_ty_1))
    );
    assert_eq!(
        ::core::mem::align_of::<mmuext_op__bindgen_ty_1>(),
        8usize,
        concat!("Alignment of ", stringify!(mmuext_op__bindgen_ty_1))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<mmuext_op__bindgen_ty_1>())).mfn as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(mmuext_op__bindgen_ty_1),
            "::",
            stringify!(mfn)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<mmuext_op__bindgen_ty_1>())).linear_addr as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(mmuext_op__bindgen_ty_1),
            "::",
            stringify!(linear_addr)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union mmuext_op__bindgen_ty_2 {
    pub nr_ents: cty::c_uint,
    pub vcpumask: *const cty::c_void,
    pub src_mfn: xen_pfn_t,
}
#[test]
fn bindgen_test_layout_mmuext_op__bindgen_ty_2() {
    assert_eq!(
        ::core::mem::size_of::<mmuext_op__bindgen_ty_2>(),
        8usize,
        concat!("Size of: ", stringify!(mmuext_op__bindgen_ty_2))
    );
    assert_eq!(
        ::core::mem::align_of::<mmuext_op__bindgen_ty_2>(),
        8usize,
        concat!("Alignment of ", stringify!(mmuext_op__bindgen_ty_2))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<mmuext_op__bindgen_ty_2>())).nr_ents as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(mmuext_op__bindgen_ty_2),
            "::",
            stringify!(nr_ents)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<mmuext_op__bindgen_ty_2>())).vcpumask as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(mmuext_op__bindgen_ty_2),
            "::",
            stringify!(vcpumask)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<mmuext_op__bindgen_ty_2>())).src_mfn as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(mmuext_op__bindgen_ty_2),
            "::",
            stringify!(src_mfn)
        )
    );
}
#[test]
fn bindgen_test_layout_mmuext_op() {
    assert_eq!(
        ::core::mem::size_of::<mmuext_op>(),
        24usize,
        concat!("Size of: ", stringify!(mmuext_op))
    );
    assert_eq!(
        ::core::mem::align_of::<mmuext_op>(),
        8usize,
        concat!("Alignment of ", stringify!(mmuext_op))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<mmuext_op>())).cmd as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(mmuext_op),
            "::",
            stringify!(cmd)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<mmuext_op>())).arg1 as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(mmuext_op),
            "::",
            stringify!(arg1)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<mmuext_op>())).arg2 as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(mmuext_op),
            "::",
            stringify!(arg2)
        )
    );
}
pub type mmuext_op_t = mmuext_op;
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_mmuext_op_t {
    pub p: *mut mmuext_op_t,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_mmuext_op_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_mmuext_op_t>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_mmuext_op_t))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_mmuext_op_t>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_mmuext_op_t))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_mmuext_op_t>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_mmuext_op_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_mmuext_op_t>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_mmuext_op_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_mmuext_op_t {
    pub p: *mut mmuext_op_t,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_mmuext_op_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_mmuext_op_t>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_64_mmuext_op_t))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_mmuext_op_t>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_64_mmuext_op_t))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_mmuext_op_t>())).p as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_mmuext_op_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_mmuext_op_t>())).q as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_mmuext_op_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_const_mmuext_op_t {
    pub p: *const mmuext_op_t,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_const_mmuext_op_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_const_mmuext_op_t>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_const_mmuext_op_t))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_const_mmuext_op_t>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(__guest_handle_const_mmuext_op_t)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_const_mmuext_op_t>())).p as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_mmuext_op_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_const_mmuext_op_t>())).q as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_mmuext_op_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_const_mmuext_op_t {
    pub p: *const mmuext_op_t,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_const_mmuext_op_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_const_mmuext_op_t>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_64_const_mmuext_op_t))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_const_mmuext_op_t>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(__guest_handle_64_const_mmuext_op_t)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_const_mmuext_op_t>())).p as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_mmuext_op_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_const_mmuext_op_t>())).q as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_mmuext_op_t),
            "::",
            stringify!(q)
        )
    );
}
pub type domid_t = u16;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mmu_update {
    pub ptr: u64,
    pub val: u64,
}
#[test]
fn bindgen_test_layout_mmu_update() {
    assert_eq!(
        ::core::mem::size_of::<mmu_update>(),
        16usize,
        concat!("Size of: ", stringify!(mmu_update))
    );
    assert_eq!(
        ::core::mem::align_of::<mmu_update>(),
        8usize,
        concat!("Alignment of ", stringify!(mmu_update))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<mmu_update>())).ptr as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(mmu_update),
            "::",
            stringify!(ptr)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<mmu_update>())).val as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(mmu_update),
            "::",
            stringify!(val)
        )
    );
}
pub type mmu_update_t = mmu_update;
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_mmu_update_t {
    pub p: *mut mmu_update_t,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_mmu_update_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_mmu_update_t>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_mmu_update_t))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_mmu_update_t>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_mmu_update_t))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_mmu_update_t>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_mmu_update_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_mmu_update_t>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_mmu_update_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_mmu_update_t {
    pub p: *mut mmu_update_t,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_mmu_update_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_mmu_update_t>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_64_mmu_update_t))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_mmu_update_t>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_64_mmu_update_t))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_mmu_update_t>())).p as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_mmu_update_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_mmu_update_t>())).q as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_mmu_update_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_const_mmu_update_t {
    pub p: *const mmu_update_t,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_const_mmu_update_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_const_mmu_update_t>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_const_mmu_update_t))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_const_mmu_update_t>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(__guest_handle_const_mmu_update_t)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_const_mmu_update_t>())).p as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_mmu_update_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_const_mmu_update_t>())).q as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_mmu_update_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_const_mmu_update_t {
    pub p: *const mmu_update_t,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_const_mmu_update_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_const_mmu_update_t>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(__guest_handle_64_const_mmu_update_t)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_const_mmu_update_t>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(__guest_handle_64_const_mmu_update_t)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_const_mmu_update_t>())).p as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_mmu_update_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_const_mmu_update_t>())).q as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_mmu_update_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct multicall_entry {
    pub op: xen_ulong_t,
    pub result: xen_ulong_t,
    pub args: [xen_ulong_t; 6usize],
}
#[test]
fn bindgen_test_layout_multicall_entry() {
    assert_eq!(
        ::core::mem::size_of::<multicall_entry>(),
        64usize,
        concat!("Size of: ", stringify!(multicall_entry))
    );
    assert_eq!(
        ::core::mem::align_of::<multicall_entry>(),
        8usize,
        concat!("Alignment of ", stringify!(multicall_entry))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<multicall_entry>())).op as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(multicall_entry),
            "::",
            stringify!(op)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<multicall_entry>())).result as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(multicall_entry),
            "::",
            stringify!(result)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<multicall_entry>())).args as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(multicall_entry),
            "::",
            stringify!(args)
        )
    );
}
pub type multicall_entry_t = multicall_entry;
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_multicall_entry_t {
    pub p: *mut multicall_entry_t,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_multicall_entry_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_multicall_entry_t>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_multicall_entry_t))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_multicall_entry_t>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(__guest_handle_multicall_entry_t)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_multicall_entry_t>())).p as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_multicall_entry_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_multicall_entry_t>())).q as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_multicall_entry_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_multicall_entry_t {
    pub p: *mut multicall_entry_t,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_multicall_entry_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_multicall_entry_t>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_64_multicall_entry_t))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_multicall_entry_t>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(__guest_handle_64_multicall_entry_t)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_multicall_entry_t>())).p as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_multicall_entry_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_multicall_entry_t>())).q as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_multicall_entry_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_const_multicall_entry_t {
    pub p: *const multicall_entry_t,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_const_multicall_entry_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_const_multicall_entry_t>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(__guest_handle_const_multicall_entry_t)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_const_multicall_entry_t>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(__guest_handle_const_multicall_entry_t)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_const_multicall_entry_t>())).p as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_multicall_entry_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_const_multicall_entry_t>())).q as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_multicall_entry_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_const_multicall_entry_t {
    pub p: *const multicall_entry_t,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_const_multicall_entry_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_const_multicall_entry_t>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(__guest_handle_64_const_multicall_entry_t)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_const_multicall_entry_t>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(__guest_handle_64_const_multicall_entry_t)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_const_multicall_entry_t>())).p as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_multicall_entry_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_const_multicall_entry_t>())).q as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_multicall_entry_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct vcpu_time_info {
    pub version: u32,
    pub pad0: u32,
    pub tsc_timestamp: u64,
    pub system_time: u64,
    pub tsc_to_system_mul: u32,
    pub tsc_shift: i8,
    pub pad1: [i8; 3usize],
}
#[test]
fn bindgen_test_layout_vcpu_time_info() {
    assert_eq!(
        ::core::mem::size_of::<vcpu_time_info>(),
        32usize,
        concat!("Size of: ", stringify!(vcpu_time_info))
    );
    assert_eq!(
        ::core::mem::align_of::<vcpu_time_info>(),
        8usize,
        concat!("Alignment of ", stringify!(vcpu_time_info))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<vcpu_time_info>())).version as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_time_info),
            "::",
            stringify!(version)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<vcpu_time_info>())).pad0 as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_time_info),
            "::",
            stringify!(pad0)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<vcpu_time_info>())).tsc_timestamp as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_time_info),
            "::",
            stringify!(tsc_timestamp)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<vcpu_time_info>())).system_time as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_time_info),
            "::",
            stringify!(system_time)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<vcpu_time_info>())).tsc_to_system_mul as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_time_info),
            "::",
            stringify!(tsc_to_system_mul)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<vcpu_time_info>())).tsc_shift as *const _ as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_time_info),
            "::",
            stringify!(tsc_shift)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<vcpu_time_info>())).pad1 as *const _ as usize },
        29usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_time_info),
            "::",
            stringify!(pad1)
        )
    );
}
pub type vcpu_time_info_t = vcpu_time_info;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct vcpu_info {
    pub evtchn_upcall_pending: u8,
    pub pad0: u8,
    pub evtchn_pending_sel: xen_ulong_t,
    pub arch: arch_vcpu_info,
    pub time: vcpu_time_info_t,
}
#[test]
fn bindgen_test_layout_vcpu_info() {
    assert_eq!(
        ::core::mem::size_of::<vcpu_info>(),
        48usize,
        concat!("Size of: ", stringify!(vcpu_info))
    );
    assert_eq!(
        ::core::mem::align_of::<vcpu_info>(),
        8usize,
        concat!("Alignment of ", stringify!(vcpu_info))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<vcpu_info>())).evtchn_upcall_pending as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_info),
            "::",
            stringify!(evtchn_upcall_pending)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<vcpu_info>())).pad0 as *const _ as usize },
        1usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_info),
            "::",
            stringify!(pad0)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<vcpu_info>())).evtchn_pending_sel as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_info),
            "::",
            stringify!(evtchn_pending_sel)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<vcpu_info>())).arch as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_info),
            "::",
            stringify!(arch)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<vcpu_info>())).time as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(vcpu_info),
            "::",
            stringify!(time)
        )
    );
}
pub type vcpu_info_t = vcpu_info;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct shared_info {
    pub vcpu_info: [vcpu_info; 1usize],
    pub evtchn_pending: [xen_ulong_t; 64usize],
    pub evtchn_mask: [xen_ulong_t; 64usize],
    pub wc_version: u32,
    pub wc_sec: u32,
    pub wc_nsec: u32,
    pub wc_sec_hi: u32,
    pub arch: arch_shared_info,
}
#[test]
fn bindgen_test_layout_shared_info() {
    assert_eq!(
        ::core::mem::size_of::<shared_info>(),
        1088usize,
        concat!("Size of: ", stringify!(shared_info))
    );
    assert_eq!(
        ::core::mem::align_of::<shared_info>(),
        8usize,
        concat!("Alignment of ", stringify!(shared_info))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<shared_info>())).vcpu_info as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(shared_info),
            "::",
            stringify!(vcpu_info)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<shared_info>())).evtchn_pending as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(shared_info),
            "::",
            stringify!(evtchn_pending)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<shared_info>())).evtchn_mask as *const _ as usize },
        560usize,
        concat!(
            "Offset of field: ",
            stringify!(shared_info),
            "::",
            stringify!(evtchn_mask)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<shared_info>())).wc_version as *const _ as usize },
        1072usize,
        concat!(
            "Offset of field: ",
            stringify!(shared_info),
            "::",
            stringify!(wc_version)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<shared_info>())).wc_sec as *const _ as usize },
        1076usize,
        concat!(
            "Offset of field: ",
            stringify!(shared_info),
            "::",
            stringify!(wc_sec)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<shared_info>())).wc_nsec as *const _ as usize },
        1080usize,
        concat!(
            "Offset of field: ",
            stringify!(shared_info),
            "::",
            stringify!(wc_nsec)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<shared_info>())).wc_sec_hi as *const _ as usize },
        1084usize,
        concat!(
            "Offset of field: ",
            stringify!(shared_info),
            "::",
            stringify!(wc_sec_hi)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<shared_info>())).arch as *const _ as usize },
        1088usize,
        concat!(
            "Offset of field: ",
            stringify!(shared_info),
            "::",
            stringify!(arch)
        )
    );
}
pub type shared_info_t = shared_info;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct xen_multiboot_mod_list {
    pub mod_start: u32,
    pub mod_end: u32,
    pub cmdline: u32,
    pub pad: u32,
}
#[test]
fn bindgen_test_layout_xen_multiboot_mod_list() {
    assert_eq!(
        ::core::mem::size_of::<xen_multiboot_mod_list>(),
        16usize,
        concat!("Size of: ", stringify!(xen_multiboot_mod_list))
    );
    assert_eq!(
        ::core::mem::align_of::<xen_multiboot_mod_list>(),
        4usize,
        concat!("Alignment of ", stringify!(xen_multiboot_mod_list))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<xen_multiboot_mod_list>())).mod_start as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(xen_multiboot_mod_list),
            "::",
            stringify!(mod_start)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<xen_multiboot_mod_list>())).mod_end as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(xen_multiboot_mod_list),
            "::",
            stringify!(mod_end)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<xen_multiboot_mod_list>())).cmdline as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(xen_multiboot_mod_list),
            "::",
            stringify!(cmdline)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<xen_multiboot_mod_list>())).pad as *const _ as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(xen_multiboot_mod_list),
            "::",
            stringify!(pad)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct dom0_vga_console_info {
    pub video_type: u8,
    pub u: dom0_vga_console_info__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union dom0_vga_console_info__bindgen_ty_1 {
    pub text_mode_3: dom0_vga_console_info__bindgen_ty_1__bindgen_ty_1,
    pub vesa_lfb: dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dom0_vga_console_info__bindgen_ty_1__bindgen_ty_1 {
    pub font_height: u16,
    pub cursor_x: u16,
    pub cursor_y: u16,
    pub rows: u16,
    pub columns: u16,
}
#[test]
fn bindgen_test_layout_dom0_vga_console_info__bindgen_ty_1__bindgen_ty_1() {
    assert_eq!(
        ::core::mem::size_of::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_1>(),
        10usize,
        concat!(
            "Size of: ",
            stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_1>(),
        2usize,
        concat!(
            "Alignment of ",
            stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_1>()))
                .font_height as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(font_height)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_1>())).cursor_x
                as *const _ as usize
        },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(cursor_x)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_1>())).cursor_y
                as *const _ as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(cursor_y)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_1>())).rows
                as *const _ as usize
        },
        6usize,
        concat!(
            "Offset of field: ",
            stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(rows)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_1>())).columns
                as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(columns)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2 {
    pub width: u16,
    pub height: u16,
    pub bytes_per_line: u16,
    pub bits_per_pixel: u16,
    pub lfb_base: u32,
    pub lfb_size: u32,
    pub red_pos: u8,
    pub red_size: u8,
    pub green_pos: u8,
    pub green_size: u8,
    pub blue_pos: u8,
    pub blue_size: u8,
    pub rsvd_pos: u8,
    pub rsvd_size: u8,
}
#[test]
fn bindgen_test_layout_dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2() {
    assert_eq!(
        ::core::mem::size_of::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2>())).width
                as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2),
            "::",
            stringify!(width)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2>())).height
                as *const _ as usize
        },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2),
            "::",
            stringify!(height)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2>()))
                .bytes_per_line as *const _ as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2),
            "::",
            stringify!(bytes_per_line)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2>()))
                .bits_per_pixel as *const _ as usize
        },
        6usize,
        concat!(
            "Offset of field: ",
            stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2),
            "::",
            stringify!(bits_per_pixel)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2>())).lfb_base
                as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2),
            "::",
            stringify!(lfb_base)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2>())).lfb_size
                as *const _ as usize
        },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2),
            "::",
            stringify!(lfb_size)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2>())).red_pos
                as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2),
            "::",
            stringify!(red_pos)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2>())).red_size
                as *const _ as usize
        },
        17usize,
        concat!(
            "Offset of field: ",
            stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2),
            "::",
            stringify!(red_size)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2>())).green_pos
                as *const _ as usize
        },
        18usize,
        concat!(
            "Offset of field: ",
            stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2),
            "::",
            stringify!(green_pos)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2>()))
                .green_size as *const _ as usize
        },
        19usize,
        concat!(
            "Offset of field: ",
            stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2),
            "::",
            stringify!(green_size)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2>())).blue_pos
                as *const _ as usize
        },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2),
            "::",
            stringify!(blue_pos)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2>())).blue_size
                as *const _ as usize
        },
        21usize,
        concat!(
            "Offset of field: ",
            stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2),
            "::",
            stringify!(blue_size)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2>())).rsvd_pos
                as *const _ as usize
        },
        22usize,
        concat!(
            "Offset of field: ",
            stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2),
            "::",
            stringify!(rsvd_pos)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2>())).rsvd_size
                as *const _ as usize
        },
        23usize,
        concat!(
            "Offset of field: ",
            stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2),
            "::",
            stringify!(rsvd_size)
        )
    );
}
#[test]
fn bindgen_test_layout_dom0_vga_console_info__bindgen_ty_1() {
    assert_eq!(
        ::core::mem::size_of::<dom0_vga_console_info__bindgen_ty_1>(),
        24usize,
        concat!("Size of: ", stringify!(dom0_vga_console_info__bindgen_ty_1))
    );
    assert_eq!(
        ::core::mem::align_of::<dom0_vga_console_info__bindgen_ty_1>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(dom0_vga_console_info__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1>())).text_mode_3 as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(dom0_vga_console_info__bindgen_ty_1),
            "::",
            stringify!(text_mode_3)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1>())).vesa_lfb as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(dom0_vga_console_info__bindgen_ty_1),
            "::",
            stringify!(vesa_lfb)
        )
    );
}
#[test]
fn bindgen_test_layout_dom0_vga_console_info() {
    assert_eq!(
        ::core::mem::size_of::<dom0_vga_console_info>(),
        28usize,
        concat!("Size of: ", stringify!(dom0_vga_console_info))
    );
    assert_eq!(
        ::core::mem::align_of::<dom0_vga_console_info>(),
        4usize,
        concat!("Alignment of ", stringify!(dom0_vga_console_info))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<dom0_vga_console_info>())).video_type as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(dom0_vga_console_info),
            "::",
            stringify!(video_type)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<dom0_vga_console_info>())).u as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(dom0_vga_console_info),
            "::",
            stringify!(u)
        )
    );
}
pub type dom0_vga_console_info_t = dom0_vga_console_info;
pub type xen_domain_handle_t = [u8; 16usize];
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_uint8 {
    pub p: *mut u8,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_uint8() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_uint8>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_uint8))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_uint8>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_uint8))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_uint8>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_uint8),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_uint8>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_uint8),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_uint8 {
    pub p: *mut u8,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_uint8() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_uint8>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_64_uint8))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_uint8>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_64_uint8))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_64_uint8>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_uint8),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_64_uint8>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_uint8),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_const_uint8 {
    pub p: *const u8,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_const_uint8() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_const_uint8>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_const_uint8))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_const_uint8>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_const_uint8))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_const_uint8>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_uint8),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_const_uint8>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_uint8),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_const_uint8 {
    pub p: *const u8,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_const_uint8() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_const_uint8>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_64_const_uint8))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_const_uint8>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_64_const_uint8))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_const_uint8>())).p as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_uint8),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_const_uint8>())).q as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_uint8),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_uint16 {
    pub p: *mut u16,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_uint16() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_uint16>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_uint16))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_uint16>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_uint16))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_uint16>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_uint16),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_uint16>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_uint16),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_uint16 {
    pub p: *mut u16,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_uint16() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_uint16>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_64_uint16))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_uint16>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_64_uint16))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_64_uint16>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_uint16),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_64_uint16>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_uint16),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_const_uint16 {
    pub p: *const u16,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_const_uint16() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_const_uint16>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_const_uint16))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_const_uint16>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_const_uint16))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_const_uint16>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_uint16),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_const_uint16>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_uint16),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_const_uint16 {
    pub p: *const u16,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_const_uint16() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_const_uint16>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_64_const_uint16))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_const_uint16>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_64_const_uint16))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_const_uint16>())).p as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_uint16),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_const_uint16>())).q as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_uint16),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_uint32 {
    pub p: *mut u32,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_uint32() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_uint32>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_uint32))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_uint32>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_uint32))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_uint32>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_uint32),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_uint32>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_uint32),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_uint32 {
    pub p: *mut u32,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_uint32() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_uint32>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_64_uint32))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_uint32>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_64_uint32))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_64_uint32>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_uint32),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_64_uint32>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_uint32),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_const_uint32 {
    pub p: *const u32,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_const_uint32() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_const_uint32>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_const_uint32))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_const_uint32>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_const_uint32))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_const_uint32>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_uint32),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_const_uint32>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_uint32),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_const_uint32 {
    pub p: *const u32,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_const_uint32() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_const_uint32>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_64_const_uint32))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_const_uint32>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_64_const_uint32))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_const_uint32>())).p as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_uint32),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_const_uint32>())).q as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_uint32),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_uint64 {
    pub p: *mut u64,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_uint64() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_uint64>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_uint64))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_uint64>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_uint64))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_uint64>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_uint64),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_uint64>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_uint64),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_uint64 {
    pub p: *mut u64,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_uint64() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_uint64>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_64_uint64))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_uint64>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_64_uint64))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_64_uint64>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_uint64),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_64_uint64>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_uint64),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_const_uint64 {
    pub p: *const u64,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_const_uint64() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_const_uint64>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_const_uint64))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_const_uint64>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_const_uint64))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_const_uint64>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_uint64),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_const_uint64>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_uint64),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_const_uint64 {
    pub p: *const u64,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_const_uint64() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_const_uint64>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_64_const_uint64))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_const_uint64>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_64_const_uint64))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_const_uint64>())).p as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_uint64),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_const_uint64>())).q as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_uint64),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct xen_uuid_t {
    pub a: [u8; 16usize],
}
#[test]
fn bindgen_test_layout_xen_uuid_t() {
    assert_eq!(
        ::core::mem::size_of::<xen_uuid_t>(),
        16usize,
        concat!("Size of: ", stringify!(xen_uuid_t))
    );
    assert_eq!(
        ::core::mem::align_of::<xen_uuid_t>(),
        1usize,
        concat!("Alignment of ", stringify!(xen_uuid_t))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<xen_uuid_t>())).a as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(xen_uuid_t),
            "::",
            stringify!(a)
        )
    );
}
pub type evtchn_port_t = u32;
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_evtchn_port_t {
    pub p: *mut evtchn_port_t,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_evtchn_port_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_evtchn_port_t>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_evtchn_port_t))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_evtchn_port_t>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_evtchn_port_t))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_evtchn_port_t>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_evtchn_port_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_evtchn_port_t>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_evtchn_port_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_evtchn_port_t {
    pub p: *mut evtchn_port_t,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_evtchn_port_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_evtchn_port_t>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_64_evtchn_port_t))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_evtchn_port_t>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_64_evtchn_port_t))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_evtchn_port_t>())).p as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_evtchn_port_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_evtchn_port_t>())).q as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_evtchn_port_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_const_evtchn_port_t {
    pub p: *const evtchn_port_t,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_const_evtchn_port_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_const_evtchn_port_t>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_const_evtchn_port_t))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_const_evtchn_port_t>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(__guest_handle_const_evtchn_port_t)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_const_evtchn_port_t>())).p as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_evtchn_port_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_const_evtchn_port_t>())).q as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_evtchn_port_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_const_evtchn_port_t {
    pub p: *const evtchn_port_t,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_const_evtchn_port_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_const_evtchn_port_t>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(__guest_handle_64_const_evtchn_port_t)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_const_evtchn_port_t>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(__guest_handle_64_const_evtchn_port_t)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_const_evtchn_port_t>())).p as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_evtchn_port_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_const_evtchn_port_t>())).q as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_evtchn_port_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct evtchn_alloc_unbound {
    pub dom: domid_t,
    pub remote_dom: domid_t,
    pub port: evtchn_port_t,
}
#[test]
fn bindgen_test_layout_evtchn_alloc_unbound() {
    assert_eq!(
        ::core::mem::size_of::<evtchn_alloc_unbound>(),
        8usize,
        concat!("Size of: ", stringify!(evtchn_alloc_unbound))
    );
    assert_eq!(
        ::core::mem::align_of::<evtchn_alloc_unbound>(),
        4usize,
        concat!("Alignment of ", stringify!(evtchn_alloc_unbound))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<evtchn_alloc_unbound>())).dom as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_alloc_unbound),
            "::",
            stringify!(dom)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<evtchn_alloc_unbound>())).remote_dom as *const _ as usize
        },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_alloc_unbound),
            "::",
            stringify!(remote_dom)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<evtchn_alloc_unbound>())).port as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_alloc_unbound),
            "::",
            stringify!(port)
        )
    );
}
pub type evtchn_alloc_unbound_t = evtchn_alloc_unbound;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct evtchn_bind_interdomain {
    pub remote_dom: domid_t,
    pub remote_port: evtchn_port_t,
    pub local_port: evtchn_port_t,
}
#[test]
fn bindgen_test_layout_evtchn_bind_interdomain() {
    assert_eq!(
        ::core::mem::size_of::<evtchn_bind_interdomain>(),
        12usize,
        concat!("Size of: ", stringify!(evtchn_bind_interdomain))
    );
    assert_eq!(
        ::core::mem::align_of::<evtchn_bind_interdomain>(),
        4usize,
        concat!("Alignment of ", stringify!(evtchn_bind_interdomain))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<evtchn_bind_interdomain>())).remote_dom as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_bind_interdomain),
            "::",
            stringify!(remote_dom)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<evtchn_bind_interdomain>())).remote_port as *const _ as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_bind_interdomain),
            "::",
            stringify!(remote_port)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<evtchn_bind_interdomain>())).local_port as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_bind_interdomain),
            "::",
            stringify!(local_port)
        )
    );
}
pub type evtchn_bind_interdomain_t = evtchn_bind_interdomain;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct evtchn_bind_virq {
    pub virq: u32,
    pub vcpu: u32,
    pub port: evtchn_port_t,
}
#[test]
fn bindgen_test_layout_evtchn_bind_virq() {
    assert_eq!(
        ::core::mem::size_of::<evtchn_bind_virq>(),
        12usize,
        concat!("Size of: ", stringify!(evtchn_bind_virq))
    );
    assert_eq!(
        ::core::mem::align_of::<evtchn_bind_virq>(),
        4usize,
        concat!("Alignment of ", stringify!(evtchn_bind_virq))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<evtchn_bind_virq>())).virq as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_bind_virq),
            "::",
            stringify!(virq)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<evtchn_bind_virq>())).vcpu as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_bind_virq),
            "::",
            stringify!(vcpu)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<evtchn_bind_virq>())).port as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_bind_virq),
            "::",
            stringify!(port)
        )
    );
}
pub type evtchn_bind_virq_t = evtchn_bind_virq;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct evtchn_bind_pirq {
    pub pirq: u32,
    pub flags: u32,
    pub port: evtchn_port_t,
}
#[test]
fn bindgen_test_layout_evtchn_bind_pirq() {
    assert_eq!(
        ::core::mem::size_of::<evtchn_bind_pirq>(),
        12usize,
        concat!("Size of: ", stringify!(evtchn_bind_pirq))
    );
    assert_eq!(
        ::core::mem::align_of::<evtchn_bind_pirq>(),
        4usize,
        concat!("Alignment of ", stringify!(evtchn_bind_pirq))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<evtchn_bind_pirq>())).pirq as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_bind_pirq),
            "::",
            stringify!(pirq)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<evtchn_bind_pirq>())).flags as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_bind_pirq),
            "::",
            stringify!(flags)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<evtchn_bind_pirq>())).port as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_bind_pirq),
            "::",
            stringify!(port)
        )
    );
}
pub type evtchn_bind_pirq_t = evtchn_bind_pirq;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct evtchn_bind_ipi {
    pub vcpu: u32,
    pub port: evtchn_port_t,
}
#[test]
fn bindgen_test_layout_evtchn_bind_ipi() {
    assert_eq!(
        ::core::mem::size_of::<evtchn_bind_ipi>(),
        8usize,
        concat!("Size of: ", stringify!(evtchn_bind_ipi))
    );
    assert_eq!(
        ::core::mem::align_of::<evtchn_bind_ipi>(),
        4usize,
        concat!("Alignment of ", stringify!(evtchn_bind_ipi))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<evtchn_bind_ipi>())).vcpu as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_bind_ipi),
            "::",
            stringify!(vcpu)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<evtchn_bind_ipi>())).port as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_bind_ipi),
            "::",
            stringify!(port)
        )
    );
}
pub type evtchn_bind_ipi_t = evtchn_bind_ipi;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct evtchn_close {
    pub port: evtchn_port_t,
}
#[test]
fn bindgen_test_layout_evtchn_close() {
    assert_eq!(
        ::core::mem::size_of::<evtchn_close>(),
        4usize,
        concat!("Size of: ", stringify!(evtchn_close))
    );
    assert_eq!(
        ::core::mem::align_of::<evtchn_close>(),
        4usize,
        concat!("Alignment of ", stringify!(evtchn_close))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<evtchn_close>())).port as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_close),
            "::",
            stringify!(port)
        )
    );
}
pub type evtchn_close_t = evtchn_close;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct evtchn_send {
    pub port: evtchn_port_t,
}
#[test]
fn bindgen_test_layout_evtchn_send() {
    assert_eq!(
        ::core::mem::size_of::<evtchn_send>(),
        4usize,
        concat!("Size of: ", stringify!(evtchn_send))
    );
    assert_eq!(
        ::core::mem::align_of::<evtchn_send>(),
        4usize,
        concat!("Alignment of ", stringify!(evtchn_send))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<evtchn_send>())).port as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_send),
            "::",
            stringify!(port)
        )
    );
}
pub type evtchn_send_t = evtchn_send;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct evtchn_status {
    pub dom: domid_t,
    pub port: evtchn_port_t,
    pub status: u32,
    pub vcpu: u32,
    pub u: evtchn_status__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union evtchn_status__bindgen_ty_1 {
    pub unbound: evtchn_status__bindgen_ty_1__bindgen_ty_1,
    pub interdomain: evtchn_status__bindgen_ty_1__bindgen_ty_2,
    pub pirq: u32,
    pub virq: u32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct evtchn_status__bindgen_ty_1__bindgen_ty_1 {
    pub dom: domid_t,
}
#[test]
fn bindgen_test_layout_evtchn_status__bindgen_ty_1__bindgen_ty_1() {
    assert_eq!(
        ::core::mem::size_of::<evtchn_status__bindgen_ty_1__bindgen_ty_1>(),
        2usize,
        concat!(
            "Size of: ",
            stringify!(evtchn_status__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<evtchn_status__bindgen_ty_1__bindgen_ty_1>(),
        2usize,
        concat!(
            "Alignment of ",
            stringify!(evtchn_status__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<evtchn_status__bindgen_ty_1__bindgen_ty_1>())).dom as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_status__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(dom)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct evtchn_status__bindgen_ty_1__bindgen_ty_2 {
    pub dom: domid_t,
    pub port: evtchn_port_t,
}
#[test]
fn bindgen_test_layout_evtchn_status__bindgen_ty_1__bindgen_ty_2() {
    assert_eq!(
        ::core::mem::size_of::<evtchn_status__bindgen_ty_1__bindgen_ty_2>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(evtchn_status__bindgen_ty_1__bindgen_ty_2)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<evtchn_status__bindgen_ty_1__bindgen_ty_2>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(evtchn_status__bindgen_ty_1__bindgen_ty_2)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<evtchn_status__bindgen_ty_1__bindgen_ty_2>())).dom as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_status__bindgen_ty_1__bindgen_ty_2),
            "::",
            stringify!(dom)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<evtchn_status__bindgen_ty_1__bindgen_ty_2>())).port as *const _
                as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_status__bindgen_ty_1__bindgen_ty_2),
            "::",
            stringify!(port)
        )
    );
}
#[test]
fn bindgen_test_layout_evtchn_status__bindgen_ty_1() {
    assert_eq!(
        ::core::mem::size_of::<evtchn_status__bindgen_ty_1>(),
        8usize,
        concat!("Size of: ", stringify!(evtchn_status__bindgen_ty_1))
    );
    assert_eq!(
        ::core::mem::align_of::<evtchn_status__bindgen_ty_1>(),
        4usize,
        concat!("Alignment of ", stringify!(evtchn_status__bindgen_ty_1))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<evtchn_status__bindgen_ty_1>())).unbound as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_status__bindgen_ty_1),
            "::",
            stringify!(unbound)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<evtchn_status__bindgen_ty_1>())).interdomain as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_status__bindgen_ty_1),
            "::",
            stringify!(interdomain)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<evtchn_status__bindgen_ty_1>())).pirq as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_status__bindgen_ty_1),
            "::",
            stringify!(pirq)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<evtchn_status__bindgen_ty_1>())).virq as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_status__bindgen_ty_1),
            "::",
            stringify!(virq)
        )
    );
}
#[test]
fn bindgen_test_layout_evtchn_status() {
    assert_eq!(
        ::core::mem::size_of::<evtchn_status>(),
        24usize,
        concat!("Size of: ", stringify!(evtchn_status))
    );
    assert_eq!(
        ::core::mem::align_of::<evtchn_status>(),
        4usize,
        concat!("Alignment of ", stringify!(evtchn_status))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<evtchn_status>())).dom as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_status),
            "::",
            stringify!(dom)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<evtchn_status>())).port as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_status),
            "::",
            stringify!(port)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<evtchn_status>())).status as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_status),
            "::",
            stringify!(status)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<evtchn_status>())).vcpu as *const _ as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_status),
            "::",
            stringify!(vcpu)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<evtchn_status>())).u as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_status),
            "::",
            stringify!(u)
        )
    );
}
pub type evtchn_status_t = evtchn_status;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct evtchn_bind_vcpu {
    pub port: evtchn_port_t,
    pub vcpu: u32,
}
#[test]
fn bindgen_test_layout_evtchn_bind_vcpu() {
    assert_eq!(
        ::core::mem::size_of::<evtchn_bind_vcpu>(),
        8usize,
        concat!("Size of: ", stringify!(evtchn_bind_vcpu))
    );
    assert_eq!(
        ::core::mem::align_of::<evtchn_bind_vcpu>(),
        4usize,
        concat!("Alignment of ", stringify!(evtchn_bind_vcpu))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<evtchn_bind_vcpu>())).port as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_bind_vcpu),
            "::",
            stringify!(port)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<evtchn_bind_vcpu>())).vcpu as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_bind_vcpu),
            "::",
            stringify!(vcpu)
        )
    );
}
pub type evtchn_bind_vcpu_t = evtchn_bind_vcpu;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct evtchn_unmask {
    pub port: evtchn_port_t,
}
#[test]
fn bindgen_test_layout_evtchn_unmask() {
    assert_eq!(
        ::core::mem::size_of::<evtchn_unmask>(),
        4usize,
        concat!("Size of: ", stringify!(evtchn_unmask))
    );
    assert_eq!(
        ::core::mem::align_of::<evtchn_unmask>(),
        4usize,
        concat!("Alignment of ", stringify!(evtchn_unmask))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<evtchn_unmask>())).port as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_unmask),
            "::",
            stringify!(port)
        )
    );
}
pub type evtchn_unmask_t = evtchn_unmask;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct evtchn_reset {
    pub dom: domid_t,
}
#[test]
fn bindgen_test_layout_evtchn_reset() {
    assert_eq!(
        ::core::mem::size_of::<evtchn_reset>(),
        2usize,
        concat!("Size of: ", stringify!(evtchn_reset))
    );
    assert_eq!(
        ::core::mem::align_of::<evtchn_reset>(),
        2usize,
        concat!("Alignment of ", stringify!(evtchn_reset))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<evtchn_reset>())).dom as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_reset),
            "::",
            stringify!(dom)
        )
    );
}
pub type evtchn_reset_t = evtchn_reset;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct evtchn_init_control {
    pub control_gfn: u64,
    pub offset: u32,
    pub vcpu: u32,
    pub link_bits: u8,
    pub _pad: [u8; 7usize],
}
#[test]
fn bindgen_test_layout_evtchn_init_control() {
    assert_eq!(
        ::core::mem::size_of::<evtchn_init_control>(),
        24usize,
        concat!("Size of: ", stringify!(evtchn_init_control))
    );
    assert_eq!(
        ::core::mem::align_of::<evtchn_init_control>(),
        8usize,
        concat!("Alignment of ", stringify!(evtchn_init_control))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<evtchn_init_control>())).control_gfn as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_init_control),
            "::",
            stringify!(control_gfn)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<evtchn_init_control>())).offset as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_init_control),
            "::",
            stringify!(offset)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<evtchn_init_control>())).vcpu as *const _ as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_init_control),
            "::",
            stringify!(vcpu)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<evtchn_init_control>())).link_bits as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_init_control),
            "::",
            stringify!(link_bits)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<evtchn_init_control>()))._pad as *const _ as usize },
        17usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_init_control),
            "::",
            stringify!(_pad)
        )
    );
}
pub type evtchn_init_control_t = evtchn_init_control;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct evtchn_expand_array {
    pub array_gfn: u64,
}
#[test]
fn bindgen_test_layout_evtchn_expand_array() {
    assert_eq!(
        ::core::mem::size_of::<evtchn_expand_array>(),
        8usize,
        concat!("Size of: ", stringify!(evtchn_expand_array))
    );
    assert_eq!(
        ::core::mem::align_of::<evtchn_expand_array>(),
        8usize,
        concat!("Alignment of ", stringify!(evtchn_expand_array))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<evtchn_expand_array>())).array_gfn as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_expand_array),
            "::",
            stringify!(array_gfn)
        )
    );
}
pub type evtchn_expand_array_t = evtchn_expand_array;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct evtchn_set_priority {
    pub port: evtchn_port_t,
    pub priority: u32,
}
#[test]
fn bindgen_test_layout_evtchn_set_priority() {
    assert_eq!(
        ::core::mem::size_of::<evtchn_set_priority>(),
        8usize,
        concat!("Size of: ", stringify!(evtchn_set_priority))
    );
    assert_eq!(
        ::core::mem::align_of::<evtchn_set_priority>(),
        4usize,
        concat!("Alignment of ", stringify!(evtchn_set_priority))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<evtchn_set_priority>())).port as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_set_priority),
            "::",
            stringify!(port)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<evtchn_set_priority>())).priority as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_set_priority),
            "::",
            stringify!(priority)
        )
    );
}
pub type evtchn_set_priority_t = evtchn_set_priority;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct evtchn_op {
    pub cmd: u32,
    pub u: evtchn_op__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union evtchn_op__bindgen_ty_1 {
    pub alloc_unbound: evtchn_alloc_unbound_t,
    pub bind_interdomain: evtchn_bind_interdomain_t,
    pub bind_virq: evtchn_bind_virq_t,
    pub bind_pirq: evtchn_bind_pirq_t,
    pub bind_ipi: evtchn_bind_ipi_t,
    pub close: evtchn_close_t,
    pub send: evtchn_send_t,
    pub status: evtchn_status_t,
    pub bind_vcpu: evtchn_bind_vcpu_t,
    pub unmask: evtchn_unmask_t,
}
#[test]
fn bindgen_test_layout_evtchn_op__bindgen_ty_1() {
    assert_eq!(
        ::core::mem::size_of::<evtchn_op__bindgen_ty_1>(),
        24usize,
        concat!("Size of: ", stringify!(evtchn_op__bindgen_ty_1))
    );
    assert_eq!(
        ::core::mem::align_of::<evtchn_op__bindgen_ty_1>(),
        4usize,
        concat!("Alignment of ", stringify!(evtchn_op__bindgen_ty_1))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<evtchn_op__bindgen_ty_1>())).alloc_unbound as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_op__bindgen_ty_1),
            "::",
            stringify!(alloc_unbound)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<evtchn_op__bindgen_ty_1>())).bind_interdomain as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_op__bindgen_ty_1),
            "::",
            stringify!(bind_interdomain)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<evtchn_op__bindgen_ty_1>())).bind_virq as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_op__bindgen_ty_1),
            "::",
            stringify!(bind_virq)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<evtchn_op__bindgen_ty_1>())).bind_pirq as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_op__bindgen_ty_1),
            "::",
            stringify!(bind_pirq)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<evtchn_op__bindgen_ty_1>())).bind_ipi as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_op__bindgen_ty_1),
            "::",
            stringify!(bind_ipi)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<evtchn_op__bindgen_ty_1>())).close as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_op__bindgen_ty_1),
            "::",
            stringify!(close)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<evtchn_op__bindgen_ty_1>())).send as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_op__bindgen_ty_1),
            "::",
            stringify!(send)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<evtchn_op__bindgen_ty_1>())).status as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_op__bindgen_ty_1),
            "::",
            stringify!(status)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<evtchn_op__bindgen_ty_1>())).bind_vcpu as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_op__bindgen_ty_1),
            "::",
            stringify!(bind_vcpu)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<evtchn_op__bindgen_ty_1>())).unmask as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_op__bindgen_ty_1),
            "::",
            stringify!(unmask)
        )
    );
}
#[test]
fn bindgen_test_layout_evtchn_op() {
    assert_eq!(
        ::core::mem::size_of::<evtchn_op>(),
        28usize,
        concat!("Size of: ", stringify!(evtchn_op))
    );
    assert_eq!(
        ::core::mem::align_of::<evtchn_op>(),
        4usize,
        concat!("Alignment of ", stringify!(evtchn_op))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<evtchn_op>())).cmd as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_op),
            "::",
            stringify!(cmd)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<evtchn_op>())).u as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_op),
            "::",
            stringify!(u)
        )
    );
}
pub type evtchn_op_t = evtchn_op;
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_evtchn_op_t {
    pub p: *mut evtchn_op_t,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_evtchn_op_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_evtchn_op_t>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_evtchn_op_t))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_evtchn_op_t>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_evtchn_op_t))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_evtchn_op_t>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_evtchn_op_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_evtchn_op_t>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_evtchn_op_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_evtchn_op_t {
    pub p: *mut evtchn_op_t,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_evtchn_op_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_evtchn_op_t>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_64_evtchn_op_t))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_evtchn_op_t>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_64_evtchn_op_t))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_evtchn_op_t>())).p as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_evtchn_op_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_evtchn_op_t>())).q as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_evtchn_op_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_const_evtchn_op_t {
    pub p: *const evtchn_op_t,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_const_evtchn_op_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_const_evtchn_op_t>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_const_evtchn_op_t))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_const_evtchn_op_t>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(__guest_handle_const_evtchn_op_t)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_const_evtchn_op_t>())).p as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_evtchn_op_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_const_evtchn_op_t>())).q as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_evtchn_op_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_const_evtchn_op_t {
    pub p: *const evtchn_op_t,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_const_evtchn_op_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_const_evtchn_op_t>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_64_const_evtchn_op_t))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_const_evtchn_op_t>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(__guest_handle_64_const_evtchn_op_t)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_const_evtchn_op_t>())).p as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_evtchn_op_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_const_evtchn_op_t>())).q as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_evtchn_op_t),
            "::",
            stringify!(q)
        )
    );
}
pub type event_word_t = u32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct evtchn_fifo_control_block {
    pub ready: u32,
    pub _rsvd: u32,
    pub head: [u32; 16usize],
}
#[test]
fn bindgen_test_layout_evtchn_fifo_control_block() {
    assert_eq!(
        ::core::mem::size_of::<evtchn_fifo_control_block>(),
        72usize,
        concat!("Size of: ", stringify!(evtchn_fifo_control_block))
    );
    assert_eq!(
        ::core::mem::align_of::<evtchn_fifo_control_block>(),
        4usize,
        concat!("Alignment of ", stringify!(evtchn_fifo_control_block))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<evtchn_fifo_control_block>())).ready as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_fifo_control_block),
            "::",
            stringify!(ready)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<evtchn_fifo_control_block>()))._rsvd as *const _ as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_fifo_control_block),
            "::",
            stringify!(_rsvd)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<evtchn_fifo_control_block>())).head as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(evtchn_fifo_control_block),
            "::",
            stringify!(head)
        )
    );
}
pub type evtchn_fifo_control_block_t = evtchn_fifo_control_block;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sched_shutdown {
    pub reason: cty::c_uint,
}
#[test]
fn bindgen_test_layout_sched_shutdown() {
    assert_eq!(
        ::core::mem::size_of::<sched_shutdown>(),
        4usize,
        concat!("Size of: ", stringify!(sched_shutdown))
    );
    assert_eq!(
        ::core::mem::align_of::<sched_shutdown>(),
        4usize,
        concat!("Alignment of ", stringify!(sched_shutdown))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<sched_shutdown>())).reason as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sched_shutdown),
            "::",
            stringify!(reason)
        )
    );
}
pub type sched_shutdown_t = sched_shutdown;
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_sched_shutdown_t {
    pub p: *mut sched_shutdown_t,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_sched_shutdown_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_sched_shutdown_t>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_sched_shutdown_t))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_sched_shutdown_t>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_sched_shutdown_t))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_sched_shutdown_t>())).p as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_sched_shutdown_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_sched_shutdown_t>())).q as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_sched_shutdown_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_sched_shutdown_t {
    pub p: *mut sched_shutdown_t,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_sched_shutdown_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_sched_shutdown_t>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_64_sched_shutdown_t))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_sched_shutdown_t>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(__guest_handle_64_sched_shutdown_t)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_sched_shutdown_t>())).p as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_sched_shutdown_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_sched_shutdown_t>())).q as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_sched_shutdown_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_const_sched_shutdown_t {
    pub p: *const sched_shutdown_t,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_const_sched_shutdown_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_const_sched_shutdown_t>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(__guest_handle_const_sched_shutdown_t)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_const_sched_shutdown_t>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(__guest_handle_const_sched_shutdown_t)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_const_sched_shutdown_t>())).p as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_sched_shutdown_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_const_sched_shutdown_t>())).q as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_sched_shutdown_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_const_sched_shutdown_t {
    pub p: *const sched_shutdown_t,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_const_sched_shutdown_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_const_sched_shutdown_t>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(__guest_handle_64_const_sched_shutdown_t)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_const_sched_shutdown_t>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(__guest_handle_64_const_sched_shutdown_t)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_const_sched_shutdown_t>())).p as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_sched_shutdown_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_const_sched_shutdown_t>())).q as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_sched_shutdown_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct sched_poll {
    pub ports: __guest_handle_64_evtchn_port_t,
    pub nr_ports: cty::c_uint,
    pub timeout: u64,
}
#[test]
fn bindgen_test_layout_sched_poll() {
    assert_eq!(
        ::core::mem::size_of::<sched_poll>(),
        24usize,
        concat!("Size of: ", stringify!(sched_poll))
    );
    assert_eq!(
        ::core::mem::align_of::<sched_poll>(),
        8usize,
        concat!("Alignment of ", stringify!(sched_poll))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<sched_poll>())).ports as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sched_poll),
            "::",
            stringify!(ports)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<sched_poll>())).nr_ports as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sched_poll),
            "::",
            stringify!(nr_ports)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<sched_poll>())).timeout as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(sched_poll),
            "::",
            stringify!(timeout)
        )
    );
}
pub type sched_poll_t = sched_poll;
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_sched_poll_t {
    pub p: *mut sched_poll_t,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_sched_poll_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_sched_poll_t>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_sched_poll_t))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_sched_poll_t>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_sched_poll_t))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_sched_poll_t>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_sched_poll_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<__guest_handle_sched_poll_t>())).q as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_sched_poll_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_sched_poll_t {
    pub p: *mut sched_poll_t,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_sched_poll_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_sched_poll_t>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_64_sched_poll_t))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_sched_poll_t>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_64_sched_poll_t))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_sched_poll_t>())).p as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_sched_poll_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_sched_poll_t>())).q as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_sched_poll_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_const_sched_poll_t {
    pub p: *const sched_poll_t,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_const_sched_poll_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_const_sched_poll_t>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_const_sched_poll_t))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_const_sched_poll_t>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(__guest_handle_const_sched_poll_t)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_const_sched_poll_t>())).p as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_sched_poll_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_const_sched_poll_t>())).q as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_sched_poll_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_const_sched_poll_t {
    pub p: *const sched_poll_t,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_const_sched_poll_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_const_sched_poll_t>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(__guest_handle_64_const_sched_poll_t)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_const_sched_poll_t>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(__guest_handle_64_const_sched_poll_t)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_const_sched_poll_t>())).p as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_sched_poll_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_const_sched_poll_t>())).q as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_sched_poll_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sched_remote_shutdown {
    pub domain_id: domid_t,
    pub reason: cty::c_uint,
}
#[test]
fn bindgen_test_layout_sched_remote_shutdown() {
    assert_eq!(
        ::core::mem::size_of::<sched_remote_shutdown>(),
        8usize,
        concat!("Size of: ", stringify!(sched_remote_shutdown))
    );
    assert_eq!(
        ::core::mem::align_of::<sched_remote_shutdown>(),
        4usize,
        concat!("Alignment of ", stringify!(sched_remote_shutdown))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<sched_remote_shutdown>())).domain_id as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sched_remote_shutdown),
            "::",
            stringify!(domain_id)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<sched_remote_shutdown>())).reason as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(sched_remote_shutdown),
            "::",
            stringify!(reason)
        )
    );
}
pub type sched_remote_shutdown_t = sched_remote_shutdown;
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_sched_remote_shutdown_t {
    pub p: *mut sched_remote_shutdown_t,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_sched_remote_shutdown_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_sched_remote_shutdown_t>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(__guest_handle_sched_remote_shutdown_t)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_sched_remote_shutdown_t>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(__guest_handle_sched_remote_shutdown_t)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_sched_remote_shutdown_t>())).p as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_sched_remote_shutdown_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_sched_remote_shutdown_t>())).q as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_sched_remote_shutdown_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_sched_remote_shutdown_t {
    pub p: *mut sched_remote_shutdown_t,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_sched_remote_shutdown_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_sched_remote_shutdown_t>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(__guest_handle_64_sched_remote_shutdown_t)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_sched_remote_shutdown_t>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(__guest_handle_64_sched_remote_shutdown_t)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_sched_remote_shutdown_t>())).p as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_sched_remote_shutdown_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_sched_remote_shutdown_t>())).q as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_sched_remote_shutdown_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_const_sched_remote_shutdown_t {
    pub p: *const sched_remote_shutdown_t,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_const_sched_remote_shutdown_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_const_sched_remote_shutdown_t>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(__guest_handle_const_sched_remote_shutdown_t)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_const_sched_remote_shutdown_t>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(__guest_handle_const_sched_remote_shutdown_t)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_const_sched_remote_shutdown_t>())).p as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_sched_remote_shutdown_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_const_sched_remote_shutdown_t>())).q as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_sched_remote_shutdown_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_const_sched_remote_shutdown_t {
    pub p: *const sched_remote_shutdown_t,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_const_sched_remote_shutdown_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_const_sched_remote_shutdown_t>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(__guest_handle_64_const_sched_remote_shutdown_t)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_const_sched_remote_shutdown_t>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(__guest_handle_64_const_sched_remote_shutdown_t)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_const_sched_remote_shutdown_t>())).p
                as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_sched_remote_shutdown_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_const_sched_remote_shutdown_t>())).q
                as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_sched_remote_shutdown_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sched_watchdog {
    pub id: u32,
    pub timeout: u32,
}
#[test]
fn bindgen_test_layout_sched_watchdog() {
    assert_eq!(
        ::core::mem::size_of::<sched_watchdog>(),
        8usize,
        concat!("Size of: ", stringify!(sched_watchdog))
    );
    assert_eq!(
        ::core::mem::align_of::<sched_watchdog>(),
        4usize,
        concat!("Alignment of ", stringify!(sched_watchdog))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<sched_watchdog>())).id as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sched_watchdog),
            "::",
            stringify!(id)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<sched_watchdog>())).timeout as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(sched_watchdog),
            "::",
            stringify!(timeout)
        )
    );
}
pub type sched_watchdog_t = sched_watchdog;
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_sched_watchdog_t {
    pub p: *mut sched_watchdog_t,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_sched_watchdog_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_sched_watchdog_t>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_sched_watchdog_t))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_sched_watchdog_t>(),
        8usize,
        concat!("Alignment of ", stringify!(__guest_handle_sched_watchdog_t))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_sched_watchdog_t>())).p as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_sched_watchdog_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_sched_watchdog_t>())).q as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_sched_watchdog_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_sched_watchdog_t {
    pub p: *mut sched_watchdog_t,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_sched_watchdog_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_sched_watchdog_t>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_64_sched_watchdog_t))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_sched_watchdog_t>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(__guest_handle_64_sched_watchdog_t)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_sched_watchdog_t>())).p as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_sched_watchdog_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_sched_watchdog_t>())).q as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_sched_watchdog_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_const_sched_watchdog_t {
    pub p: *const sched_watchdog_t,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_const_sched_watchdog_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_const_sched_watchdog_t>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(__guest_handle_const_sched_watchdog_t)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_const_sched_watchdog_t>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(__guest_handle_const_sched_watchdog_t)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_const_sched_watchdog_t>())).p as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_sched_watchdog_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_const_sched_watchdog_t>())).q as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_sched_watchdog_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_const_sched_watchdog_t {
    pub p: *const sched_watchdog_t,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_const_sched_watchdog_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_const_sched_watchdog_t>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(__guest_handle_64_const_sched_watchdog_t)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_const_sched_watchdog_t>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(__guest_handle_64_const_sched_watchdog_t)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_const_sched_watchdog_t>())).p as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_sched_watchdog_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_const_sched_watchdog_t>())).q as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_sched_watchdog_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sched_pin_override {
    pub pcpu: i32,
}
#[test]
fn bindgen_test_layout_sched_pin_override() {
    assert_eq!(
        ::core::mem::size_of::<sched_pin_override>(),
        4usize,
        concat!("Size of: ", stringify!(sched_pin_override))
    );
    assert_eq!(
        ::core::mem::align_of::<sched_pin_override>(),
        4usize,
        concat!("Alignment of ", stringify!(sched_pin_override))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<sched_pin_override>())).pcpu as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sched_pin_override),
            "::",
            stringify!(pcpu)
        )
    );
}
pub type sched_pin_override_t = sched_pin_override;
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_sched_pin_override_t {
    pub p: *mut sched_pin_override_t,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_sched_pin_override_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_sched_pin_override_t>(),
        8usize,
        concat!("Size of: ", stringify!(__guest_handle_sched_pin_override_t))
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_sched_pin_override_t>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(__guest_handle_sched_pin_override_t)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_sched_pin_override_t>())).p as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_sched_pin_override_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_sched_pin_override_t>())).q as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_sched_pin_override_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_sched_pin_override_t {
    pub p: *mut sched_pin_override_t,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_sched_pin_override_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_sched_pin_override_t>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(__guest_handle_64_sched_pin_override_t)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_sched_pin_override_t>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(__guest_handle_64_sched_pin_override_t)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_sched_pin_override_t>())).p as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_sched_pin_override_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_sched_pin_override_t>())).q as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_sched_pin_override_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_const_sched_pin_override_t {
    pub p: *const sched_pin_override_t,
    pub q: cty::c_ulong,
}
#[test]
fn bindgen_test_layout___guest_handle_const_sched_pin_override_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_const_sched_pin_override_t>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(__guest_handle_const_sched_pin_override_t)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_const_sched_pin_override_t>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(__guest_handle_const_sched_pin_override_t)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_const_sched_pin_override_t>())).p as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_sched_pin_override_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_const_sched_pin_override_t>())).q as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_const_sched_pin_override_t),
            "::",
            stringify!(q)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __guest_handle_64_const_sched_pin_override_t {
    pub p: *const sched_pin_override_t,
    pub q: u64,
}
#[test]
fn bindgen_test_layout___guest_handle_64_const_sched_pin_override_t() {
    assert_eq!(
        ::core::mem::size_of::<__guest_handle_64_const_sched_pin_override_t>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(__guest_handle_64_const_sched_pin_override_t)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<__guest_handle_64_const_sched_pin_override_t>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(__guest_handle_64_const_sched_pin_override_t)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_const_sched_pin_override_t>())).p as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_sched_pin_override_t),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<__guest_handle_64_const_sched_pin_override_t>())).q as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__guest_handle_64_const_sched_pin_override_t),
            "::",
            stringify!(q)
        )
    );
}