/* automatically generated by rust-bindgen 0.63.0 */

#[repr(C)]
#[derive(Default)]
pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
impl<T> __IncompleteArrayField<T> {
    #[inline]
    pub const fn new() -> Self {
        __IncompleteArrayField(::std::marker::PhantomData, [])
    }
    #[inline]
    pub fn as_ptr(&self) -> *const T {
        self as *const _ as *const T
    }
    #[inline]
    pub fn as_mut_ptr(&mut self) -> *mut T {
        self as *mut _ as *mut T
    }
    #[inline]
    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
        ::std::slice::from_raw_parts(self.as_ptr(), len)
    }
    #[inline]
    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
    }
}
impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        fmt.write_str("__IncompleteArrayField")
    }
}
pub const VIRTIO_GPU_F_VIRGL: u32 = 0;
pub const VIRTIO_GPU_F_EDID: u32 = 1;
pub const VIRTIO_GPU_F_RESOURCE_UUID: u32 = 2;
pub const VIRTIO_GPU_F_RESOURCE_BLOB: u32 = 3;
pub const VIRTIO_GPU_F_CONTEXT_INIT: u32 = 4;
pub const VIRTIO_GPU_FLAG_FENCE: u32 = 1;
pub const VIRTIO_GPU_FLAG_INFO_RING_IDX: u32 = 2;
pub const VIRTIO_GPU_MAX_SCANOUTS: u32 = 16;
pub const VIRTIO_GPU_RESOURCE_FLAG_Y_0_TOP: u32 = 1;
pub const VIRTIO_GPU_CONTEXT_INIT_CAPSET_ID_MASK: u32 = 255;
pub const VIRTIO_GPU_CAPSET_VIRGL: u32 = 1;
pub const VIRTIO_GPU_CAPSET_VIRGL2: u32 = 2;
pub const VIRTIO_GPU_EVENT_DISPLAY: u32 = 1;
pub const VIRTIO_GPU_BLOB_MEM_GUEST: u32 = 1;
pub const VIRTIO_GPU_BLOB_MEM_HOST3D: u32 = 2;
pub const VIRTIO_GPU_BLOB_MEM_HOST3D_GUEST: u32 = 3;
pub const VIRTIO_GPU_BLOB_FLAG_USE_MAPPABLE: u32 = 1;
pub const VIRTIO_GPU_BLOB_FLAG_USE_SHAREABLE: u32 = 2;
pub const VIRTIO_GPU_BLOB_FLAG_USE_CROSS_DEVICE: u32 = 4;
pub const VIRTIO_GPU_MAP_CACHE_MASK: u32 = 15;
pub const VIRTIO_GPU_MAP_CACHE_NONE: u32 = 0;
pub const VIRTIO_GPU_MAP_CACHE_CACHED: u32 = 1;
pub const VIRTIO_GPU_MAP_CACHE_UNCACHED: u32 = 2;
pub const VIRTIO_GPU_MAP_CACHE_WC: u32 = 3;
pub type __u8 = ::std::os::raw::c_uchar;
pub type __u32 = ::std::os::raw::c_uint;
pub type __u64 = ::std::os::raw::c_ulonglong;
pub type __le32 = __u32;
pub type __le64 = __u64;
pub const virtio_gpu_ctrl_type_VIRTIO_GPU_UNDEFINED: virtio_gpu_ctrl_type = 0;
pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_GET_DISPLAY_INFO: virtio_gpu_ctrl_type = 256;
pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_RESOURCE_CREATE_2D: virtio_gpu_ctrl_type = 257;
pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_RESOURCE_UNREF: virtio_gpu_ctrl_type = 258;
pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_SET_SCANOUT: virtio_gpu_ctrl_type = 259;
pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_RESOURCE_FLUSH: virtio_gpu_ctrl_type = 260;
pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_TRANSFER_TO_HOST_2D: virtio_gpu_ctrl_type = 261;
pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_RESOURCE_ATTACH_BACKING: virtio_gpu_ctrl_type = 262;
pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_RESOURCE_DETACH_BACKING: virtio_gpu_ctrl_type = 263;
pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_GET_CAPSET_INFO: virtio_gpu_ctrl_type = 264;
pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_GET_CAPSET: virtio_gpu_ctrl_type = 265;
pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_GET_EDID: virtio_gpu_ctrl_type = 266;
pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_RESOURCE_ASSIGN_UUID: virtio_gpu_ctrl_type = 267;
pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_RESOURCE_CREATE_BLOB: virtio_gpu_ctrl_type = 268;
pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_SET_SCANOUT_BLOB: virtio_gpu_ctrl_type = 269;
pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_CTX_CREATE: virtio_gpu_ctrl_type = 512;
pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_CTX_DESTROY: virtio_gpu_ctrl_type = 513;
pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_CTX_ATTACH_RESOURCE: virtio_gpu_ctrl_type = 514;
pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_CTX_DETACH_RESOURCE: virtio_gpu_ctrl_type = 515;
pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_RESOURCE_CREATE_3D: virtio_gpu_ctrl_type = 516;
pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_TRANSFER_TO_HOST_3D: virtio_gpu_ctrl_type = 517;
pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_TRANSFER_FROM_HOST_3D: virtio_gpu_ctrl_type = 518;
pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_SUBMIT_3D: virtio_gpu_ctrl_type = 519;
pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_RESOURCE_MAP_BLOB: virtio_gpu_ctrl_type = 520;
pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_RESOURCE_UNMAP_BLOB: virtio_gpu_ctrl_type = 521;
pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_UPDATE_CURSOR: virtio_gpu_ctrl_type = 768;
pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_MOVE_CURSOR: virtio_gpu_ctrl_type = 769;
pub const virtio_gpu_ctrl_type_VIRTIO_GPU_RESP_OK_NODATA: virtio_gpu_ctrl_type = 4352;
pub const virtio_gpu_ctrl_type_VIRTIO_GPU_RESP_OK_DISPLAY_INFO: virtio_gpu_ctrl_type = 4353;
pub const virtio_gpu_ctrl_type_VIRTIO_GPU_RESP_OK_CAPSET_INFO: virtio_gpu_ctrl_type = 4354;
pub const virtio_gpu_ctrl_type_VIRTIO_GPU_RESP_OK_CAPSET: virtio_gpu_ctrl_type = 4355;
pub const virtio_gpu_ctrl_type_VIRTIO_GPU_RESP_OK_EDID: virtio_gpu_ctrl_type = 4356;
pub const virtio_gpu_ctrl_type_VIRTIO_GPU_RESP_OK_RESOURCE_UUID: virtio_gpu_ctrl_type = 4357;
pub const virtio_gpu_ctrl_type_VIRTIO_GPU_RESP_OK_MAP_INFO: virtio_gpu_ctrl_type = 4358;
pub const virtio_gpu_ctrl_type_VIRTIO_GPU_RESP_ERR_UNSPEC: virtio_gpu_ctrl_type = 4608;
pub const virtio_gpu_ctrl_type_VIRTIO_GPU_RESP_ERR_OUT_OF_MEMORY: virtio_gpu_ctrl_type = 4609;
pub const virtio_gpu_ctrl_type_VIRTIO_GPU_RESP_ERR_INVALID_SCANOUT_ID: virtio_gpu_ctrl_type = 4610;
pub const virtio_gpu_ctrl_type_VIRTIO_GPU_RESP_ERR_INVALID_RESOURCE_ID: virtio_gpu_ctrl_type = 4611;
pub const virtio_gpu_ctrl_type_VIRTIO_GPU_RESP_ERR_INVALID_CONTEXT_ID: virtio_gpu_ctrl_type = 4612;
pub const virtio_gpu_ctrl_type_VIRTIO_GPU_RESP_ERR_INVALID_PARAMETER: virtio_gpu_ctrl_type = 4613;
pub type virtio_gpu_ctrl_type = ::std::os::raw::c_uint;
pub const virtio_gpu_shm_id_VIRTIO_GPU_SHM_ID_UNDEFINED: virtio_gpu_shm_id = 0;
pub const virtio_gpu_shm_id_VIRTIO_GPU_SHM_ID_HOST_VISIBLE: virtio_gpu_shm_id = 1;
pub type virtio_gpu_shm_id = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct virtio_gpu_ctrl_hdr {
    pub type_: __le32,
    pub flags: __le32,
    pub fence_id: __le64,
    pub ctx_id: __le32,
    pub ring_idx: __u8,
    pub padding: [__u8; 3usize],
}
#[test]
fn bindgen_test_layout_virtio_gpu_ctrl_hdr() {
    const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_ctrl_hdr> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<virtio_gpu_ctrl_hdr>(),
        24usize,
        concat!("Size of: ", stringify!(virtio_gpu_ctrl_hdr))
    );
    assert_eq!(
        ::std::mem::align_of::<virtio_gpu_ctrl_hdr>(),
        8usize,
        concat!("Alignment of ", stringify!(virtio_gpu_ctrl_hdr))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_ctrl_hdr),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_ctrl_hdr),
            "::",
            stringify!(flags)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fence_id) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_ctrl_hdr),
            "::",
            stringify!(fence_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ctx_id) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_ctrl_hdr),
            "::",
            stringify!(ctx_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ring_idx) as usize - ptr as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_ctrl_hdr),
            "::",
            stringify!(ring_idx)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
        21usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_ctrl_hdr),
            "::",
            stringify!(padding)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct virtio_gpu_cursor_pos {
    pub scanout_id: __le32,
    pub x: __le32,
    pub y: __le32,
    pub padding: __le32,
}
#[test]
fn bindgen_test_layout_virtio_gpu_cursor_pos() {
    const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_cursor_pos> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<virtio_gpu_cursor_pos>(),
        16usize,
        concat!("Size of: ", stringify!(virtio_gpu_cursor_pos))
    );
    assert_eq!(
        ::std::mem::align_of::<virtio_gpu_cursor_pos>(),
        4usize,
        concat!("Alignment of ", stringify!(virtio_gpu_cursor_pos))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).scanout_id) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_cursor_pos),
            "::",
            stringify!(scanout_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_cursor_pos),
            "::",
            stringify!(x)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_cursor_pos),
            "::",
            stringify!(y)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_cursor_pos),
            "::",
            stringify!(padding)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct virtio_gpu_update_cursor {
    pub hdr: virtio_gpu_ctrl_hdr,
    pub pos: virtio_gpu_cursor_pos,
    pub resource_id: __le32,
    pub hot_x: __le32,
    pub hot_y: __le32,
    pub padding: __le32,
}
#[test]
fn bindgen_test_layout_virtio_gpu_update_cursor() {
    const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_update_cursor> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<virtio_gpu_update_cursor>(),
        56usize,
        concat!("Size of: ", stringify!(virtio_gpu_update_cursor))
    );
    assert_eq!(
        ::std::mem::align_of::<virtio_gpu_update_cursor>(),
        8usize,
        concat!("Alignment of ", stringify!(virtio_gpu_update_cursor))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_update_cursor),
            "::",
            stringify!(hdr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pos) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_update_cursor),
            "::",
            stringify!(pos)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).resource_id) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_update_cursor),
            "::",
            stringify!(resource_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hot_x) as usize - ptr as usize },
        44usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_update_cursor),
            "::",
            stringify!(hot_x)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hot_y) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_update_cursor),
            "::",
            stringify!(hot_y)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
        52usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_update_cursor),
            "::",
            stringify!(padding)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct virtio_gpu_rect {
    pub x: __le32,
    pub y: __le32,
    pub width: __le32,
    pub height: __le32,
}
#[test]
fn bindgen_test_layout_virtio_gpu_rect() {
    const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_rect> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<virtio_gpu_rect>(),
        16usize,
        concat!("Size of: ", stringify!(virtio_gpu_rect))
    );
    assert_eq!(
        ::std::mem::align_of::<virtio_gpu_rect>(),
        4usize,
        concat!("Alignment of ", stringify!(virtio_gpu_rect))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_rect),
            "::",
            stringify!(x)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_rect),
            "::",
            stringify!(y)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_rect),
            "::",
            stringify!(width)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_rect),
            "::",
            stringify!(height)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct virtio_gpu_resource_unref {
    pub hdr: virtio_gpu_ctrl_hdr,
    pub resource_id: __le32,
    pub padding: __le32,
}
#[test]
fn bindgen_test_layout_virtio_gpu_resource_unref() {
    const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_resource_unref> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<virtio_gpu_resource_unref>(),
        32usize,
        concat!("Size of: ", stringify!(virtio_gpu_resource_unref))
    );
    assert_eq!(
        ::std::mem::align_of::<virtio_gpu_resource_unref>(),
        8usize,
        concat!("Alignment of ", stringify!(virtio_gpu_resource_unref))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_unref),
            "::",
            stringify!(hdr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).resource_id) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_unref),
            "::",
            stringify!(resource_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_unref),
            "::",
            stringify!(padding)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct virtio_gpu_resource_create_2d {
    pub hdr: virtio_gpu_ctrl_hdr,
    pub resource_id: __le32,
    pub format: __le32,
    pub width: __le32,
    pub height: __le32,
}
#[test]
fn bindgen_test_layout_virtio_gpu_resource_create_2d() {
    const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_resource_create_2d> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<virtio_gpu_resource_create_2d>(),
        40usize,
        concat!("Size of: ", stringify!(virtio_gpu_resource_create_2d))
    );
    assert_eq!(
        ::std::mem::align_of::<virtio_gpu_resource_create_2d>(),
        8usize,
        concat!("Alignment of ", stringify!(virtio_gpu_resource_create_2d))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_create_2d),
            "::",
            stringify!(hdr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).resource_id) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_create_2d),
            "::",
            stringify!(resource_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).format) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_create_2d),
            "::",
            stringify!(format)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_create_2d),
            "::",
            stringify!(width)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_create_2d),
            "::",
            stringify!(height)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct virtio_gpu_set_scanout {
    pub hdr: virtio_gpu_ctrl_hdr,
    pub r: virtio_gpu_rect,
    pub scanout_id: __le32,
    pub resource_id: __le32,
}
#[test]
fn bindgen_test_layout_virtio_gpu_set_scanout() {
    const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_set_scanout> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<virtio_gpu_set_scanout>(),
        48usize,
        concat!("Size of: ", stringify!(virtio_gpu_set_scanout))
    );
    assert_eq!(
        ::std::mem::align_of::<virtio_gpu_set_scanout>(),
        8usize,
        concat!("Alignment of ", stringify!(virtio_gpu_set_scanout))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_set_scanout),
            "::",
            stringify!(hdr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).r) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_set_scanout),
            "::",
            stringify!(r)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).scanout_id) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_set_scanout),
            "::",
            stringify!(scanout_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).resource_id) as usize - ptr as usize },
        44usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_set_scanout),
            "::",
            stringify!(resource_id)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct virtio_gpu_resource_flush {
    pub hdr: virtio_gpu_ctrl_hdr,
    pub r: virtio_gpu_rect,
    pub resource_id: __le32,
    pub padding: __le32,
}
#[test]
fn bindgen_test_layout_virtio_gpu_resource_flush() {
    const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_resource_flush> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<virtio_gpu_resource_flush>(),
        48usize,
        concat!("Size of: ", stringify!(virtio_gpu_resource_flush))
    );
    assert_eq!(
        ::std::mem::align_of::<virtio_gpu_resource_flush>(),
        8usize,
        concat!("Alignment of ", stringify!(virtio_gpu_resource_flush))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_flush),
            "::",
            stringify!(hdr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).r) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_flush),
            "::",
            stringify!(r)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).resource_id) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_flush),
            "::",
            stringify!(resource_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
        44usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_flush),
            "::",
            stringify!(padding)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct virtio_gpu_transfer_to_host_2d {
    pub hdr: virtio_gpu_ctrl_hdr,
    pub r: virtio_gpu_rect,
    pub offset: __le64,
    pub resource_id: __le32,
    pub padding: __le32,
}
#[test]
fn bindgen_test_layout_virtio_gpu_transfer_to_host_2d() {
    const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_transfer_to_host_2d> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<virtio_gpu_transfer_to_host_2d>(),
        56usize,
        concat!("Size of: ", stringify!(virtio_gpu_transfer_to_host_2d))
    );
    assert_eq!(
        ::std::mem::align_of::<virtio_gpu_transfer_to_host_2d>(),
        8usize,
        concat!("Alignment of ", stringify!(virtio_gpu_transfer_to_host_2d))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_transfer_to_host_2d),
            "::",
            stringify!(hdr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).r) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_transfer_to_host_2d),
            "::",
            stringify!(r)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).offset) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_transfer_to_host_2d),
            "::",
            stringify!(offset)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).resource_id) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_transfer_to_host_2d),
            "::",
            stringify!(resource_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
        52usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_transfer_to_host_2d),
            "::",
            stringify!(padding)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct virtio_gpu_mem_entry {
    pub addr: __le64,
    pub length: __le32,
    pub padding: __le32,
}
#[test]
fn bindgen_test_layout_virtio_gpu_mem_entry() {
    const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_mem_entry> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<virtio_gpu_mem_entry>(),
        16usize,
        concat!("Size of: ", stringify!(virtio_gpu_mem_entry))
    );
    assert_eq!(
        ::std::mem::align_of::<virtio_gpu_mem_entry>(),
        8usize,
        concat!("Alignment of ", stringify!(virtio_gpu_mem_entry))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).addr) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_mem_entry),
            "::",
            stringify!(addr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_mem_entry),
            "::",
            stringify!(length)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_mem_entry),
            "::",
            stringify!(padding)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct virtio_gpu_resource_attach_backing {
    pub hdr: virtio_gpu_ctrl_hdr,
    pub resource_id: __le32,
    pub nr_entries: __le32,
}
#[test]
fn bindgen_test_layout_virtio_gpu_resource_attach_backing() {
    const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_resource_attach_backing> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<virtio_gpu_resource_attach_backing>(),
        32usize,
        concat!("Size of: ", stringify!(virtio_gpu_resource_attach_backing))
    );
    assert_eq!(
        ::std::mem::align_of::<virtio_gpu_resource_attach_backing>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(virtio_gpu_resource_attach_backing)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_attach_backing),
            "::",
            stringify!(hdr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).resource_id) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_attach_backing),
            "::",
            stringify!(resource_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nr_entries) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_attach_backing),
            "::",
            stringify!(nr_entries)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct virtio_gpu_resource_detach_backing {
    pub hdr: virtio_gpu_ctrl_hdr,
    pub resource_id: __le32,
    pub padding: __le32,
}
#[test]
fn bindgen_test_layout_virtio_gpu_resource_detach_backing() {
    const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_resource_detach_backing> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<virtio_gpu_resource_detach_backing>(),
        32usize,
        concat!("Size of: ", stringify!(virtio_gpu_resource_detach_backing))
    );
    assert_eq!(
        ::std::mem::align_of::<virtio_gpu_resource_detach_backing>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(virtio_gpu_resource_detach_backing)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_detach_backing),
            "::",
            stringify!(hdr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).resource_id) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_detach_backing),
            "::",
            stringify!(resource_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_detach_backing),
            "::",
            stringify!(padding)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct virtio_gpu_resp_display_info {
    pub hdr: virtio_gpu_ctrl_hdr,
    pub pmodes: [virtio_gpu_resp_display_info_virtio_gpu_display_one; 16usize],
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct virtio_gpu_resp_display_info_virtio_gpu_display_one {
    pub r: virtio_gpu_rect,
    pub enabled: __le32,
    pub flags: __le32,
}
#[test]
fn bindgen_test_layout_virtio_gpu_resp_display_info_virtio_gpu_display_one() {
    const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_resp_display_info_virtio_gpu_display_one> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<virtio_gpu_resp_display_info_virtio_gpu_display_one>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(virtio_gpu_resp_display_info_virtio_gpu_display_one)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<virtio_gpu_resp_display_info_virtio_gpu_display_one>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(virtio_gpu_resp_display_info_virtio_gpu_display_one)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).r) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resp_display_info_virtio_gpu_display_one),
            "::",
            stringify!(r)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).enabled) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resp_display_info_virtio_gpu_display_one),
            "::",
            stringify!(enabled)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resp_display_info_virtio_gpu_display_one),
            "::",
            stringify!(flags)
        )
    );
}
#[test]
fn bindgen_test_layout_virtio_gpu_resp_display_info() {
    const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_resp_display_info> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<virtio_gpu_resp_display_info>(),
        408usize,
        concat!("Size of: ", stringify!(virtio_gpu_resp_display_info))
    );
    assert_eq!(
        ::std::mem::align_of::<virtio_gpu_resp_display_info>(),
        8usize,
        concat!("Alignment of ", stringify!(virtio_gpu_resp_display_info))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resp_display_info),
            "::",
            stringify!(hdr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pmodes) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resp_display_info),
            "::",
            stringify!(pmodes)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct virtio_gpu_box {
    pub x: __le32,
    pub y: __le32,
    pub z: __le32,
    pub w: __le32,
    pub h: __le32,
    pub d: __le32,
}
#[test]
fn bindgen_test_layout_virtio_gpu_box() {
    const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_box> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<virtio_gpu_box>(),
        24usize,
        concat!("Size of: ", stringify!(virtio_gpu_box))
    );
    assert_eq!(
        ::std::mem::align_of::<virtio_gpu_box>(),
        4usize,
        concat!("Alignment of ", stringify!(virtio_gpu_box))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_box),
            "::",
            stringify!(x)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_box),
            "::",
            stringify!(y)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).z) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_box),
            "::",
            stringify!(z)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).w) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_box),
            "::",
            stringify!(w)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).h) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_box),
            "::",
            stringify!(h)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_box),
            "::",
            stringify!(d)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct virtio_gpu_transfer_host_3d {
    pub hdr: virtio_gpu_ctrl_hdr,
    pub box_: virtio_gpu_box,
    pub offset: __le64,
    pub resource_id: __le32,
    pub level: __le32,
    pub stride: __le32,
    pub layer_stride: __le32,
}
#[test]
fn bindgen_test_layout_virtio_gpu_transfer_host_3d() {
    const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_transfer_host_3d> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<virtio_gpu_transfer_host_3d>(),
        72usize,
        concat!("Size of: ", stringify!(virtio_gpu_transfer_host_3d))
    );
    assert_eq!(
        ::std::mem::align_of::<virtio_gpu_transfer_host_3d>(),
        8usize,
        concat!("Alignment of ", stringify!(virtio_gpu_transfer_host_3d))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_transfer_host_3d),
            "::",
            stringify!(hdr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).box_) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_transfer_host_3d),
            "::",
            stringify!(box_)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).offset) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_transfer_host_3d),
            "::",
            stringify!(offset)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).resource_id) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_transfer_host_3d),
            "::",
            stringify!(resource_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).level) as usize - ptr as usize },
        60usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_transfer_host_3d),
            "::",
            stringify!(level)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).stride) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_transfer_host_3d),
            "::",
            stringify!(stride)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).layer_stride) as usize - ptr as usize },
        68usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_transfer_host_3d),
            "::",
            stringify!(layer_stride)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct virtio_gpu_resource_create_3d {
    pub hdr: virtio_gpu_ctrl_hdr,
    pub resource_id: __le32,
    pub target: __le32,
    pub format: __le32,
    pub bind: __le32,
    pub width: __le32,
    pub height: __le32,
    pub depth: __le32,
    pub array_size: __le32,
    pub last_level: __le32,
    pub nr_samples: __le32,
    pub flags: __le32,
    pub padding: __le32,
}
#[test]
fn bindgen_test_layout_virtio_gpu_resource_create_3d() {
    const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_resource_create_3d> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<virtio_gpu_resource_create_3d>(),
        72usize,
        concat!("Size of: ", stringify!(virtio_gpu_resource_create_3d))
    );
    assert_eq!(
        ::std::mem::align_of::<virtio_gpu_resource_create_3d>(),
        8usize,
        concat!("Alignment of ", stringify!(virtio_gpu_resource_create_3d))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_create_3d),
            "::",
            stringify!(hdr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).resource_id) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_create_3d),
            "::",
            stringify!(resource_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).target) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_create_3d),
            "::",
            stringify!(target)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).format) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_create_3d),
            "::",
            stringify!(format)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bind) as usize - ptr as usize },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_create_3d),
            "::",
            stringify!(bind)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_create_3d),
            "::",
            stringify!(width)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
        44usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_create_3d),
            "::",
            stringify!(height)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).depth) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_create_3d),
            "::",
            stringify!(depth)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).array_size) as usize - ptr as usize },
        52usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_create_3d),
            "::",
            stringify!(array_size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).last_level) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_create_3d),
            "::",
            stringify!(last_level)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nr_samples) as usize - ptr as usize },
        60usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_create_3d),
            "::",
            stringify!(nr_samples)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_create_3d),
            "::",
            stringify!(flags)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
        68usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_create_3d),
            "::",
            stringify!(padding)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct virtio_gpu_ctx_create {
    pub hdr: virtio_gpu_ctrl_hdr,
    pub nlen: __le32,
    pub context_init: __le32,
    pub debug_name: [::std::os::raw::c_char; 64usize],
}
#[test]
fn bindgen_test_layout_virtio_gpu_ctx_create() {
    const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_ctx_create> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<virtio_gpu_ctx_create>(),
        96usize,
        concat!("Size of: ", stringify!(virtio_gpu_ctx_create))
    );
    assert_eq!(
        ::std::mem::align_of::<virtio_gpu_ctx_create>(),
        8usize,
        concat!("Alignment of ", stringify!(virtio_gpu_ctx_create))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_ctx_create),
            "::",
            stringify!(hdr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nlen) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_ctx_create),
            "::",
            stringify!(nlen)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).context_init) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_ctx_create),
            "::",
            stringify!(context_init)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).debug_name) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_ctx_create),
            "::",
            stringify!(debug_name)
        )
    );
}
impl Default for virtio_gpu_ctx_create {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct virtio_gpu_ctx_destroy {
    pub hdr: virtio_gpu_ctrl_hdr,
}
#[test]
fn bindgen_test_layout_virtio_gpu_ctx_destroy() {
    const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_ctx_destroy> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<virtio_gpu_ctx_destroy>(),
        24usize,
        concat!("Size of: ", stringify!(virtio_gpu_ctx_destroy))
    );
    assert_eq!(
        ::std::mem::align_of::<virtio_gpu_ctx_destroy>(),
        8usize,
        concat!("Alignment of ", stringify!(virtio_gpu_ctx_destroy))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_ctx_destroy),
            "::",
            stringify!(hdr)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct virtio_gpu_ctx_resource {
    pub hdr: virtio_gpu_ctrl_hdr,
    pub resource_id: __le32,
    pub padding: __le32,
}
#[test]
fn bindgen_test_layout_virtio_gpu_ctx_resource() {
    const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_ctx_resource> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<virtio_gpu_ctx_resource>(),
        32usize,
        concat!("Size of: ", stringify!(virtio_gpu_ctx_resource))
    );
    assert_eq!(
        ::std::mem::align_of::<virtio_gpu_ctx_resource>(),
        8usize,
        concat!("Alignment of ", stringify!(virtio_gpu_ctx_resource))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_ctx_resource),
            "::",
            stringify!(hdr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).resource_id) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_ctx_resource),
            "::",
            stringify!(resource_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_ctx_resource),
            "::",
            stringify!(padding)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct virtio_gpu_cmd_submit {
    pub hdr: virtio_gpu_ctrl_hdr,
    pub size: __le32,
    pub padding: __le32,
}
#[test]
fn bindgen_test_layout_virtio_gpu_cmd_submit() {
    const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_cmd_submit> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<virtio_gpu_cmd_submit>(),
        32usize,
        concat!("Size of: ", stringify!(virtio_gpu_cmd_submit))
    );
    assert_eq!(
        ::std::mem::align_of::<virtio_gpu_cmd_submit>(),
        8usize,
        concat!("Alignment of ", stringify!(virtio_gpu_cmd_submit))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_cmd_submit),
            "::",
            stringify!(hdr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_cmd_submit),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_cmd_submit),
            "::",
            stringify!(padding)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct virtio_gpu_get_capset_info {
    pub hdr: virtio_gpu_ctrl_hdr,
    pub capset_index: __le32,
    pub padding: __le32,
}
#[test]
fn bindgen_test_layout_virtio_gpu_get_capset_info() {
    const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_get_capset_info> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<virtio_gpu_get_capset_info>(),
        32usize,
        concat!("Size of: ", stringify!(virtio_gpu_get_capset_info))
    );
    assert_eq!(
        ::std::mem::align_of::<virtio_gpu_get_capset_info>(),
        8usize,
        concat!("Alignment of ", stringify!(virtio_gpu_get_capset_info))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_get_capset_info),
            "::",
            stringify!(hdr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capset_index) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_get_capset_info),
            "::",
            stringify!(capset_index)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_get_capset_info),
            "::",
            stringify!(padding)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct virtio_gpu_resp_capset_info {
    pub hdr: virtio_gpu_ctrl_hdr,
    pub capset_id: __le32,
    pub capset_max_version: __le32,
    pub capset_max_size: __le32,
    pub padding: __le32,
}
#[test]
fn bindgen_test_layout_virtio_gpu_resp_capset_info() {
    const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_resp_capset_info> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<virtio_gpu_resp_capset_info>(),
        40usize,
        concat!("Size of: ", stringify!(virtio_gpu_resp_capset_info))
    );
    assert_eq!(
        ::std::mem::align_of::<virtio_gpu_resp_capset_info>(),
        8usize,
        concat!("Alignment of ", stringify!(virtio_gpu_resp_capset_info))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resp_capset_info),
            "::",
            stringify!(hdr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capset_id) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resp_capset_info),
            "::",
            stringify!(capset_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capset_max_version) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resp_capset_info),
            "::",
            stringify!(capset_max_version)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capset_max_size) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resp_capset_info),
            "::",
            stringify!(capset_max_size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resp_capset_info),
            "::",
            stringify!(padding)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct virtio_gpu_get_capset {
    pub hdr: virtio_gpu_ctrl_hdr,
    pub capset_id: __le32,
    pub capset_version: __le32,
}
#[test]
fn bindgen_test_layout_virtio_gpu_get_capset() {
    const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_get_capset> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<virtio_gpu_get_capset>(),
        32usize,
        concat!("Size of: ", stringify!(virtio_gpu_get_capset))
    );
    assert_eq!(
        ::std::mem::align_of::<virtio_gpu_get_capset>(),
        8usize,
        concat!("Alignment of ", stringify!(virtio_gpu_get_capset))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_get_capset),
            "::",
            stringify!(hdr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capset_id) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_get_capset),
            "::",
            stringify!(capset_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capset_version) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_get_capset),
            "::",
            stringify!(capset_version)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct virtio_gpu_resp_capset {
    pub hdr: virtio_gpu_ctrl_hdr,
    pub capset_data: __IncompleteArrayField<__u8>,
}
#[test]
fn bindgen_test_layout_virtio_gpu_resp_capset() {
    const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_resp_capset> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<virtio_gpu_resp_capset>(),
        24usize,
        concat!("Size of: ", stringify!(virtio_gpu_resp_capset))
    );
    assert_eq!(
        ::std::mem::align_of::<virtio_gpu_resp_capset>(),
        8usize,
        concat!("Alignment of ", stringify!(virtio_gpu_resp_capset))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resp_capset),
            "::",
            stringify!(hdr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capset_data) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resp_capset),
            "::",
            stringify!(capset_data)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct virtio_gpu_cmd_get_edid {
    pub hdr: virtio_gpu_ctrl_hdr,
    pub scanout: __le32,
    pub padding: __le32,
}
#[test]
fn bindgen_test_layout_virtio_gpu_cmd_get_edid() {
    const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_cmd_get_edid> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<virtio_gpu_cmd_get_edid>(),
        32usize,
        concat!("Size of: ", stringify!(virtio_gpu_cmd_get_edid))
    );
    assert_eq!(
        ::std::mem::align_of::<virtio_gpu_cmd_get_edid>(),
        8usize,
        concat!("Alignment of ", stringify!(virtio_gpu_cmd_get_edid))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_cmd_get_edid),
            "::",
            stringify!(hdr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).scanout) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_cmd_get_edid),
            "::",
            stringify!(scanout)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_cmd_get_edid),
            "::",
            stringify!(padding)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct virtio_gpu_resp_edid {
    pub hdr: virtio_gpu_ctrl_hdr,
    pub size: __le32,
    pub padding: __le32,
    pub edid: [__u8; 1024usize],
}
#[test]
fn bindgen_test_layout_virtio_gpu_resp_edid() {
    const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_resp_edid> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<virtio_gpu_resp_edid>(),
        1056usize,
        concat!("Size of: ", stringify!(virtio_gpu_resp_edid))
    );
    assert_eq!(
        ::std::mem::align_of::<virtio_gpu_resp_edid>(),
        8usize,
        concat!("Alignment of ", stringify!(virtio_gpu_resp_edid))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resp_edid),
            "::",
            stringify!(hdr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resp_edid),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resp_edid),
            "::",
            stringify!(padding)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).edid) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resp_edid),
            "::",
            stringify!(edid)
        )
    );
}
impl Default for virtio_gpu_resp_edid {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct virtio_gpu_config {
    pub events_read: __le32,
    pub events_clear: __le32,
    pub num_scanouts: __le32,
    pub num_capsets: __le32,
}
#[test]
fn bindgen_test_layout_virtio_gpu_config() {
    const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_config> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<virtio_gpu_config>(),
        16usize,
        concat!("Size of: ", stringify!(virtio_gpu_config))
    );
    assert_eq!(
        ::std::mem::align_of::<virtio_gpu_config>(),
        4usize,
        concat!("Alignment of ", stringify!(virtio_gpu_config))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).events_read) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_config),
            "::",
            stringify!(events_read)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).events_clear) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_config),
            "::",
            stringify!(events_clear)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).num_scanouts) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_config),
            "::",
            stringify!(num_scanouts)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).num_capsets) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_config),
            "::",
            stringify!(num_capsets)
        )
    );
}
pub const virtio_gpu_formats_VIRTIO_GPU_FORMAT_B8G8R8A8_UNORM: virtio_gpu_formats = 1;
pub const virtio_gpu_formats_VIRTIO_GPU_FORMAT_B8G8R8X8_UNORM: virtio_gpu_formats = 2;
pub const virtio_gpu_formats_VIRTIO_GPU_FORMAT_A8R8G8B8_UNORM: virtio_gpu_formats = 3;
pub const virtio_gpu_formats_VIRTIO_GPU_FORMAT_X8R8G8B8_UNORM: virtio_gpu_formats = 4;
pub const virtio_gpu_formats_VIRTIO_GPU_FORMAT_R8G8B8A8_UNORM: virtio_gpu_formats = 67;
pub const virtio_gpu_formats_VIRTIO_GPU_FORMAT_X8B8G8R8_UNORM: virtio_gpu_formats = 68;
pub const virtio_gpu_formats_VIRTIO_GPU_FORMAT_A8B8G8R8_UNORM: virtio_gpu_formats = 121;
pub const virtio_gpu_formats_VIRTIO_GPU_FORMAT_R8G8B8X8_UNORM: virtio_gpu_formats = 134;
pub type virtio_gpu_formats = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct virtio_gpu_resource_assign_uuid {
    pub hdr: virtio_gpu_ctrl_hdr,
    pub resource_id: __le32,
    pub padding: __le32,
}
#[test]
fn bindgen_test_layout_virtio_gpu_resource_assign_uuid() {
    const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_resource_assign_uuid> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<virtio_gpu_resource_assign_uuid>(),
        32usize,
        concat!("Size of: ", stringify!(virtio_gpu_resource_assign_uuid))
    );
    assert_eq!(
        ::std::mem::align_of::<virtio_gpu_resource_assign_uuid>(),
        8usize,
        concat!("Alignment of ", stringify!(virtio_gpu_resource_assign_uuid))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_assign_uuid),
            "::",
            stringify!(hdr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).resource_id) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_assign_uuid),
            "::",
            stringify!(resource_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_assign_uuid),
            "::",
            stringify!(padding)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct virtio_gpu_resp_resource_uuid {
    pub hdr: virtio_gpu_ctrl_hdr,
    pub uuid: [__u8; 16usize],
}
#[test]
fn bindgen_test_layout_virtio_gpu_resp_resource_uuid() {
    const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_resp_resource_uuid> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<virtio_gpu_resp_resource_uuid>(),
        40usize,
        concat!("Size of: ", stringify!(virtio_gpu_resp_resource_uuid))
    );
    assert_eq!(
        ::std::mem::align_of::<virtio_gpu_resp_resource_uuid>(),
        8usize,
        concat!("Alignment of ", stringify!(virtio_gpu_resp_resource_uuid))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resp_resource_uuid),
            "::",
            stringify!(hdr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uuid) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resp_resource_uuid),
            "::",
            stringify!(uuid)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct virtio_gpu_resource_create_blob {
    pub hdr: virtio_gpu_ctrl_hdr,
    pub resource_id: __le32,
    pub blob_mem: __le32,
    pub blob_flags: __le32,
    pub nr_entries: __le32,
    pub blob_id: __le64,
    pub size: __le64,
}
#[test]
fn bindgen_test_layout_virtio_gpu_resource_create_blob() {
    const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_resource_create_blob> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<virtio_gpu_resource_create_blob>(),
        56usize,
        concat!("Size of: ", stringify!(virtio_gpu_resource_create_blob))
    );
    assert_eq!(
        ::std::mem::align_of::<virtio_gpu_resource_create_blob>(),
        8usize,
        concat!("Alignment of ", stringify!(virtio_gpu_resource_create_blob))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_create_blob),
            "::",
            stringify!(hdr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).resource_id) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_create_blob),
            "::",
            stringify!(resource_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).blob_mem) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_create_blob),
            "::",
            stringify!(blob_mem)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).blob_flags) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_create_blob),
            "::",
            stringify!(blob_flags)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nr_entries) as usize - ptr as usize },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_create_blob),
            "::",
            stringify!(nr_entries)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).blob_id) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_create_blob),
            "::",
            stringify!(blob_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_create_blob),
            "::",
            stringify!(size)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct virtio_gpu_set_scanout_blob {
    pub hdr: virtio_gpu_ctrl_hdr,
    pub r: virtio_gpu_rect,
    pub scanout_id: __le32,
    pub resource_id: __le32,
    pub width: __le32,
    pub height: __le32,
    pub format: __le32,
    pub padding: __le32,
    pub strides: [__le32; 4usize],
    pub offsets: [__le32; 4usize],
}
#[test]
fn bindgen_test_layout_virtio_gpu_set_scanout_blob() {
    const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_set_scanout_blob> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<virtio_gpu_set_scanout_blob>(),
        96usize,
        concat!("Size of: ", stringify!(virtio_gpu_set_scanout_blob))
    );
    assert_eq!(
        ::std::mem::align_of::<virtio_gpu_set_scanout_blob>(),
        8usize,
        concat!("Alignment of ", stringify!(virtio_gpu_set_scanout_blob))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_set_scanout_blob),
            "::",
            stringify!(hdr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).r) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_set_scanout_blob),
            "::",
            stringify!(r)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).scanout_id) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_set_scanout_blob),
            "::",
            stringify!(scanout_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).resource_id) as usize - ptr as usize },
        44usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_set_scanout_blob),
            "::",
            stringify!(resource_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_set_scanout_blob),
            "::",
            stringify!(width)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
        52usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_set_scanout_blob),
            "::",
            stringify!(height)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).format) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_set_scanout_blob),
            "::",
            stringify!(format)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
        60usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_set_scanout_blob),
            "::",
            stringify!(padding)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).strides) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_set_scanout_blob),
            "::",
            stringify!(strides)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).offsets) as usize - ptr as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_set_scanout_blob),
            "::",
            stringify!(offsets)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct virtio_gpu_resource_map_blob {
    pub hdr: virtio_gpu_ctrl_hdr,
    pub resource_id: __le32,
    pub padding: __le32,
    pub offset: __le64,
}
#[test]
fn bindgen_test_layout_virtio_gpu_resource_map_blob() {
    const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_resource_map_blob> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<virtio_gpu_resource_map_blob>(),
        40usize,
        concat!("Size of: ", stringify!(virtio_gpu_resource_map_blob))
    );
    assert_eq!(
        ::std::mem::align_of::<virtio_gpu_resource_map_blob>(),
        8usize,
        concat!("Alignment of ", stringify!(virtio_gpu_resource_map_blob))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_map_blob),
            "::",
            stringify!(hdr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).resource_id) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_map_blob),
            "::",
            stringify!(resource_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_map_blob),
            "::",
            stringify!(padding)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).offset) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_map_blob),
            "::",
            stringify!(offset)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct virtio_gpu_resp_map_info {
    pub hdr: virtio_gpu_ctrl_hdr,
    pub map_info: __u32,
    pub padding: __u32,
}
#[test]
fn bindgen_test_layout_virtio_gpu_resp_map_info() {
    const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_resp_map_info> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<virtio_gpu_resp_map_info>(),
        32usize,
        concat!("Size of: ", stringify!(virtio_gpu_resp_map_info))
    );
    assert_eq!(
        ::std::mem::align_of::<virtio_gpu_resp_map_info>(),
        8usize,
        concat!("Alignment of ", stringify!(virtio_gpu_resp_map_info))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resp_map_info),
            "::",
            stringify!(hdr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).map_info) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resp_map_info),
            "::",
            stringify!(map_info)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resp_map_info),
            "::",
            stringify!(padding)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct virtio_gpu_resource_unmap_blob {
    pub hdr: virtio_gpu_ctrl_hdr,
    pub resource_id: __le32,
    pub padding: __le32,
}
#[test]
fn bindgen_test_layout_virtio_gpu_resource_unmap_blob() {
    const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_resource_unmap_blob> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<virtio_gpu_resource_unmap_blob>(),
        32usize,
        concat!("Size of: ", stringify!(virtio_gpu_resource_unmap_blob))
    );
    assert_eq!(
        ::std::mem::align_of::<virtio_gpu_resource_unmap_blob>(),
        8usize,
        concat!("Alignment of ", stringify!(virtio_gpu_resource_unmap_blob))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_unmap_blob),
            "::",
            stringify!(hdr)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).resource_id) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_unmap_blob),
            "::",
            stringify!(resource_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(virtio_gpu_resource_unmap_blob),
            "::",
            stringify!(padding)
        )
    );
}
