//! Bindings from "cuda.h" generated by rust-bindgen 0.60.1

pub const CUDA_VERSION: u32 = 11030;
pub const CU_IPC_HANDLE_SIZE: u32 = 64;
pub const CU_MEMHOSTALLOC_PORTABLE: u32 = 1;
pub const CU_MEMHOSTALLOC_DEVICEMAP: u32 = 2;
pub const CU_MEMHOSTALLOC_WRITECOMBINED: u32 = 4;
pub const CU_MEMHOSTREGISTER_PORTABLE: u32 = 1;
pub const CU_MEMHOSTREGISTER_DEVICEMAP: u32 = 2;
pub const CU_MEMHOSTREGISTER_IOMEMORY: u32 = 4;
pub const CU_MEMHOSTREGISTER_READ_ONLY: u32 = 8;
pub const CU_ARRAY_SPARSE_PROPERTIES_SINGLE_MIPTAIL: u32 = 1;
pub const CUDA_EXTERNAL_MEMORY_DEDICATED: u32 = 1;
pub const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_SKIP_NVSCIBUF_MEMSYNC: u32 = 1;
pub const CUDA_EXTERNAL_SEMAPHORE_WAIT_SKIP_NVSCIBUF_MEMSYNC: u32 = 2;
pub const CUDA_NVSCISYNC_ATTR_SIGNAL: u32 = 1;
pub const CUDA_NVSCISYNC_ATTR_WAIT: u32 = 2;
pub const CU_MEM_CREATE_USAGE_TILE_POOL: u32 = 1;
pub const CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_PRE_LAUNCH_SYNC: u32 = 1;
pub const CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_POST_LAUNCH_SYNC: u32 = 2;
pub const CUDA_ARRAY3D_LAYERED: u32 = 1;
pub const CUDA_ARRAY3D_2DARRAY: u32 = 1;
pub const CUDA_ARRAY3D_SURFACE_LDST: u32 = 2;
pub const CUDA_ARRAY3D_CUBEMAP: u32 = 4;
pub const CUDA_ARRAY3D_TEXTURE_GATHER: u32 = 8;
pub const CUDA_ARRAY3D_DEPTH_TEXTURE: u32 = 16;
pub const CUDA_ARRAY3D_COLOR_ATTACHMENT: u32 = 32;
pub const CUDA_ARRAY3D_SPARSE: u32 = 64;
pub const CU_TRSA_OVERRIDE_FORMAT: u32 = 1;
pub const CU_TRSF_READ_AS_INTEGER: u32 = 1;
pub const CU_TRSF_NORMALIZED_COORDINATES: u32 = 2;
pub const CU_TRSF_SRGB: u32 = 16;
pub const CU_TRSF_DISABLE_TRILINEAR_OPTIMIZATION: u32 = 32;
pub const CU_PARAM_TR_DEFAULT: i32 = -1;
pub type __uint32_t = core::ffi::c_uint;
pub type __uint64_t = core::ffi::c_ulong;
pub type cuuint32_t = u32;
pub type cuuint64_t = u64;
pub type CUdeviceptr_v2 = core::ffi::c_ulonglong;
pub type CUdeviceptr = CUdeviceptr_v2;
pub type CUdevice_v1 = core::ffi::c_int;
pub type CUdevice = CUdevice_v1;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CUctx_st {
    _unused: [u8; 0],
}
pub type CUcontext = *mut CUctx_st;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CUmod_st {
    _unused: [u8; 0],
}
pub type CUmodule = *mut CUmod_st;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CUfunc_st {
    _unused: [u8; 0],
}
pub type CUfunction = *mut CUfunc_st;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CUarray_st {
    _unused: [u8; 0],
}
pub type CUarray = *mut CUarray_st;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CUmipmappedArray_st {
    _unused: [u8; 0],
}
pub type CUmipmappedArray = *mut CUmipmappedArray_st;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CUtexref_st {
    _unused: [u8; 0],
}
pub type CUtexref = *mut CUtexref_st;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CUsurfref_st {
    _unused: [u8; 0],
}
pub type CUsurfref = *mut CUsurfref_st;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CUevent_st {
    _unused: [u8; 0],
}
pub type CUevent = *mut CUevent_st;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CUstream_st {
    _unused: [u8; 0],
}
pub type CUstream = *mut CUstream_st;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CUgraphicsResource_st {
    _unused: [u8; 0],
}
pub type CUgraphicsResource = *mut CUgraphicsResource_st;
pub type CUtexObject_v1 = core::ffi::c_ulonglong;
pub type CUtexObject = CUtexObject_v1;
pub type CUsurfObject_v1 = core::ffi::c_ulonglong;
pub type CUsurfObject = CUsurfObject_v1;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CUextMemory_st {
    _unused: [u8; 0],
}
pub type CUexternalMemory = *mut CUextMemory_st;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CUextSemaphore_st {
    _unused: [u8; 0],
}
pub type CUexternalSemaphore = *mut CUextSemaphore_st;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CUgraph_st {
    _unused: [u8; 0],
}
pub type CUgraph = *mut CUgraph_st;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CUgraphNode_st {
    _unused: [u8; 0],
}
pub type CUgraphNode = *mut CUgraphNode_st;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CUgraphExec_st {
    _unused: [u8; 0],
}
pub type CUgraphExec = *mut CUgraphExec_st;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CUmemPoolHandle_st {
    _unused: [u8; 0],
}
pub type CUmemoryPool = *mut CUmemPoolHandle_st;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CUuserObject_st {
    _unused: [u8; 0],
}
pub type CUuserObject = *mut CUuserObject_st;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct CUuuid_st {
    pub bytes: [core::ffi::c_char; 16usize],
}
#[test]
fn bindgen_test_layout_CUuuid_st() {
    assert_eq!(
        ::core::mem::size_of::<CUuuid_st>(),
        16usize,
        concat!("Size of: ", stringify!(CUuuid_st))
    );
    assert_eq!(
        ::core::mem::align_of::<CUuuid_st>(),
        1usize,
        concat!("Alignment of ", stringify!(CUuuid_st))
    );
    fn test_field_bytes() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUuuid_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).bytes) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUuuid_st),
                "::",
                stringify!(bytes)
            )
        );
    }
    test_field_bytes();
}
pub type CUuuid = CUuuid_st;
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct CUipcEventHandle_st {
    pub reserved: [core::ffi::c_char; 64usize],
}
#[test]
fn bindgen_test_layout_CUipcEventHandle_st() {
    assert_eq!(
        ::core::mem::size_of::<CUipcEventHandle_st>(),
        64usize,
        concat!("Size of: ", stringify!(CUipcEventHandle_st))
    );
    assert_eq!(
        ::core::mem::align_of::<CUipcEventHandle_st>(),
        1usize,
        concat!("Alignment of ", stringify!(CUipcEventHandle_st))
    );
    fn test_field_reserved() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUipcEventHandle_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUipcEventHandle_st),
                "::",
                stringify!(reserved)
            )
        );
    }
    test_field_reserved();
}
impl Default for CUipcEventHandle_st {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type CUipcEventHandle_v1 = CUipcEventHandle_st;
pub type CUipcEventHandle = CUipcEventHandle_v1;
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct CUipcMemHandle_st {
    pub reserved: [core::ffi::c_char; 64usize],
}
#[test]
fn bindgen_test_layout_CUipcMemHandle_st() {
    assert_eq!(
        ::core::mem::size_of::<CUipcMemHandle_st>(),
        64usize,
        concat!("Size of: ", stringify!(CUipcMemHandle_st))
    );
    assert_eq!(
        ::core::mem::align_of::<CUipcMemHandle_st>(),
        1usize,
        concat!("Alignment of ", stringify!(CUipcMemHandle_st))
    );
    fn test_field_reserved() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUipcMemHandle_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUipcMemHandle_st),
                "::",
                stringify!(reserved)
            )
        );
    }
    test_field_reserved();
}
impl Default for CUipcMemHandle_st {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type CUipcMemHandle_v1 = CUipcMemHandle_st;
pub type CUipcMemHandle = CUipcMemHandle_v1;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUipcMem_flags_enum {
    CU_IPC_MEM_LAZY_ENABLE_PEER_ACCESS = 1,
}
pub use self::CUipcMem_flags_enum as CUipcMem_flags;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUmemAttach_flags_enum {
    CU_MEM_ATTACH_GLOBAL = 1,
    CU_MEM_ATTACH_HOST = 2,
    CU_MEM_ATTACH_SINGLE = 4,
}
pub use self::CUmemAttach_flags_enum as CUmemAttach_flags;
impl CUctx_flags_enum {
    pub const CU_CTX_BLOCKING_SYNC: CUctx_flags_enum = CUctx_flags_enum::CU_CTX_SCHED_BLOCKING_SYNC;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUctx_flags_enum {
    CU_CTX_SCHED_AUTO = 0,
    CU_CTX_SCHED_SPIN = 1,
    CU_CTX_SCHED_YIELD = 2,
    CU_CTX_SCHED_BLOCKING_SYNC = 4,
    CU_CTX_SCHED_MASK = 7,
    CU_CTX_MAP_HOST = 8,
    CU_CTX_LMEM_RESIZE_TO_MAX = 16,
    CU_CTX_FLAGS_MASK = 31,
}
pub use self::CUctx_flags_enum as CUctx_flags;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUstream_flags_enum {
    CU_STREAM_DEFAULT = 0,
    CU_STREAM_NON_BLOCKING = 1,
}
pub use self::CUstream_flags_enum as CUstream_flags;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUevent_flags_enum {
    CU_EVENT_DEFAULT = 0,
    CU_EVENT_BLOCKING_SYNC = 1,
    CU_EVENT_DISABLE_TIMING = 2,
    CU_EVENT_INTERPROCESS = 4,
}
pub use self::CUevent_flags_enum as CUevent_flags;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUevent_record_flags_enum {
    CU_EVENT_RECORD_DEFAULT = 0,
    CU_EVENT_RECORD_EXTERNAL = 1,
}
pub use self::CUevent_record_flags_enum as CUevent_record_flags;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUevent_wait_flags_enum {
    CU_EVENT_WAIT_DEFAULT = 0,
    CU_EVENT_WAIT_EXTERNAL = 1,
}
pub use self::CUevent_wait_flags_enum as CUevent_wait_flags;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUstreamWaitValue_flags_enum {
    CU_STREAM_WAIT_VALUE_GEQ = 0,
    CU_STREAM_WAIT_VALUE_EQ = 1,
    CU_STREAM_WAIT_VALUE_AND = 2,
    CU_STREAM_WAIT_VALUE_NOR = 3,
    CU_STREAM_WAIT_VALUE_FLUSH = 1073741824,
}
pub use self::CUstreamWaitValue_flags_enum as CUstreamWaitValue_flags;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUstreamWriteValue_flags_enum {
    CU_STREAM_WRITE_VALUE_DEFAULT = 0,
    CU_STREAM_WRITE_VALUE_NO_MEMORY_BARRIER = 1,
}
pub use self::CUstreamWriteValue_flags_enum as CUstreamWriteValue_flags;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUstreamBatchMemOpType_enum {
    CU_STREAM_MEM_OP_WAIT_VALUE_32 = 1,
    CU_STREAM_MEM_OP_WRITE_VALUE_32 = 2,
    CU_STREAM_MEM_OP_WAIT_VALUE_64 = 4,
    CU_STREAM_MEM_OP_WRITE_VALUE_64 = 5,
    CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES = 3,
}
pub use self::CUstreamBatchMemOpType_enum as CUstreamBatchMemOpType;
#[repr(C)]
#[derive(Copy, Clone)]
pub union CUstreamBatchMemOpParams_union {
    pub operation: CUstreamBatchMemOpType,
    pub waitValue: CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st,
    pub writeValue: CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st,
    pub flushRemoteWrites: CUstreamBatchMemOpParams_union_CUstreamMemOpFlushRemoteWritesParams_st,
    pub pad: [cuuint64_t; 6usize],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st {
    pub operation: CUstreamBatchMemOpType,
    pub address: CUdeviceptr,
    pub __bindgen_anon_1:
        CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st__bindgen_ty_1,
    pub flags: core::ffi::c_uint,
    pub alias: CUdeviceptr,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st__bindgen_ty_1 {
    pub value: cuuint32_t,
    pub value64: cuuint64_t,
}
#[test]
fn bindgen_test_layout_CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st__bindgen_ty_1(
) {
    assert_eq!(
        ::core::mem::size_of::<
            CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st__bindgen_ty_1,
        >(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(
                CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st__bindgen_ty_1
            )
        )
    );
    assert_eq!(
        ::core::mem::align_of::<
            CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st__bindgen_ty_1,
        >(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(
                CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st__bindgen_ty_1
            )
        )
    );
    fn test_field_value() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st__bindgen_ty_1,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).value) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(
                    CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st__bindgen_ty_1
                ),
                "::",
                stringify!(value)
            )
        );
    }
    test_field_value();
    fn test_field_value64() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st__bindgen_ty_1,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).value64) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(
                    CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st__bindgen_ty_1
                ),
                "::",
                stringify!(value64)
            )
        );
    }
    test_field_value64();
}
impl Default for CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[test]
fn bindgen_test_layout_CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st() {
    assert_eq!(
        ::core::mem::size_of::<CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st>(),
        40usize,
        concat!(
            "Size of: ",
            stringify!(CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st)
        )
    );
    fn test_field_operation() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).operation) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st),
                "::",
                stringify!(operation)
            )
        );
    }
    test_field_operation();
    fn test_field_address() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).address) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st),
                "::",
                stringify!(address)
            )
        );
    }
    test_field_address();
    fn test_field_flags() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st),
                "::",
                stringify!(flags)
            )
        );
    }
    test_field_flags();
    fn test_field_alias() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).alias) as usize - ptr as usize
            },
            32usize,
            concat!(
                "Offset of field: ",
                stringify!(CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st),
                "::",
                stringify!(alias)
            )
        );
    }
    test_field_alias();
}
impl Default for CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st {
    pub operation: CUstreamBatchMemOpType,
    pub address: CUdeviceptr,
    pub __bindgen_anon_1:
        CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st__bindgen_ty_1,
    pub flags: core::ffi::c_uint,
    pub alias: CUdeviceptr,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st__bindgen_ty_1 {
    pub value: cuuint32_t,
    pub value64: cuuint64_t,
}
#[test]
fn bindgen_test_layout_CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st__bindgen_ty_1(
) {
    assert_eq!(
        ::core::mem::size_of::<
            CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st__bindgen_ty_1,
        >(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(
                CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st__bindgen_ty_1
            )
        )
    );
    assert_eq!(
        ::core::mem::align_of::<
            CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st__bindgen_ty_1,
        >(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(
                CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st__bindgen_ty_1
            )
        )
    );
    fn test_field_value() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st__bindgen_ty_1,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).value) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(
                    CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st__bindgen_ty_1
                ),
                "::",
                stringify!(value)
            )
        );
    }
    test_field_value();
    fn test_field_value64() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st__bindgen_ty_1,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).value64) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(
                    CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st__bindgen_ty_1
                ),
                "::",
                stringify!(value64)
            )
        );
    }
    test_field_value64();
}
impl Default for CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[test]
fn bindgen_test_layout_CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st() {
    assert_eq!(
        ::core::mem::size_of::<CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st>(),
        40usize,
        concat!(
            "Size of: ",
            stringify!(CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st)
        )
    );
    fn test_field_operation() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).operation) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st),
                "::",
                stringify!(operation)
            )
        );
    }
    test_field_operation();
    fn test_field_address() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).address) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st),
                "::",
                stringify!(address)
            )
        );
    }
    test_field_address();
    fn test_field_flags() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st),
                "::",
                stringify!(flags)
            )
        );
    }
    test_field_flags();
    fn test_field_alias() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).alias) as usize - ptr as usize
            },
            32usize,
            concat!(
                "Offset of field: ",
                stringify!(CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st),
                "::",
                stringify!(alias)
            )
        );
    }
    test_field_alias();
}
impl Default for CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct CUstreamBatchMemOpParams_union_CUstreamMemOpFlushRemoteWritesParams_st {
    pub operation: CUstreamBatchMemOpType,
    pub flags: core::ffi::c_uint,
}
#[test]
fn bindgen_test_layout_CUstreamBatchMemOpParams_union_CUstreamMemOpFlushRemoteWritesParams_st() {
    assert_eq!(
        ::core::mem::size_of::<
            CUstreamBatchMemOpParams_union_CUstreamMemOpFlushRemoteWritesParams_st,
        >(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(CUstreamBatchMemOpParams_union_CUstreamMemOpFlushRemoteWritesParams_st)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<
            CUstreamBatchMemOpParams_union_CUstreamMemOpFlushRemoteWritesParams_st,
        >(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(CUstreamBatchMemOpParams_union_CUstreamMemOpFlushRemoteWritesParams_st)
        )
    );
    fn test_field_operation() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUstreamBatchMemOpParams_union_CUstreamMemOpFlushRemoteWritesParams_st,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).operation) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUstreamBatchMemOpParams_union_CUstreamMemOpFlushRemoteWritesParams_st),
                "::",
                stringify!(operation)
            )
        );
    }
    test_field_operation();
    fn test_field_flags() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUstreamBatchMemOpParams_union_CUstreamMemOpFlushRemoteWritesParams_st,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize
            },
            4usize,
            concat!(
                "Offset of field: ",
                stringify!(CUstreamBatchMemOpParams_union_CUstreamMemOpFlushRemoteWritesParams_st),
                "::",
                stringify!(flags)
            )
        );
    }
    test_field_flags();
}
impl Default for CUstreamBatchMemOpParams_union_CUstreamMemOpFlushRemoteWritesParams_st {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[test]
fn bindgen_test_layout_CUstreamBatchMemOpParams_union() {
    assert_eq!(
        ::core::mem::size_of::<CUstreamBatchMemOpParams_union>(),
        48usize,
        concat!("Size of: ", stringify!(CUstreamBatchMemOpParams_union))
    );
    assert_eq!(
        ::core::mem::align_of::<CUstreamBatchMemOpParams_union>(),
        8usize,
        concat!("Alignment of ", stringify!(CUstreamBatchMemOpParams_union))
    );
    fn test_field_operation() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUstreamBatchMemOpParams_union>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).operation) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUstreamBatchMemOpParams_union),
                "::",
                stringify!(operation)
            )
        );
    }
    test_field_operation();
    fn test_field_waitValue() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUstreamBatchMemOpParams_union>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).waitValue) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUstreamBatchMemOpParams_union),
                "::",
                stringify!(waitValue)
            )
        );
    }
    test_field_waitValue();
    fn test_field_writeValue() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUstreamBatchMemOpParams_union>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).writeValue) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUstreamBatchMemOpParams_union),
                "::",
                stringify!(writeValue)
            )
        );
    }
    test_field_writeValue();
    fn test_field_flushRemoteWrites() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUstreamBatchMemOpParams_union>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).flushRemoteWrites) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUstreamBatchMemOpParams_union),
                "::",
                stringify!(flushRemoteWrites)
            )
        );
    }
    test_field_flushRemoteWrites();
    fn test_field_pad() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUstreamBatchMemOpParams_union>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).pad) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUstreamBatchMemOpParams_union),
                "::",
                stringify!(pad)
            )
        );
    }
    test_field_pad();
}
impl Default for CUstreamBatchMemOpParams_union {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type CUstreamBatchMemOpParams_v1 = CUstreamBatchMemOpParams_union;
pub type CUstreamBatchMemOpParams = CUstreamBatchMemOpParams_v1;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUoccupancy_flags_enum {
    CU_OCCUPANCY_DEFAULT = 0,
    CU_OCCUPANCY_DISABLE_CACHING_OVERRIDE = 1,
}
pub use self::CUoccupancy_flags_enum as CUoccupancy_flags;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUstreamUpdateCaptureDependencies_flags_enum {
    CU_STREAM_ADD_CAPTURE_DEPENDENCIES = 0,
    CU_STREAM_SET_CAPTURE_DEPENDENCIES = 1,
}
pub use self::CUstreamUpdateCaptureDependencies_flags_enum as CUstreamUpdateCaptureDependencies_flags;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUarray_format_enum {
    CU_AD_FORMAT_UNSIGNED_INT8 = 1,
    CU_AD_FORMAT_UNSIGNED_INT16 = 2,
    CU_AD_FORMAT_UNSIGNED_INT32 = 3,
    CU_AD_FORMAT_SIGNED_INT8 = 8,
    CU_AD_FORMAT_SIGNED_INT16 = 9,
    CU_AD_FORMAT_SIGNED_INT32 = 10,
    CU_AD_FORMAT_HALF = 16,
    CU_AD_FORMAT_FLOAT = 32,
    CU_AD_FORMAT_NV12 = 176,
}
pub use self::CUarray_format_enum as CUarray_format;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUaddress_mode_enum {
    CU_TR_ADDRESS_MODE_WRAP = 0,
    CU_TR_ADDRESS_MODE_CLAMP = 1,
    CU_TR_ADDRESS_MODE_MIRROR = 2,
    CU_TR_ADDRESS_MODE_BORDER = 3,
}
pub use self::CUaddress_mode_enum as CUaddress_mode;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUfilter_mode_enum {
    CU_TR_FILTER_MODE_POINT = 0,
    CU_TR_FILTER_MODE_LINEAR = 1,
}
pub use self::CUfilter_mode_enum as CUfilter_mode;
impl CUdevice_attribute_enum {
    pub const CU_DEVICE_ATTRIBUTE_SHARED_MEMORY_PER_BLOCK: CUdevice_attribute_enum =
        CUdevice_attribute_enum::CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK;
}
impl CUdevice_attribute_enum {
    pub const CU_DEVICE_ATTRIBUTE_REGISTERS_PER_BLOCK: CUdevice_attribute_enum =
        CUdevice_attribute_enum::CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK;
}
impl CUdevice_attribute_enum {
    pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_WIDTH: CUdevice_attribute_enum =
        CUdevice_attribute_enum::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH;
}
impl CUdevice_attribute_enum {
    pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_HEIGHT: CUdevice_attribute_enum =
        CUdevice_attribute_enum::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT;
}
impl CUdevice_attribute_enum {
    pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_NUMSLICES: CUdevice_attribute_enum =
        CUdevice_attribute_enum::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS;
}
impl CUdevice_attribute_enum {
    pub const CU_DEVICE_ATTRIBUTE_VIRTUAL_MEMORY_MANAGEMENT_SUPPORTED: CUdevice_attribute_enum =
        CUdevice_attribute_enum::CU_DEVICE_ATTRIBUTE_VIRTUAL_ADDRESS_MANAGEMENT_SUPPORTED;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUdevice_attribute_enum {
    CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK = 1,
    CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X = 2,
    CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y = 3,
    CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z = 4,
    CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X = 5,
    CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y = 6,
    CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z = 7,
    CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK = 8,
    CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY = 9,
    CU_DEVICE_ATTRIBUTE_WARP_SIZE = 10,
    CU_DEVICE_ATTRIBUTE_MAX_PITCH = 11,
    CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK = 12,
    CU_DEVICE_ATTRIBUTE_CLOCK_RATE = 13,
    CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT = 14,
    CU_DEVICE_ATTRIBUTE_GPU_OVERLAP = 15,
    CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT = 16,
    CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT = 17,
    CU_DEVICE_ATTRIBUTE_INTEGRATED = 18,
    CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY = 19,
    CU_DEVICE_ATTRIBUTE_COMPUTE_MODE = 20,
    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH = 21,
    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_WIDTH = 22,
    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_HEIGHT = 23,
    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH = 24,
    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT = 25,
    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH = 26,
    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH = 27,
    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT = 28,
    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS = 29,
    CU_DEVICE_ATTRIBUTE_SURFACE_ALIGNMENT = 30,
    CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS = 31,
    CU_DEVICE_ATTRIBUTE_ECC_ENABLED = 32,
    CU_DEVICE_ATTRIBUTE_PCI_BUS_ID = 33,
    CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID = 34,
    CU_DEVICE_ATTRIBUTE_TCC_DRIVER = 35,
    CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE = 36,
    CU_DEVICE_ATTRIBUTE_GLOBAL_MEMORY_BUS_WIDTH = 37,
    CU_DEVICE_ATTRIBUTE_L2_CACHE_SIZE = 38,
    CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_MULTIPROCESSOR = 39,
    CU_DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT = 40,
    CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING = 41,
    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_WIDTH = 42,
    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_LAYERS = 43,
    CU_DEVICE_ATTRIBUTE_CAN_TEX2D_GATHER = 44,
    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_WIDTH = 45,
    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_HEIGHT = 46,
    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH_ALTERNATE = 47,
    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT_ALTERNATE = 48,
    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH_ALTERNATE = 49,
    CU_DEVICE_ATTRIBUTE_PCI_DOMAIN_ID = 50,
    CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT = 51,
    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_WIDTH = 52,
    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_WIDTH = 53,
    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_LAYERS = 54,
    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_WIDTH = 55,
    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_WIDTH = 56,
    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_HEIGHT = 57,
    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_WIDTH = 58,
    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_HEIGHT = 59,
    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_DEPTH = 60,
    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_WIDTH = 61,
    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_LAYERS = 62,
    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_WIDTH = 63,
    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_HEIGHT = 64,
    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_LAYERS = 65,
    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_WIDTH = 66,
    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_WIDTH = 67,
    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_LAYERS = 68,
    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LINEAR_WIDTH = 69,
    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_WIDTH = 70,
    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_HEIGHT = 71,
    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_PITCH = 72,
    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_WIDTH = 73,
    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_HEIGHT = 74,
    CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR = 75,
    CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR = 76,
    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_MIPMAPPED_WIDTH = 77,
    CU_DEVICE_ATTRIBUTE_STREAM_PRIORITIES_SUPPORTED = 78,
    CU_DEVICE_ATTRIBUTE_GLOBAL_L1_CACHE_SUPPORTED = 79,
    CU_DEVICE_ATTRIBUTE_LOCAL_L1_CACHE_SUPPORTED = 80,
    CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR = 81,
    CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_MULTIPROCESSOR = 82,
    CU_DEVICE_ATTRIBUTE_MANAGED_MEMORY = 83,
    CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD = 84,
    CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD_GROUP_ID = 85,
    CU_DEVICE_ATTRIBUTE_HOST_NATIVE_ATOMIC_SUPPORTED = 86,
    CU_DEVICE_ATTRIBUTE_SINGLE_TO_DOUBLE_PRECISION_PERF_RATIO = 87,
    CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS = 88,
    CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS = 89,
    CU_DEVICE_ATTRIBUTE_COMPUTE_PREEMPTION_SUPPORTED = 90,
    CU_DEVICE_ATTRIBUTE_CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM = 91,
    CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_MEM_OPS = 92,
    CU_DEVICE_ATTRIBUTE_CAN_USE_64_BIT_STREAM_MEM_OPS = 93,
    CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_WAIT_VALUE_NOR = 94,
    CU_DEVICE_ATTRIBUTE_COOPERATIVE_LAUNCH = 95,
    CU_DEVICE_ATTRIBUTE_COOPERATIVE_MULTI_DEVICE_LAUNCH = 96,
    CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK_OPTIN = 97,
    CU_DEVICE_ATTRIBUTE_CAN_FLUSH_REMOTE_WRITES = 98,
    CU_DEVICE_ATTRIBUTE_HOST_REGISTER_SUPPORTED = 99,
    CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES = 100,
    CU_DEVICE_ATTRIBUTE_DIRECT_MANAGED_MEM_ACCESS_FROM_HOST = 101,
    CU_DEVICE_ATTRIBUTE_VIRTUAL_ADDRESS_MANAGEMENT_SUPPORTED = 102,
    CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR_SUPPORTED = 103,
    CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_WIN32_HANDLE_SUPPORTED = 104,
    CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_WIN32_KMT_HANDLE_SUPPORTED = 105,
    CU_DEVICE_ATTRIBUTE_MAX_BLOCKS_PER_MULTIPROCESSOR = 106,
    CU_DEVICE_ATTRIBUTE_GENERIC_COMPRESSION_SUPPORTED = 107,
    CU_DEVICE_ATTRIBUTE_MAX_PERSISTING_L2_CACHE_SIZE = 108,
    CU_DEVICE_ATTRIBUTE_MAX_ACCESS_POLICY_WINDOW_SIZE = 109,
    CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_WITH_CUDA_VMM_SUPPORTED = 110,
    CU_DEVICE_ATTRIBUTE_RESERVED_SHARED_MEMORY_PER_BLOCK = 111,
    CU_DEVICE_ATTRIBUTE_SPARSE_CUDA_ARRAY_SUPPORTED = 112,
    CU_DEVICE_ATTRIBUTE_READ_ONLY_HOST_REGISTER_SUPPORTED = 113,
    CU_DEVICE_ATTRIBUTE_TIMELINE_SEMAPHORE_INTEROP_SUPPORTED = 114,
    CU_DEVICE_ATTRIBUTE_MEMORY_POOLS_SUPPORTED = 115,
    CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_SUPPORTED = 116,
    CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_FLUSH_WRITES_OPTIONS = 117,
    CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_WRITES_ORDERING = 118,
    CU_DEVICE_ATTRIBUTE_MEMPOOL_SUPPORTED_HANDLE_TYPES = 119,
    CU_DEVICE_ATTRIBUTE_MAX = 120,
}
pub use self::CUdevice_attribute_enum as CUdevice_attribute;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct CUdevprop_st {
    pub maxThreadsPerBlock: core::ffi::c_int,
    pub maxThreadsDim: [core::ffi::c_int; 3usize],
    pub maxGridSize: [core::ffi::c_int; 3usize],
    pub sharedMemPerBlock: core::ffi::c_int,
    pub totalConstantMemory: core::ffi::c_int,
    pub SIMDWidth: core::ffi::c_int,
    pub memPitch: core::ffi::c_int,
    pub regsPerBlock: core::ffi::c_int,
    pub clockRate: core::ffi::c_int,
    pub textureAlign: core::ffi::c_int,
}
#[test]
fn bindgen_test_layout_CUdevprop_st() {
    assert_eq!(
        ::core::mem::size_of::<CUdevprop_st>(),
        56usize,
        concat!("Size of: ", stringify!(CUdevprop_st))
    );
    assert_eq!(
        ::core::mem::align_of::<CUdevprop_st>(),
        4usize,
        concat!("Alignment of ", stringify!(CUdevprop_st))
    );
    fn test_field_maxThreadsPerBlock() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUdevprop_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).maxThreadsPerBlock) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUdevprop_st),
                "::",
                stringify!(maxThreadsPerBlock)
            )
        );
    }
    test_field_maxThreadsPerBlock();
    fn test_field_maxThreadsDim() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUdevprop_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).maxThreadsDim) as usize - ptr as usize
            },
            4usize,
            concat!(
                "Offset of field: ",
                stringify!(CUdevprop_st),
                "::",
                stringify!(maxThreadsDim)
            )
        );
    }
    test_field_maxThreadsDim();
    fn test_field_maxGridSize() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUdevprop_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).maxGridSize) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(CUdevprop_st),
                "::",
                stringify!(maxGridSize)
            )
        );
    }
    test_field_maxGridSize();
    fn test_field_sharedMemPerBlock() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUdevprop_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).sharedMemPerBlock) as usize - ptr as usize
            },
            28usize,
            concat!(
                "Offset of field: ",
                stringify!(CUdevprop_st),
                "::",
                stringify!(sharedMemPerBlock)
            )
        );
    }
    test_field_sharedMemPerBlock();
    fn test_field_totalConstantMemory() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUdevprop_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).totalConstantMemory) as usize - ptr as usize
            },
            32usize,
            concat!(
                "Offset of field: ",
                stringify!(CUdevprop_st),
                "::",
                stringify!(totalConstantMemory)
            )
        );
    }
    test_field_totalConstantMemory();
    fn test_field_SIMDWidth() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUdevprop_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).SIMDWidth) as usize - ptr as usize
            },
            36usize,
            concat!(
                "Offset of field: ",
                stringify!(CUdevprop_st),
                "::",
                stringify!(SIMDWidth)
            )
        );
    }
    test_field_SIMDWidth();
    fn test_field_memPitch() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUdevprop_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).memPitch) as usize - ptr as usize
            },
            40usize,
            concat!(
                "Offset of field: ",
                stringify!(CUdevprop_st),
                "::",
                stringify!(memPitch)
            )
        );
    }
    test_field_memPitch();
    fn test_field_regsPerBlock() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUdevprop_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).regsPerBlock) as usize - ptr as usize
            },
            44usize,
            concat!(
                "Offset of field: ",
                stringify!(CUdevprop_st),
                "::",
                stringify!(regsPerBlock)
            )
        );
    }
    test_field_regsPerBlock();
    fn test_field_clockRate() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUdevprop_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).clockRate) as usize - ptr as usize
            },
            48usize,
            concat!(
                "Offset of field: ",
                stringify!(CUdevprop_st),
                "::",
                stringify!(clockRate)
            )
        );
    }
    test_field_clockRate();
    fn test_field_textureAlign() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUdevprop_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).textureAlign) as usize - ptr as usize
            },
            52usize,
            concat!(
                "Offset of field: ",
                stringify!(CUdevprop_st),
                "::",
                stringify!(textureAlign)
            )
        );
    }
    test_field_textureAlign();
}
pub type CUdevprop_v1 = CUdevprop_st;
pub type CUdevprop = CUdevprop_v1;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUpointer_attribute_enum {
    CU_POINTER_ATTRIBUTE_CONTEXT = 1,
    CU_POINTER_ATTRIBUTE_MEMORY_TYPE = 2,
    CU_POINTER_ATTRIBUTE_DEVICE_POINTER = 3,
    CU_POINTER_ATTRIBUTE_HOST_POINTER = 4,
    CU_POINTER_ATTRIBUTE_P2P_TOKENS = 5,
    CU_POINTER_ATTRIBUTE_SYNC_MEMOPS = 6,
    CU_POINTER_ATTRIBUTE_BUFFER_ID = 7,
    CU_POINTER_ATTRIBUTE_IS_MANAGED = 8,
    CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL = 9,
    CU_POINTER_ATTRIBUTE_IS_LEGACY_CUDA_IPC_CAPABLE = 10,
    CU_POINTER_ATTRIBUTE_RANGE_START_ADDR = 11,
    CU_POINTER_ATTRIBUTE_RANGE_SIZE = 12,
    CU_POINTER_ATTRIBUTE_MAPPED = 13,
    CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES = 14,
    CU_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE = 15,
    CU_POINTER_ATTRIBUTE_ACCESS_FLAGS = 16,
    CU_POINTER_ATTRIBUTE_MEMPOOL_HANDLE = 17,
}
pub use self::CUpointer_attribute_enum as CUpointer_attribute;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUfunction_attribute_enum {
    CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK = 0,
    CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES = 1,
    CU_FUNC_ATTRIBUTE_CONST_SIZE_BYTES = 2,
    CU_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES = 3,
    CU_FUNC_ATTRIBUTE_NUM_REGS = 4,
    CU_FUNC_ATTRIBUTE_PTX_VERSION = 5,
    CU_FUNC_ATTRIBUTE_BINARY_VERSION = 6,
    CU_FUNC_ATTRIBUTE_CACHE_MODE_CA = 7,
    CU_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES = 8,
    CU_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT = 9,
    CU_FUNC_ATTRIBUTE_MAX = 10,
}
pub use self::CUfunction_attribute_enum as CUfunction_attribute;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUfunc_cache_enum {
    CU_FUNC_CACHE_PREFER_NONE = 0,
    CU_FUNC_CACHE_PREFER_SHARED = 1,
    CU_FUNC_CACHE_PREFER_L1 = 2,
    CU_FUNC_CACHE_PREFER_EQUAL = 3,
}
pub use self::CUfunc_cache_enum as CUfunc_cache;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUsharedconfig_enum {
    CU_SHARED_MEM_CONFIG_DEFAULT_BANK_SIZE = 0,
    CU_SHARED_MEM_CONFIG_FOUR_BYTE_BANK_SIZE = 1,
    CU_SHARED_MEM_CONFIG_EIGHT_BYTE_BANK_SIZE = 2,
}
pub use self::CUsharedconfig_enum as CUsharedconfig;
#[repr(i32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUshared_carveout_enum {
    CU_SHAREDMEM_CARVEOUT_DEFAULT = -1,
    CU_SHAREDMEM_CARVEOUT_MAX_SHARED = 100,
    CU_SHAREDMEM_CARVEOUT_MAX_L1 = 0,
}
pub use self::CUshared_carveout_enum as CUshared_carveout;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUmemorytype_enum {
    CU_MEMORYTYPE_HOST = 1,
    CU_MEMORYTYPE_DEVICE = 2,
    CU_MEMORYTYPE_ARRAY = 3,
    CU_MEMORYTYPE_UNIFIED = 4,
}
pub use self::CUmemorytype_enum as CUmemorytype;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUcomputemode_enum {
    CU_COMPUTEMODE_DEFAULT = 0,
    CU_COMPUTEMODE_PROHIBITED = 2,
    CU_COMPUTEMODE_EXCLUSIVE_PROCESS = 3,
}
pub use self::CUcomputemode_enum as CUcomputemode;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUmem_advise_enum {
    CU_MEM_ADVISE_SET_READ_MOSTLY = 1,
    CU_MEM_ADVISE_UNSET_READ_MOSTLY = 2,
    CU_MEM_ADVISE_SET_PREFERRED_LOCATION = 3,
    CU_MEM_ADVISE_UNSET_PREFERRED_LOCATION = 4,
    CU_MEM_ADVISE_SET_ACCESSED_BY = 5,
    CU_MEM_ADVISE_UNSET_ACCESSED_BY = 6,
}
pub use self::CUmem_advise_enum as CUmem_advise;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUmem_range_attribute_enum {
    CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY = 1,
    CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION = 2,
    CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY = 3,
    CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION = 4,
}
pub use self::CUmem_range_attribute_enum as CUmem_range_attribute;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUjit_option_enum {
    CU_JIT_MAX_REGISTERS = 0,
    CU_JIT_THREADS_PER_BLOCK = 1,
    CU_JIT_WALL_TIME = 2,
    CU_JIT_INFO_LOG_BUFFER = 3,
    CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES = 4,
    CU_JIT_ERROR_LOG_BUFFER = 5,
    CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES = 6,
    CU_JIT_OPTIMIZATION_LEVEL = 7,
    CU_JIT_TARGET_FROM_CUCONTEXT = 8,
    CU_JIT_TARGET = 9,
    CU_JIT_FALLBACK_STRATEGY = 10,
    CU_JIT_GENERATE_DEBUG_INFO = 11,
    CU_JIT_LOG_VERBOSE = 12,
    CU_JIT_GENERATE_LINE_INFO = 13,
    CU_JIT_CACHE_MODE = 14,
    CU_JIT_NEW_SM3X_OPT = 15,
    CU_JIT_FAST_COMPILE = 16,
    CU_JIT_GLOBAL_SYMBOL_NAMES = 17,
    CU_JIT_GLOBAL_SYMBOL_ADDRESSES = 18,
    CU_JIT_GLOBAL_SYMBOL_COUNT = 19,
    CU_JIT_NUM_OPTIONS = 20,
}
pub use self::CUjit_option_enum as CUjit_option;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUjit_target_enum {
    CU_TARGET_COMPUTE_20 = 20,
    CU_TARGET_COMPUTE_21 = 21,
    CU_TARGET_COMPUTE_30 = 30,
    CU_TARGET_COMPUTE_32 = 32,
    CU_TARGET_COMPUTE_35 = 35,
    CU_TARGET_COMPUTE_37 = 37,
    CU_TARGET_COMPUTE_50 = 50,
    CU_TARGET_COMPUTE_52 = 52,
    CU_TARGET_COMPUTE_53 = 53,
    CU_TARGET_COMPUTE_60 = 60,
    CU_TARGET_COMPUTE_61 = 61,
    CU_TARGET_COMPUTE_62 = 62,
    CU_TARGET_COMPUTE_70 = 70,
    CU_TARGET_COMPUTE_72 = 72,
    CU_TARGET_COMPUTE_75 = 75,
    CU_TARGET_COMPUTE_80 = 80,
    CU_TARGET_COMPUTE_86 = 86,
}
pub use self::CUjit_target_enum as CUjit_target;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUjit_fallback_enum {
    CU_PREFER_PTX = 0,
    CU_PREFER_BINARY = 1,
}
pub use self::CUjit_fallback_enum as CUjit_fallback;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUjit_cacheMode_enum {
    CU_JIT_CACHE_OPTION_NONE = 0,
    CU_JIT_CACHE_OPTION_CG = 1,
    CU_JIT_CACHE_OPTION_CA = 2,
}
pub use self::CUjit_cacheMode_enum as CUjit_cacheMode;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUjitInputType_enum {
    CU_JIT_INPUT_CUBIN = 0,
    CU_JIT_INPUT_PTX = 1,
    CU_JIT_INPUT_FATBINARY = 2,
    CU_JIT_INPUT_OBJECT = 3,
    CU_JIT_INPUT_LIBRARY = 4,
    CU_JIT_NUM_INPUT_TYPES = 5,
}
pub use self::CUjitInputType_enum as CUjitInputType;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CUlinkState_st {
    _unused: [u8; 0],
}
pub type CUlinkState = *mut CUlinkState_st;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUgraphicsRegisterFlags_enum {
    CU_GRAPHICS_REGISTER_FLAGS_NONE = 0,
    CU_GRAPHICS_REGISTER_FLAGS_READ_ONLY = 1,
    CU_GRAPHICS_REGISTER_FLAGS_WRITE_DISCARD = 2,
    CU_GRAPHICS_REGISTER_FLAGS_SURFACE_LDST = 4,
    CU_GRAPHICS_REGISTER_FLAGS_TEXTURE_GATHER = 8,
}
pub use self::CUgraphicsRegisterFlags_enum as CUgraphicsRegisterFlags;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUgraphicsMapResourceFlags_enum {
    CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE = 0,
    CU_GRAPHICS_MAP_RESOURCE_FLAGS_READ_ONLY = 1,
    CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITE_DISCARD = 2,
}
pub use self::CUgraphicsMapResourceFlags_enum as CUgraphicsMapResourceFlags;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUarray_cubemap_face_enum {
    CU_CUBEMAP_FACE_POSITIVE_X = 0,
    CU_CUBEMAP_FACE_NEGATIVE_X = 1,
    CU_CUBEMAP_FACE_POSITIVE_Y = 2,
    CU_CUBEMAP_FACE_NEGATIVE_Y = 3,
    CU_CUBEMAP_FACE_POSITIVE_Z = 4,
    CU_CUBEMAP_FACE_NEGATIVE_Z = 5,
}
pub use self::CUarray_cubemap_face_enum as CUarray_cubemap_face;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUlimit_enum {
    CU_LIMIT_STACK_SIZE = 0,
    CU_LIMIT_PRINTF_FIFO_SIZE = 1,
    CU_LIMIT_MALLOC_HEAP_SIZE = 2,
    CU_LIMIT_DEV_RUNTIME_SYNC_DEPTH = 3,
    CU_LIMIT_DEV_RUNTIME_PENDING_LAUNCH_COUNT = 4,
    CU_LIMIT_MAX_L2_FETCH_GRANULARITY = 5,
    CU_LIMIT_PERSISTING_L2_CACHE_SIZE = 6,
    CU_LIMIT_MAX = 7,
}
pub use self::CUlimit_enum as CUlimit;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUresourcetype_enum {
    CU_RESOURCE_TYPE_ARRAY = 0,
    CU_RESOURCE_TYPE_MIPMAPPED_ARRAY = 1,
    CU_RESOURCE_TYPE_LINEAR = 2,
    CU_RESOURCE_TYPE_PITCH2D = 3,
}
pub use self::CUresourcetype_enum as CUresourcetype;
pub type CUhostFn =
    ::core::option::Option<unsafe extern "C" fn(userData: *mut ::core::ffi::c_void)>;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUaccessProperty_enum {
    CU_ACCESS_PROPERTY_NORMAL = 0,
    CU_ACCESS_PROPERTY_STREAMING = 1,
    CU_ACCESS_PROPERTY_PERSISTING = 2,
}
pub use self::CUaccessProperty_enum as CUaccessProperty;
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialOrd, PartialEq)]
pub struct CUaccessPolicyWindow_st {
    pub base_ptr: *mut ::core::ffi::c_void,
    pub num_bytes: usize,
    pub hitRatio: f32,
    pub hitProp: CUaccessProperty,
    pub missProp: CUaccessProperty,
}
#[test]
fn bindgen_test_layout_CUaccessPolicyWindow_st() {
    assert_eq!(
        ::core::mem::size_of::<CUaccessPolicyWindow_st>(),
        32usize,
        concat!("Size of: ", stringify!(CUaccessPolicyWindow_st))
    );
    assert_eq!(
        ::core::mem::align_of::<CUaccessPolicyWindow_st>(),
        8usize,
        concat!("Alignment of ", stringify!(CUaccessPolicyWindow_st))
    );
    fn test_field_base_ptr() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUaccessPolicyWindow_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).base_ptr) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUaccessPolicyWindow_st),
                "::",
                stringify!(base_ptr)
            )
        );
    }
    test_field_base_ptr();
    fn test_field_num_bytes() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUaccessPolicyWindow_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).num_bytes) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(CUaccessPolicyWindow_st),
                "::",
                stringify!(num_bytes)
            )
        );
    }
    test_field_num_bytes();
    fn test_field_hitRatio() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUaccessPolicyWindow_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).hitRatio) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(CUaccessPolicyWindow_st),
                "::",
                stringify!(hitRatio)
            )
        );
    }
    test_field_hitRatio();
    fn test_field_hitProp() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUaccessPolicyWindow_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).hitProp) as usize - ptr as usize
            },
            20usize,
            concat!(
                "Offset of field: ",
                stringify!(CUaccessPolicyWindow_st),
                "::",
                stringify!(hitProp)
            )
        );
    }
    test_field_hitProp();
    fn test_field_missProp() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUaccessPolicyWindow_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).missProp) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(CUaccessPolicyWindow_st),
                "::",
                stringify!(missProp)
            )
        );
    }
    test_field_missProp();
}
impl Default for CUaccessPolicyWindow_st {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type CUaccessPolicyWindow_v1 = CUaccessPolicyWindow_st;
pub type CUaccessPolicyWindow = CUaccessPolicyWindow_v1;
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct CUDA_KERNEL_NODE_PARAMS_st {
    pub func: CUfunction,
    pub gridDimX: core::ffi::c_uint,
    pub gridDimY: core::ffi::c_uint,
    pub gridDimZ: core::ffi::c_uint,
    pub blockDimX: core::ffi::c_uint,
    pub blockDimY: core::ffi::c_uint,
    pub blockDimZ: core::ffi::c_uint,
    pub sharedMemBytes: core::ffi::c_uint,
    pub kernelParams: *mut *mut ::core::ffi::c_void,
    pub extra: *mut *mut ::core::ffi::c_void,
}
#[test]
fn bindgen_test_layout_CUDA_KERNEL_NODE_PARAMS_st() {
    assert_eq!(
        ::core::mem::size_of::<CUDA_KERNEL_NODE_PARAMS_st>(),
        56usize,
        concat!("Size of: ", stringify!(CUDA_KERNEL_NODE_PARAMS_st))
    );
    assert_eq!(
        ::core::mem::align_of::<CUDA_KERNEL_NODE_PARAMS_st>(),
        8usize,
        concat!("Alignment of ", stringify!(CUDA_KERNEL_NODE_PARAMS_st))
    );
    fn test_field_func() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_KERNEL_NODE_PARAMS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).func) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_KERNEL_NODE_PARAMS_st),
                "::",
                stringify!(func)
            )
        );
    }
    test_field_func();
    fn test_field_gridDimX() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_KERNEL_NODE_PARAMS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).gridDimX) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_KERNEL_NODE_PARAMS_st),
                "::",
                stringify!(gridDimX)
            )
        );
    }
    test_field_gridDimX();
    fn test_field_gridDimY() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_KERNEL_NODE_PARAMS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).gridDimY) as usize - ptr as usize
            },
            12usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_KERNEL_NODE_PARAMS_st),
                "::",
                stringify!(gridDimY)
            )
        );
    }
    test_field_gridDimY();
    fn test_field_gridDimZ() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_KERNEL_NODE_PARAMS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).gridDimZ) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_KERNEL_NODE_PARAMS_st),
                "::",
                stringify!(gridDimZ)
            )
        );
    }
    test_field_gridDimZ();
    fn test_field_blockDimX() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_KERNEL_NODE_PARAMS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).blockDimX) as usize - ptr as usize
            },
            20usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_KERNEL_NODE_PARAMS_st),
                "::",
                stringify!(blockDimX)
            )
        );
    }
    test_field_blockDimX();
    fn test_field_blockDimY() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_KERNEL_NODE_PARAMS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).blockDimY) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_KERNEL_NODE_PARAMS_st),
                "::",
                stringify!(blockDimY)
            )
        );
    }
    test_field_blockDimY();
    fn test_field_blockDimZ() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_KERNEL_NODE_PARAMS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).blockDimZ) as usize - ptr as usize
            },
            28usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_KERNEL_NODE_PARAMS_st),
                "::",
                stringify!(blockDimZ)
            )
        );
    }
    test_field_blockDimZ();
    fn test_field_sharedMemBytes() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_KERNEL_NODE_PARAMS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).sharedMemBytes) as usize - ptr as usize
            },
            32usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_KERNEL_NODE_PARAMS_st),
                "::",
                stringify!(sharedMemBytes)
            )
        );
    }
    test_field_sharedMemBytes();
    fn test_field_kernelParams() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_KERNEL_NODE_PARAMS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).kernelParams) as usize - ptr as usize
            },
            40usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_KERNEL_NODE_PARAMS_st),
                "::",
                stringify!(kernelParams)
            )
        );
    }
    test_field_kernelParams();
    fn test_field_extra() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_KERNEL_NODE_PARAMS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).extra) as usize - ptr as usize
            },
            48usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_KERNEL_NODE_PARAMS_st),
                "::",
                stringify!(extra)
            )
        );
    }
    test_field_extra();
}
impl Default for CUDA_KERNEL_NODE_PARAMS_st {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type CUDA_KERNEL_NODE_PARAMS_v1 = CUDA_KERNEL_NODE_PARAMS_st;
pub type CUDA_KERNEL_NODE_PARAMS = CUDA_KERNEL_NODE_PARAMS_v1;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct CUDA_MEMSET_NODE_PARAMS_st {
    pub dst: CUdeviceptr,
    pub pitch: usize,
    pub value: core::ffi::c_uint,
    pub elementSize: core::ffi::c_uint,
    pub width: usize,
    pub height: usize,
}
#[test]
fn bindgen_test_layout_CUDA_MEMSET_NODE_PARAMS_st() {
    assert_eq!(
        ::core::mem::size_of::<CUDA_MEMSET_NODE_PARAMS_st>(),
        40usize,
        concat!("Size of: ", stringify!(CUDA_MEMSET_NODE_PARAMS_st))
    );
    assert_eq!(
        ::core::mem::align_of::<CUDA_MEMSET_NODE_PARAMS_st>(),
        8usize,
        concat!("Alignment of ", stringify!(CUDA_MEMSET_NODE_PARAMS_st))
    );
    fn test_field_dst() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMSET_NODE_PARAMS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).dst) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMSET_NODE_PARAMS_st),
                "::",
                stringify!(dst)
            )
        );
    }
    test_field_dst();
    fn test_field_pitch() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMSET_NODE_PARAMS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).pitch) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMSET_NODE_PARAMS_st),
                "::",
                stringify!(pitch)
            )
        );
    }
    test_field_pitch();
    fn test_field_value() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMSET_NODE_PARAMS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).value) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMSET_NODE_PARAMS_st),
                "::",
                stringify!(value)
            )
        );
    }
    test_field_value();
    fn test_field_elementSize() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMSET_NODE_PARAMS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).elementSize) as usize - ptr as usize
            },
            20usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMSET_NODE_PARAMS_st),
                "::",
                stringify!(elementSize)
            )
        );
    }
    test_field_elementSize();
    fn test_field_width() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMSET_NODE_PARAMS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).width) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMSET_NODE_PARAMS_st),
                "::",
                stringify!(width)
            )
        );
    }
    test_field_width();
    fn test_field_height() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMSET_NODE_PARAMS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).height) as usize - ptr as usize
            },
            32usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMSET_NODE_PARAMS_st),
                "::",
                stringify!(height)
            )
        );
    }
    test_field_height();
}
pub type CUDA_MEMSET_NODE_PARAMS_v1 = CUDA_MEMSET_NODE_PARAMS_st;
pub type CUDA_MEMSET_NODE_PARAMS = CUDA_MEMSET_NODE_PARAMS_v1;
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct CUDA_HOST_NODE_PARAMS_st {
    pub fn_: CUhostFn,
    pub userData: *mut ::core::ffi::c_void,
}
#[test]
fn bindgen_test_layout_CUDA_HOST_NODE_PARAMS_st() {
    assert_eq!(
        ::core::mem::size_of::<CUDA_HOST_NODE_PARAMS_st>(),
        16usize,
        concat!("Size of: ", stringify!(CUDA_HOST_NODE_PARAMS_st))
    );
    assert_eq!(
        ::core::mem::align_of::<CUDA_HOST_NODE_PARAMS_st>(),
        8usize,
        concat!("Alignment of ", stringify!(CUDA_HOST_NODE_PARAMS_st))
    );
    fn test_field_fn() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_HOST_NODE_PARAMS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).fn_) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_HOST_NODE_PARAMS_st),
                "::",
                stringify!(fn_)
            )
        );
    }
    test_field_fn();
    fn test_field_userData() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_HOST_NODE_PARAMS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).userData) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_HOST_NODE_PARAMS_st),
                "::",
                stringify!(userData)
            )
        );
    }
    test_field_userData();
}
impl Default for CUDA_HOST_NODE_PARAMS_st {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type CUDA_HOST_NODE_PARAMS_v1 = CUDA_HOST_NODE_PARAMS_st;
pub type CUDA_HOST_NODE_PARAMS = CUDA_HOST_NODE_PARAMS_v1;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUgraphNodeType_enum {
    CU_GRAPH_NODE_TYPE_KERNEL = 0,
    CU_GRAPH_NODE_TYPE_MEMCPY = 1,
    CU_GRAPH_NODE_TYPE_MEMSET = 2,
    CU_GRAPH_NODE_TYPE_HOST = 3,
    CU_GRAPH_NODE_TYPE_GRAPH = 4,
    CU_GRAPH_NODE_TYPE_EMPTY = 5,
    CU_GRAPH_NODE_TYPE_WAIT_EVENT = 6,
    CU_GRAPH_NODE_TYPE_EVENT_RECORD = 7,
    CU_GRAPH_NODE_TYPE_EXT_SEMAS_SIGNAL = 8,
    CU_GRAPH_NODE_TYPE_EXT_SEMAS_WAIT = 9,
}
pub use self::CUgraphNodeType_enum as CUgraphNodeType;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUsynchronizationPolicy_enum {
    CU_SYNC_POLICY_AUTO = 1,
    CU_SYNC_POLICY_SPIN = 2,
    CU_SYNC_POLICY_YIELD = 3,
    CU_SYNC_POLICY_BLOCKING_SYNC = 4,
}
pub use self::CUsynchronizationPolicy_enum as CUsynchronizationPolicy;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUkernelNodeAttrID_enum {
    CU_KERNEL_NODE_ATTRIBUTE_ACCESS_POLICY_WINDOW = 1,
    CU_KERNEL_NODE_ATTRIBUTE_COOPERATIVE = 2,
}
pub use self::CUkernelNodeAttrID_enum as CUkernelNodeAttrID;
#[repr(C)]
#[derive(Copy, Clone)]
pub union CUkernelNodeAttrValue_union {
    pub accessPolicyWindow: CUaccessPolicyWindow,
    pub cooperative: core::ffi::c_int,
}
#[test]
fn bindgen_test_layout_CUkernelNodeAttrValue_union() {
    assert_eq!(
        ::core::mem::size_of::<CUkernelNodeAttrValue_union>(),
        32usize,
        concat!("Size of: ", stringify!(CUkernelNodeAttrValue_union))
    );
    assert_eq!(
        ::core::mem::align_of::<CUkernelNodeAttrValue_union>(),
        8usize,
        concat!("Alignment of ", stringify!(CUkernelNodeAttrValue_union))
    );
    fn test_field_accessPolicyWindow() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUkernelNodeAttrValue_union>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).accessPolicyWindow) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUkernelNodeAttrValue_union),
                "::",
                stringify!(accessPolicyWindow)
            )
        );
    }
    test_field_accessPolicyWindow();
    fn test_field_cooperative() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUkernelNodeAttrValue_union>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).cooperative) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUkernelNodeAttrValue_union),
                "::",
                stringify!(cooperative)
            )
        );
    }
    test_field_cooperative();
}
impl Default for CUkernelNodeAttrValue_union {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type CUkernelNodeAttrValue_v1 = CUkernelNodeAttrValue_union;
pub type CUkernelNodeAttrValue = CUkernelNodeAttrValue_v1;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUstreamCaptureStatus_enum {
    CU_STREAM_CAPTURE_STATUS_NONE = 0,
    CU_STREAM_CAPTURE_STATUS_ACTIVE = 1,
    CU_STREAM_CAPTURE_STATUS_INVALIDATED = 2,
}
pub use self::CUstreamCaptureStatus_enum as CUstreamCaptureStatus;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUstreamCaptureMode_enum {
    CU_STREAM_CAPTURE_MODE_GLOBAL = 0,
    CU_STREAM_CAPTURE_MODE_THREAD_LOCAL = 1,
    CU_STREAM_CAPTURE_MODE_RELAXED = 2,
}
pub use self::CUstreamCaptureMode_enum as CUstreamCaptureMode;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUstreamAttrID_enum {
    CU_STREAM_ATTRIBUTE_ACCESS_POLICY_WINDOW = 1,
    CU_STREAM_ATTRIBUTE_SYNCHRONIZATION_POLICY = 3,
}
pub use self::CUstreamAttrID_enum as CUstreamAttrID;
#[repr(C)]
#[derive(Copy, Clone)]
pub union CUstreamAttrValue_union {
    pub accessPolicyWindow: CUaccessPolicyWindow,
    pub syncPolicy: CUsynchronizationPolicy,
}
#[test]
fn bindgen_test_layout_CUstreamAttrValue_union() {
    assert_eq!(
        ::core::mem::size_of::<CUstreamAttrValue_union>(),
        32usize,
        concat!("Size of: ", stringify!(CUstreamAttrValue_union))
    );
    assert_eq!(
        ::core::mem::align_of::<CUstreamAttrValue_union>(),
        8usize,
        concat!("Alignment of ", stringify!(CUstreamAttrValue_union))
    );
    fn test_field_accessPolicyWindow() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUstreamAttrValue_union>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).accessPolicyWindow) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUstreamAttrValue_union),
                "::",
                stringify!(accessPolicyWindow)
            )
        );
    }
    test_field_accessPolicyWindow();
    fn test_field_syncPolicy() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUstreamAttrValue_union>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).syncPolicy) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUstreamAttrValue_union),
                "::",
                stringify!(syncPolicy)
            )
        );
    }
    test_field_syncPolicy();
}
impl Default for CUstreamAttrValue_union {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type CUstreamAttrValue_v1 = CUstreamAttrValue_union;
pub type CUstreamAttrValue = CUstreamAttrValue_v1;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUdriverProcAddress_flags_enum {
    CU_GET_PROC_ADDRESS_DEFAULT = 0,
    CU_GET_PROC_ADDRESS_LEGACY_STREAM = 1,
    CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM = 2,
}
pub use self::CUdriverProcAddress_flags_enum as CUdriverProcAddress_flags;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum cudaError_enum {
    CUDA_SUCCESS = 0,
    CUDA_ERROR_INVALID_VALUE = 1,
    CUDA_ERROR_OUT_OF_MEMORY = 2,
    CUDA_ERROR_NOT_INITIALIZED = 3,
    CUDA_ERROR_DEINITIALIZED = 4,
    CUDA_ERROR_PROFILER_DISABLED = 5,
    CUDA_ERROR_PROFILER_NOT_INITIALIZED = 6,
    CUDA_ERROR_PROFILER_ALREADY_STARTED = 7,
    CUDA_ERROR_PROFILER_ALREADY_STOPPED = 8,
    CUDA_ERROR_STUB_LIBRARY = 34,
    CUDA_ERROR_NO_DEVICE = 100,
    CUDA_ERROR_INVALID_DEVICE = 101,
    CUDA_ERROR_DEVICE_NOT_LICENSED = 102,
    CUDA_ERROR_INVALID_IMAGE = 200,
    CUDA_ERROR_INVALID_CONTEXT = 201,
    CUDA_ERROR_CONTEXT_ALREADY_CURRENT = 202,
    CUDA_ERROR_MAP_FAILED = 205,
    CUDA_ERROR_UNMAP_FAILED = 206,
    CUDA_ERROR_ARRAY_IS_MAPPED = 207,
    CUDA_ERROR_ALREADY_MAPPED = 208,
    CUDA_ERROR_NO_BINARY_FOR_GPU = 209,
    CUDA_ERROR_ALREADY_ACQUIRED = 210,
    CUDA_ERROR_NOT_MAPPED = 211,
    CUDA_ERROR_NOT_MAPPED_AS_ARRAY = 212,
    CUDA_ERROR_NOT_MAPPED_AS_POINTER = 213,
    CUDA_ERROR_ECC_UNCORRECTABLE = 214,
    CUDA_ERROR_UNSUPPORTED_LIMIT = 215,
    CUDA_ERROR_CONTEXT_ALREADY_IN_USE = 216,
    CUDA_ERROR_PEER_ACCESS_UNSUPPORTED = 217,
    CUDA_ERROR_INVALID_PTX = 218,
    CUDA_ERROR_INVALID_GRAPHICS_CONTEXT = 219,
    CUDA_ERROR_NVLINK_UNCORRECTABLE = 220,
    CUDA_ERROR_JIT_COMPILER_NOT_FOUND = 221,
    CUDA_ERROR_UNSUPPORTED_PTX_VERSION = 222,
    CUDA_ERROR_JIT_COMPILATION_DISABLED = 223,
    CUDA_ERROR_INVALID_SOURCE = 300,
    CUDA_ERROR_FILE_NOT_FOUND = 301,
    CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND = 302,
    CUDA_ERROR_SHARED_OBJECT_INIT_FAILED = 303,
    CUDA_ERROR_OPERATING_SYSTEM = 304,
    CUDA_ERROR_INVALID_HANDLE = 400,
    CUDA_ERROR_ILLEGAL_STATE = 401,
    CUDA_ERROR_NOT_FOUND = 500,
    CUDA_ERROR_NOT_READY = 600,
    CUDA_ERROR_ILLEGAL_ADDRESS = 700,
    CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES = 701,
    CUDA_ERROR_LAUNCH_TIMEOUT = 702,
    CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING = 703,
    CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED = 704,
    CUDA_ERROR_PEER_ACCESS_NOT_ENABLED = 705,
    CUDA_ERROR_PRIMARY_CONTEXT_ACTIVE = 708,
    CUDA_ERROR_CONTEXT_IS_DESTROYED = 709,
    CUDA_ERROR_ASSERT = 710,
    CUDA_ERROR_TOO_MANY_PEERS = 711,
    CUDA_ERROR_HOST_MEMORY_ALREADY_REGISTERED = 712,
    CUDA_ERROR_HOST_MEMORY_NOT_REGISTERED = 713,
    CUDA_ERROR_HARDWARE_STACK_ERROR = 714,
    CUDA_ERROR_ILLEGAL_INSTRUCTION = 715,
    CUDA_ERROR_MISALIGNED_ADDRESS = 716,
    CUDA_ERROR_INVALID_ADDRESS_SPACE = 717,
    CUDA_ERROR_INVALID_PC = 718,
    CUDA_ERROR_LAUNCH_FAILED = 719,
    CUDA_ERROR_COOPERATIVE_LAUNCH_TOO_LARGE = 720,
    CUDA_ERROR_NOT_PERMITTED = 800,
    CUDA_ERROR_NOT_SUPPORTED = 801,
    CUDA_ERROR_SYSTEM_NOT_READY = 802,
    CUDA_ERROR_SYSTEM_DRIVER_MISMATCH = 803,
    CUDA_ERROR_COMPAT_NOT_SUPPORTED_ON_DEVICE = 804,
    CUDA_ERROR_STREAM_CAPTURE_UNSUPPORTED = 900,
    CUDA_ERROR_STREAM_CAPTURE_INVALIDATED = 901,
    CUDA_ERROR_STREAM_CAPTURE_MERGE = 902,
    CUDA_ERROR_STREAM_CAPTURE_UNMATCHED = 903,
    CUDA_ERROR_STREAM_CAPTURE_UNJOINED = 904,
    CUDA_ERROR_STREAM_CAPTURE_ISOLATION = 905,
    CUDA_ERROR_STREAM_CAPTURE_IMPLICIT = 906,
    CUDA_ERROR_CAPTURED_EVENT = 907,
    CUDA_ERROR_STREAM_CAPTURE_WRONG_THREAD = 908,
    CUDA_ERROR_TIMEOUT = 909,
    CUDA_ERROR_GRAPH_EXEC_UPDATE_FAILURE = 910,
    CUDA_ERROR_UNKNOWN = 999,
}
pub use self::cudaError_enum as CUresult;
impl CUdevice_P2PAttribute_enum {
    pub const CU_DEVICE_P2P_ATTRIBUTE_CUDA_ARRAY_ACCESS_SUPPORTED: CUdevice_P2PAttribute_enum =
        CUdevice_P2PAttribute_enum::CU_DEVICE_P2P_ATTRIBUTE_ACCESS_ACCESS_SUPPORTED;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUdevice_P2PAttribute_enum {
    CU_DEVICE_P2P_ATTRIBUTE_PERFORMANCE_RANK = 1,
    CU_DEVICE_P2P_ATTRIBUTE_ACCESS_SUPPORTED = 2,
    CU_DEVICE_P2P_ATTRIBUTE_NATIVE_ATOMIC_SUPPORTED = 3,
    CU_DEVICE_P2P_ATTRIBUTE_ACCESS_ACCESS_SUPPORTED = 4,
}
pub use self::CUdevice_P2PAttribute_enum as CUdevice_P2PAttribute;
pub type CUstreamCallback = ::core::option::Option<
    unsafe extern "C" fn(hStream: CUstream, status: CUresult, userData: *mut ::core::ffi::c_void),
>;
pub type CUoccupancyB2DSize =
    ::core::option::Option<unsafe extern "C" fn(blockSize: core::ffi::c_int) -> usize>;
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct CUDA_MEMCPY2D_st {
    pub srcXInBytes: usize,
    pub srcY: usize,
    pub srcMemoryType: CUmemorytype,
    pub srcHost: *const ::core::ffi::c_void,
    pub srcDevice: CUdeviceptr,
    pub srcArray: CUarray,
    pub srcPitch: usize,
    pub dstXInBytes: usize,
    pub dstY: usize,
    pub dstMemoryType: CUmemorytype,
    pub dstHost: *mut ::core::ffi::c_void,
    pub dstDevice: CUdeviceptr,
    pub dstArray: CUarray,
    pub dstPitch: usize,
    pub WidthInBytes: usize,
    pub Height: usize,
}
#[test]
fn bindgen_test_layout_CUDA_MEMCPY2D_st() {
    assert_eq!(
        ::core::mem::size_of::<CUDA_MEMCPY2D_st>(),
        128usize,
        concat!("Size of: ", stringify!(CUDA_MEMCPY2D_st))
    );
    assert_eq!(
        ::core::mem::align_of::<CUDA_MEMCPY2D_st>(),
        8usize,
        concat!("Alignment of ", stringify!(CUDA_MEMCPY2D_st))
    );
    fn test_field_srcXInBytes() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY2D_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).srcXInBytes) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY2D_st),
                "::",
                stringify!(srcXInBytes)
            )
        );
    }
    test_field_srcXInBytes();
    fn test_field_srcY() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY2D_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).srcY) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY2D_st),
                "::",
                stringify!(srcY)
            )
        );
    }
    test_field_srcY();
    fn test_field_srcMemoryType() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY2D_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).srcMemoryType) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY2D_st),
                "::",
                stringify!(srcMemoryType)
            )
        );
    }
    test_field_srcMemoryType();
    fn test_field_srcHost() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY2D_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).srcHost) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY2D_st),
                "::",
                stringify!(srcHost)
            )
        );
    }
    test_field_srcHost();
    fn test_field_srcDevice() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY2D_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).srcDevice) as usize - ptr as usize
            },
            32usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY2D_st),
                "::",
                stringify!(srcDevice)
            )
        );
    }
    test_field_srcDevice();
    fn test_field_srcArray() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY2D_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).srcArray) as usize - ptr as usize
            },
            40usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY2D_st),
                "::",
                stringify!(srcArray)
            )
        );
    }
    test_field_srcArray();
    fn test_field_srcPitch() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY2D_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).srcPitch) as usize - ptr as usize
            },
            48usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY2D_st),
                "::",
                stringify!(srcPitch)
            )
        );
    }
    test_field_srcPitch();
    fn test_field_dstXInBytes() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY2D_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).dstXInBytes) as usize - ptr as usize
            },
            56usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY2D_st),
                "::",
                stringify!(dstXInBytes)
            )
        );
    }
    test_field_dstXInBytes();
    fn test_field_dstY() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY2D_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).dstY) as usize - ptr as usize
            },
            64usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY2D_st),
                "::",
                stringify!(dstY)
            )
        );
    }
    test_field_dstY();
    fn test_field_dstMemoryType() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY2D_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).dstMemoryType) as usize - ptr as usize
            },
            72usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY2D_st),
                "::",
                stringify!(dstMemoryType)
            )
        );
    }
    test_field_dstMemoryType();
    fn test_field_dstHost() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY2D_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).dstHost) as usize - ptr as usize
            },
            80usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY2D_st),
                "::",
                stringify!(dstHost)
            )
        );
    }
    test_field_dstHost();
    fn test_field_dstDevice() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY2D_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).dstDevice) as usize - ptr as usize
            },
            88usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY2D_st),
                "::",
                stringify!(dstDevice)
            )
        );
    }
    test_field_dstDevice();
    fn test_field_dstArray() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY2D_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).dstArray) as usize - ptr as usize
            },
            96usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY2D_st),
                "::",
                stringify!(dstArray)
            )
        );
    }
    test_field_dstArray();
    fn test_field_dstPitch() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY2D_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).dstPitch) as usize - ptr as usize
            },
            104usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY2D_st),
                "::",
                stringify!(dstPitch)
            )
        );
    }
    test_field_dstPitch();
    fn test_field_WidthInBytes() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY2D_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).WidthInBytes) as usize - ptr as usize
            },
            112usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY2D_st),
                "::",
                stringify!(WidthInBytes)
            )
        );
    }
    test_field_WidthInBytes();
    fn test_field_Height() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY2D_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).Height) as usize - ptr as usize
            },
            120usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY2D_st),
                "::",
                stringify!(Height)
            )
        );
    }
    test_field_Height();
}
impl Default for CUDA_MEMCPY2D_st {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type CUDA_MEMCPY2D_v2 = CUDA_MEMCPY2D_st;
pub type CUDA_MEMCPY2D = CUDA_MEMCPY2D_v2;
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct CUDA_MEMCPY3D_st {
    pub srcXInBytes: usize,
    pub srcY: usize,
    pub srcZ: usize,
    pub srcLOD: usize,
    pub srcMemoryType: CUmemorytype,
    pub srcHost: *const ::core::ffi::c_void,
    pub srcDevice: CUdeviceptr,
    pub srcArray: CUarray,
    pub reserved0: *mut ::core::ffi::c_void,
    pub srcPitch: usize,
    pub srcHeight: usize,
    pub dstXInBytes: usize,
    pub dstY: usize,
    pub dstZ: usize,
    pub dstLOD: usize,
    pub dstMemoryType: CUmemorytype,
    pub dstHost: *mut ::core::ffi::c_void,
    pub dstDevice: CUdeviceptr,
    pub dstArray: CUarray,
    pub reserved1: *mut ::core::ffi::c_void,
    pub dstPitch: usize,
    pub dstHeight: usize,
    pub WidthInBytes: usize,
    pub Height: usize,
    pub Depth: usize,
}
#[test]
fn bindgen_test_layout_CUDA_MEMCPY3D_st() {
    assert_eq!(
        ::core::mem::size_of::<CUDA_MEMCPY3D_st>(),
        200usize,
        concat!("Size of: ", stringify!(CUDA_MEMCPY3D_st))
    );
    assert_eq!(
        ::core::mem::align_of::<CUDA_MEMCPY3D_st>(),
        8usize,
        concat!("Alignment of ", stringify!(CUDA_MEMCPY3D_st))
    );
    fn test_field_srcXInBytes() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).srcXInBytes) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_st),
                "::",
                stringify!(srcXInBytes)
            )
        );
    }
    test_field_srcXInBytes();
    fn test_field_srcY() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).srcY) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_st),
                "::",
                stringify!(srcY)
            )
        );
    }
    test_field_srcY();
    fn test_field_srcZ() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).srcZ) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_st),
                "::",
                stringify!(srcZ)
            )
        );
    }
    test_field_srcZ();
    fn test_field_srcLOD() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).srcLOD) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_st),
                "::",
                stringify!(srcLOD)
            )
        );
    }
    test_field_srcLOD();
    fn test_field_srcMemoryType() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).srcMemoryType) as usize - ptr as usize
            },
            32usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_st),
                "::",
                stringify!(srcMemoryType)
            )
        );
    }
    test_field_srcMemoryType();
    fn test_field_srcHost() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).srcHost) as usize - ptr as usize
            },
            40usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_st),
                "::",
                stringify!(srcHost)
            )
        );
    }
    test_field_srcHost();
    fn test_field_srcDevice() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).srcDevice) as usize - ptr as usize
            },
            48usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_st),
                "::",
                stringify!(srcDevice)
            )
        );
    }
    test_field_srcDevice();
    fn test_field_srcArray() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).srcArray) as usize - ptr as usize
            },
            56usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_st),
                "::",
                stringify!(srcArray)
            )
        );
    }
    test_field_srcArray();
    fn test_field_reserved0() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).reserved0) as usize - ptr as usize
            },
            64usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_st),
                "::",
                stringify!(reserved0)
            )
        );
    }
    test_field_reserved0();
    fn test_field_srcPitch() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).srcPitch) as usize - ptr as usize
            },
            72usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_st),
                "::",
                stringify!(srcPitch)
            )
        );
    }
    test_field_srcPitch();
    fn test_field_srcHeight() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).srcHeight) as usize - ptr as usize
            },
            80usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_st),
                "::",
                stringify!(srcHeight)
            )
        );
    }
    test_field_srcHeight();
    fn test_field_dstXInBytes() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).dstXInBytes) as usize - ptr as usize
            },
            88usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_st),
                "::",
                stringify!(dstXInBytes)
            )
        );
    }
    test_field_dstXInBytes();
    fn test_field_dstY() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).dstY) as usize - ptr as usize
            },
            96usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_st),
                "::",
                stringify!(dstY)
            )
        );
    }
    test_field_dstY();
    fn test_field_dstZ() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).dstZ) as usize - ptr as usize
            },
            104usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_st),
                "::",
                stringify!(dstZ)
            )
        );
    }
    test_field_dstZ();
    fn test_field_dstLOD() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).dstLOD) as usize - ptr as usize
            },
            112usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_st),
                "::",
                stringify!(dstLOD)
            )
        );
    }
    test_field_dstLOD();
    fn test_field_dstMemoryType() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).dstMemoryType) as usize - ptr as usize
            },
            120usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_st),
                "::",
                stringify!(dstMemoryType)
            )
        );
    }
    test_field_dstMemoryType();
    fn test_field_dstHost() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).dstHost) as usize - ptr as usize
            },
            128usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_st),
                "::",
                stringify!(dstHost)
            )
        );
    }
    test_field_dstHost();
    fn test_field_dstDevice() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).dstDevice) as usize - ptr as usize
            },
            136usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_st),
                "::",
                stringify!(dstDevice)
            )
        );
    }
    test_field_dstDevice();
    fn test_field_dstArray() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).dstArray) as usize - ptr as usize
            },
            144usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_st),
                "::",
                stringify!(dstArray)
            )
        );
    }
    test_field_dstArray();
    fn test_field_reserved1() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize
            },
            152usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_st),
                "::",
                stringify!(reserved1)
            )
        );
    }
    test_field_reserved1();
    fn test_field_dstPitch() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).dstPitch) as usize - ptr as usize
            },
            160usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_st),
                "::",
                stringify!(dstPitch)
            )
        );
    }
    test_field_dstPitch();
    fn test_field_dstHeight() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).dstHeight) as usize - ptr as usize
            },
            168usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_st),
                "::",
                stringify!(dstHeight)
            )
        );
    }
    test_field_dstHeight();
    fn test_field_WidthInBytes() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).WidthInBytes) as usize - ptr as usize
            },
            176usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_st),
                "::",
                stringify!(WidthInBytes)
            )
        );
    }
    test_field_WidthInBytes();
    fn test_field_Height() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).Height) as usize - ptr as usize
            },
            184usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_st),
                "::",
                stringify!(Height)
            )
        );
    }
    test_field_Height();
    fn test_field_Depth() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).Depth) as usize - ptr as usize
            },
            192usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_st),
                "::",
                stringify!(Depth)
            )
        );
    }
    test_field_Depth();
}
impl Default for CUDA_MEMCPY3D_st {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type CUDA_MEMCPY3D_v2 = CUDA_MEMCPY3D_st;
pub type CUDA_MEMCPY3D = CUDA_MEMCPY3D_v2;
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct CUDA_MEMCPY3D_PEER_st {
    pub srcXInBytes: usize,
    pub srcY: usize,
    pub srcZ: usize,
    pub srcLOD: usize,
    pub srcMemoryType: CUmemorytype,
    pub srcHost: *const ::core::ffi::c_void,
    pub srcDevice: CUdeviceptr,
    pub srcArray: CUarray,
    pub srcContext: CUcontext,
    pub srcPitch: usize,
    pub srcHeight: usize,
    pub dstXInBytes: usize,
    pub dstY: usize,
    pub dstZ: usize,
    pub dstLOD: usize,
    pub dstMemoryType: CUmemorytype,
    pub dstHost: *mut ::core::ffi::c_void,
    pub dstDevice: CUdeviceptr,
    pub dstArray: CUarray,
    pub dstContext: CUcontext,
    pub dstPitch: usize,
    pub dstHeight: usize,
    pub WidthInBytes: usize,
    pub Height: usize,
    pub Depth: usize,
}
#[test]
fn bindgen_test_layout_CUDA_MEMCPY3D_PEER_st() {
    assert_eq!(
        ::core::mem::size_of::<CUDA_MEMCPY3D_PEER_st>(),
        200usize,
        concat!("Size of: ", stringify!(CUDA_MEMCPY3D_PEER_st))
    );
    assert_eq!(
        ::core::mem::align_of::<CUDA_MEMCPY3D_PEER_st>(),
        8usize,
        concat!("Alignment of ", stringify!(CUDA_MEMCPY3D_PEER_st))
    );
    fn test_field_srcXInBytes() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_PEER_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).srcXInBytes) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_PEER_st),
                "::",
                stringify!(srcXInBytes)
            )
        );
    }
    test_field_srcXInBytes();
    fn test_field_srcY() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_PEER_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).srcY) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_PEER_st),
                "::",
                stringify!(srcY)
            )
        );
    }
    test_field_srcY();
    fn test_field_srcZ() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_PEER_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).srcZ) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_PEER_st),
                "::",
                stringify!(srcZ)
            )
        );
    }
    test_field_srcZ();
    fn test_field_srcLOD() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_PEER_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).srcLOD) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_PEER_st),
                "::",
                stringify!(srcLOD)
            )
        );
    }
    test_field_srcLOD();
    fn test_field_srcMemoryType() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_PEER_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).srcMemoryType) as usize - ptr as usize
            },
            32usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_PEER_st),
                "::",
                stringify!(srcMemoryType)
            )
        );
    }
    test_field_srcMemoryType();
    fn test_field_srcHost() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_PEER_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).srcHost) as usize - ptr as usize
            },
            40usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_PEER_st),
                "::",
                stringify!(srcHost)
            )
        );
    }
    test_field_srcHost();
    fn test_field_srcDevice() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_PEER_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).srcDevice) as usize - ptr as usize
            },
            48usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_PEER_st),
                "::",
                stringify!(srcDevice)
            )
        );
    }
    test_field_srcDevice();
    fn test_field_srcArray() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_PEER_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).srcArray) as usize - ptr as usize
            },
            56usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_PEER_st),
                "::",
                stringify!(srcArray)
            )
        );
    }
    test_field_srcArray();
    fn test_field_srcContext() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_PEER_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).srcContext) as usize - ptr as usize
            },
            64usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_PEER_st),
                "::",
                stringify!(srcContext)
            )
        );
    }
    test_field_srcContext();
    fn test_field_srcPitch() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_PEER_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).srcPitch) as usize - ptr as usize
            },
            72usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_PEER_st),
                "::",
                stringify!(srcPitch)
            )
        );
    }
    test_field_srcPitch();
    fn test_field_srcHeight() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_PEER_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).srcHeight) as usize - ptr as usize
            },
            80usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_PEER_st),
                "::",
                stringify!(srcHeight)
            )
        );
    }
    test_field_srcHeight();
    fn test_field_dstXInBytes() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_PEER_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).dstXInBytes) as usize - ptr as usize
            },
            88usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_PEER_st),
                "::",
                stringify!(dstXInBytes)
            )
        );
    }
    test_field_dstXInBytes();
    fn test_field_dstY() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_PEER_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).dstY) as usize - ptr as usize
            },
            96usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_PEER_st),
                "::",
                stringify!(dstY)
            )
        );
    }
    test_field_dstY();
    fn test_field_dstZ() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_PEER_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).dstZ) as usize - ptr as usize
            },
            104usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_PEER_st),
                "::",
                stringify!(dstZ)
            )
        );
    }
    test_field_dstZ();
    fn test_field_dstLOD() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_PEER_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).dstLOD) as usize - ptr as usize
            },
            112usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_PEER_st),
                "::",
                stringify!(dstLOD)
            )
        );
    }
    test_field_dstLOD();
    fn test_field_dstMemoryType() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_PEER_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).dstMemoryType) as usize - ptr as usize
            },
            120usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_PEER_st),
                "::",
                stringify!(dstMemoryType)
            )
        );
    }
    test_field_dstMemoryType();
    fn test_field_dstHost() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_PEER_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).dstHost) as usize - ptr as usize
            },
            128usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_PEER_st),
                "::",
                stringify!(dstHost)
            )
        );
    }
    test_field_dstHost();
    fn test_field_dstDevice() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_PEER_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).dstDevice) as usize - ptr as usize
            },
            136usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_PEER_st),
                "::",
                stringify!(dstDevice)
            )
        );
    }
    test_field_dstDevice();
    fn test_field_dstArray() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_PEER_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).dstArray) as usize - ptr as usize
            },
            144usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_PEER_st),
                "::",
                stringify!(dstArray)
            )
        );
    }
    test_field_dstArray();
    fn test_field_dstContext() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_PEER_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).dstContext) as usize - ptr as usize
            },
            152usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_PEER_st),
                "::",
                stringify!(dstContext)
            )
        );
    }
    test_field_dstContext();
    fn test_field_dstPitch() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_PEER_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).dstPitch) as usize - ptr as usize
            },
            160usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_PEER_st),
                "::",
                stringify!(dstPitch)
            )
        );
    }
    test_field_dstPitch();
    fn test_field_dstHeight() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_PEER_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).dstHeight) as usize - ptr as usize
            },
            168usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_PEER_st),
                "::",
                stringify!(dstHeight)
            )
        );
    }
    test_field_dstHeight();
    fn test_field_WidthInBytes() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_PEER_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).WidthInBytes) as usize - ptr as usize
            },
            176usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_PEER_st),
                "::",
                stringify!(WidthInBytes)
            )
        );
    }
    test_field_WidthInBytes();
    fn test_field_Height() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_PEER_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).Height) as usize - ptr as usize
            },
            184usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_PEER_st),
                "::",
                stringify!(Height)
            )
        );
    }
    test_field_Height();
    fn test_field_Depth() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_MEMCPY3D_PEER_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).Depth) as usize - ptr as usize
            },
            192usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_MEMCPY3D_PEER_st),
                "::",
                stringify!(Depth)
            )
        );
    }
    test_field_Depth();
}
impl Default for CUDA_MEMCPY3D_PEER_st {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type CUDA_MEMCPY3D_PEER_v1 = CUDA_MEMCPY3D_PEER_st;
pub type CUDA_MEMCPY3D_PEER = CUDA_MEMCPY3D_PEER_v1;
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct CUDA_ARRAY_DESCRIPTOR_st {
    pub Width: usize,
    pub Height: usize,
    pub Format: CUarray_format,
    pub NumChannels: core::ffi::c_uint,
}
#[test]
fn bindgen_test_layout_CUDA_ARRAY_DESCRIPTOR_st() {
    assert_eq!(
        ::core::mem::size_of::<CUDA_ARRAY_DESCRIPTOR_st>(),
        24usize,
        concat!("Size of: ", stringify!(CUDA_ARRAY_DESCRIPTOR_st))
    );
    assert_eq!(
        ::core::mem::align_of::<CUDA_ARRAY_DESCRIPTOR_st>(),
        8usize,
        concat!("Alignment of ", stringify!(CUDA_ARRAY_DESCRIPTOR_st))
    );
    fn test_field_Width() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_ARRAY_DESCRIPTOR_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).Width) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_ARRAY_DESCRIPTOR_st),
                "::",
                stringify!(Width)
            )
        );
    }
    test_field_Width();
    fn test_field_Height() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_ARRAY_DESCRIPTOR_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).Height) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_ARRAY_DESCRIPTOR_st),
                "::",
                stringify!(Height)
            )
        );
    }
    test_field_Height();
    fn test_field_Format() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_ARRAY_DESCRIPTOR_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).Format) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_ARRAY_DESCRIPTOR_st),
                "::",
                stringify!(Format)
            )
        );
    }
    test_field_Format();
    fn test_field_NumChannels() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_ARRAY_DESCRIPTOR_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).NumChannels) as usize - ptr as usize
            },
            20usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_ARRAY_DESCRIPTOR_st),
                "::",
                stringify!(NumChannels)
            )
        );
    }
    test_field_NumChannels();
}
impl Default for CUDA_ARRAY_DESCRIPTOR_st {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type CUDA_ARRAY_DESCRIPTOR_v2 = CUDA_ARRAY_DESCRIPTOR_st;
pub type CUDA_ARRAY_DESCRIPTOR = CUDA_ARRAY_DESCRIPTOR_v2;
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct CUDA_ARRAY3D_DESCRIPTOR_st {
    pub Width: usize,
    pub Height: usize,
    pub Depth: usize,
    pub Format: CUarray_format,
    pub NumChannels: core::ffi::c_uint,
    pub Flags: core::ffi::c_uint,
}
#[test]
fn bindgen_test_layout_CUDA_ARRAY3D_DESCRIPTOR_st() {
    assert_eq!(
        ::core::mem::size_of::<CUDA_ARRAY3D_DESCRIPTOR_st>(),
        40usize,
        concat!("Size of: ", stringify!(CUDA_ARRAY3D_DESCRIPTOR_st))
    );
    assert_eq!(
        ::core::mem::align_of::<CUDA_ARRAY3D_DESCRIPTOR_st>(),
        8usize,
        concat!("Alignment of ", stringify!(CUDA_ARRAY3D_DESCRIPTOR_st))
    );
    fn test_field_Width() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_ARRAY3D_DESCRIPTOR_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).Width) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_ARRAY3D_DESCRIPTOR_st),
                "::",
                stringify!(Width)
            )
        );
    }
    test_field_Width();
    fn test_field_Height() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_ARRAY3D_DESCRIPTOR_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).Height) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_ARRAY3D_DESCRIPTOR_st),
                "::",
                stringify!(Height)
            )
        );
    }
    test_field_Height();
    fn test_field_Depth() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_ARRAY3D_DESCRIPTOR_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).Depth) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_ARRAY3D_DESCRIPTOR_st),
                "::",
                stringify!(Depth)
            )
        );
    }
    test_field_Depth();
    fn test_field_Format() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_ARRAY3D_DESCRIPTOR_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).Format) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_ARRAY3D_DESCRIPTOR_st),
                "::",
                stringify!(Format)
            )
        );
    }
    test_field_Format();
    fn test_field_NumChannels() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_ARRAY3D_DESCRIPTOR_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).NumChannels) as usize - ptr as usize
            },
            28usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_ARRAY3D_DESCRIPTOR_st),
                "::",
                stringify!(NumChannels)
            )
        );
    }
    test_field_NumChannels();
    fn test_field_Flags() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_ARRAY3D_DESCRIPTOR_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize
            },
            32usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_ARRAY3D_DESCRIPTOR_st),
                "::",
                stringify!(Flags)
            )
        );
    }
    test_field_Flags();
}
impl Default for CUDA_ARRAY3D_DESCRIPTOR_st {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type CUDA_ARRAY3D_DESCRIPTOR_v2 = CUDA_ARRAY3D_DESCRIPTOR_st;
pub type CUDA_ARRAY3D_DESCRIPTOR = CUDA_ARRAY3D_DESCRIPTOR_v2;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct CUDA_ARRAY_SPARSE_PROPERTIES_st {
    pub tileExtent: CUDA_ARRAY_SPARSE_PROPERTIES_st__bindgen_ty_1,
    pub miptailFirstLevel: core::ffi::c_uint,
    pub miptailSize: core::ffi::c_ulonglong,
    pub flags: core::ffi::c_uint,
    pub reserved: [core::ffi::c_uint; 4usize],
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct CUDA_ARRAY_SPARSE_PROPERTIES_st__bindgen_ty_1 {
    pub width: core::ffi::c_uint,
    pub height: core::ffi::c_uint,
    pub depth: core::ffi::c_uint,
}
#[test]
fn bindgen_test_layout_CUDA_ARRAY_SPARSE_PROPERTIES_st__bindgen_ty_1() {
    assert_eq!(
        ::core::mem::size_of::<CUDA_ARRAY_SPARSE_PROPERTIES_st__bindgen_ty_1>(),
        12usize,
        concat!(
            "Size of: ",
            stringify!(CUDA_ARRAY_SPARSE_PROPERTIES_st__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<CUDA_ARRAY_SPARSE_PROPERTIES_st__bindgen_ty_1>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(CUDA_ARRAY_SPARSE_PROPERTIES_st__bindgen_ty_1)
        )
    );
    fn test_field_width() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_ARRAY_SPARSE_PROPERTIES_st__bindgen_ty_1,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).width) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_ARRAY_SPARSE_PROPERTIES_st__bindgen_ty_1),
                "::",
                stringify!(width)
            )
        );
    }
    test_field_width();
    fn test_field_height() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_ARRAY_SPARSE_PROPERTIES_st__bindgen_ty_1,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).height) as usize - ptr as usize
            },
            4usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_ARRAY_SPARSE_PROPERTIES_st__bindgen_ty_1),
                "::",
                stringify!(height)
            )
        );
    }
    test_field_height();
    fn test_field_depth() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_ARRAY_SPARSE_PROPERTIES_st__bindgen_ty_1,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).depth) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_ARRAY_SPARSE_PROPERTIES_st__bindgen_ty_1),
                "::",
                stringify!(depth)
            )
        );
    }
    test_field_depth();
}
#[test]
fn bindgen_test_layout_CUDA_ARRAY_SPARSE_PROPERTIES_st() {
    assert_eq!(
        ::core::mem::size_of::<CUDA_ARRAY_SPARSE_PROPERTIES_st>(),
        48usize,
        concat!("Size of: ", stringify!(CUDA_ARRAY_SPARSE_PROPERTIES_st))
    );
    assert_eq!(
        ::core::mem::align_of::<CUDA_ARRAY_SPARSE_PROPERTIES_st>(),
        8usize,
        concat!("Alignment of ", stringify!(CUDA_ARRAY_SPARSE_PROPERTIES_st))
    );
    fn test_field_tileExtent() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_ARRAY_SPARSE_PROPERTIES_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).tileExtent) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_ARRAY_SPARSE_PROPERTIES_st),
                "::",
                stringify!(tileExtent)
            )
        );
    }
    test_field_tileExtent();
    fn test_field_miptailFirstLevel() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_ARRAY_SPARSE_PROPERTIES_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).miptailFirstLevel) as usize - ptr as usize
            },
            12usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_ARRAY_SPARSE_PROPERTIES_st),
                "::",
                stringify!(miptailFirstLevel)
            )
        );
    }
    test_field_miptailFirstLevel();
    fn test_field_miptailSize() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_ARRAY_SPARSE_PROPERTIES_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).miptailSize) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_ARRAY_SPARSE_PROPERTIES_st),
                "::",
                stringify!(miptailSize)
            )
        );
    }
    test_field_miptailSize();
    fn test_field_flags() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_ARRAY_SPARSE_PROPERTIES_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_ARRAY_SPARSE_PROPERTIES_st),
                "::",
                stringify!(flags)
            )
        );
    }
    test_field_flags();
    fn test_field_reserved() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_ARRAY_SPARSE_PROPERTIES_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize
            },
            28usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_ARRAY_SPARSE_PROPERTIES_st),
                "::",
                stringify!(reserved)
            )
        );
    }
    test_field_reserved();
}
pub type CUDA_ARRAY_SPARSE_PROPERTIES_v1 = CUDA_ARRAY_SPARSE_PROPERTIES_st;
pub type CUDA_ARRAY_SPARSE_PROPERTIES = CUDA_ARRAY_SPARSE_PROPERTIES_v1;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct CUDA_RESOURCE_DESC_st {
    pub resType: CUresourcetype,
    pub res: CUDA_RESOURCE_DESC_st__bindgen_ty_1,
    pub flags: core::ffi::c_uint,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union CUDA_RESOURCE_DESC_st__bindgen_ty_1 {
    pub array: CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_1,
    pub mipmap: CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_2,
    pub linear: CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3,
    pub pitch2D: CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4,
    pub reserved: CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_5,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_1 {
    pub hArray: CUarray,
}
#[test]
fn bindgen_test_layout_CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_1() {
    assert_eq!(
        ::core::mem::size_of::<CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_1>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_1>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_1)
        )
    );
    fn test_field_hArray() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_1,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).hArray) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_1),
                "::",
                stringify!(hArray)
            )
        );
    }
    test_field_hArray();
}
impl Default for CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_2 {
    pub hMipmappedArray: CUmipmappedArray,
}
#[test]
fn bindgen_test_layout_CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_2() {
    assert_eq!(
        ::core::mem::size_of::<CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_2>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_2)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_2>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_2)
        )
    );
    fn test_field_hMipmappedArray() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_2,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).hMipmappedArray) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_2),
                "::",
                stringify!(hMipmappedArray)
            )
        );
    }
    test_field_hMipmappedArray();
}
impl Default for CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_2 {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3 {
    pub devPtr: CUdeviceptr,
    pub format: CUarray_format,
    pub numChannels: core::ffi::c_uint,
    pub sizeInBytes: usize,
}
#[test]
fn bindgen_test_layout_CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3() {
    assert_eq!(
        ::core::mem::size_of::<CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3)
        )
    );
    fn test_field_devPtr() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).devPtr) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3),
                "::",
                stringify!(devPtr)
            )
        );
    }
    test_field_devPtr();
    fn test_field_format() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).format) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3),
                "::",
                stringify!(format)
            )
        );
    }
    test_field_format();
    fn test_field_numChannels() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).numChannels) as usize - ptr as usize
            },
            12usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3),
                "::",
                stringify!(numChannels)
            )
        );
    }
    test_field_numChannels();
    fn test_field_sizeInBytes() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).sizeInBytes) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3),
                "::",
                stringify!(sizeInBytes)
            )
        );
    }
    test_field_sizeInBytes();
}
impl Default for CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3 {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4 {
    pub devPtr: CUdeviceptr,
    pub format: CUarray_format,
    pub numChannels: core::ffi::c_uint,
    pub width: usize,
    pub height: usize,
    pub pitchInBytes: usize,
}
#[test]
fn bindgen_test_layout_CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4() {
    assert_eq!(
        ::core::mem::size_of::<CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4>(),
        40usize,
        concat!(
            "Size of: ",
            stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4)
        )
    );
    fn test_field_devPtr() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).devPtr) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4),
                "::",
                stringify!(devPtr)
            )
        );
    }
    test_field_devPtr();
    fn test_field_format() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).format) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4),
                "::",
                stringify!(format)
            )
        );
    }
    test_field_format();
    fn test_field_numChannels() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).numChannels) as usize - ptr as usize
            },
            12usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4),
                "::",
                stringify!(numChannels)
            )
        );
    }
    test_field_numChannels();
    fn test_field_width() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).width) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4),
                "::",
                stringify!(width)
            )
        );
    }
    test_field_width();
    fn test_field_height() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).height) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4),
                "::",
                stringify!(height)
            )
        );
    }
    test_field_height();
    fn test_field_pitchInBytes() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).pitchInBytes) as usize - ptr as usize
            },
            32usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4),
                "::",
                stringify!(pitchInBytes)
            )
        );
    }
    test_field_pitchInBytes();
}
impl Default for CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4 {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_5 {
    pub reserved: [core::ffi::c_int; 32usize],
}
#[test]
fn bindgen_test_layout_CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_5() {
    assert_eq!(
        ::core::mem::size_of::<CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_5>(),
        128usize,
        concat!(
            "Size of: ",
            stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_5)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_5>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_5)
        )
    );
    fn test_field_reserved() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_5,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_5),
                "::",
                stringify!(reserved)
            )
        );
    }
    test_field_reserved();
}
#[test]
fn bindgen_test_layout_CUDA_RESOURCE_DESC_st__bindgen_ty_1() {
    assert_eq!(
        ::core::mem::size_of::<CUDA_RESOURCE_DESC_st__bindgen_ty_1>(),
        128usize,
        concat!("Size of: ", stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1))
    );
    assert_eq!(
        ::core::mem::align_of::<CUDA_RESOURCE_DESC_st__bindgen_ty_1>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1)
        )
    );
    fn test_field_array() {
        assert_eq!(
            unsafe {
                let uninit =
                    ::core::mem::MaybeUninit::<CUDA_RESOURCE_DESC_st__bindgen_ty_1>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).array) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1),
                "::",
                stringify!(array)
            )
        );
    }
    test_field_array();
    fn test_field_mipmap() {
        assert_eq!(
            unsafe {
                let uninit =
                    ::core::mem::MaybeUninit::<CUDA_RESOURCE_DESC_st__bindgen_ty_1>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).mipmap) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1),
                "::",
                stringify!(mipmap)
            )
        );
    }
    test_field_mipmap();
    fn test_field_linear() {
        assert_eq!(
            unsafe {
                let uninit =
                    ::core::mem::MaybeUninit::<CUDA_RESOURCE_DESC_st__bindgen_ty_1>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).linear) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1),
                "::",
                stringify!(linear)
            )
        );
    }
    test_field_linear();
    fn test_field_pitch2D() {
        assert_eq!(
            unsafe {
                let uninit =
                    ::core::mem::MaybeUninit::<CUDA_RESOURCE_DESC_st__bindgen_ty_1>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).pitch2D) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1),
                "::",
                stringify!(pitch2D)
            )
        );
    }
    test_field_pitch2D();
    fn test_field_reserved() {
        assert_eq!(
            unsafe {
                let uninit =
                    ::core::mem::MaybeUninit::<CUDA_RESOURCE_DESC_st__bindgen_ty_1>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_RESOURCE_DESC_st__bindgen_ty_1),
                "::",
                stringify!(reserved)
            )
        );
    }
    test_field_reserved();
}
impl Default for CUDA_RESOURCE_DESC_st__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[test]
fn bindgen_test_layout_CUDA_RESOURCE_DESC_st() {
    assert_eq!(
        ::core::mem::size_of::<CUDA_RESOURCE_DESC_st>(),
        144usize,
        concat!("Size of: ", stringify!(CUDA_RESOURCE_DESC_st))
    );
    assert_eq!(
        ::core::mem::align_of::<CUDA_RESOURCE_DESC_st>(),
        8usize,
        concat!("Alignment of ", stringify!(CUDA_RESOURCE_DESC_st))
    );
    fn test_field_resType() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_RESOURCE_DESC_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).resType) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_RESOURCE_DESC_st),
                "::",
                stringify!(resType)
            )
        );
    }
    test_field_resType();
    fn test_field_res() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_RESOURCE_DESC_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).res) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_RESOURCE_DESC_st),
                "::",
                stringify!(res)
            )
        );
    }
    test_field_res();
    fn test_field_flags() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_RESOURCE_DESC_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize
            },
            136usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_RESOURCE_DESC_st),
                "::",
                stringify!(flags)
            )
        );
    }
    test_field_flags();
}
impl Default for CUDA_RESOURCE_DESC_st {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type CUDA_RESOURCE_DESC_v1 = CUDA_RESOURCE_DESC_st;
pub type CUDA_RESOURCE_DESC = CUDA_RESOURCE_DESC_v1;
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialOrd, PartialEq)]
pub struct CUDA_TEXTURE_DESC_st {
    pub addressMode: [CUaddress_mode; 3usize],
    pub filterMode: CUfilter_mode,
    pub flags: core::ffi::c_uint,
    pub maxAnisotropy: core::ffi::c_uint,
    pub mipmapFilterMode: CUfilter_mode,
    pub mipmapLevelBias: f32,
    pub minMipmapLevelClamp: f32,
    pub maxMipmapLevelClamp: f32,
    pub borderColor: [f32; 4usize],
    pub reserved: [core::ffi::c_int; 12usize],
}
#[test]
fn bindgen_test_layout_CUDA_TEXTURE_DESC_st() {
    assert_eq!(
        ::core::mem::size_of::<CUDA_TEXTURE_DESC_st>(),
        104usize,
        concat!("Size of: ", stringify!(CUDA_TEXTURE_DESC_st))
    );
    assert_eq!(
        ::core::mem::align_of::<CUDA_TEXTURE_DESC_st>(),
        4usize,
        concat!("Alignment of ", stringify!(CUDA_TEXTURE_DESC_st))
    );
    fn test_field_addressMode() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_TEXTURE_DESC_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).addressMode) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_TEXTURE_DESC_st),
                "::",
                stringify!(addressMode)
            )
        );
    }
    test_field_addressMode();
    fn test_field_filterMode() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_TEXTURE_DESC_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).filterMode) as usize - ptr as usize
            },
            12usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_TEXTURE_DESC_st),
                "::",
                stringify!(filterMode)
            )
        );
    }
    test_field_filterMode();
    fn test_field_flags() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_TEXTURE_DESC_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_TEXTURE_DESC_st),
                "::",
                stringify!(flags)
            )
        );
    }
    test_field_flags();
    fn test_field_maxAnisotropy() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_TEXTURE_DESC_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).maxAnisotropy) as usize - ptr as usize
            },
            20usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_TEXTURE_DESC_st),
                "::",
                stringify!(maxAnisotropy)
            )
        );
    }
    test_field_maxAnisotropy();
    fn test_field_mipmapFilterMode() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_TEXTURE_DESC_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).mipmapFilterMode) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_TEXTURE_DESC_st),
                "::",
                stringify!(mipmapFilterMode)
            )
        );
    }
    test_field_mipmapFilterMode();
    fn test_field_mipmapLevelBias() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_TEXTURE_DESC_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).mipmapLevelBias) as usize - ptr as usize
            },
            28usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_TEXTURE_DESC_st),
                "::",
                stringify!(mipmapLevelBias)
            )
        );
    }
    test_field_mipmapLevelBias();
    fn test_field_minMipmapLevelClamp() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_TEXTURE_DESC_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).minMipmapLevelClamp) as usize - ptr as usize
            },
            32usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_TEXTURE_DESC_st),
                "::",
                stringify!(minMipmapLevelClamp)
            )
        );
    }
    test_field_minMipmapLevelClamp();
    fn test_field_maxMipmapLevelClamp() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_TEXTURE_DESC_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).maxMipmapLevelClamp) as usize - ptr as usize
            },
            36usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_TEXTURE_DESC_st),
                "::",
                stringify!(maxMipmapLevelClamp)
            )
        );
    }
    test_field_maxMipmapLevelClamp();
    fn test_field_borderColor() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_TEXTURE_DESC_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).borderColor) as usize - ptr as usize
            },
            40usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_TEXTURE_DESC_st),
                "::",
                stringify!(borderColor)
            )
        );
    }
    test_field_borderColor();
    fn test_field_reserved() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_TEXTURE_DESC_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize
            },
            56usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_TEXTURE_DESC_st),
                "::",
                stringify!(reserved)
            )
        );
    }
    test_field_reserved();
}
impl Default for CUDA_TEXTURE_DESC_st {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type CUDA_TEXTURE_DESC_v1 = CUDA_TEXTURE_DESC_st;
pub type CUDA_TEXTURE_DESC = CUDA_TEXTURE_DESC_v1;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUresourceViewFormat_enum {
    CU_RES_VIEW_FORMAT_NONE = 0,
    CU_RES_VIEW_FORMAT_UINT_1X8 = 1,
    CU_RES_VIEW_FORMAT_UINT_2X8 = 2,
    CU_RES_VIEW_FORMAT_UINT_4X8 = 3,
    CU_RES_VIEW_FORMAT_SINT_1X8 = 4,
    CU_RES_VIEW_FORMAT_SINT_2X8 = 5,
    CU_RES_VIEW_FORMAT_SINT_4X8 = 6,
    CU_RES_VIEW_FORMAT_UINT_1X16 = 7,
    CU_RES_VIEW_FORMAT_UINT_2X16 = 8,
    CU_RES_VIEW_FORMAT_UINT_4X16 = 9,
    CU_RES_VIEW_FORMAT_SINT_1X16 = 10,
    CU_RES_VIEW_FORMAT_SINT_2X16 = 11,
    CU_RES_VIEW_FORMAT_SINT_4X16 = 12,
    CU_RES_VIEW_FORMAT_UINT_1X32 = 13,
    CU_RES_VIEW_FORMAT_UINT_2X32 = 14,
    CU_RES_VIEW_FORMAT_UINT_4X32 = 15,
    CU_RES_VIEW_FORMAT_SINT_1X32 = 16,
    CU_RES_VIEW_FORMAT_SINT_2X32 = 17,
    CU_RES_VIEW_FORMAT_SINT_4X32 = 18,
    CU_RES_VIEW_FORMAT_FLOAT_1X16 = 19,
    CU_RES_VIEW_FORMAT_FLOAT_2X16 = 20,
    CU_RES_VIEW_FORMAT_FLOAT_4X16 = 21,
    CU_RES_VIEW_FORMAT_FLOAT_1X32 = 22,
    CU_RES_VIEW_FORMAT_FLOAT_2X32 = 23,
    CU_RES_VIEW_FORMAT_FLOAT_4X32 = 24,
    CU_RES_VIEW_FORMAT_UNSIGNED_BC1 = 25,
    CU_RES_VIEW_FORMAT_UNSIGNED_BC2 = 26,
    CU_RES_VIEW_FORMAT_UNSIGNED_BC3 = 27,
    CU_RES_VIEW_FORMAT_UNSIGNED_BC4 = 28,
    CU_RES_VIEW_FORMAT_SIGNED_BC4 = 29,
    CU_RES_VIEW_FORMAT_UNSIGNED_BC5 = 30,
    CU_RES_VIEW_FORMAT_SIGNED_BC5 = 31,
    CU_RES_VIEW_FORMAT_UNSIGNED_BC6H = 32,
    CU_RES_VIEW_FORMAT_SIGNED_BC6H = 33,
    CU_RES_VIEW_FORMAT_UNSIGNED_BC7 = 34,
}
pub use self::CUresourceViewFormat_enum as CUresourceViewFormat;
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct CUDA_RESOURCE_VIEW_DESC_st {
    pub format: CUresourceViewFormat,
    pub width: usize,
    pub height: usize,
    pub depth: usize,
    pub firstMipmapLevel: core::ffi::c_uint,
    pub lastMipmapLevel: core::ffi::c_uint,
    pub firstLayer: core::ffi::c_uint,
    pub lastLayer: core::ffi::c_uint,
    pub reserved: [core::ffi::c_uint; 16usize],
}
#[test]
fn bindgen_test_layout_CUDA_RESOURCE_VIEW_DESC_st() {
    assert_eq!(
        ::core::mem::size_of::<CUDA_RESOURCE_VIEW_DESC_st>(),
        112usize,
        concat!("Size of: ", stringify!(CUDA_RESOURCE_VIEW_DESC_st))
    );
    assert_eq!(
        ::core::mem::align_of::<CUDA_RESOURCE_VIEW_DESC_st>(),
        8usize,
        concat!("Alignment of ", stringify!(CUDA_RESOURCE_VIEW_DESC_st))
    );
    fn test_field_format() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_RESOURCE_VIEW_DESC_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).format) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_RESOURCE_VIEW_DESC_st),
                "::",
                stringify!(format)
            )
        );
    }
    test_field_format();
    fn test_field_width() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_RESOURCE_VIEW_DESC_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).width) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_RESOURCE_VIEW_DESC_st),
                "::",
                stringify!(width)
            )
        );
    }
    test_field_width();
    fn test_field_height() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_RESOURCE_VIEW_DESC_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).height) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_RESOURCE_VIEW_DESC_st),
                "::",
                stringify!(height)
            )
        );
    }
    test_field_height();
    fn test_field_depth() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_RESOURCE_VIEW_DESC_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).depth) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_RESOURCE_VIEW_DESC_st),
                "::",
                stringify!(depth)
            )
        );
    }
    test_field_depth();
    fn test_field_firstMipmapLevel() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_RESOURCE_VIEW_DESC_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).firstMipmapLevel) as usize - ptr as usize
            },
            32usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_RESOURCE_VIEW_DESC_st),
                "::",
                stringify!(firstMipmapLevel)
            )
        );
    }
    test_field_firstMipmapLevel();
    fn test_field_lastMipmapLevel() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_RESOURCE_VIEW_DESC_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).lastMipmapLevel) as usize - ptr as usize
            },
            36usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_RESOURCE_VIEW_DESC_st),
                "::",
                stringify!(lastMipmapLevel)
            )
        );
    }
    test_field_lastMipmapLevel();
    fn test_field_firstLayer() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_RESOURCE_VIEW_DESC_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).firstLayer) as usize - ptr as usize
            },
            40usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_RESOURCE_VIEW_DESC_st),
                "::",
                stringify!(firstLayer)
            )
        );
    }
    test_field_firstLayer();
    fn test_field_lastLayer() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_RESOURCE_VIEW_DESC_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).lastLayer) as usize - ptr as usize
            },
            44usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_RESOURCE_VIEW_DESC_st),
                "::",
                stringify!(lastLayer)
            )
        );
    }
    test_field_lastLayer();
    fn test_field_reserved() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_RESOURCE_VIEW_DESC_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize
            },
            48usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_RESOURCE_VIEW_DESC_st),
                "::",
                stringify!(reserved)
            )
        );
    }
    test_field_reserved();
}
impl Default for CUDA_RESOURCE_VIEW_DESC_st {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type CUDA_RESOURCE_VIEW_DESC_v1 = CUDA_RESOURCE_VIEW_DESC_st;
pub type CUDA_RESOURCE_VIEW_DESC = CUDA_RESOURCE_VIEW_DESC_v1;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st {
    pub p2pToken: core::ffi::c_ulonglong,
    pub vaSpaceToken: core::ffi::c_uint,
}
#[test]
fn bindgen_test_layout_CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st() {
    assert_eq!(
        ::core::mem::size_of::<CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st>(),
        16usize,
        concat!(
            "Size of: ",
            stringify!(CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st)
        )
    );
    fn test_field_p2pToken() {
        assert_eq!(
            unsafe {
                let uninit =
                    ::core::mem::MaybeUninit::<CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).p2pToken) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st),
                "::",
                stringify!(p2pToken)
            )
        );
    }
    test_field_p2pToken();
    fn test_field_vaSpaceToken() {
        assert_eq!(
            unsafe {
                let uninit =
                    ::core::mem::MaybeUninit::<CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).vaSpaceToken) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st),
                "::",
                stringify!(vaSpaceToken)
            )
        );
    }
    test_field_vaSpaceToken();
}
pub type CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_v1 = CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st;
pub type CUDA_POINTER_ATTRIBUTE_P2P_TOKENS = CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_v1;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUDA_POINTER_ATTRIBUTE_ACCESS_FLAGS_enum {
    CU_POINTER_ATTRIBUTE_ACCESS_FLAG_NONE = 0,
    CU_POINTER_ATTRIBUTE_ACCESS_FLAG_READ = 1,
    CU_POINTER_ATTRIBUTE_ACCESS_FLAG_READWRITE = 3,
}
pub use self::CUDA_POINTER_ATTRIBUTE_ACCESS_FLAGS_enum as CUDA_POINTER_ATTRIBUTE_ACCESS_FLAGS;
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct CUDA_LAUNCH_PARAMS_st {
    pub function: CUfunction,
    pub gridDimX: core::ffi::c_uint,
    pub gridDimY: core::ffi::c_uint,
    pub gridDimZ: core::ffi::c_uint,
    pub blockDimX: core::ffi::c_uint,
    pub blockDimY: core::ffi::c_uint,
    pub blockDimZ: core::ffi::c_uint,
    pub sharedMemBytes: core::ffi::c_uint,
    pub hStream: CUstream,
    pub kernelParams: *mut *mut ::core::ffi::c_void,
}
#[test]
fn bindgen_test_layout_CUDA_LAUNCH_PARAMS_st() {
    assert_eq!(
        ::core::mem::size_of::<CUDA_LAUNCH_PARAMS_st>(),
        56usize,
        concat!("Size of: ", stringify!(CUDA_LAUNCH_PARAMS_st))
    );
    assert_eq!(
        ::core::mem::align_of::<CUDA_LAUNCH_PARAMS_st>(),
        8usize,
        concat!("Alignment of ", stringify!(CUDA_LAUNCH_PARAMS_st))
    );
    fn test_field_function() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_LAUNCH_PARAMS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).function) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_LAUNCH_PARAMS_st),
                "::",
                stringify!(function)
            )
        );
    }
    test_field_function();
    fn test_field_gridDimX() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_LAUNCH_PARAMS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).gridDimX) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_LAUNCH_PARAMS_st),
                "::",
                stringify!(gridDimX)
            )
        );
    }
    test_field_gridDimX();
    fn test_field_gridDimY() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_LAUNCH_PARAMS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).gridDimY) as usize - ptr as usize
            },
            12usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_LAUNCH_PARAMS_st),
                "::",
                stringify!(gridDimY)
            )
        );
    }
    test_field_gridDimY();
    fn test_field_gridDimZ() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_LAUNCH_PARAMS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).gridDimZ) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_LAUNCH_PARAMS_st),
                "::",
                stringify!(gridDimZ)
            )
        );
    }
    test_field_gridDimZ();
    fn test_field_blockDimX() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_LAUNCH_PARAMS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).blockDimX) as usize - ptr as usize
            },
            20usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_LAUNCH_PARAMS_st),
                "::",
                stringify!(blockDimX)
            )
        );
    }
    test_field_blockDimX();
    fn test_field_blockDimY() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_LAUNCH_PARAMS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).blockDimY) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_LAUNCH_PARAMS_st),
                "::",
                stringify!(blockDimY)
            )
        );
    }
    test_field_blockDimY();
    fn test_field_blockDimZ() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_LAUNCH_PARAMS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).blockDimZ) as usize - ptr as usize
            },
            28usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_LAUNCH_PARAMS_st),
                "::",
                stringify!(blockDimZ)
            )
        );
    }
    test_field_blockDimZ();
    fn test_field_sharedMemBytes() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_LAUNCH_PARAMS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).sharedMemBytes) as usize - ptr as usize
            },
            32usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_LAUNCH_PARAMS_st),
                "::",
                stringify!(sharedMemBytes)
            )
        );
    }
    test_field_sharedMemBytes();
    fn test_field_hStream() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_LAUNCH_PARAMS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).hStream) as usize - ptr as usize
            },
            40usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_LAUNCH_PARAMS_st),
                "::",
                stringify!(hStream)
            )
        );
    }
    test_field_hStream();
    fn test_field_kernelParams() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_LAUNCH_PARAMS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).kernelParams) as usize - ptr as usize
            },
            48usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_LAUNCH_PARAMS_st),
                "::",
                stringify!(kernelParams)
            )
        );
    }
    test_field_kernelParams();
}
impl Default for CUDA_LAUNCH_PARAMS_st {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type CUDA_LAUNCH_PARAMS_v1 = CUDA_LAUNCH_PARAMS_st;
pub type CUDA_LAUNCH_PARAMS = CUDA_LAUNCH_PARAMS_v1;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUexternalMemoryHandleType_enum {
    CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD = 1,
    CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 = 2,
    CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT = 3,
    CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP = 4,
    CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE = 5,
    CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE = 6,
    CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE_KMT = 7,
    CU_EXTERNAL_MEMORY_HANDLE_TYPE_NVSCIBUF = 8,
}
pub use self::CUexternalMemoryHandleType_enum as CUexternalMemoryHandleType;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st {
    pub type_: CUexternalMemoryHandleType,
    pub handle: CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1,
    pub size: core::ffi::c_ulonglong,
    pub flags: core::ffi::c_uint,
    pub reserved: [core::ffi::c_uint; 16usize],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1 {
    pub fd: core::ffi::c_int,
    pub win32: CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1,
    pub nvSciBufObject: *const ::core::ffi::c_void,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1 {
    pub handle: *mut ::core::ffi::c_void,
    pub name: *const ::core::ffi::c_void,
}
#[test]
fn bindgen_test_layout_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1() {
    assert_eq!(
        ::core::mem::size_of::<CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1>(),
        16usize,
        concat!(
            "Size of: ",
            stringify!(CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1)
        )
    );
    fn test_field_handle() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).handle) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1),
                "::",
                stringify!(handle)
            )
        );
    }
    test_field_handle();
    fn test_field_name() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).name) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1),
                "::",
                stringify!(name)
            )
        );
    }
    test_field_name();
}
impl Default for CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[test]
fn bindgen_test_layout_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1() {
    assert_eq!(
        ::core::mem::size_of::<CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1>(),
        16usize,
        concat!(
            "Size of: ",
            stringify!(CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1)
        )
    );
    fn test_field_fd() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).fd) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1),
                "::",
                stringify!(fd)
            )
        );
    }
    test_field_fd();
    fn test_field_win32() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).win32) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1),
                "::",
                stringify!(win32)
            )
        );
    }
    test_field_win32();
    fn test_field_nvSciBufObject() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).nvSciBufObject) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1),
                "::",
                stringify!(nvSciBufObject)
            )
        );
    }
    test_field_nvSciBufObject();
}
impl Default for CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[test]
fn bindgen_test_layout_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st() {
    assert_eq!(
        ::core::mem::size_of::<CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st>(),
        104usize,
        concat!("Size of: ", stringify!(CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st))
    );
    assert_eq!(
        ::core::mem::align_of::<CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st)
        )
    );
    fn test_field_type() {
        assert_eq!(
            unsafe {
                let uninit =
                    ::core::mem::MaybeUninit::<CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st),
                "::",
                stringify!(type_)
            )
        );
    }
    test_field_type();
    fn test_field_handle() {
        assert_eq!(
            unsafe {
                let uninit =
                    ::core::mem::MaybeUninit::<CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).handle) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st),
                "::",
                stringify!(handle)
            )
        );
    }
    test_field_handle();
    fn test_field_size() {
        assert_eq!(
            unsafe {
                let uninit =
                    ::core::mem::MaybeUninit::<CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).size) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st),
                "::",
                stringify!(size)
            )
        );
    }
    test_field_size();
    fn test_field_flags() {
        assert_eq!(
            unsafe {
                let uninit =
                    ::core::mem::MaybeUninit::<CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize
            },
            32usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st),
                "::",
                stringify!(flags)
            )
        );
    }
    test_field_flags();
    fn test_field_reserved() {
        assert_eq!(
            unsafe {
                let uninit =
                    ::core::mem::MaybeUninit::<CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize
            },
            36usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st),
                "::",
                stringify!(reserved)
            )
        );
    }
    test_field_reserved();
}
impl Default for CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1 = CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st;
pub type CUDA_EXTERNAL_MEMORY_HANDLE_DESC = CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st {
    pub offset: core::ffi::c_ulonglong,
    pub size: core::ffi::c_ulonglong,
    pub flags: core::ffi::c_uint,
    pub reserved: [core::ffi::c_uint; 16usize],
}
#[test]
fn bindgen_test_layout_CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st() {
    assert_eq!(
        ::core::mem::size_of::<CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st>(),
        88usize,
        concat!("Size of: ", stringify!(CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st))
    );
    assert_eq!(
        ::core::mem::align_of::<CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st)
        )
    );
    fn test_field_offset() {
        assert_eq!(
            unsafe {
                let uninit =
                    ::core::mem::MaybeUninit::<CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).offset) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st),
                "::",
                stringify!(offset)
            )
        );
    }
    test_field_offset();
    fn test_field_size() {
        assert_eq!(
            unsafe {
                let uninit =
                    ::core::mem::MaybeUninit::<CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).size) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st),
                "::",
                stringify!(size)
            )
        );
    }
    test_field_size();
    fn test_field_flags() {
        assert_eq!(
            unsafe {
                let uninit =
                    ::core::mem::MaybeUninit::<CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st),
                "::",
                stringify!(flags)
            )
        );
    }
    test_field_flags();
    fn test_field_reserved() {
        assert_eq!(
            unsafe {
                let uninit =
                    ::core::mem::MaybeUninit::<CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize
            },
            20usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st),
                "::",
                stringify!(reserved)
            )
        );
    }
    test_field_reserved();
}
pub type CUDA_EXTERNAL_MEMORY_BUFFER_DESC_v1 = CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st;
pub type CUDA_EXTERNAL_MEMORY_BUFFER_DESC = CUDA_EXTERNAL_MEMORY_BUFFER_DESC_v1;
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st {
    pub offset: core::ffi::c_ulonglong,
    pub arrayDesc: CUDA_ARRAY3D_DESCRIPTOR,
    pub numLevels: core::ffi::c_uint,
    pub reserved: [core::ffi::c_uint; 16usize],
}
#[test]
fn bindgen_test_layout_CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st() {
    assert_eq!(
        ::core::mem::size_of::<CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st>(),
        120usize,
        concat!(
            "Size of: ",
            stringify!(CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st)
        )
    );
    fn test_field_offset() {
        assert_eq!(
            unsafe {
                let uninit = :: core :: mem :: MaybeUninit :: < CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st > :: uninit () ;
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).offset) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st),
                "::",
                stringify!(offset)
            )
        );
    }
    test_field_offset();
    fn test_field_arrayDesc() {
        assert_eq!(
            unsafe {
                let uninit = :: core :: mem :: MaybeUninit :: < CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st > :: uninit () ;
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).arrayDesc) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st),
                "::",
                stringify!(arrayDesc)
            )
        );
    }
    test_field_arrayDesc();
    fn test_field_numLevels() {
        assert_eq!(
            unsafe {
                let uninit = :: core :: mem :: MaybeUninit :: < CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st > :: uninit () ;
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).numLevels) as usize - ptr as usize
            },
            48usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st),
                "::",
                stringify!(numLevels)
            )
        );
    }
    test_field_numLevels();
    fn test_field_reserved() {
        assert_eq!(
            unsafe {
                let uninit = :: core :: mem :: MaybeUninit :: < CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st > :: uninit () ;
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize
            },
            52usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st),
                "::",
                stringify!(reserved)
            )
        );
    }
    test_field_reserved();
}
impl Default for CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_v1 =
    CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st;
pub type CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC = CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_v1;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUexternalSemaphoreHandleType_enum {
    CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD = 1,
    CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32 = 2,
    CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT = 3,
    CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE = 4,
    CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE = 5,
    CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NVSCISYNC = 6,
    CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX = 7,
    CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX_KMT = 8,
    CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TIMELINE_SEMAPHORE_FD = 9,
    CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TIMELINE_SEMAPHORE_WIN32 = 10,
}
pub use self::CUexternalSemaphoreHandleType_enum as CUexternalSemaphoreHandleType;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st {
    pub type_: CUexternalSemaphoreHandleType,
    pub handle: CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1,
    pub flags: core::ffi::c_uint,
    pub reserved: [core::ffi::c_uint; 16usize],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1 {
    pub fd: core::ffi::c_int,
    pub win32: CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1,
    pub nvSciSyncObj: *const ::core::ffi::c_void,
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1 {
    pub handle: *mut ::core::ffi::c_void,
    pub name: *const ::core::ffi::c_void,
}
#[test]
fn bindgen_test_layout_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1() {
    assert_eq!(
        ::core::mem::size_of::<CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1>(
        ),
        16usize,
        concat!(
            "Size of: ",
            stringify!(CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1>(
        ),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1)
        )
    );
    fn test_field_handle() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).handle) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1),
                "::",
                stringify!(handle)
            )
        );
    }
    test_field_handle();
    fn test_field_name() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).name) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1),
                "::",
                stringify!(name)
            )
        );
    }
    test_field_name();
}
impl Default for CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[test]
fn bindgen_test_layout_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1() {
    assert_eq!(
        ::core::mem::size_of::<CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1>(),
        16usize,
        concat!(
            "Size of: ",
            stringify!(CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1)
        )
    );
    fn test_field_fd() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).fd) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1),
                "::",
                stringify!(fd)
            )
        );
    }
    test_field_fd();
    fn test_field_win32() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).win32) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1),
                "::",
                stringify!(win32)
            )
        );
    }
    test_field_win32();
    fn test_field_nvSciSyncObj() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).nvSciSyncObj) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1),
                "::",
                stringify!(nvSciSyncObj)
            )
        );
    }
    test_field_nvSciSyncObj();
}
impl Default for CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[test]
fn bindgen_test_layout_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st() {
    assert_eq!(
        ::core::mem::size_of::<CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st>(),
        96usize,
        concat!(
            "Size of: ",
            stringify!(CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st)
        )
    );
    fn test_field_type() {
        assert_eq!(
            unsafe {
                let uninit =
                    ::core::mem::MaybeUninit::<CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st),
                "::",
                stringify!(type_)
            )
        );
    }
    test_field_type();
    fn test_field_handle() {
        assert_eq!(
            unsafe {
                let uninit =
                    ::core::mem::MaybeUninit::<CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).handle) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st),
                "::",
                stringify!(handle)
            )
        );
    }
    test_field_handle();
    fn test_field_flags() {
        assert_eq!(
            unsafe {
                let uninit =
                    ::core::mem::MaybeUninit::<CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st),
                "::",
                stringify!(flags)
            )
        );
    }
    test_field_flags();
    fn test_field_reserved() {
        assert_eq!(
            unsafe {
                let uninit =
                    ::core::mem::MaybeUninit::<CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize
            },
            28usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st),
                "::",
                stringify!(reserved)
            )
        );
    }
    test_field_reserved();
}
impl Default for CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1 = CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st;
pub type CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC = CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st {
    pub params: CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1,
    pub flags: core::ffi::c_uint,
    pub reserved: [core::ffi::c_uint; 16usize],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1 {
    pub fence: CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_1,
    pub nvSciSync: CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_2,
    pub keyedMutex: CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_3,
    pub reserved: [core::ffi::c_uint; 12usize],
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_1 {
    pub value: core::ffi::c_ulonglong,
}
#[test]
fn bindgen_test_layout_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_1() {
    assert_eq!(
        ::core::mem::size_of::<CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_1>(
        ),
        8usize,
        concat!(
            "Size of: ",
            stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_1>(
        ),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_1)
        )
    );
    fn test_field_value() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_1,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).value) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_1),
                "::",
                stringify!(value)
            )
        );
    }
    test_field_value();
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_2 {
    pub fence: *mut ::core::ffi::c_void,
    pub reserved: core::ffi::c_ulonglong,
}
#[test]
fn bindgen_test_layout_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_2() {
    assert_eq!(
        ::core::mem::size_of::<CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_2>(
        ),
        8usize,
        concat!(
            "Size of: ",
            stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_2)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_2>(
        ),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_2)
        )
    );
    fn test_field_fence() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_2,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).fence) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_2),
                "::",
                stringify!(fence)
            )
        );
    }
    test_field_fence();
    fn test_field_reserved() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_2,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_2),
                "::",
                stringify!(reserved)
            )
        );
    }
    test_field_reserved();
}
impl Default for CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_2 {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_3 {
    pub key: core::ffi::c_ulonglong,
}
#[test]
fn bindgen_test_layout_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_3() {
    assert_eq!(
        ::core::mem::size_of::<CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_3>(
        ),
        8usize,
        concat!(
            "Size of: ",
            stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_3)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_3>(
        ),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_3)
        )
    );
    fn test_field_key() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_3,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).key) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_3),
                "::",
                stringify!(key)
            )
        );
    }
    test_field_key();
}
#[test]
fn bindgen_test_layout_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1() {
    assert_eq!(
        ::core::mem::size_of::<CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1>(),
        72usize,
        concat!(
            "Size of: ",
            stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1)
        )
    );
    fn test_field_fence() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).fence) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1),
                "::",
                stringify!(fence)
            )
        );
    }
    test_field_fence();
    fn test_field_nvSciSync() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).nvSciSync) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1),
                "::",
                stringify!(nvSciSync)
            )
        );
    }
    test_field_nvSciSync();
    fn test_field_keyedMutex() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).keyedMutex) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1),
                "::",
                stringify!(keyedMutex)
            )
        );
    }
    test_field_keyedMutex();
    fn test_field_reserved() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1),
                "::",
                stringify!(reserved)
            )
        );
    }
    test_field_reserved();
}
impl Default for CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[test]
fn bindgen_test_layout_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st() {
    assert_eq!(
        ::core::mem::size_of::<CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st>(),
        144usize,
        concat!(
            "Size of: ",
            stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st)
        )
    );
    fn test_field_params() {
        assert_eq!(
            unsafe {
                let uninit =
                    ::core::mem::MaybeUninit::<CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).params) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st),
                "::",
                stringify!(params)
            )
        );
    }
    test_field_params();
    fn test_field_flags() {
        assert_eq!(
            unsafe {
                let uninit =
                    ::core::mem::MaybeUninit::<CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize
            },
            72usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st),
                "::",
                stringify!(flags)
            )
        );
    }
    test_field_flags();
    fn test_field_reserved() {
        assert_eq!(
            unsafe {
                let uninit =
                    ::core::mem::MaybeUninit::<CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize
            },
            76usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st),
                "::",
                stringify!(reserved)
            )
        );
    }
    test_field_reserved();
}
impl Default for CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1 = CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st;
pub type CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS = CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st {
    pub params: CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1,
    pub flags: core::ffi::c_uint,
    pub reserved: [core::ffi::c_uint; 16usize],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1 {
    pub fence: CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_1,
    pub nvSciSync: CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_2,
    pub keyedMutex: CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_3,
    pub reserved: [core::ffi::c_uint; 10usize],
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_1 {
    pub value: core::ffi::c_ulonglong,
}
#[test]
fn bindgen_test_layout_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_1() {
    assert_eq!(
        ::core::mem::size_of::<CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_1>(
        ),
        8usize,
        concat!(
            "Size of: ",
            stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_1>(
        ),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_1)
        )
    );
    fn test_field_value() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_1,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).value) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_1),
                "::",
                stringify!(value)
            )
        );
    }
    test_field_value();
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_2 {
    pub fence: *mut ::core::ffi::c_void,
    pub reserved: core::ffi::c_ulonglong,
}
#[test]
fn bindgen_test_layout_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_2() {
    assert_eq!(
        ::core::mem::size_of::<CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_2>(
        ),
        8usize,
        concat!(
            "Size of: ",
            stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_2)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_2>(
        ),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_2)
        )
    );
    fn test_field_fence() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_2,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).fence) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_2),
                "::",
                stringify!(fence)
            )
        );
    }
    test_field_fence();
    fn test_field_reserved() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_2,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_2),
                "::",
                stringify!(reserved)
            )
        );
    }
    test_field_reserved();
}
impl Default for CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_2 {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_3 {
    pub key: core::ffi::c_ulonglong,
    pub timeoutMs: core::ffi::c_uint,
}
#[test]
fn bindgen_test_layout_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_3() {
    assert_eq!(
        ::core::mem::size_of::<CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_3>(
        ),
        16usize,
        concat!(
            "Size of: ",
            stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_3)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_3>(
        ),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_3)
        )
    );
    fn test_field_key() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_3,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).key) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_3),
                "::",
                stringify!(key)
            )
        );
    }
    test_field_key();
    fn test_field_timeoutMs() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_3,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).timeoutMs) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_3),
                "::",
                stringify!(timeoutMs)
            )
        );
    }
    test_field_timeoutMs();
}
#[test]
fn bindgen_test_layout_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1() {
    assert_eq!(
        ::core::mem::size_of::<CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1>(),
        72usize,
        concat!(
            "Size of: ",
            stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1)
        )
    );
    fn test_field_fence() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).fence) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1),
                "::",
                stringify!(fence)
            )
        );
    }
    test_field_fence();
    fn test_field_nvSciSync() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).nvSciSync) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1),
                "::",
                stringify!(nvSciSync)
            )
        );
    }
    test_field_nvSciSync();
    fn test_field_keyedMutex() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).keyedMutex) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1),
                "::",
                stringify!(keyedMutex)
            )
        );
    }
    test_field_keyedMutex();
    fn test_field_reserved() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize
            },
            32usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1),
                "::",
                stringify!(reserved)
            )
        );
    }
    test_field_reserved();
}
impl Default for CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[test]
fn bindgen_test_layout_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st() {
    assert_eq!(
        ::core::mem::size_of::<CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st>(),
        144usize,
        concat!(
            "Size of: ",
            stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st)
        )
    );
    fn test_field_params() {
        assert_eq!(
            unsafe {
                let uninit =
                    ::core::mem::MaybeUninit::<CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).params) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st),
                "::",
                stringify!(params)
            )
        );
    }
    test_field_params();
    fn test_field_flags() {
        assert_eq!(
            unsafe {
                let uninit =
                    ::core::mem::MaybeUninit::<CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize
            },
            72usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st),
                "::",
                stringify!(flags)
            )
        );
    }
    test_field_flags();
    fn test_field_reserved() {
        assert_eq!(
            unsafe {
                let uninit =
                    ::core::mem::MaybeUninit::<CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize
            },
            76usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st),
                "::",
                stringify!(reserved)
            )
        );
    }
    test_field_reserved();
}
impl Default for CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1 = CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st;
pub type CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS = CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1;
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st {
    pub extSemArray: *mut CUexternalSemaphore,
    pub paramsArray: *const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS,
    pub numExtSems: core::ffi::c_uint,
}
#[test]
fn bindgen_test_layout_CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st() {
    assert_eq!(
        ::core::mem::size_of::<CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st>(),
        24usize,
        concat!("Size of: ", stringify!(CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st))
    );
    assert_eq!(
        ::core::mem::align_of::<CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st)
        )
    );
    fn test_field_extSemArray() {
        assert_eq!(
            unsafe {
                let uninit =
                    ::core::mem::MaybeUninit::<CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).extSemArray) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st),
                "::",
                stringify!(extSemArray)
            )
        );
    }
    test_field_extSemArray();
    fn test_field_paramsArray() {
        assert_eq!(
            unsafe {
                let uninit =
                    ::core::mem::MaybeUninit::<CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).paramsArray) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st),
                "::",
                stringify!(paramsArray)
            )
        );
    }
    test_field_paramsArray();
    fn test_field_numExtSems() {
        assert_eq!(
            unsafe {
                let uninit =
                    ::core::mem::MaybeUninit::<CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).numExtSems) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st),
                "::",
                stringify!(numExtSems)
            )
        );
    }
    test_field_numExtSems();
}
impl Default for CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_v1 = CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st;
pub type CUDA_EXT_SEM_SIGNAL_NODE_PARAMS = CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_v1;
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct CUDA_EXT_SEM_WAIT_NODE_PARAMS_st {
    pub extSemArray: *mut CUexternalSemaphore,
    pub paramsArray: *const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS,
    pub numExtSems: core::ffi::c_uint,
}
#[test]
fn bindgen_test_layout_CUDA_EXT_SEM_WAIT_NODE_PARAMS_st() {
    assert_eq!(
        ::core::mem::size_of::<CUDA_EXT_SEM_WAIT_NODE_PARAMS_st>(),
        24usize,
        concat!("Size of: ", stringify!(CUDA_EXT_SEM_WAIT_NODE_PARAMS_st))
    );
    assert_eq!(
        ::core::mem::align_of::<CUDA_EXT_SEM_WAIT_NODE_PARAMS_st>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(CUDA_EXT_SEM_WAIT_NODE_PARAMS_st)
        )
    );
    fn test_field_extSemArray() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_EXT_SEM_WAIT_NODE_PARAMS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).extSemArray) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXT_SEM_WAIT_NODE_PARAMS_st),
                "::",
                stringify!(extSemArray)
            )
        );
    }
    test_field_extSemArray();
    fn test_field_paramsArray() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_EXT_SEM_WAIT_NODE_PARAMS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).paramsArray) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXT_SEM_WAIT_NODE_PARAMS_st),
                "::",
                stringify!(paramsArray)
            )
        );
    }
    test_field_paramsArray();
    fn test_field_numExtSems() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUDA_EXT_SEM_WAIT_NODE_PARAMS_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).numExtSems) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(CUDA_EXT_SEM_WAIT_NODE_PARAMS_st),
                "::",
                stringify!(numExtSems)
            )
        );
    }
    test_field_numExtSems();
}
impl Default for CUDA_EXT_SEM_WAIT_NODE_PARAMS_st {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type CUDA_EXT_SEM_WAIT_NODE_PARAMS_v1 = CUDA_EXT_SEM_WAIT_NODE_PARAMS_st;
pub type CUDA_EXT_SEM_WAIT_NODE_PARAMS = CUDA_EXT_SEM_WAIT_NODE_PARAMS_v1;
pub type CUmemGenericAllocationHandle_v1 = core::ffi::c_ulonglong;
pub type CUmemGenericAllocationHandle = CUmemGenericAllocationHandle_v1;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUmemAllocationHandleType_enum {
    CU_MEM_HANDLE_TYPE_NONE = 0,
    CU_MEM_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR = 1,
    CU_MEM_HANDLE_TYPE_WIN32 = 2,
    CU_MEM_HANDLE_TYPE_WIN32_KMT = 4,
    CU_MEM_HANDLE_TYPE_MAX = 2147483647,
}
pub use self::CUmemAllocationHandleType_enum as CUmemAllocationHandleType;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUmemAccess_flags_enum {
    CU_MEM_ACCESS_FLAGS_PROT_NONE = 0,
    CU_MEM_ACCESS_FLAGS_PROT_READ = 1,
    CU_MEM_ACCESS_FLAGS_PROT_READWRITE = 3,
    CU_MEM_ACCESS_FLAGS_PROT_MAX = 2147483647,
}
pub use self::CUmemAccess_flags_enum as CUmemAccess_flags;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUmemLocationType_enum {
    CU_MEM_LOCATION_TYPE_INVALID = 0,
    CU_MEM_LOCATION_TYPE_DEVICE = 1,
    CU_MEM_LOCATION_TYPE_MAX = 2147483647,
}
pub use self::CUmemLocationType_enum as CUmemLocationType;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUmemAllocationType_enum {
    CU_MEM_ALLOCATION_TYPE_INVALID = 0,
    CU_MEM_ALLOCATION_TYPE_PINNED = 1,
    CU_MEM_ALLOCATION_TYPE_MAX = 2147483647,
}
pub use self::CUmemAllocationType_enum as CUmemAllocationType;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUmemAllocationGranularity_flags_enum {
    CU_MEM_ALLOC_GRANULARITY_MINIMUM = 0,
    CU_MEM_ALLOC_GRANULARITY_RECOMMENDED = 1,
}
pub use self::CUmemAllocationGranularity_flags_enum as CUmemAllocationGranularity_flags;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUarraySparseSubresourceType_enum {
    CU_ARRAY_SPARSE_SUBRESOURCE_TYPE_SPARSE_LEVEL = 0,
    CU_ARRAY_SPARSE_SUBRESOURCE_TYPE_MIPTAIL = 1,
}
pub use self::CUarraySparseSubresourceType_enum as CUarraySparseSubresourceType;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUmemOperationType_enum {
    CU_MEM_OPERATION_TYPE_MAP = 1,
    CU_MEM_OPERATION_TYPE_UNMAP = 2,
}
pub use self::CUmemOperationType_enum as CUmemOperationType;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUmemHandleType_enum {
    CU_MEM_HANDLE_TYPE_GENERIC = 0,
}
pub use self::CUmemHandleType_enum as CUmemHandleType;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct CUarrayMapInfo_st {
    pub resourceType: CUresourcetype,
    pub resource: CUarrayMapInfo_st__bindgen_ty_1,
    pub subresourceType: CUarraySparseSubresourceType,
    pub subresource: CUarrayMapInfo_st__bindgen_ty_2,
    pub memOperationType: CUmemOperationType,
    pub memHandleType: CUmemHandleType,
    pub memHandle: CUarrayMapInfo_st__bindgen_ty_3,
    pub offset: core::ffi::c_ulonglong,
    pub deviceBitMask: core::ffi::c_uint,
    pub flags: core::ffi::c_uint,
    pub reserved: [core::ffi::c_uint; 2usize],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union CUarrayMapInfo_st__bindgen_ty_1 {
    pub mipmap: CUmipmappedArray,
    pub array: CUarray,
}
#[test]
fn bindgen_test_layout_CUarrayMapInfo_st__bindgen_ty_1() {
    assert_eq!(
        ::core::mem::size_of::<CUarrayMapInfo_st__bindgen_ty_1>(),
        8usize,
        concat!("Size of: ", stringify!(CUarrayMapInfo_st__bindgen_ty_1))
    );
    assert_eq!(
        ::core::mem::align_of::<CUarrayMapInfo_st__bindgen_ty_1>(),
        8usize,
        concat!("Alignment of ", stringify!(CUarrayMapInfo_st__bindgen_ty_1))
    );
    fn test_field_mipmap() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUarrayMapInfo_st__bindgen_ty_1>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).mipmap) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUarrayMapInfo_st__bindgen_ty_1),
                "::",
                stringify!(mipmap)
            )
        );
    }
    test_field_mipmap();
    fn test_field_array() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUarrayMapInfo_st__bindgen_ty_1>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).array) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUarrayMapInfo_st__bindgen_ty_1),
                "::",
                stringify!(array)
            )
        );
    }
    test_field_array();
}
impl Default for CUarrayMapInfo_st__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union CUarrayMapInfo_st__bindgen_ty_2 {
    pub sparseLevel: CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_1,
    pub miptail: CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_2,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_1 {
    pub level: core::ffi::c_uint,
    pub layer: core::ffi::c_uint,
    pub offsetX: core::ffi::c_uint,
    pub offsetY: core::ffi::c_uint,
    pub offsetZ: core::ffi::c_uint,
    pub extentWidth: core::ffi::c_uint,
    pub extentHeight: core::ffi::c_uint,
    pub extentDepth: core::ffi::c_uint,
}
#[test]
fn bindgen_test_layout_CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_1() {
    assert_eq!(
        ::core::mem::size_of::<CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_1>(),
        32usize,
        concat!(
            "Size of: ",
            stringify!(CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_1>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_1)
        )
    );
    fn test_field_level() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_1,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).level) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_1),
                "::",
                stringify!(level)
            )
        );
    }
    test_field_level();
    fn test_field_layer() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_1,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).layer) as usize - ptr as usize
            },
            4usize,
            concat!(
                "Offset of field: ",
                stringify!(CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_1),
                "::",
                stringify!(layer)
            )
        );
    }
    test_field_layer();
    fn test_field_offsetX() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_1,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).offsetX) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_1),
                "::",
                stringify!(offsetX)
            )
        );
    }
    test_field_offsetX();
    fn test_field_offsetY() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_1,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).offsetY) as usize - ptr as usize
            },
            12usize,
            concat!(
                "Offset of field: ",
                stringify!(CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_1),
                "::",
                stringify!(offsetY)
            )
        );
    }
    test_field_offsetY();
    fn test_field_offsetZ() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_1,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).offsetZ) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_1),
                "::",
                stringify!(offsetZ)
            )
        );
    }
    test_field_offsetZ();
    fn test_field_extentWidth() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_1,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).extentWidth) as usize - ptr as usize
            },
            20usize,
            concat!(
                "Offset of field: ",
                stringify!(CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_1),
                "::",
                stringify!(extentWidth)
            )
        );
    }
    test_field_extentWidth();
    fn test_field_extentHeight() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_1,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).extentHeight) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_1),
                "::",
                stringify!(extentHeight)
            )
        );
    }
    test_field_extentHeight();
    fn test_field_extentDepth() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_1,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).extentDepth) as usize - ptr as usize
            },
            28usize,
            concat!(
                "Offset of field: ",
                stringify!(CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_1),
                "::",
                stringify!(extentDepth)
            )
        );
    }
    test_field_extentDepth();
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_2 {
    pub layer: core::ffi::c_uint,
    pub offset: core::ffi::c_ulonglong,
    pub size: core::ffi::c_ulonglong,
}
#[test]
fn bindgen_test_layout_CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_2() {
    assert_eq!(
        ::core::mem::size_of::<CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_2>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_2)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_2>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_2)
        )
    );
    fn test_field_layer() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_2,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).layer) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_2),
                "::",
                stringify!(layer)
            )
        );
    }
    test_field_layer();
    fn test_field_offset() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_2,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).offset) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_2),
                "::",
                stringify!(offset)
            )
        );
    }
    test_field_offset();
    fn test_field_size() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<
                    CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_2,
                >::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).size) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_2),
                "::",
                stringify!(size)
            )
        );
    }
    test_field_size();
}
#[test]
fn bindgen_test_layout_CUarrayMapInfo_st__bindgen_ty_2() {
    assert_eq!(
        ::core::mem::size_of::<CUarrayMapInfo_st__bindgen_ty_2>(),
        32usize,
        concat!("Size of: ", stringify!(CUarrayMapInfo_st__bindgen_ty_2))
    );
    assert_eq!(
        ::core::mem::align_of::<CUarrayMapInfo_st__bindgen_ty_2>(),
        8usize,
        concat!("Alignment of ", stringify!(CUarrayMapInfo_st__bindgen_ty_2))
    );
    fn test_field_sparseLevel() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUarrayMapInfo_st__bindgen_ty_2>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).sparseLevel) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUarrayMapInfo_st__bindgen_ty_2),
                "::",
                stringify!(sparseLevel)
            )
        );
    }
    test_field_sparseLevel();
    fn test_field_miptail() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUarrayMapInfo_st__bindgen_ty_2>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).miptail) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUarrayMapInfo_st__bindgen_ty_2),
                "::",
                stringify!(miptail)
            )
        );
    }
    test_field_miptail();
}
impl Default for CUarrayMapInfo_st__bindgen_ty_2 {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union CUarrayMapInfo_st__bindgen_ty_3 {
    pub memHandle: CUmemGenericAllocationHandle,
}
#[test]
fn bindgen_test_layout_CUarrayMapInfo_st__bindgen_ty_3() {
    assert_eq!(
        ::core::mem::size_of::<CUarrayMapInfo_st__bindgen_ty_3>(),
        8usize,
        concat!("Size of: ", stringify!(CUarrayMapInfo_st__bindgen_ty_3))
    );
    assert_eq!(
        ::core::mem::align_of::<CUarrayMapInfo_st__bindgen_ty_3>(),
        8usize,
        concat!("Alignment of ", stringify!(CUarrayMapInfo_st__bindgen_ty_3))
    );
    fn test_field_memHandle() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUarrayMapInfo_st__bindgen_ty_3>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).memHandle) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUarrayMapInfo_st__bindgen_ty_3),
                "::",
                stringify!(memHandle)
            )
        );
    }
    test_field_memHandle();
}
impl Default for CUarrayMapInfo_st__bindgen_ty_3 {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[test]
fn bindgen_test_layout_CUarrayMapInfo_st() {
    assert_eq!(
        ::core::mem::size_of::<CUarrayMapInfo_st>(),
        96usize,
        concat!("Size of: ", stringify!(CUarrayMapInfo_st))
    );
    assert_eq!(
        ::core::mem::align_of::<CUarrayMapInfo_st>(),
        8usize,
        concat!("Alignment of ", stringify!(CUarrayMapInfo_st))
    );
    fn test_field_resourceType() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUarrayMapInfo_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).resourceType) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUarrayMapInfo_st),
                "::",
                stringify!(resourceType)
            )
        );
    }
    test_field_resourceType();
    fn test_field_resource() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUarrayMapInfo_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).resource) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(CUarrayMapInfo_st),
                "::",
                stringify!(resource)
            )
        );
    }
    test_field_resource();
    fn test_field_subresourceType() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUarrayMapInfo_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).subresourceType) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(CUarrayMapInfo_st),
                "::",
                stringify!(subresourceType)
            )
        );
    }
    test_field_subresourceType();
    fn test_field_subresource() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUarrayMapInfo_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).subresource) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(CUarrayMapInfo_st),
                "::",
                stringify!(subresource)
            )
        );
    }
    test_field_subresource();
    fn test_field_memOperationType() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUarrayMapInfo_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).memOperationType) as usize - ptr as usize
            },
            56usize,
            concat!(
                "Offset of field: ",
                stringify!(CUarrayMapInfo_st),
                "::",
                stringify!(memOperationType)
            )
        );
    }
    test_field_memOperationType();
    fn test_field_memHandleType() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUarrayMapInfo_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).memHandleType) as usize - ptr as usize
            },
            60usize,
            concat!(
                "Offset of field: ",
                stringify!(CUarrayMapInfo_st),
                "::",
                stringify!(memHandleType)
            )
        );
    }
    test_field_memHandleType();
    fn test_field_memHandle() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUarrayMapInfo_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).memHandle) as usize - ptr as usize
            },
            64usize,
            concat!(
                "Offset of field: ",
                stringify!(CUarrayMapInfo_st),
                "::",
                stringify!(memHandle)
            )
        );
    }
    test_field_memHandle();
    fn test_field_offset() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUarrayMapInfo_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).offset) as usize - ptr as usize
            },
            72usize,
            concat!(
                "Offset of field: ",
                stringify!(CUarrayMapInfo_st),
                "::",
                stringify!(offset)
            )
        );
    }
    test_field_offset();
    fn test_field_deviceBitMask() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUarrayMapInfo_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).deviceBitMask) as usize - ptr as usize
            },
            80usize,
            concat!(
                "Offset of field: ",
                stringify!(CUarrayMapInfo_st),
                "::",
                stringify!(deviceBitMask)
            )
        );
    }
    test_field_deviceBitMask();
    fn test_field_flags() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUarrayMapInfo_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize
            },
            84usize,
            concat!(
                "Offset of field: ",
                stringify!(CUarrayMapInfo_st),
                "::",
                stringify!(flags)
            )
        );
    }
    test_field_flags();
    fn test_field_reserved() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUarrayMapInfo_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize
            },
            88usize,
            concat!(
                "Offset of field: ",
                stringify!(CUarrayMapInfo_st),
                "::",
                stringify!(reserved)
            )
        );
    }
    test_field_reserved();
}
impl Default for CUarrayMapInfo_st {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type CUarrayMapInfo_v1 = CUarrayMapInfo_st;
pub type CUarrayMapInfo = CUarrayMapInfo_v1;
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct CUmemLocation_st {
    pub type_: CUmemLocationType,
    pub id: core::ffi::c_int,
}
#[test]
fn bindgen_test_layout_CUmemLocation_st() {
    assert_eq!(
        ::core::mem::size_of::<CUmemLocation_st>(),
        8usize,
        concat!("Size of: ", stringify!(CUmemLocation_st))
    );
    assert_eq!(
        ::core::mem::align_of::<CUmemLocation_st>(),
        4usize,
        concat!("Alignment of ", stringify!(CUmemLocation_st))
    );
    fn test_field_type() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUmemLocation_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUmemLocation_st),
                "::",
                stringify!(type_)
            )
        );
    }
    test_field_type();
    fn test_field_id() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUmemLocation_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).id) as usize - ptr as usize
            },
            4usize,
            concat!(
                "Offset of field: ",
                stringify!(CUmemLocation_st),
                "::",
                stringify!(id)
            )
        );
    }
    test_field_id();
}
impl Default for CUmemLocation_st {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type CUmemLocation_v1 = CUmemLocation_st;
pub type CUmemLocation = CUmemLocation_v1;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUmemAllocationCompType_enum {
    CU_MEM_ALLOCATION_COMP_NONE = 0,
    CU_MEM_ALLOCATION_COMP_GENERIC = 1,
}
pub use self::CUmemAllocationCompType_enum as CUmemAllocationCompType;
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct CUmemAllocationProp_st {
    pub type_: CUmemAllocationType,
    pub requestedHandleTypes: CUmemAllocationHandleType,
    pub location: CUmemLocation,
    pub win32HandleMetaData: *mut ::core::ffi::c_void,
    pub allocFlags: CUmemAllocationProp_st__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct CUmemAllocationProp_st__bindgen_ty_1 {
    pub compressionType: core::ffi::c_uchar,
    pub gpuDirectRDMACapable: core::ffi::c_uchar,
    pub usage: core::ffi::c_ushort,
    pub reserved: [core::ffi::c_uchar; 4usize],
}
#[test]
fn bindgen_test_layout_CUmemAllocationProp_st__bindgen_ty_1() {
    assert_eq!(
        ::core::mem::size_of::<CUmemAllocationProp_st__bindgen_ty_1>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(CUmemAllocationProp_st__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<CUmemAllocationProp_st__bindgen_ty_1>(),
        2usize,
        concat!(
            "Alignment of ",
            stringify!(CUmemAllocationProp_st__bindgen_ty_1)
        )
    );
    fn test_field_compressionType() {
        assert_eq!(
            unsafe {
                let uninit =
                    ::core::mem::MaybeUninit::<CUmemAllocationProp_st__bindgen_ty_1>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).compressionType) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUmemAllocationProp_st__bindgen_ty_1),
                "::",
                stringify!(compressionType)
            )
        );
    }
    test_field_compressionType();
    fn test_field_gpuDirectRDMACapable() {
        assert_eq!(
            unsafe {
                let uninit =
                    ::core::mem::MaybeUninit::<CUmemAllocationProp_st__bindgen_ty_1>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).gpuDirectRDMACapable) as usize - ptr as usize
            },
            1usize,
            concat!(
                "Offset of field: ",
                stringify!(CUmemAllocationProp_st__bindgen_ty_1),
                "::",
                stringify!(gpuDirectRDMACapable)
            )
        );
    }
    test_field_gpuDirectRDMACapable();
    fn test_field_usage() {
        assert_eq!(
            unsafe {
                let uninit =
                    ::core::mem::MaybeUninit::<CUmemAllocationProp_st__bindgen_ty_1>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).usage) as usize - ptr as usize
            },
            2usize,
            concat!(
                "Offset of field: ",
                stringify!(CUmemAllocationProp_st__bindgen_ty_1),
                "::",
                stringify!(usage)
            )
        );
    }
    test_field_usage();
    fn test_field_reserved() {
        assert_eq!(
            unsafe {
                let uninit =
                    ::core::mem::MaybeUninit::<CUmemAllocationProp_st__bindgen_ty_1>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize
            },
            4usize,
            concat!(
                "Offset of field: ",
                stringify!(CUmemAllocationProp_st__bindgen_ty_1),
                "::",
                stringify!(reserved)
            )
        );
    }
    test_field_reserved();
}
#[test]
fn bindgen_test_layout_CUmemAllocationProp_st() {
    assert_eq!(
        ::core::mem::size_of::<CUmemAllocationProp_st>(),
        32usize,
        concat!("Size of: ", stringify!(CUmemAllocationProp_st))
    );
    assert_eq!(
        ::core::mem::align_of::<CUmemAllocationProp_st>(),
        8usize,
        concat!("Alignment of ", stringify!(CUmemAllocationProp_st))
    );
    fn test_field_type() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUmemAllocationProp_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUmemAllocationProp_st),
                "::",
                stringify!(type_)
            )
        );
    }
    test_field_type();
    fn test_field_requestedHandleTypes() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUmemAllocationProp_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).requestedHandleTypes) as usize - ptr as usize
            },
            4usize,
            concat!(
                "Offset of field: ",
                stringify!(CUmemAllocationProp_st),
                "::",
                stringify!(requestedHandleTypes)
            )
        );
    }
    test_field_requestedHandleTypes();
    fn test_field_location() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUmemAllocationProp_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).location) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(CUmemAllocationProp_st),
                "::",
                stringify!(location)
            )
        );
    }
    test_field_location();
    fn test_field_win32HandleMetaData() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUmemAllocationProp_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).win32HandleMetaData) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(CUmemAllocationProp_st),
                "::",
                stringify!(win32HandleMetaData)
            )
        );
    }
    test_field_win32HandleMetaData();
    fn test_field_allocFlags() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUmemAllocationProp_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).allocFlags) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(CUmemAllocationProp_st),
                "::",
                stringify!(allocFlags)
            )
        );
    }
    test_field_allocFlags();
}
impl Default for CUmemAllocationProp_st {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type CUmemAllocationProp_v1 = CUmemAllocationProp_st;
pub type CUmemAllocationProp = CUmemAllocationProp_v1;
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct CUmemAccessDesc_st {
    pub location: CUmemLocation,
    pub flags: CUmemAccess_flags,
}
#[test]
fn bindgen_test_layout_CUmemAccessDesc_st() {
    assert_eq!(
        ::core::mem::size_of::<CUmemAccessDesc_st>(),
        12usize,
        concat!("Size of: ", stringify!(CUmemAccessDesc_st))
    );
    assert_eq!(
        ::core::mem::align_of::<CUmemAccessDesc_st>(),
        4usize,
        concat!("Alignment of ", stringify!(CUmemAccessDesc_st))
    );
    fn test_field_location() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUmemAccessDesc_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).location) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUmemAccessDesc_st),
                "::",
                stringify!(location)
            )
        );
    }
    test_field_location();
    fn test_field_flags() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUmemAccessDesc_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(CUmemAccessDesc_st),
                "::",
                stringify!(flags)
            )
        );
    }
    test_field_flags();
}
impl Default for CUmemAccessDesc_st {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type CUmemAccessDesc_v1 = CUmemAccessDesc_st;
pub type CUmemAccessDesc = CUmemAccessDesc_v1;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUgraphExecUpdateResult_enum {
    CU_GRAPH_EXEC_UPDATE_SUCCESS = 0,
    CU_GRAPH_EXEC_UPDATE_ERROR = 1,
    CU_GRAPH_EXEC_UPDATE_ERROR_TOPOLOGY_CHANGED = 2,
    CU_GRAPH_EXEC_UPDATE_ERROR_NODE_TYPE_CHANGED = 3,
    CU_GRAPH_EXEC_UPDATE_ERROR_FUNCTION_CHANGED = 4,
    CU_GRAPH_EXEC_UPDATE_ERROR_PARAMETERS_CHANGED = 5,
    CU_GRAPH_EXEC_UPDATE_ERROR_NOT_SUPPORTED = 6,
    CU_GRAPH_EXEC_UPDATE_ERROR_UNSUPPORTED_FUNCTION_CHANGE = 7,
}
pub use self::CUgraphExecUpdateResult_enum as CUgraphExecUpdateResult;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUmemPool_attribute_enum {
    CU_MEMPOOL_ATTR_REUSE_FOLLOW_EVENT_DEPENDENCIES = 1,
    CU_MEMPOOL_ATTR_REUSE_ALLOW_OPPORTUNISTIC = 2,
    CU_MEMPOOL_ATTR_REUSE_ALLOW_INTERNAL_DEPENDENCIES = 3,
    CU_MEMPOOL_ATTR_RELEASE_THRESHOLD = 4,
    CU_MEMPOOL_ATTR_RESERVED_MEM_CURRENT = 5,
    CU_MEMPOOL_ATTR_RESERVED_MEM_HIGH = 6,
    CU_MEMPOOL_ATTR_USED_MEM_CURRENT = 7,
    CU_MEMPOOL_ATTR_USED_MEM_HIGH = 8,
}
pub use self::CUmemPool_attribute_enum as CUmemPool_attribute;
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct CUmemPoolProps_st {
    pub allocType: CUmemAllocationType,
    pub handleTypes: CUmemAllocationHandleType,
    pub location: CUmemLocation,
    pub win32SecurityAttributes: *mut ::core::ffi::c_void,
    pub reserved: [core::ffi::c_uchar; 64usize],
}
#[test]
fn bindgen_test_layout_CUmemPoolProps_st() {
    assert_eq!(
        ::core::mem::size_of::<CUmemPoolProps_st>(),
        88usize,
        concat!("Size of: ", stringify!(CUmemPoolProps_st))
    );
    assert_eq!(
        ::core::mem::align_of::<CUmemPoolProps_st>(),
        8usize,
        concat!("Alignment of ", stringify!(CUmemPoolProps_st))
    );
    fn test_field_allocType() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUmemPoolProps_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).allocType) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUmemPoolProps_st),
                "::",
                stringify!(allocType)
            )
        );
    }
    test_field_allocType();
    fn test_field_handleTypes() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUmemPoolProps_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).handleTypes) as usize - ptr as usize
            },
            4usize,
            concat!(
                "Offset of field: ",
                stringify!(CUmemPoolProps_st),
                "::",
                stringify!(handleTypes)
            )
        );
    }
    test_field_handleTypes();
    fn test_field_location() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUmemPoolProps_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).location) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(CUmemPoolProps_st),
                "::",
                stringify!(location)
            )
        );
    }
    test_field_location();
    fn test_field_win32SecurityAttributes() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUmemPoolProps_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).win32SecurityAttributes) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(CUmemPoolProps_st),
                "::",
                stringify!(win32SecurityAttributes)
            )
        );
    }
    test_field_win32SecurityAttributes();
    fn test_field_reserved() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUmemPoolProps_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(CUmemPoolProps_st),
                "::",
                stringify!(reserved)
            )
        );
    }
    test_field_reserved();
}
impl Default for CUmemPoolProps_st {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type CUmemPoolProps_v1 = CUmemPoolProps_st;
pub type CUmemPoolProps = CUmemPoolProps_v1;
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct CUmemPoolPtrExportData_st {
    pub reserved: [core::ffi::c_uchar; 64usize],
}
#[test]
fn bindgen_test_layout_CUmemPoolPtrExportData_st() {
    assert_eq!(
        ::core::mem::size_of::<CUmemPoolPtrExportData_st>(),
        64usize,
        concat!("Size of: ", stringify!(CUmemPoolPtrExportData_st))
    );
    assert_eq!(
        ::core::mem::align_of::<CUmemPoolPtrExportData_st>(),
        1usize,
        concat!("Alignment of ", stringify!(CUmemPoolPtrExportData_st))
    );
    fn test_field_reserved() {
        assert_eq!(
            unsafe {
                let uninit = ::core::mem::MaybeUninit::<CUmemPoolPtrExportData_st>::uninit();
                let ptr = uninit.as_ptr();
                ::core::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(CUmemPoolPtrExportData_st),
                "::",
                stringify!(reserved)
            )
        );
    }
    test_field_reserved();
}
impl Default for CUmemPoolPtrExportData_st {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type CUmemPoolPtrExportData_v1 = CUmemPoolPtrExportData_st;
pub type CUmemPoolPtrExportData = CUmemPoolPtrExportData_v1;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUflushGPUDirectRDMAWritesOptions_enum {
    CU_FLUSH_GPU_DIRECT_RDMA_WRITES_OPTION_HOST = 1,
    CU_FLUSH_GPU_DIRECT_RDMA_WRITES_OPTION_MEMOPS = 2,
}
pub use self::CUflushGPUDirectRDMAWritesOptions_enum as CUflushGPUDirectRDMAWritesOptions;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUGPUDirectRDMAWritesOrdering_enum {
    CU_GPU_DIRECT_RDMA_WRITES_ORDERING_NONE = 0,
    CU_GPU_DIRECT_RDMA_WRITES_ORDERING_OWNER = 100,
    CU_GPU_DIRECT_RDMA_WRITES_ORDERING_ALL_DEVICES = 200,
}
pub use self::CUGPUDirectRDMAWritesOrdering_enum as CUGPUDirectRDMAWritesOrdering;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUflushGPUDirectRDMAWritesScope_enum {
    CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TO_OWNER = 100,
    CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TO_ALL_DEVICES = 200,
}
pub use self::CUflushGPUDirectRDMAWritesScope_enum as CUflushGPUDirectRDMAWritesScope;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUflushGPUDirectRDMAWritesTarget_enum {
    CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TARGET_CURRENT_CTX = 0,
}
pub use self::CUflushGPUDirectRDMAWritesTarget_enum as CUflushGPUDirectRDMAWritesTarget;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUgraphDebugDot_flags_enum {
    CU_GRAPH_DEBUG_DOT_FLAGS_VERBOSE = 1,
    CU_GRAPH_DEBUG_DOT_FLAGS_RUNTIME_TYPES = 2,
    CU_GRAPH_DEBUG_DOT_FLAGS_KERNEL_NODE_PARAMS = 4,
    CU_GRAPH_DEBUG_DOT_FLAGS_MEMCPY_NODE_PARAMS = 8,
    CU_GRAPH_DEBUG_DOT_FLAGS_MEMSET_NODE_PARAMS = 16,
    CU_GRAPH_DEBUG_DOT_FLAGS_HOST_NODE_PARAMS = 32,
    CU_GRAPH_DEBUG_DOT_FLAGS_EVENT_NODE_PARAMS = 64,
    CU_GRAPH_DEBUG_DOT_FLAGS_EXT_SEMAS_SIGNAL_NODE_PARAMS = 128,
    CU_GRAPH_DEBUG_DOT_FLAGS_EXT_SEMAS_WAIT_NODE_PARAMS = 256,
    CU_GRAPH_DEBUG_DOT_FLAGS_KERNEL_NODE_ATTRIBUTES = 512,
    CU_GRAPH_DEBUG_DOT_FLAGS_HANDLES = 1024,
}
pub use self::CUgraphDebugDot_flags_enum as CUgraphDebugDot_flags;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUuserObject_flags_enum {
    CU_USER_OBJECT_NO_DESTRUCTOR_SYNC = 1,
}
pub use self::CUuserObject_flags_enum as CUuserObject_flags;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum CUuserObjectRetain_flags_enum {
    CU_GRAPH_USER_OBJECT_MOVE = 1,
}
pub use self::CUuserObjectRetain_flags_enum as CUuserObjectRetain_flags;
extern "C" {
    pub fn cuGetErrorString(error: CUresult, pStr: *mut *const core::ffi::c_char) -> CUresult;
}
extern "C" {
    pub fn cuGetErrorName(error: CUresult, pStr: *mut *const core::ffi::c_char) -> CUresult;
}
extern "C" {
    pub fn cuInit(Flags: core::ffi::c_uint) -> CUresult;
}
extern "C" {
    pub fn cuDriverGetVersion(driverVersion: *mut core::ffi::c_int) -> CUresult;
}
extern "C" {
    pub fn cuDeviceGet(device: *mut CUdevice, ordinal: core::ffi::c_int) -> CUresult;
}
extern "C" {
    pub fn cuDeviceGetCount(count: *mut core::ffi::c_int) -> CUresult;
}
extern "C" {
    pub fn cuDeviceGetName(
        name: *mut core::ffi::c_char,
        len: core::ffi::c_int,
        dev: CUdevice,
    ) -> CUresult;
}
extern "C" {
    pub fn cuDeviceGetUuid(uuid: *mut CUuuid, dev: CUdevice) -> CUresult;
}
extern "C" {
    pub fn cuDeviceGetLuid(
        luid: *mut core::ffi::c_char,
        deviceNodeMask: *mut core::ffi::c_uint,
        dev: CUdevice,
    ) -> CUresult;
}
extern "C" {
    pub fn cuDeviceTotalMem_v2(bytes: *mut usize, dev: CUdevice) -> CUresult;
}
extern "C" {
    pub fn cuDeviceGetTexture1DLinearMaxWidth(
        maxWidthInElements: *mut usize,
        format: CUarray_format,
        numChannels: core::ffi::c_uint,
        dev: CUdevice,
    ) -> CUresult;
}
extern "C" {
    pub fn cuDeviceGetAttribute(
        pi: *mut core::ffi::c_int,
        attrib: CUdevice_attribute,
        dev: CUdevice,
    ) -> CUresult;
}
extern "C" {
    pub fn cuDeviceGetNvSciSyncAttributes(
        nvSciSyncAttrList: *mut ::core::ffi::c_void,
        dev: CUdevice,
        flags: core::ffi::c_int,
    ) -> CUresult;
}
extern "C" {
    pub fn cuDeviceSetMemPool(dev: CUdevice, pool: CUmemoryPool) -> CUresult;
}
extern "C" {
    pub fn cuDeviceGetMemPool(pool: *mut CUmemoryPool, dev: CUdevice) -> CUresult;
}
extern "C" {
    pub fn cuDeviceGetDefaultMemPool(pool_out: *mut CUmemoryPool, dev: CUdevice) -> CUresult;
}
extern "C" {
    pub fn cuDeviceGetProperties(prop: *mut CUdevprop, dev: CUdevice) -> CUresult;
}
extern "C" {
    pub fn cuDeviceComputeCapability(
        major: *mut core::ffi::c_int,
        minor: *mut core::ffi::c_int,
        dev: CUdevice,
    ) -> CUresult;
}
extern "C" {
    pub fn cuDevicePrimaryCtxRetain(pctx: *mut CUcontext, dev: CUdevice) -> CUresult;
}
extern "C" {
    pub fn cuDevicePrimaryCtxRelease_v2(dev: CUdevice) -> CUresult;
}
extern "C" {
    pub fn cuDevicePrimaryCtxSetFlags_v2(dev: CUdevice, flags: core::ffi::c_uint) -> CUresult;
}
extern "C" {
    pub fn cuDevicePrimaryCtxGetState(
        dev: CUdevice,
        flags: *mut core::ffi::c_uint,
        active: *mut core::ffi::c_int,
    ) -> CUresult;
}
extern "C" {
    pub fn cuDevicePrimaryCtxReset_v2(dev: CUdevice) -> CUresult;
}
extern "C" {
    pub fn cuCtxCreate_v2(
        pctx: *mut CUcontext,
        flags: core::ffi::c_uint,
        dev: CUdevice,
    ) -> CUresult;
}
extern "C" {
    pub fn cuCtxDestroy_v2(ctx: CUcontext) -> CUresult;
}
extern "C" {
    pub fn cuCtxPushCurrent_v2(ctx: CUcontext) -> CUresult;
}
extern "C" {
    pub fn cuCtxPopCurrent_v2(pctx: *mut CUcontext) -> CUresult;
}
extern "C" {
    pub fn cuCtxSetCurrent(ctx: CUcontext) -> CUresult;
}
extern "C" {
    pub fn cuCtxGetCurrent(pctx: *mut CUcontext) -> CUresult;
}
extern "C" {
    pub fn cuCtxGetDevice(device: *mut CUdevice) -> CUresult;
}
extern "C" {
    pub fn cuCtxGetFlags(flags: *mut core::ffi::c_uint) -> CUresult;
}
extern "C" {
    pub fn cuCtxSynchronize() -> CUresult;
}
extern "C" {
    pub fn cuCtxSetLimit(limit: CUlimit, value: usize) -> CUresult;
}
extern "C" {
    pub fn cuCtxGetLimit(pvalue: *mut usize, limit: CUlimit) -> CUresult;
}
extern "C" {
    pub fn cuCtxGetCacheConfig(pconfig: *mut CUfunc_cache) -> CUresult;
}
extern "C" {
    pub fn cuCtxSetCacheConfig(config: CUfunc_cache) -> CUresult;
}
extern "C" {
    pub fn cuCtxGetSharedMemConfig(pConfig: *mut CUsharedconfig) -> CUresult;
}
extern "C" {
    pub fn cuCtxSetSharedMemConfig(config: CUsharedconfig) -> CUresult;
}
extern "C" {
    pub fn cuCtxGetApiVersion(ctx: CUcontext, version: *mut core::ffi::c_uint) -> CUresult;
}
extern "C" {
    pub fn cuCtxGetStreamPriorityRange(
        leastPriority: *mut core::ffi::c_int,
        greatestPriority: *mut core::ffi::c_int,
    ) -> CUresult;
}
extern "C" {
    pub fn cuCtxResetPersistingL2Cache() -> CUresult;
}
extern "C" {
    pub fn cuCtxAttach(pctx: *mut CUcontext, flags: core::ffi::c_uint) -> CUresult;
}
extern "C" {
    pub fn cuCtxDetach(ctx: CUcontext) -> CUresult;
}
extern "C" {
    pub fn cuModuleLoad(module: *mut CUmodule, fname: *const core::ffi::c_char) -> CUresult;
}
extern "C" {
    pub fn cuModuleLoadData(module: *mut CUmodule, image: *const ::core::ffi::c_void) -> CUresult;
}
extern "C" {
    pub fn cuModuleLoadDataEx(
        module: *mut CUmodule,
        image: *const ::core::ffi::c_void,
        numOptions: core::ffi::c_uint,
        options: *mut CUjit_option,
        optionValues: *mut *mut ::core::ffi::c_void,
    ) -> CUresult;
}
extern "C" {
    pub fn cuModuleLoadFatBinary(
        module: *mut CUmodule,
        fatCubin: *const ::core::ffi::c_void,
    ) -> CUresult;
}
extern "C" {
    pub fn cuModuleUnload(hmod: CUmodule) -> CUresult;
}
extern "C" {
    pub fn cuModuleGetFunction(
        hfunc: *mut CUfunction,
        hmod: CUmodule,
        name: *const core::ffi::c_char,
    ) -> CUresult;
}
extern "C" {
    pub fn cuModuleGetGlobal_v2(
        dptr: *mut CUdeviceptr,
        bytes: *mut usize,
        hmod: CUmodule,
        name: *const core::ffi::c_char,
    ) -> CUresult;
}
extern "C" {
    pub fn cuModuleGetTexRef(
        pTexRef: *mut CUtexref,
        hmod: CUmodule,
        name: *const core::ffi::c_char,
    ) -> CUresult;
}
extern "C" {
    pub fn cuModuleGetSurfRef(
        pSurfRef: *mut CUsurfref,
        hmod: CUmodule,
        name: *const core::ffi::c_char,
    ) -> CUresult;
}
extern "C" {
    pub fn cuLinkCreate_v2(
        numOptions: core::ffi::c_uint,
        options: *mut CUjit_option,
        optionValues: *mut *mut ::core::ffi::c_void,
        stateOut: *mut CUlinkState,
    ) -> CUresult;
}
extern "C" {
    pub fn cuLinkAddData_v2(
        state: CUlinkState,
        type_: CUjitInputType,
        data: *mut ::core::ffi::c_void,
        size: usize,
        name: *const core::ffi::c_char,
        numOptions: core::ffi::c_uint,
        options: *mut CUjit_option,
        optionValues: *mut *mut ::core::ffi::c_void,
    ) -> CUresult;
}
extern "C" {
    pub fn cuLinkAddFile_v2(
        state: CUlinkState,
        type_: CUjitInputType,
        path: *const core::ffi::c_char,
        numOptions: core::ffi::c_uint,
        options: *mut CUjit_option,
        optionValues: *mut *mut ::core::ffi::c_void,
    ) -> CUresult;
}
extern "C" {
    pub fn cuLinkComplete(
        state: CUlinkState,
        cubinOut: *mut *mut ::core::ffi::c_void,
        sizeOut: *mut usize,
    ) -> CUresult;
}
extern "C" {
    pub fn cuLinkDestroy(state: CUlinkState) -> CUresult;
}
extern "C" {
    pub fn cuMemGetInfo_v2(free: *mut usize, total: *mut usize) -> CUresult;
}
extern "C" {
    pub fn cuMemAlloc_v2(dptr: *mut CUdeviceptr, bytesize: usize) -> CUresult;
}
extern "C" {
    pub fn cuMemAllocPitch_v2(
        dptr: *mut CUdeviceptr,
        pPitch: *mut usize,
        WidthInBytes: usize,
        Height: usize,
        ElementSizeBytes: core::ffi::c_uint,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemFree_v2(dptr: CUdeviceptr) -> CUresult;
}
extern "C" {
    pub fn cuMemGetAddressRange_v2(
        pbase: *mut CUdeviceptr,
        psize: *mut usize,
        dptr: CUdeviceptr,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemAllocHost_v2(pp: *mut *mut ::core::ffi::c_void, bytesize: usize) -> CUresult;
}
extern "C" {
    pub fn cuMemFreeHost(p: *mut ::core::ffi::c_void) -> CUresult;
}
extern "C" {
    pub fn cuMemHostAlloc(
        pp: *mut *mut ::core::ffi::c_void,
        bytesize: usize,
        Flags: core::ffi::c_uint,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemHostGetDevicePointer_v2(
        pdptr: *mut CUdeviceptr,
        p: *mut ::core::ffi::c_void,
        Flags: core::ffi::c_uint,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemHostGetFlags(
        pFlags: *mut core::ffi::c_uint,
        p: *mut ::core::ffi::c_void,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemAllocManaged(
        dptr: *mut CUdeviceptr,
        bytesize: usize,
        flags: core::ffi::c_uint,
    ) -> CUresult;
}
extern "C" {
    pub fn cuDeviceGetByPCIBusId(
        dev: *mut CUdevice,
        pciBusId: *const core::ffi::c_char,
    ) -> CUresult;
}
extern "C" {
    pub fn cuDeviceGetPCIBusId(
        pciBusId: *mut core::ffi::c_char,
        len: core::ffi::c_int,
        dev: CUdevice,
    ) -> CUresult;
}
extern "C" {
    pub fn cuIpcGetEventHandle(pHandle: *mut CUipcEventHandle, event: CUevent) -> CUresult;
}
extern "C" {
    pub fn cuIpcOpenEventHandle(phEvent: *mut CUevent, handle: CUipcEventHandle) -> CUresult;
}
extern "C" {
    pub fn cuIpcGetMemHandle(pHandle: *mut CUipcMemHandle, dptr: CUdeviceptr) -> CUresult;
}
extern "C" {
    pub fn cuIpcOpenMemHandle_v2(
        pdptr: *mut CUdeviceptr,
        handle: CUipcMemHandle,
        Flags: core::ffi::c_uint,
    ) -> CUresult;
}
extern "C" {
    pub fn cuIpcCloseMemHandle(dptr: CUdeviceptr) -> CUresult;
}
extern "C" {
    pub fn cuMemHostRegister_v2(
        p: *mut ::core::ffi::c_void,
        bytesize: usize,
        Flags: core::ffi::c_uint,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemHostUnregister(p: *mut ::core::ffi::c_void) -> CUresult;
}
extern "C" {
    pub fn cuMemcpy(dst: CUdeviceptr, src: CUdeviceptr, ByteCount: usize) -> CUresult;
}
extern "C" {
    pub fn cuMemcpyPeer(
        dstDevice: CUdeviceptr,
        dstContext: CUcontext,
        srcDevice: CUdeviceptr,
        srcContext: CUcontext,
        ByteCount: usize,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemcpyHtoD_v2(
        dstDevice: CUdeviceptr,
        srcHost: *const ::core::ffi::c_void,
        ByteCount: usize,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemcpyDtoH_v2(
        dstHost: *mut ::core::ffi::c_void,
        srcDevice: CUdeviceptr,
        ByteCount: usize,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemcpyDtoD_v2(
        dstDevice: CUdeviceptr,
        srcDevice: CUdeviceptr,
        ByteCount: usize,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemcpyDtoA_v2(
        dstArray: CUarray,
        dstOffset: usize,
        srcDevice: CUdeviceptr,
        ByteCount: usize,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemcpyAtoD_v2(
        dstDevice: CUdeviceptr,
        srcArray: CUarray,
        srcOffset: usize,
        ByteCount: usize,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemcpyHtoA_v2(
        dstArray: CUarray,
        dstOffset: usize,
        srcHost: *const ::core::ffi::c_void,
        ByteCount: usize,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemcpyAtoH_v2(
        dstHost: *mut ::core::ffi::c_void,
        srcArray: CUarray,
        srcOffset: usize,
        ByteCount: usize,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemcpyAtoA_v2(
        dstArray: CUarray,
        dstOffset: usize,
        srcArray: CUarray,
        srcOffset: usize,
        ByteCount: usize,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemcpy2D_v2(pCopy: *const CUDA_MEMCPY2D) -> CUresult;
}
extern "C" {
    pub fn cuMemcpy2DUnaligned_v2(pCopy: *const CUDA_MEMCPY2D) -> CUresult;
}
extern "C" {
    pub fn cuMemcpy3D_v2(pCopy: *const CUDA_MEMCPY3D) -> CUresult;
}
extern "C" {
    pub fn cuMemcpy3DPeer(pCopy: *const CUDA_MEMCPY3D_PEER) -> CUresult;
}
extern "C" {
    pub fn cuMemcpyAsync(
        dst: CUdeviceptr,
        src: CUdeviceptr,
        ByteCount: usize,
        hStream: CUstream,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemcpyPeerAsync(
        dstDevice: CUdeviceptr,
        dstContext: CUcontext,
        srcDevice: CUdeviceptr,
        srcContext: CUcontext,
        ByteCount: usize,
        hStream: CUstream,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemcpyHtoDAsync_v2(
        dstDevice: CUdeviceptr,
        srcHost: *const ::core::ffi::c_void,
        ByteCount: usize,
        hStream: CUstream,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemcpyDtoHAsync_v2(
        dstHost: *mut ::core::ffi::c_void,
        srcDevice: CUdeviceptr,
        ByteCount: usize,
        hStream: CUstream,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemcpyDtoDAsync_v2(
        dstDevice: CUdeviceptr,
        srcDevice: CUdeviceptr,
        ByteCount: usize,
        hStream: CUstream,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemcpyHtoAAsync_v2(
        dstArray: CUarray,
        dstOffset: usize,
        srcHost: *const ::core::ffi::c_void,
        ByteCount: usize,
        hStream: CUstream,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemcpyAtoHAsync_v2(
        dstHost: *mut ::core::ffi::c_void,
        srcArray: CUarray,
        srcOffset: usize,
        ByteCount: usize,
        hStream: CUstream,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemcpy2DAsync_v2(pCopy: *const CUDA_MEMCPY2D, hStream: CUstream) -> CUresult;
}
extern "C" {
    pub fn cuMemcpy3DAsync_v2(pCopy: *const CUDA_MEMCPY3D, hStream: CUstream) -> CUresult;
}
extern "C" {
    pub fn cuMemcpy3DPeerAsync(pCopy: *const CUDA_MEMCPY3D_PEER, hStream: CUstream) -> CUresult;
}
extern "C" {
    pub fn cuMemsetD8_v2(dstDevice: CUdeviceptr, uc: core::ffi::c_uchar, N: usize) -> CUresult;
}
extern "C" {
    pub fn cuMemsetD16_v2(dstDevice: CUdeviceptr, us: core::ffi::c_ushort, N: usize) -> CUresult;
}
extern "C" {
    pub fn cuMemsetD32_v2(dstDevice: CUdeviceptr, ui: core::ffi::c_uint, N: usize) -> CUresult;
}
extern "C" {
    pub fn cuMemsetD2D8_v2(
        dstDevice: CUdeviceptr,
        dstPitch: usize,
        uc: core::ffi::c_uchar,
        Width: usize,
        Height: usize,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemsetD2D16_v2(
        dstDevice: CUdeviceptr,
        dstPitch: usize,
        us: core::ffi::c_ushort,
        Width: usize,
        Height: usize,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemsetD2D32_v2(
        dstDevice: CUdeviceptr,
        dstPitch: usize,
        ui: core::ffi::c_uint,
        Width: usize,
        Height: usize,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemsetD8Async(
        dstDevice: CUdeviceptr,
        uc: core::ffi::c_uchar,
        N: usize,
        hStream: CUstream,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemsetD16Async(
        dstDevice: CUdeviceptr,
        us: core::ffi::c_ushort,
        N: usize,
        hStream: CUstream,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemsetD32Async(
        dstDevice: CUdeviceptr,
        ui: core::ffi::c_uint,
        N: usize,
        hStream: CUstream,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemsetD2D8Async(
        dstDevice: CUdeviceptr,
        dstPitch: usize,
        uc: core::ffi::c_uchar,
        Width: usize,
        Height: usize,
        hStream: CUstream,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemsetD2D16Async(
        dstDevice: CUdeviceptr,
        dstPitch: usize,
        us: core::ffi::c_ushort,
        Width: usize,
        Height: usize,
        hStream: CUstream,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemsetD2D32Async(
        dstDevice: CUdeviceptr,
        dstPitch: usize,
        ui: core::ffi::c_uint,
        Width: usize,
        Height: usize,
        hStream: CUstream,
    ) -> CUresult;
}
extern "C" {
    pub fn cuArrayCreate_v2(
        pHandle: *mut CUarray,
        pAllocateArray: *const CUDA_ARRAY_DESCRIPTOR,
    ) -> CUresult;
}
extern "C" {
    pub fn cuArrayGetDescriptor_v2(
        pArrayDescriptor: *mut CUDA_ARRAY_DESCRIPTOR,
        hArray: CUarray,
    ) -> CUresult;
}
extern "C" {
    pub fn cuArrayGetSparseProperties(
        sparseProperties: *mut CUDA_ARRAY_SPARSE_PROPERTIES,
        array: CUarray,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMipmappedArrayGetSparseProperties(
        sparseProperties: *mut CUDA_ARRAY_SPARSE_PROPERTIES,
        mipmap: CUmipmappedArray,
    ) -> CUresult;
}
extern "C" {
    pub fn cuArrayGetPlane(
        pPlaneArray: *mut CUarray,
        hArray: CUarray,
        planeIdx: core::ffi::c_uint,
    ) -> CUresult;
}
extern "C" {
    pub fn cuArrayDestroy(hArray: CUarray) -> CUresult;
}
extern "C" {
    pub fn cuArray3DCreate_v2(
        pHandle: *mut CUarray,
        pAllocateArray: *const CUDA_ARRAY3D_DESCRIPTOR,
    ) -> CUresult;
}
extern "C" {
    pub fn cuArray3DGetDescriptor_v2(
        pArrayDescriptor: *mut CUDA_ARRAY3D_DESCRIPTOR,
        hArray: CUarray,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMipmappedArrayCreate(
        pHandle: *mut CUmipmappedArray,
        pMipmappedArrayDesc: *const CUDA_ARRAY3D_DESCRIPTOR,
        numMipmapLevels: core::ffi::c_uint,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMipmappedArrayGetLevel(
        pLevelArray: *mut CUarray,
        hMipmappedArray: CUmipmappedArray,
        level: core::ffi::c_uint,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMipmappedArrayDestroy(hMipmappedArray: CUmipmappedArray) -> CUresult;
}
extern "C" {
    pub fn cuMemAddressReserve(
        ptr: *mut CUdeviceptr,
        size: usize,
        alignment: usize,
        addr: CUdeviceptr,
        flags: core::ffi::c_ulonglong,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemAddressFree(ptr: CUdeviceptr, size: usize) -> CUresult;
}
extern "C" {
    pub fn cuMemCreate(
        handle: *mut CUmemGenericAllocationHandle,
        size: usize,
        prop: *const CUmemAllocationProp,
        flags: core::ffi::c_ulonglong,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemRelease(handle: CUmemGenericAllocationHandle) -> CUresult;
}
extern "C" {
    pub fn cuMemMap(
        ptr: CUdeviceptr,
        size: usize,
        offset: usize,
        handle: CUmemGenericAllocationHandle,
        flags: core::ffi::c_ulonglong,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemMapArrayAsync(
        mapInfoList: *mut CUarrayMapInfo,
        count: core::ffi::c_uint,
        hStream: CUstream,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemUnmap(ptr: CUdeviceptr, size: usize) -> CUresult;
}
extern "C" {
    pub fn cuMemSetAccess(
        ptr: CUdeviceptr,
        size: usize,
        desc: *const CUmemAccessDesc,
        count: usize,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemGetAccess(
        flags: *mut core::ffi::c_ulonglong,
        location: *const CUmemLocation,
        ptr: CUdeviceptr,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemExportToShareableHandle(
        shareableHandle: *mut ::core::ffi::c_void,
        handle: CUmemGenericAllocationHandle,
        handleType: CUmemAllocationHandleType,
        flags: core::ffi::c_ulonglong,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemImportFromShareableHandle(
        handle: *mut CUmemGenericAllocationHandle,
        osHandle: *mut ::core::ffi::c_void,
        shHandleType: CUmemAllocationHandleType,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemGetAllocationGranularity(
        granularity: *mut usize,
        prop: *const CUmemAllocationProp,
        option: CUmemAllocationGranularity_flags,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemGetAllocationPropertiesFromHandle(
        prop: *mut CUmemAllocationProp,
        handle: CUmemGenericAllocationHandle,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemRetainAllocationHandle(
        handle: *mut CUmemGenericAllocationHandle,
        addr: *mut ::core::ffi::c_void,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemFreeAsync(dptr: CUdeviceptr, hStream: CUstream) -> CUresult;
}
extern "C" {
    pub fn cuMemAllocAsync(dptr: *mut CUdeviceptr, bytesize: usize, hStream: CUstream) -> CUresult;
}
extern "C" {
    pub fn cuMemPoolTrimTo(pool: CUmemoryPool, minBytesToKeep: usize) -> CUresult;
}
extern "C" {
    pub fn cuMemPoolSetAttribute(
        pool: CUmemoryPool,
        attr: CUmemPool_attribute,
        value: *mut ::core::ffi::c_void,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemPoolGetAttribute(
        pool: CUmemoryPool,
        attr: CUmemPool_attribute,
        value: *mut ::core::ffi::c_void,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemPoolSetAccess(
        pool: CUmemoryPool,
        map: *const CUmemAccessDesc,
        count: usize,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemPoolGetAccess(
        flags: *mut CUmemAccess_flags,
        memPool: CUmemoryPool,
        location: *mut CUmemLocation,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemPoolCreate(pool: *mut CUmemoryPool, poolProps: *const CUmemPoolProps) -> CUresult;
}
extern "C" {
    pub fn cuMemPoolDestroy(pool: CUmemoryPool) -> CUresult;
}
extern "C" {
    pub fn cuMemAllocFromPoolAsync(
        dptr: *mut CUdeviceptr,
        bytesize: usize,
        pool: CUmemoryPool,
        hStream: CUstream,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemPoolExportToShareableHandle(
        handle_out: *mut ::core::ffi::c_void,
        pool: CUmemoryPool,
        handleType: CUmemAllocationHandleType,
        flags: core::ffi::c_ulonglong,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemPoolImportFromShareableHandle(
        pool_out: *mut CUmemoryPool,
        handle: *mut ::core::ffi::c_void,
        handleType: CUmemAllocationHandleType,
        flags: core::ffi::c_ulonglong,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemPoolExportPointer(
        shareData_out: *mut CUmemPoolPtrExportData,
        ptr: CUdeviceptr,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemPoolImportPointer(
        ptr_out: *mut CUdeviceptr,
        pool: CUmemoryPool,
        shareData: *mut CUmemPoolPtrExportData,
    ) -> CUresult;
}
extern "C" {
    pub fn cuPointerGetAttribute(
        data: *mut ::core::ffi::c_void,
        attribute: CUpointer_attribute,
        ptr: CUdeviceptr,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemPrefetchAsync(
        devPtr: CUdeviceptr,
        count: usize,
        dstDevice: CUdevice,
        hStream: CUstream,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemAdvise(
        devPtr: CUdeviceptr,
        count: usize,
        advice: CUmem_advise,
        device: CUdevice,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemRangeGetAttribute(
        data: *mut ::core::ffi::c_void,
        dataSize: usize,
        attribute: CUmem_range_attribute,
        devPtr: CUdeviceptr,
        count: usize,
    ) -> CUresult;
}
extern "C" {
    pub fn cuMemRangeGetAttributes(
        data: *mut *mut ::core::ffi::c_void,
        dataSizes: *mut usize,
        attributes: *mut CUmem_range_attribute,
        numAttributes: usize,
        devPtr: CUdeviceptr,
        count: usize,
    ) -> CUresult;
}
extern "C" {
    pub fn cuPointerSetAttribute(
        value: *const ::core::ffi::c_void,
        attribute: CUpointer_attribute,
        ptr: CUdeviceptr,
    ) -> CUresult;
}
extern "C" {
    pub fn cuPointerGetAttributes(
        numAttributes: core::ffi::c_uint,
        attributes: *mut CUpointer_attribute,
        data: *mut *mut ::core::ffi::c_void,
        ptr: CUdeviceptr,
    ) -> CUresult;
}
extern "C" {
    pub fn cuStreamCreate(phStream: *mut CUstream, Flags: core::ffi::c_uint) -> CUresult;
}
extern "C" {
    pub fn cuStreamCreateWithPriority(
        phStream: *mut CUstream,
        flags: core::ffi::c_uint,
        priority: core::ffi::c_int,
    ) -> CUresult;
}
extern "C" {
    pub fn cuStreamGetPriority(hStream: CUstream, priority: *mut core::ffi::c_int) -> CUresult;
}
extern "C" {
    pub fn cuStreamGetFlags(hStream: CUstream, flags: *mut core::ffi::c_uint) -> CUresult;
}
extern "C" {
    pub fn cuStreamGetCtx(hStream: CUstream, pctx: *mut CUcontext) -> CUresult;
}
extern "C" {
    pub fn cuStreamWaitEvent(
        hStream: CUstream,
        hEvent: CUevent,
        Flags: core::ffi::c_uint,
    ) -> CUresult;
}
extern "C" {
    pub fn cuStreamAddCallback(
        hStream: CUstream,
        callback: CUstreamCallback,
        userData: *mut ::core::ffi::c_void,
        flags: core::ffi::c_uint,
    ) -> CUresult;
}
extern "C" {
    pub fn cuStreamBeginCapture_v2(hStream: CUstream, mode: CUstreamCaptureMode) -> CUresult;
}
extern "C" {
    pub fn cuThreadExchangeStreamCaptureMode(mode: *mut CUstreamCaptureMode) -> CUresult;
}
extern "C" {
    pub fn cuStreamEndCapture(hStream: CUstream, phGraph: *mut CUgraph) -> CUresult;
}
extern "C" {
    pub fn cuStreamIsCapturing(
        hStream: CUstream,
        captureStatus: *mut CUstreamCaptureStatus,
    ) -> CUresult;
}
extern "C" {
    pub fn cuStreamGetCaptureInfo(
        hStream: CUstream,
        captureStatus_out: *mut CUstreamCaptureStatus,
        id_out: *mut cuuint64_t,
    ) -> CUresult;
}
extern "C" {
    pub fn cuStreamGetCaptureInfo_v2(
        hStream: CUstream,
        captureStatus_out: *mut CUstreamCaptureStatus,
        id_out: *mut cuuint64_t,
        graph_out: *mut CUgraph,
        dependencies_out: *mut *const CUgraphNode,
        numDependencies_out: *mut usize,
    ) -> CUresult;
}
extern "C" {
    pub fn cuStreamUpdateCaptureDependencies(
        hStream: CUstream,
        dependencies: *mut CUgraphNode,
        numDependencies: usize,
        flags: core::ffi::c_uint,
    ) -> CUresult;
}
extern "C" {
    pub fn cuStreamAttachMemAsync(
        hStream: CUstream,
        dptr: CUdeviceptr,
        length: usize,
        flags: core::ffi::c_uint,
    ) -> CUresult;
}
extern "C" {
    pub fn cuStreamQuery(hStream: CUstream) -> CUresult;
}
extern "C" {
    pub fn cuStreamSynchronize(hStream: CUstream) -> CUresult;
}
extern "C" {
    pub fn cuStreamDestroy_v2(hStream: CUstream) -> CUresult;
}
extern "C" {
    pub fn cuStreamCopyAttributes(dst: CUstream, src: CUstream) -> CUresult;
}
extern "C" {
    pub fn cuStreamGetAttribute(
        hStream: CUstream,
        attr: CUstreamAttrID,
        value_out: *mut CUstreamAttrValue,
    ) -> CUresult;
}
extern "C" {
    pub fn cuStreamSetAttribute(
        hStream: CUstream,
        attr: CUstreamAttrID,
        value: *const CUstreamAttrValue,
    ) -> CUresult;
}
extern "C" {
    pub fn cuEventCreate(phEvent: *mut CUevent, Flags: core::ffi::c_uint) -> CUresult;
}
extern "C" {
    pub fn cuEventRecord(hEvent: CUevent, hStream: CUstream) -> CUresult;
}
extern "C" {
    pub fn cuEventRecordWithFlags(
        hEvent: CUevent,
        hStream: CUstream,
        flags: core::ffi::c_uint,
    ) -> CUresult;
}
extern "C" {
    pub fn cuEventQuery(hEvent: CUevent) -> CUresult;
}
extern "C" {
    pub fn cuEventSynchronize(hEvent: CUevent) -> CUresult;
}
extern "C" {
    pub fn cuEventDestroy_v2(hEvent: CUevent) -> CUresult;
}
extern "C" {
    pub fn cuEventElapsedTime(pMilliseconds: *mut f32, hStart: CUevent, hEnd: CUevent) -> CUresult;
}
extern "C" {
    pub fn cuImportExternalMemory(
        extMem_out: *mut CUexternalMemory,
        memHandleDesc: *const CUDA_EXTERNAL_MEMORY_HANDLE_DESC,
    ) -> CUresult;
}
extern "C" {
    pub fn cuExternalMemoryGetMappedBuffer(
        devPtr: *mut CUdeviceptr,
        extMem: CUexternalMemory,
        bufferDesc: *const CUDA_EXTERNAL_MEMORY_BUFFER_DESC,
    ) -> CUresult;
}
extern "C" {
    pub fn cuExternalMemoryGetMappedMipmappedArray(
        mipmap: *mut CUmipmappedArray,
        extMem: CUexternalMemory,
        mipmapDesc: *const CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC,
    ) -> CUresult;
}
extern "C" {
    pub fn cuDestroyExternalMemory(extMem: CUexternalMemory) -> CUresult;
}
extern "C" {
    pub fn cuImportExternalSemaphore(
        extSem_out: *mut CUexternalSemaphore,
        semHandleDesc: *const CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC,
    ) -> CUresult;
}
extern "C" {
    pub fn cuSignalExternalSemaphoresAsync(
        extSemArray: *const CUexternalSemaphore,
        paramsArray: *const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS,
        numExtSems: core::ffi::c_uint,
        stream: CUstream,
    ) -> CUresult;
}
extern "C" {
    pub fn cuWaitExternalSemaphoresAsync(
        extSemArray: *const CUexternalSemaphore,
        paramsArray: *const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS,
        numExtSems: core::ffi::c_uint,
        stream: CUstream,
    ) -> CUresult;
}
extern "C" {
    pub fn cuDestroyExternalSemaphore(extSem: CUexternalSemaphore) -> CUresult;
}
extern "C" {
    pub fn cuStreamWaitValue32(
        stream: CUstream,
        addr: CUdeviceptr,
        value: cuuint32_t,
        flags: core::ffi::c_uint,
    ) -> CUresult;
}
extern "C" {
    pub fn cuStreamWaitValue64(
        stream: CUstream,
        addr: CUdeviceptr,
        value: cuuint64_t,
        flags: core::ffi::c_uint,
    ) -> CUresult;
}
extern "C" {
    pub fn cuStreamWriteValue32(
        stream: CUstream,
        addr: CUdeviceptr,
        value: cuuint32_t,
        flags: core::ffi::c_uint,
    ) -> CUresult;
}
extern "C" {
    pub fn cuStreamWriteValue64(
        stream: CUstream,
        addr: CUdeviceptr,
        value: cuuint64_t,
        flags: core::ffi::c_uint,
    ) -> CUresult;
}
extern "C" {
    pub fn cuStreamBatchMemOp(
        stream: CUstream,
        count: core::ffi::c_uint,
        paramArray: *mut CUstreamBatchMemOpParams,
        flags: core::ffi::c_uint,
    ) -> CUresult;
}
extern "C" {
    pub fn cuFuncGetAttribute(
        pi: *mut core::ffi::c_int,
        attrib: CUfunction_attribute,
        hfunc: CUfunction,
    ) -> CUresult;
}
extern "C" {
    pub fn cuFuncSetAttribute(
        hfunc: CUfunction,
        attrib: CUfunction_attribute,
        value: core::ffi::c_int,
    ) -> CUresult;
}
extern "C" {
    pub fn cuFuncSetCacheConfig(hfunc: CUfunction, config: CUfunc_cache) -> CUresult;
}
extern "C" {
    pub fn cuFuncSetSharedMemConfig(hfunc: CUfunction, config: CUsharedconfig) -> CUresult;
}
extern "C" {
    pub fn cuFuncGetModule(hmod: *mut CUmodule, hfunc: CUfunction) -> CUresult;
}
extern "C" {
    pub fn cuLaunchKernel(
        f: CUfunction,
        gridDimX: core::ffi::c_uint,
        gridDimY: core::ffi::c_uint,
        gridDimZ: core::ffi::c_uint,
        blockDimX: core::ffi::c_uint,
        blockDimY: core::ffi::c_uint,
        blockDimZ: core::ffi::c_uint,
        sharedMemBytes: core::ffi::c_uint,
        hStream: CUstream,
        kernelParams: *mut *mut ::core::ffi::c_void,
        extra: *mut *mut ::core::ffi::c_void,
    ) -> CUresult;
}
extern "C" {
    pub fn cuLaunchCooperativeKernel(
        f: CUfunction,
        gridDimX: core::ffi::c_uint,
        gridDimY: core::ffi::c_uint,
        gridDimZ: core::ffi::c_uint,
        blockDimX: core::ffi::c_uint,
        blockDimY: core::ffi::c_uint,
        blockDimZ: core::ffi::c_uint,
        sharedMemBytes: core::ffi::c_uint,
        hStream: CUstream,
        kernelParams: *mut *mut ::core::ffi::c_void,
    ) -> CUresult;
}
extern "C" {
    pub fn cuLaunchCooperativeKernelMultiDevice(
        launchParamsList: *mut CUDA_LAUNCH_PARAMS,
        numDevices: core::ffi::c_uint,
        flags: core::ffi::c_uint,
    ) -> CUresult;
}
extern "C" {
    pub fn cuLaunchHostFunc(
        hStream: CUstream,
        fn_: CUhostFn,
        userData: *mut ::core::ffi::c_void,
    ) -> CUresult;
}
extern "C" {
    pub fn cuFuncSetBlockShape(
        hfunc: CUfunction,
        x: core::ffi::c_int,
        y: core::ffi::c_int,
        z: core::ffi::c_int,
    ) -> CUresult;
}
extern "C" {
    pub fn cuFuncSetSharedSize(hfunc: CUfunction, bytes: core::ffi::c_uint) -> CUresult;
}
extern "C" {
    pub fn cuParamSetSize(hfunc: CUfunction, numbytes: core::ffi::c_uint) -> CUresult;
}
extern "C" {
    pub fn cuParamSeti(
        hfunc: CUfunction,
        offset: core::ffi::c_int,
        value: core::ffi::c_uint,
    ) -> CUresult;
}
extern "C" {
    pub fn cuParamSetf(hfunc: CUfunction, offset: core::ffi::c_int, value: f32) -> CUresult;
}
extern "C" {
    pub fn cuParamSetv(
        hfunc: CUfunction,
        offset: core::ffi::c_int,
        ptr: *mut ::core::ffi::c_void,
        numbytes: core::ffi::c_uint,
    ) -> CUresult;
}
extern "C" {
    pub fn cuLaunch(f: CUfunction) -> CUresult;
}
extern "C" {
    pub fn cuLaunchGrid(
        f: CUfunction,
        grid_width: core::ffi::c_int,
        grid_height: core::ffi::c_int,
    ) -> CUresult;
}
extern "C" {
    pub fn cuLaunchGridAsync(
        f: CUfunction,
        grid_width: core::ffi::c_int,
        grid_height: core::ffi::c_int,
        hStream: CUstream,
    ) -> CUresult;
}
extern "C" {
    pub fn cuParamSetTexRef(
        hfunc: CUfunction,
        texunit: core::ffi::c_int,
        hTexRef: CUtexref,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphCreate(phGraph: *mut CUgraph, flags: core::ffi::c_uint) -> CUresult;
}
extern "C" {
    pub fn cuGraphAddKernelNode(
        phGraphNode: *mut CUgraphNode,
        hGraph: CUgraph,
        dependencies: *const CUgraphNode,
        numDependencies: usize,
        nodeParams: *const CUDA_KERNEL_NODE_PARAMS,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphKernelNodeGetParams(
        hNode: CUgraphNode,
        nodeParams: *mut CUDA_KERNEL_NODE_PARAMS,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphKernelNodeSetParams(
        hNode: CUgraphNode,
        nodeParams: *const CUDA_KERNEL_NODE_PARAMS,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphAddMemcpyNode(
        phGraphNode: *mut CUgraphNode,
        hGraph: CUgraph,
        dependencies: *const CUgraphNode,
        numDependencies: usize,
        copyParams: *const CUDA_MEMCPY3D,
        ctx: CUcontext,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphMemcpyNodeGetParams(
        hNode: CUgraphNode,
        nodeParams: *mut CUDA_MEMCPY3D,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphMemcpyNodeSetParams(
        hNode: CUgraphNode,
        nodeParams: *const CUDA_MEMCPY3D,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphAddMemsetNode(
        phGraphNode: *mut CUgraphNode,
        hGraph: CUgraph,
        dependencies: *const CUgraphNode,
        numDependencies: usize,
        memsetParams: *const CUDA_MEMSET_NODE_PARAMS,
        ctx: CUcontext,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphMemsetNodeGetParams(
        hNode: CUgraphNode,
        nodeParams: *mut CUDA_MEMSET_NODE_PARAMS,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphMemsetNodeSetParams(
        hNode: CUgraphNode,
        nodeParams: *const CUDA_MEMSET_NODE_PARAMS,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphAddHostNode(
        phGraphNode: *mut CUgraphNode,
        hGraph: CUgraph,
        dependencies: *const CUgraphNode,
        numDependencies: usize,
        nodeParams: *const CUDA_HOST_NODE_PARAMS,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphHostNodeGetParams(
        hNode: CUgraphNode,
        nodeParams: *mut CUDA_HOST_NODE_PARAMS,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphHostNodeSetParams(
        hNode: CUgraphNode,
        nodeParams: *const CUDA_HOST_NODE_PARAMS,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphAddChildGraphNode(
        phGraphNode: *mut CUgraphNode,
        hGraph: CUgraph,
        dependencies: *const CUgraphNode,
        numDependencies: usize,
        childGraph: CUgraph,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphChildGraphNodeGetGraph(hNode: CUgraphNode, phGraph: *mut CUgraph) -> CUresult;
}
extern "C" {
    pub fn cuGraphAddEmptyNode(
        phGraphNode: *mut CUgraphNode,
        hGraph: CUgraph,
        dependencies: *const CUgraphNode,
        numDependencies: usize,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphAddEventRecordNode(
        phGraphNode: *mut CUgraphNode,
        hGraph: CUgraph,
        dependencies: *const CUgraphNode,
        numDependencies: usize,
        event: CUevent,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphEventRecordNodeGetEvent(hNode: CUgraphNode, event_out: *mut CUevent) -> CUresult;
}
extern "C" {
    pub fn cuGraphEventRecordNodeSetEvent(hNode: CUgraphNode, event: CUevent) -> CUresult;
}
extern "C" {
    pub fn cuGraphAddEventWaitNode(
        phGraphNode: *mut CUgraphNode,
        hGraph: CUgraph,
        dependencies: *const CUgraphNode,
        numDependencies: usize,
        event: CUevent,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphEventWaitNodeGetEvent(hNode: CUgraphNode, event_out: *mut CUevent) -> CUresult;
}
extern "C" {
    pub fn cuGraphEventWaitNodeSetEvent(hNode: CUgraphNode, event: CUevent) -> CUresult;
}
extern "C" {
    pub fn cuGraphAddExternalSemaphoresSignalNode(
        phGraphNode: *mut CUgraphNode,
        hGraph: CUgraph,
        dependencies: *const CUgraphNode,
        numDependencies: usize,
        nodeParams: *const CUDA_EXT_SEM_SIGNAL_NODE_PARAMS,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphExternalSemaphoresSignalNodeGetParams(
        hNode: CUgraphNode,
        params_out: *mut CUDA_EXT_SEM_SIGNAL_NODE_PARAMS,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphExternalSemaphoresSignalNodeSetParams(
        hNode: CUgraphNode,
        nodeParams: *const CUDA_EXT_SEM_SIGNAL_NODE_PARAMS,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphAddExternalSemaphoresWaitNode(
        phGraphNode: *mut CUgraphNode,
        hGraph: CUgraph,
        dependencies: *const CUgraphNode,
        numDependencies: usize,
        nodeParams: *const CUDA_EXT_SEM_WAIT_NODE_PARAMS,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphExternalSemaphoresWaitNodeGetParams(
        hNode: CUgraphNode,
        params_out: *mut CUDA_EXT_SEM_WAIT_NODE_PARAMS,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphExternalSemaphoresWaitNodeSetParams(
        hNode: CUgraphNode,
        nodeParams: *const CUDA_EXT_SEM_WAIT_NODE_PARAMS,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphClone(phGraphClone: *mut CUgraph, originalGraph: CUgraph) -> CUresult;
}
extern "C" {
    pub fn cuGraphNodeFindInClone(
        phNode: *mut CUgraphNode,
        hOriginalNode: CUgraphNode,
        hClonedGraph: CUgraph,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphNodeGetType(hNode: CUgraphNode, type_: *mut CUgraphNodeType) -> CUresult;
}
extern "C" {
    pub fn cuGraphGetNodes(
        hGraph: CUgraph,
        nodes: *mut CUgraphNode,
        numNodes: *mut usize,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphGetRootNodes(
        hGraph: CUgraph,
        rootNodes: *mut CUgraphNode,
        numRootNodes: *mut usize,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphGetEdges(
        hGraph: CUgraph,
        from: *mut CUgraphNode,
        to: *mut CUgraphNode,
        numEdges: *mut usize,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphNodeGetDependencies(
        hNode: CUgraphNode,
        dependencies: *mut CUgraphNode,
        numDependencies: *mut usize,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphNodeGetDependentNodes(
        hNode: CUgraphNode,
        dependentNodes: *mut CUgraphNode,
        numDependentNodes: *mut usize,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphAddDependencies(
        hGraph: CUgraph,
        from: *const CUgraphNode,
        to: *const CUgraphNode,
        numDependencies: usize,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphRemoveDependencies(
        hGraph: CUgraph,
        from: *const CUgraphNode,
        to: *const CUgraphNode,
        numDependencies: usize,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphDestroyNode(hNode: CUgraphNode) -> CUresult;
}
extern "C" {
    pub fn cuGraphInstantiate_v2(
        phGraphExec: *mut CUgraphExec,
        hGraph: CUgraph,
        phErrorNode: *mut CUgraphNode,
        logBuffer: *mut core::ffi::c_char,
        bufferSize: usize,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphExecKernelNodeSetParams(
        hGraphExec: CUgraphExec,
        hNode: CUgraphNode,
        nodeParams: *const CUDA_KERNEL_NODE_PARAMS,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphExecMemcpyNodeSetParams(
        hGraphExec: CUgraphExec,
        hNode: CUgraphNode,
        copyParams: *const CUDA_MEMCPY3D,
        ctx: CUcontext,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphExecMemsetNodeSetParams(
        hGraphExec: CUgraphExec,
        hNode: CUgraphNode,
        memsetParams: *const CUDA_MEMSET_NODE_PARAMS,
        ctx: CUcontext,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphExecHostNodeSetParams(
        hGraphExec: CUgraphExec,
        hNode: CUgraphNode,
        nodeParams: *const CUDA_HOST_NODE_PARAMS,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphExecChildGraphNodeSetParams(
        hGraphExec: CUgraphExec,
        hNode: CUgraphNode,
        childGraph: CUgraph,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphExecEventRecordNodeSetEvent(
        hGraphExec: CUgraphExec,
        hNode: CUgraphNode,
        event: CUevent,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphExecEventWaitNodeSetEvent(
        hGraphExec: CUgraphExec,
        hNode: CUgraphNode,
        event: CUevent,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphExecExternalSemaphoresSignalNodeSetParams(
        hGraphExec: CUgraphExec,
        hNode: CUgraphNode,
        nodeParams: *const CUDA_EXT_SEM_SIGNAL_NODE_PARAMS,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphExecExternalSemaphoresWaitNodeSetParams(
        hGraphExec: CUgraphExec,
        hNode: CUgraphNode,
        nodeParams: *const CUDA_EXT_SEM_WAIT_NODE_PARAMS,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphUpload(hGraphExec: CUgraphExec, hStream: CUstream) -> CUresult;
}
extern "C" {
    pub fn cuGraphLaunch(hGraphExec: CUgraphExec, hStream: CUstream) -> CUresult;
}
extern "C" {
    pub fn cuGraphExecDestroy(hGraphExec: CUgraphExec) -> CUresult;
}
extern "C" {
    pub fn cuGraphDestroy(hGraph: CUgraph) -> CUresult;
}
extern "C" {
    pub fn cuGraphExecUpdate(
        hGraphExec: CUgraphExec,
        hGraph: CUgraph,
        hErrorNode_out: *mut CUgraphNode,
        updateResult_out: *mut CUgraphExecUpdateResult,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphKernelNodeCopyAttributes(dst: CUgraphNode, src: CUgraphNode) -> CUresult;
}
extern "C" {
    pub fn cuGraphKernelNodeGetAttribute(
        hNode: CUgraphNode,
        attr: CUkernelNodeAttrID,
        value_out: *mut CUkernelNodeAttrValue,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphKernelNodeSetAttribute(
        hNode: CUgraphNode,
        attr: CUkernelNodeAttrID,
        value: *const CUkernelNodeAttrValue,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphDebugDotPrint(
        hGraph: CUgraph,
        path: *const core::ffi::c_char,
        flags: core::ffi::c_uint,
    ) -> CUresult;
}
extern "C" {
    pub fn cuUserObjectCreate(
        object_out: *mut CUuserObject,
        ptr: *mut ::core::ffi::c_void,
        destroy: CUhostFn,
        initialRefcount: core::ffi::c_uint,
        flags: core::ffi::c_uint,
    ) -> CUresult;
}
extern "C" {
    pub fn cuUserObjectRetain(object: CUuserObject, count: core::ffi::c_uint) -> CUresult;
}
extern "C" {
    pub fn cuUserObjectRelease(object: CUuserObject, count: core::ffi::c_uint) -> CUresult;
}
extern "C" {
    pub fn cuGraphRetainUserObject(
        graph: CUgraph,
        object: CUuserObject,
        count: core::ffi::c_uint,
        flags: core::ffi::c_uint,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphReleaseUserObject(
        graph: CUgraph,
        object: CUuserObject,
        count: core::ffi::c_uint,
    ) -> CUresult;
}
extern "C" {
    pub fn cuOccupancyMaxActiveBlocksPerMultiprocessor(
        numBlocks: *mut core::ffi::c_int,
        func: CUfunction,
        blockSize: core::ffi::c_int,
        dynamicSMemSize: usize,
    ) -> CUresult;
}
extern "C" {
    pub fn cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(
        numBlocks: *mut core::ffi::c_int,
        func: CUfunction,
        blockSize: core::ffi::c_int,
        dynamicSMemSize: usize,
        flags: core::ffi::c_uint,
    ) -> CUresult;
}
extern "C" {
    pub fn cuOccupancyMaxPotentialBlockSize(
        minGridSize: *mut core::ffi::c_int,
        blockSize: *mut core::ffi::c_int,
        func: CUfunction,
        blockSizeToDynamicSMemSize: CUoccupancyB2DSize,
        dynamicSMemSize: usize,
        blockSizeLimit: core::ffi::c_int,
    ) -> CUresult;
}
extern "C" {
    pub fn cuOccupancyMaxPotentialBlockSizeWithFlags(
        minGridSize: *mut core::ffi::c_int,
        blockSize: *mut core::ffi::c_int,
        func: CUfunction,
        blockSizeToDynamicSMemSize: CUoccupancyB2DSize,
        dynamicSMemSize: usize,
        blockSizeLimit: core::ffi::c_int,
        flags: core::ffi::c_uint,
    ) -> CUresult;
}
extern "C" {
    pub fn cuOccupancyAvailableDynamicSMemPerBlock(
        dynamicSmemSize: *mut usize,
        func: CUfunction,
        numBlocks: core::ffi::c_int,
        blockSize: core::ffi::c_int,
    ) -> CUresult;
}
extern "C" {
    pub fn cuTexRefSetArray(
        hTexRef: CUtexref,
        hArray: CUarray,
        Flags: core::ffi::c_uint,
    ) -> CUresult;
}
extern "C" {
    pub fn cuTexRefSetMipmappedArray(
        hTexRef: CUtexref,
        hMipmappedArray: CUmipmappedArray,
        Flags: core::ffi::c_uint,
    ) -> CUresult;
}
extern "C" {
    pub fn cuTexRefSetAddress_v2(
        ByteOffset: *mut usize,
        hTexRef: CUtexref,
        dptr: CUdeviceptr,
        bytes: usize,
    ) -> CUresult;
}
extern "C" {
    pub fn cuTexRefSetAddress2D_v3(
        hTexRef: CUtexref,
        desc: *const CUDA_ARRAY_DESCRIPTOR,
        dptr: CUdeviceptr,
        Pitch: usize,
    ) -> CUresult;
}
extern "C" {
    pub fn cuTexRefSetFormat(
        hTexRef: CUtexref,
        fmt: CUarray_format,
        NumPackedComponents: core::ffi::c_int,
    ) -> CUresult;
}
extern "C" {
    pub fn cuTexRefSetAddressMode(
        hTexRef: CUtexref,
        dim: core::ffi::c_int,
        am: CUaddress_mode,
    ) -> CUresult;
}
extern "C" {
    pub fn cuTexRefSetFilterMode(hTexRef: CUtexref, fm: CUfilter_mode) -> CUresult;
}
extern "C" {
    pub fn cuTexRefSetMipmapFilterMode(hTexRef: CUtexref, fm: CUfilter_mode) -> CUresult;
}
extern "C" {
    pub fn cuTexRefSetMipmapLevelBias(hTexRef: CUtexref, bias: f32) -> CUresult;
}
extern "C" {
    pub fn cuTexRefSetMipmapLevelClamp(
        hTexRef: CUtexref,
        minMipmapLevelClamp: f32,
        maxMipmapLevelClamp: f32,
    ) -> CUresult;
}
extern "C" {
    pub fn cuTexRefSetMaxAnisotropy(hTexRef: CUtexref, maxAniso: core::ffi::c_uint) -> CUresult;
}
extern "C" {
    pub fn cuTexRefSetBorderColor(hTexRef: CUtexref, pBorderColor: *mut f32) -> CUresult;
}
extern "C" {
    pub fn cuTexRefSetFlags(hTexRef: CUtexref, Flags: core::ffi::c_uint) -> CUresult;
}
extern "C" {
    pub fn cuTexRefGetAddress_v2(pdptr: *mut CUdeviceptr, hTexRef: CUtexref) -> CUresult;
}
extern "C" {
    pub fn cuTexRefGetArray(phArray: *mut CUarray, hTexRef: CUtexref) -> CUresult;
}
extern "C" {
    pub fn cuTexRefGetMipmappedArray(
        phMipmappedArray: *mut CUmipmappedArray,
        hTexRef: CUtexref,
    ) -> CUresult;
}
extern "C" {
    pub fn cuTexRefGetAddressMode(
        pam: *mut CUaddress_mode,
        hTexRef: CUtexref,
        dim: core::ffi::c_int,
    ) -> CUresult;
}
extern "C" {
    pub fn cuTexRefGetFilterMode(pfm: *mut CUfilter_mode, hTexRef: CUtexref) -> CUresult;
}
extern "C" {
    pub fn cuTexRefGetFormat(
        pFormat: *mut CUarray_format,
        pNumChannels: *mut core::ffi::c_int,
        hTexRef: CUtexref,
    ) -> CUresult;
}
extern "C" {
    pub fn cuTexRefGetMipmapFilterMode(pfm: *mut CUfilter_mode, hTexRef: CUtexref) -> CUresult;
}
extern "C" {
    pub fn cuTexRefGetMipmapLevelBias(pbias: *mut f32, hTexRef: CUtexref) -> CUresult;
}
extern "C" {
    pub fn cuTexRefGetMipmapLevelClamp(
        pminMipmapLevelClamp: *mut f32,
        pmaxMipmapLevelClamp: *mut f32,
        hTexRef: CUtexref,
    ) -> CUresult;
}
extern "C" {
    pub fn cuTexRefGetMaxAnisotropy(
        pmaxAniso: *mut core::ffi::c_int,
        hTexRef: CUtexref,
    ) -> CUresult;
}
extern "C" {
    pub fn cuTexRefGetBorderColor(pBorderColor: *mut f32, hTexRef: CUtexref) -> CUresult;
}
extern "C" {
    pub fn cuTexRefGetFlags(pFlags: *mut core::ffi::c_uint, hTexRef: CUtexref) -> CUresult;
}
extern "C" {
    pub fn cuTexRefCreate(pTexRef: *mut CUtexref) -> CUresult;
}
extern "C" {
    pub fn cuTexRefDestroy(hTexRef: CUtexref) -> CUresult;
}
extern "C" {
    pub fn cuSurfRefSetArray(
        hSurfRef: CUsurfref,
        hArray: CUarray,
        Flags: core::ffi::c_uint,
    ) -> CUresult;
}
extern "C" {
    pub fn cuSurfRefGetArray(phArray: *mut CUarray, hSurfRef: CUsurfref) -> CUresult;
}
extern "C" {
    pub fn cuTexObjectCreate(
        pTexObject: *mut CUtexObject,
        pResDesc: *const CUDA_RESOURCE_DESC,
        pTexDesc: *const CUDA_TEXTURE_DESC,
        pResViewDesc: *const CUDA_RESOURCE_VIEW_DESC,
    ) -> CUresult;
}
extern "C" {
    pub fn cuTexObjectDestroy(texObject: CUtexObject) -> CUresult;
}
extern "C" {
    pub fn cuTexObjectGetResourceDesc(
        pResDesc: *mut CUDA_RESOURCE_DESC,
        texObject: CUtexObject,
    ) -> CUresult;
}
extern "C" {
    pub fn cuTexObjectGetTextureDesc(
        pTexDesc: *mut CUDA_TEXTURE_DESC,
        texObject: CUtexObject,
    ) -> CUresult;
}
extern "C" {
    pub fn cuTexObjectGetResourceViewDesc(
        pResViewDesc: *mut CUDA_RESOURCE_VIEW_DESC,
        texObject: CUtexObject,
    ) -> CUresult;
}
extern "C" {
    pub fn cuSurfObjectCreate(
        pSurfObject: *mut CUsurfObject,
        pResDesc: *const CUDA_RESOURCE_DESC,
    ) -> CUresult;
}
extern "C" {
    pub fn cuSurfObjectDestroy(surfObject: CUsurfObject) -> CUresult;
}
extern "C" {
    pub fn cuSurfObjectGetResourceDesc(
        pResDesc: *mut CUDA_RESOURCE_DESC,
        surfObject: CUsurfObject,
    ) -> CUresult;
}
extern "C" {
    pub fn cuDeviceCanAccessPeer(
        canAccessPeer: *mut core::ffi::c_int,
        dev: CUdevice,
        peerDev: CUdevice,
    ) -> CUresult;
}
extern "C" {
    pub fn cuCtxEnablePeerAccess(peerContext: CUcontext, Flags: core::ffi::c_uint) -> CUresult;
}
extern "C" {
    pub fn cuCtxDisablePeerAccess(peerContext: CUcontext) -> CUresult;
}
extern "C" {
    pub fn cuDeviceGetP2PAttribute(
        value: *mut core::ffi::c_int,
        attrib: CUdevice_P2PAttribute,
        srcDevice: CUdevice,
        dstDevice: CUdevice,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphicsUnregisterResource(resource: CUgraphicsResource) -> CUresult;
}
extern "C" {
    pub fn cuGraphicsSubResourceGetMappedArray(
        pArray: *mut CUarray,
        resource: CUgraphicsResource,
        arrayIndex: core::ffi::c_uint,
        mipLevel: core::ffi::c_uint,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphicsResourceGetMappedMipmappedArray(
        pMipmappedArray: *mut CUmipmappedArray,
        resource: CUgraphicsResource,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphicsResourceGetMappedPointer_v2(
        pDevPtr: *mut CUdeviceptr,
        pSize: *mut usize,
        resource: CUgraphicsResource,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphicsResourceSetMapFlags_v2(
        resource: CUgraphicsResource,
        flags: core::ffi::c_uint,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphicsMapResources(
        count: core::ffi::c_uint,
        resources: *mut CUgraphicsResource,
        hStream: CUstream,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGraphicsUnmapResources(
        count: core::ffi::c_uint,
        resources: *mut CUgraphicsResource,
        hStream: CUstream,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGetProcAddress(
        symbol: *const core::ffi::c_char,
        pfn: *mut *mut ::core::ffi::c_void,
        cudaVersion: core::ffi::c_int,
        flags: cuuint64_t,
    ) -> CUresult;
}
extern "C" {
    pub fn cuGetExportTable(
        ppExportTable: *mut *const ::core::ffi::c_void,
        pExportTableId: *const CUuuid,
    ) -> CUresult;
}
extern "C" {
    pub fn cuFlushGPUDirectRDMAWrites(
        target: CUflushGPUDirectRDMAWritesTarget,
        scope: CUflushGPUDirectRDMAWritesScope,
    ) -> CUresult;
}
