fna3d-sys 0.1.8

/* automatically generated by rust-bindgen 0.55.1 */

pub const MOJOSHADER_VERSION: i32 = -1;
pub const MOJOSHADER_CHANGESET: &'static [u8; 4usize] = b"???\0";
pub const MOJOSHADER_POSITION_NONE: i32 = -3;
pub const MOJOSHADER_POSITION_BEFORE: i32 = -2;
pub const MOJOSHADER_POSITION_AFTER: i32 = -1;
pub const MOJOSHADER_PROFILE_D3D: &'static [u8; 4usize] = b"d3d\0";
pub const MOJOSHADER_PROFILE_BYTECODE: &'static [u8; 9usize] = b"bytecode\0";
pub const MOJOSHADER_PROFILE_HLSL: &'static [u8; 5usize] = b"hlsl\0";
pub const MOJOSHADER_PROFILE_GLSL: &'static [u8; 5usize] = b"glsl\0";
pub const MOJOSHADER_PROFILE_GLSL120: &'static [u8; 8usize] = b"glsl120\0";
pub const MOJOSHADER_PROFILE_GLSLES: &'static [u8; 7usize] = b"glsles\0";
pub const MOJOSHADER_PROFILE_ARB1: &'static [u8; 5usize] = b"arb1\0";
pub const MOJOSHADER_PROFILE_NV2: &'static [u8; 4usize] = b"nv2\0";
pub const MOJOSHADER_PROFILE_NV3: &'static [u8; 4usize] = b"nv3\0";
pub const MOJOSHADER_PROFILE_NV4: &'static [u8; 4usize] = b"nv4\0";
pub const MOJOSHADER_PROFILE_METAL: &'static [u8; 6usize] = b"metal\0";
pub const MOJOSHADER_PROFILE_SPIRV: &'static [u8; 6usize] = b"spirv\0";
pub const MOJOSHADER_PROFILE_GLSPIRV: &'static [u8; 8usize] = b"glspirv\0";
pub const MOJOSHADER_SRC_PROFILE_HLSL_VS_1_1: &'static [u8; 12usize] = b"hlsl_vs_1_1\0";
pub const MOJOSHADER_SRC_PROFILE_HLSL_VS_2_0: &'static [u8; 12usize] = b"hlsl_vs_2_0\0";
pub const MOJOSHADER_SRC_PROFILE_HLSL_VS_3_0: &'static [u8; 12usize] = b"hlsl_vs_3_0\0";
pub const MOJOSHADER_SRC_PROFILE_HLSL_PS_1_1: &'static [u8; 12usize] = b"hlsl_ps_1_1\0";
pub const MOJOSHADER_SRC_PROFILE_HLSL_PS_1_2: &'static [u8; 12usize] = b"hlsl_ps_1_2\0";
pub const MOJOSHADER_SRC_PROFILE_HLSL_PS_1_3: &'static [u8; 12usize] = b"hlsl_ps_1_3\0";
pub const MOJOSHADER_SRC_PROFILE_HLSL_PS_1_4: &'static [u8; 12usize] = b"hlsl_ps_1_4\0";
pub const MOJOSHADER_SRC_PROFILE_HLSL_PS_2_0: &'static [u8; 12usize] = b"hlsl_ps_2_0\0";
pub const MOJOSHADER_SRC_PROFILE_HLSL_PS_3_0: &'static [u8; 12usize] = b"hlsl_ps_3_0\0";
pub const MOJOSHADER_AST_DATATYPE_CONST: u32 = 2147483648;
extern "C" {
    pub fn MOJOSHADER_version() -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn MOJOSHADER_changeset() -> *const ::std::os::raw::c_char;
}
pub type MOJOSHADER_malloc = ::std::option::Option<
    unsafe extern "C" fn(
        bytes: ::std::os::raw::c_int,
        data: *mut ::std::os::raw::c_void,
    ) -> *mut ::std::os::raw::c_void,
>;
pub type MOJOSHADER_free = ::std::option::Option<
    unsafe extern "C" fn(ptr: *mut ::std::os::raw::c_void, data: *mut ::std::os::raw::c_void),
>;
pub const MOJOSHADER_shaderType_MOJOSHADER_TYPE_UNKNOWN: MOJOSHADER_shaderType = 0;
pub const MOJOSHADER_shaderType_MOJOSHADER_TYPE_PIXEL: MOJOSHADER_shaderType = 1;
pub const MOJOSHADER_shaderType_MOJOSHADER_TYPE_VERTEX: MOJOSHADER_shaderType = 2;
pub const MOJOSHADER_shaderType_MOJOSHADER_TYPE_GEOMETRY: MOJOSHADER_shaderType = 4;
pub const MOJOSHADER_shaderType_MOJOSHADER_TYPE_ANY: MOJOSHADER_shaderType = 2147483647;
pub type MOJOSHADER_shaderType = ::std::os::raw::c_uint;
pub const MOJOSHADER_attributeType_MOJOSHADER_ATTRIBUTE_UNKNOWN: MOJOSHADER_attributeType = -1;
pub const MOJOSHADER_attributeType_MOJOSHADER_ATTRIBUTE_BYTE: MOJOSHADER_attributeType = 0;
pub const MOJOSHADER_attributeType_MOJOSHADER_ATTRIBUTE_UBYTE: MOJOSHADER_attributeType = 1;
pub const MOJOSHADER_attributeType_MOJOSHADER_ATTRIBUTE_SHORT: MOJOSHADER_attributeType = 2;
pub const MOJOSHADER_attributeType_MOJOSHADER_ATTRIBUTE_USHORT: MOJOSHADER_attributeType = 3;
pub const MOJOSHADER_attributeType_MOJOSHADER_ATTRIBUTE_INT: MOJOSHADER_attributeType = 4;
pub const MOJOSHADER_attributeType_MOJOSHADER_ATTRIBUTE_UINT: MOJOSHADER_attributeType = 5;
pub const MOJOSHADER_attributeType_MOJOSHADER_ATTRIBUTE_FLOAT: MOJOSHADER_attributeType = 6;
pub const MOJOSHADER_attributeType_MOJOSHADER_ATTRIBUTE_DOUBLE: MOJOSHADER_attributeType = 7;
pub const MOJOSHADER_attributeType_MOJOSHADER_ATTRIBUTE_HALF_FLOAT: MOJOSHADER_attributeType = 8;
pub type MOJOSHADER_attributeType = ::std::os::raw::c_int;
pub const MOJOSHADER_uniformType_MOJOSHADER_UNIFORM_UNKNOWN: MOJOSHADER_uniformType = -1;
pub const MOJOSHADER_uniformType_MOJOSHADER_UNIFORM_FLOAT: MOJOSHADER_uniformType = 0;
pub const MOJOSHADER_uniformType_MOJOSHADER_UNIFORM_INT: MOJOSHADER_uniformType = 1;
pub const MOJOSHADER_uniformType_MOJOSHADER_UNIFORM_BOOL: MOJOSHADER_uniformType = 2;
pub type MOJOSHADER_uniformType = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_uniform {
    pub type_: MOJOSHADER_uniformType,
    pub index: ::std::os::raw::c_int,
    pub array_count: ::std::os::raw::c_int,
    pub constant: ::std::os::raw::c_int,
    pub name: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_uniform() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_uniform>(),
        24usize,
        concat!("Size of: ", stringify!(MOJOSHADER_uniform))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_uniform>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_uniform))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_uniform>())).type_ as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_uniform),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_uniform>())).index as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_uniform),
            "::",
            stringify!(index)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_uniform>())).array_count as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_uniform),
            "::",
            stringify!(array_count)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_uniform>())).constant as *const _ as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_uniform),
            "::",
            stringify!(constant)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_uniform>())).name as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_uniform),
            "::",
            stringify!(name)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct MOJOSHADER_constant {
    pub type_: MOJOSHADER_uniformType,
    pub index: ::std::os::raw::c_int,
    pub value: MOJOSHADER_constant__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union MOJOSHADER_constant__bindgen_ty_1 {
    pub f: [f32; 4usize],
    pub i: [::std::os::raw::c_int; 4usize],
    pub b: ::std::os::raw::c_int,
    _bindgen_union_align: [u32; 4usize],
}
#[test]
fn bindgen_test_layout_MOJOSHADER_constant__bindgen_ty_1() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_constant__bindgen_ty_1>(),
        16usize,
        concat!("Size of: ", stringify!(MOJOSHADER_constant__bindgen_ty_1))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_constant__bindgen_ty_1>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(MOJOSHADER_constant__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_constant__bindgen_ty_1>())).f as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_constant__bindgen_ty_1),
            "::",
            stringify!(f)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_constant__bindgen_ty_1>())).i as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_constant__bindgen_ty_1),
            "::",
            stringify!(i)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_constant__bindgen_ty_1>())).b as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_constant__bindgen_ty_1),
            "::",
            stringify!(b)
        )
    );
}
#[test]
fn bindgen_test_layout_MOJOSHADER_constant() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_constant>(),
        24usize,
        concat!("Size of: ", stringify!(MOJOSHADER_constant))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_constant>(),
        4usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_constant))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_constant>())).type_ as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_constant),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_constant>())).index as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_constant),
            "::",
            stringify!(index)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_constant>())).value as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_constant),
            "::",
            stringify!(value)
        )
    );
}
pub const MOJOSHADER_samplerType_MOJOSHADER_SAMPLER_UNKNOWN: MOJOSHADER_samplerType = -1;
pub const MOJOSHADER_samplerType_MOJOSHADER_SAMPLER_2D: MOJOSHADER_samplerType = 0;
pub const MOJOSHADER_samplerType_MOJOSHADER_SAMPLER_CUBE: MOJOSHADER_samplerType = 1;
pub const MOJOSHADER_samplerType_MOJOSHADER_SAMPLER_VOLUME: MOJOSHADER_samplerType = 2;
pub type MOJOSHADER_samplerType = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_sampler {
    pub type_: MOJOSHADER_samplerType,
    pub index: ::std::os::raw::c_int,
    pub name: *const ::std::os::raw::c_char,
    pub texbem: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_sampler() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_sampler>(),
        24usize,
        concat!("Size of: ", stringify!(MOJOSHADER_sampler))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_sampler>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_sampler))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_sampler>())).type_ as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_sampler),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_sampler>())).index as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_sampler),
            "::",
            stringify!(index)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_sampler>())).name as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_sampler),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_sampler>())).texbem as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_sampler),
            "::",
            stringify!(texbem)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_samplerMap {
    pub index: ::std::os::raw::c_int,
    pub type_: MOJOSHADER_samplerType,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_samplerMap() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_samplerMap>(),
        8usize,
        concat!("Size of: ", stringify!(MOJOSHADER_samplerMap))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_samplerMap>(),
        4usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_samplerMap))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_samplerMap>())).index as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_samplerMap),
            "::",
            stringify!(index)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_samplerMap>())).type_ as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_samplerMap),
            "::",
            stringify!(type_)
        )
    );
}
pub const MOJOSHADER_usage_MOJOSHADER_USAGE_UNKNOWN: MOJOSHADER_usage = -1;
pub const MOJOSHADER_usage_MOJOSHADER_USAGE_POSITION: MOJOSHADER_usage = 0;
pub const MOJOSHADER_usage_MOJOSHADER_USAGE_BLENDWEIGHT: MOJOSHADER_usage = 1;
pub const MOJOSHADER_usage_MOJOSHADER_USAGE_BLENDINDICES: MOJOSHADER_usage = 2;
pub const MOJOSHADER_usage_MOJOSHADER_USAGE_NORMAL: MOJOSHADER_usage = 3;
pub const MOJOSHADER_usage_MOJOSHADER_USAGE_POINTSIZE: MOJOSHADER_usage = 4;
pub const MOJOSHADER_usage_MOJOSHADER_USAGE_TEXCOORD: MOJOSHADER_usage = 5;
pub const MOJOSHADER_usage_MOJOSHADER_USAGE_TANGENT: MOJOSHADER_usage = 6;
pub const MOJOSHADER_usage_MOJOSHADER_USAGE_BINORMAL: MOJOSHADER_usage = 7;
pub const MOJOSHADER_usage_MOJOSHADER_USAGE_TESSFACTOR: MOJOSHADER_usage = 8;
pub const MOJOSHADER_usage_MOJOSHADER_USAGE_POSITIONT: MOJOSHADER_usage = 9;
pub const MOJOSHADER_usage_MOJOSHADER_USAGE_COLOR: MOJOSHADER_usage = 10;
pub const MOJOSHADER_usage_MOJOSHADER_USAGE_FOG: MOJOSHADER_usage = 11;
pub const MOJOSHADER_usage_MOJOSHADER_USAGE_DEPTH: MOJOSHADER_usage = 12;
pub const MOJOSHADER_usage_MOJOSHADER_USAGE_SAMPLE: MOJOSHADER_usage = 13;
pub const MOJOSHADER_usage_MOJOSHADER_USAGE_TOTAL: MOJOSHADER_usage = 14;
pub type MOJOSHADER_usage = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_attribute {
    pub usage: MOJOSHADER_usage,
    pub index: ::std::os::raw::c_int,
    pub name: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_attribute() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_attribute>(),
        16usize,
        concat!("Size of: ", stringify!(MOJOSHADER_attribute))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_attribute>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_attribute))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_attribute>())).usage as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_attribute),
            "::",
            stringify!(usage)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_attribute>())).index as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_attribute),
            "::",
            stringify!(index)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_attribute>())).name as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_attribute),
            "::",
            stringify!(name)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_swizzle {
    pub usage: MOJOSHADER_usage,
    pub index: ::std::os::raw::c_uint,
    pub swizzles: [::std::os::raw::c_uchar; 4usize],
}
#[test]
fn bindgen_test_layout_MOJOSHADER_swizzle() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_swizzle>(),
        12usize,
        concat!("Size of: ", stringify!(MOJOSHADER_swizzle))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_swizzle>(),
        4usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_swizzle))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_swizzle>())).usage as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_swizzle),
            "::",
            stringify!(usage)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_swizzle>())).index as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_swizzle),
            "::",
            stringify!(index)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_swizzle>())).swizzles as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_swizzle),
            "::",
            stringify!(swizzles)
        )
    );
}
pub const MOJOSHADER_symbolRegisterSet_MOJOSHADER_SYMREGSET_BOOL: MOJOSHADER_symbolRegisterSet = 0;
pub const MOJOSHADER_symbolRegisterSet_MOJOSHADER_SYMREGSET_INT4: MOJOSHADER_symbolRegisterSet = 1;
pub const MOJOSHADER_symbolRegisterSet_MOJOSHADER_SYMREGSET_FLOAT4: MOJOSHADER_symbolRegisterSet =
    2;
pub const MOJOSHADER_symbolRegisterSet_MOJOSHADER_SYMREGSET_SAMPLER: MOJOSHADER_symbolRegisterSet =
    3;
pub const MOJOSHADER_symbolRegisterSet_MOJOSHADER_SYMREGSET_TOTAL: MOJOSHADER_symbolRegisterSet = 4;
pub type MOJOSHADER_symbolRegisterSet = ::std::os::raw::c_uint;
pub const MOJOSHADER_symbolClass_MOJOSHADER_SYMCLASS_SCALAR: MOJOSHADER_symbolClass = 0;
pub const MOJOSHADER_symbolClass_MOJOSHADER_SYMCLASS_VECTOR: MOJOSHADER_symbolClass = 1;
pub const MOJOSHADER_symbolClass_MOJOSHADER_SYMCLASS_MATRIX_ROWS: MOJOSHADER_symbolClass = 2;
pub const MOJOSHADER_symbolClass_MOJOSHADER_SYMCLASS_MATRIX_COLUMNS: MOJOSHADER_symbolClass = 3;
pub const MOJOSHADER_symbolClass_MOJOSHADER_SYMCLASS_OBJECT: MOJOSHADER_symbolClass = 4;
pub const MOJOSHADER_symbolClass_MOJOSHADER_SYMCLASS_STRUCT: MOJOSHADER_symbolClass = 5;
pub const MOJOSHADER_symbolClass_MOJOSHADER_SYMCLASS_TOTAL: MOJOSHADER_symbolClass = 6;
pub type MOJOSHADER_symbolClass = ::std::os::raw::c_uint;
pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_VOID: MOJOSHADER_symbolType = 0;
pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_BOOL: MOJOSHADER_symbolType = 1;
pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_INT: MOJOSHADER_symbolType = 2;
pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_FLOAT: MOJOSHADER_symbolType = 3;
pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_STRING: MOJOSHADER_symbolType = 4;
pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_TEXTURE: MOJOSHADER_symbolType = 5;
pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_TEXTURE1D: MOJOSHADER_symbolType = 6;
pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_TEXTURE2D: MOJOSHADER_symbolType = 7;
pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_TEXTURE3D: MOJOSHADER_symbolType = 8;
pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_TEXTURECUBE: MOJOSHADER_symbolType = 9;
pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_SAMPLER: MOJOSHADER_symbolType = 10;
pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_SAMPLER1D: MOJOSHADER_symbolType = 11;
pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_SAMPLER2D: MOJOSHADER_symbolType = 12;
pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_SAMPLER3D: MOJOSHADER_symbolType = 13;
pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_SAMPLERCUBE: MOJOSHADER_symbolType = 14;
pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_PIXELSHADER: MOJOSHADER_symbolType = 15;
pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_VERTEXSHADER: MOJOSHADER_symbolType = 16;
pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_PIXELFRAGMENT: MOJOSHADER_symbolType = 17;
pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_VERTEXFRAGMENT: MOJOSHADER_symbolType = 18;
pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_UNSUPPORTED: MOJOSHADER_symbolType = 19;
pub const MOJOSHADER_symbolType_MOJOSHADER_SYMTYPE_TOTAL: MOJOSHADER_symbolType = 20;
pub type MOJOSHADER_symbolType = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_symbolTypeInfo {
    pub parameter_class: MOJOSHADER_symbolClass,
    pub parameter_type: MOJOSHADER_symbolType,
    pub rows: ::std::os::raw::c_uint,
    pub columns: ::std::os::raw::c_uint,
    pub elements: ::std::os::raw::c_uint,
    pub member_count: ::std::os::raw::c_uint,
    pub members: *mut MOJOSHADER_symbolStructMember,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_symbolTypeInfo() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_symbolTypeInfo>(),
        32usize,
        concat!("Size of: ", stringify!(MOJOSHADER_symbolTypeInfo))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_symbolTypeInfo>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_symbolTypeInfo))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_symbolTypeInfo>())).parameter_class as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_symbolTypeInfo),
            "::",
            stringify!(parameter_class)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_symbolTypeInfo>())).parameter_type as *const _
                as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_symbolTypeInfo),
            "::",
            stringify!(parameter_type)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_symbolTypeInfo>())).rows as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_symbolTypeInfo),
            "::",
            stringify!(rows)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_symbolTypeInfo>())).columns as *const _ as usize
        },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_symbolTypeInfo),
            "::",
            stringify!(columns)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_symbolTypeInfo>())).elements as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_symbolTypeInfo),
            "::",
            stringify!(elements)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_symbolTypeInfo>())).member_count as *const _ as usize
        },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_symbolTypeInfo),
            "::",
            stringify!(member_count)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_symbolTypeInfo>())).members as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_symbolTypeInfo),
            "::",
            stringify!(members)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_symbolStructMember {
    pub name: *const ::std::os::raw::c_char,
    pub info: MOJOSHADER_symbolTypeInfo,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_symbolStructMember() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_symbolStructMember>(),
        40usize,
        concat!("Size of: ", stringify!(MOJOSHADER_symbolStructMember))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_symbolStructMember>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_symbolStructMember))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_symbolStructMember>())).name as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_symbolStructMember),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_symbolStructMember>())).info as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_symbolStructMember),
            "::",
            stringify!(info)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_symbol {
    pub name: *const ::std::os::raw::c_char,
    pub register_set: MOJOSHADER_symbolRegisterSet,
    pub register_index: ::std::os::raw::c_uint,
    pub register_count: ::std::os::raw::c_uint,
    pub info: MOJOSHADER_symbolTypeInfo,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_symbol() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_symbol>(),
        56usize,
        concat!("Size of: ", stringify!(MOJOSHADER_symbol))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_symbol>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_symbol))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_symbol>())).name as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_symbol),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_symbol>())).register_set as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_symbol),
            "::",
            stringify!(register_set)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_symbol>())).register_index as *const _ as usize
        },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_symbol),
            "::",
            stringify!(register_index)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_symbol>())).register_count as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_symbol),
            "::",
            stringify!(register_count)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_symbol>())).info as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_symbol),
            "::",
            stringify!(info)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_error {
    pub error: *const ::std::os::raw::c_char,
    pub filename: *const ::std::os::raw::c_char,
    pub error_position: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_error() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_error>(),
        24usize,
        concat!("Size of: ", stringify!(MOJOSHADER_error))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_error>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_error))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_error>())).error as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_error),
            "::",
            stringify!(error)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_error>())).filename as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_error),
            "::",
            stringify!(filename)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_error>())).error_position as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_error),
            "::",
            stringify!(error_position)
        )
    );
}
pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_NOP: MOJOSHADER_preshaderOpcode = 0;
pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_MOV: MOJOSHADER_preshaderOpcode = 1;
pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_NEG: MOJOSHADER_preshaderOpcode = 2;
pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_RCP: MOJOSHADER_preshaderOpcode = 3;
pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_FRC: MOJOSHADER_preshaderOpcode = 4;
pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_EXP: MOJOSHADER_preshaderOpcode = 5;
pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_LOG: MOJOSHADER_preshaderOpcode = 6;
pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_RSQ: MOJOSHADER_preshaderOpcode = 7;
pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_SIN: MOJOSHADER_preshaderOpcode = 8;
pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_COS: MOJOSHADER_preshaderOpcode = 9;
pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_ASIN: MOJOSHADER_preshaderOpcode = 10;
pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_ACOS: MOJOSHADER_preshaderOpcode = 11;
pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_ATAN: MOJOSHADER_preshaderOpcode = 12;
pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_MIN: MOJOSHADER_preshaderOpcode = 13;
pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_MAX: MOJOSHADER_preshaderOpcode = 14;
pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_LT: MOJOSHADER_preshaderOpcode = 15;
pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_GE: MOJOSHADER_preshaderOpcode = 16;
pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_ADD: MOJOSHADER_preshaderOpcode = 17;
pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_MUL: MOJOSHADER_preshaderOpcode = 18;
pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_ATAN2: MOJOSHADER_preshaderOpcode = 19;
pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_DIV: MOJOSHADER_preshaderOpcode = 20;
pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_CMP: MOJOSHADER_preshaderOpcode = 21;
pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_MOVC: MOJOSHADER_preshaderOpcode = 22;
pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_DOT: MOJOSHADER_preshaderOpcode = 23;
pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_NOISE: MOJOSHADER_preshaderOpcode = 24;
pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_SCALAR_OPS: MOJOSHADER_preshaderOpcode =
    25;
pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_MIN_SCALAR: MOJOSHADER_preshaderOpcode =
    25;
pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_MAX_SCALAR: MOJOSHADER_preshaderOpcode =
    26;
pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_LT_SCALAR: MOJOSHADER_preshaderOpcode =
    27;
pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_GE_SCALAR: MOJOSHADER_preshaderOpcode =
    28;
pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_ADD_SCALAR: MOJOSHADER_preshaderOpcode =
    29;
pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_MUL_SCALAR: MOJOSHADER_preshaderOpcode =
    30;
pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_ATAN2_SCALAR:
    MOJOSHADER_preshaderOpcode = 31;
pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_DIV_SCALAR: MOJOSHADER_preshaderOpcode =
    32;
pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_DOT_SCALAR: MOJOSHADER_preshaderOpcode =
    33;
pub const MOJOSHADER_preshaderOpcode_MOJOSHADER_PRESHADEROP_NOISE_SCALAR:
    MOJOSHADER_preshaderOpcode = 34;
pub type MOJOSHADER_preshaderOpcode = ::std::os::raw::c_uint;
pub const MOJOSHADER_preshaderOperandType_MOJOSHADER_PRESHADEROPERAND_INPUT:
    MOJOSHADER_preshaderOperandType = 0;
pub const MOJOSHADER_preshaderOperandType_MOJOSHADER_PRESHADEROPERAND_OUTPUT:
    MOJOSHADER_preshaderOperandType = 1;
pub const MOJOSHADER_preshaderOperandType_MOJOSHADER_PRESHADEROPERAND_LITERAL:
    MOJOSHADER_preshaderOperandType = 2;
pub const MOJOSHADER_preshaderOperandType_MOJOSHADER_PRESHADEROPERAND_TEMP:
    MOJOSHADER_preshaderOperandType = 3;
pub type MOJOSHADER_preshaderOperandType = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_preshaderOperand {
    pub type_: MOJOSHADER_preshaderOperandType,
    pub index: ::std::os::raw::c_uint,
    pub array_register_count: ::std::os::raw::c_uint,
    pub array_registers: *mut ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_preshaderOperand() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_preshaderOperand>(),
        24usize,
        concat!("Size of: ", stringify!(MOJOSHADER_preshaderOperand))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_preshaderOperand>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_preshaderOperand))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_preshaderOperand>())).type_ as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_preshaderOperand),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_preshaderOperand>())).index as *const _ as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_preshaderOperand),
            "::",
            stringify!(index)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_preshaderOperand>())).array_register_count as *const _
                as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_preshaderOperand),
            "::",
            stringify!(array_register_count)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_preshaderOperand>())).array_registers as *const _
                as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_preshaderOperand),
            "::",
            stringify!(array_registers)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_preshaderInstruction {
    pub opcode: MOJOSHADER_preshaderOpcode,
    pub element_count: ::std::os::raw::c_uint,
    pub operand_count: ::std::os::raw::c_uint,
    pub operands: [MOJOSHADER_preshaderOperand; 4usize],
}
#[test]
fn bindgen_test_layout_MOJOSHADER_preshaderInstruction() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_preshaderInstruction>(),
        112usize,
        concat!("Size of: ", stringify!(MOJOSHADER_preshaderInstruction))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_preshaderInstruction>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_preshaderInstruction))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_preshaderInstruction>())).opcode as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_preshaderInstruction),
            "::",
            stringify!(opcode)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_preshaderInstruction>())).element_count as *const _
                as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_preshaderInstruction),
            "::",
            stringify!(element_count)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_preshaderInstruction>())).operand_count as *const _
                as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_preshaderInstruction),
            "::",
            stringify!(operand_count)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_preshaderInstruction>())).operands as *const _
                as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_preshaderInstruction),
            "::",
            stringify!(operands)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_preshader {
    pub literal_count: ::std::os::raw::c_uint,
    pub literals: *mut f64,
    pub temp_count: ::std::os::raw::c_uint,
    pub symbol_count: ::std::os::raw::c_uint,
    pub symbols: *mut MOJOSHADER_symbol,
    pub instruction_count: ::std::os::raw::c_uint,
    pub instructions: *mut MOJOSHADER_preshaderInstruction,
    pub register_count: ::std::os::raw::c_uint,
    pub registers: *mut f32,
    pub malloc: MOJOSHADER_malloc,
    pub free: MOJOSHADER_free,
    pub malloc_data: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_preshader() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_preshader>(),
        88usize,
        concat!("Size of: ", stringify!(MOJOSHADER_preshader))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_preshader>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_preshader))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_preshader>())).literal_count as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_preshader),
            "::",
            stringify!(literal_count)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_preshader>())).literals as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_preshader),
            "::",
            stringify!(literals)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_preshader>())).temp_count as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_preshader),
            "::",
            stringify!(temp_count)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_preshader>())).symbol_count as *const _ as usize
        },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_preshader),
            "::",
            stringify!(symbol_count)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_preshader>())).symbols as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_preshader),
            "::",
            stringify!(symbols)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_preshader>())).instruction_count as *const _ as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_preshader),
            "::",
            stringify!(instruction_count)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_preshader>())).instructions as *const _ as usize
        },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_preshader),
            "::",
            stringify!(instructions)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_preshader>())).register_count as *const _ as usize
        },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_preshader),
            "::",
            stringify!(register_count)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_preshader>())).registers as *const _ as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_preshader),
            "::",
            stringify!(registers)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_preshader>())).malloc as *const _ as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_preshader),
            "::",
            stringify!(malloc)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_preshader>())).free as *const _ as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_preshader),
            "::",
            stringify!(free)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_preshader>())).malloc_data as *const _ as usize
        },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_preshader),
            "::",
            stringify!(malloc_data)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_parseData {
    pub error_count: ::std::os::raw::c_int,
    pub errors: *mut MOJOSHADER_error,
    pub profile: *const ::std::os::raw::c_char,
    pub output: *const ::std::os::raw::c_char,
    pub output_len: ::std::os::raw::c_int,
    pub instruction_count: ::std::os::raw::c_int,
    pub shader_type: MOJOSHADER_shaderType,
    pub major_ver: ::std::os::raw::c_int,
    pub minor_ver: ::std::os::raw::c_int,
    pub mainfn: *const ::std::os::raw::c_char,
    pub uniform_count: ::std::os::raw::c_int,
    pub uniforms: *mut MOJOSHADER_uniform,
    pub constant_count: ::std::os::raw::c_int,
    pub constants: *mut MOJOSHADER_constant,
    pub sampler_count: ::std::os::raw::c_int,
    pub samplers: *mut MOJOSHADER_sampler,
    pub attribute_count: ::std::os::raw::c_int,
    pub attributes: *mut MOJOSHADER_attribute,
    pub output_count: ::std::os::raw::c_int,
    pub outputs: *mut MOJOSHADER_attribute,
    pub swizzle_count: ::std::os::raw::c_int,
    pub swizzles: *mut MOJOSHADER_swizzle,
    pub symbol_count: ::std::os::raw::c_int,
    pub symbols: *mut MOJOSHADER_symbol,
    pub preshader: *mut MOJOSHADER_preshader,
    pub malloc: MOJOSHADER_malloc,
    pub free: MOJOSHADER_free,
    pub malloc_data: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_parseData() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_parseData>(),
        208usize,
        concat!("Size of: ", stringify!(MOJOSHADER_parseData))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_parseData>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_parseData))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_parseData>())).error_count as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_parseData),
            "::",
            stringify!(error_count)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_parseData>())).errors as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_parseData),
            "::",
            stringify!(errors)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_parseData>())).profile as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_parseData),
            "::",
            stringify!(profile)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_parseData>())).output as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_parseData),
            "::",
            stringify!(output)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_parseData>())).output_len as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_parseData),
            "::",
            stringify!(output_len)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_parseData>())).instruction_count as *const _ as usize
        },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_parseData),
            "::",
            stringify!(instruction_count)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_parseData>())).shader_type as *const _ as usize
        },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_parseData),
            "::",
            stringify!(shader_type)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_parseData>())).major_ver as *const _ as usize },
        44usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_parseData),
            "::",
            stringify!(major_ver)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_parseData>())).minor_ver as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_parseData),
            "::",
            stringify!(minor_ver)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_parseData>())).mainfn as *const _ as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_parseData),
            "::",
            stringify!(mainfn)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_parseData>())).uniform_count as *const _ as usize
        },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_parseData),
            "::",
            stringify!(uniform_count)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_parseData>())).uniforms as *const _ as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_parseData),
            "::",
            stringify!(uniforms)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_parseData>())).constant_count as *const _ as usize
        },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_parseData),
            "::",
            stringify!(constant_count)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_parseData>())).constants as *const _ as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_parseData),
            "::",
            stringify!(constants)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_parseData>())).sampler_count as *const _ as usize
        },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_parseData),
            "::",
            stringify!(sampler_count)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_parseData>())).samplers as *const _ as usize },
        104usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_parseData),
            "::",
            stringify!(samplers)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_parseData>())).attribute_count as *const _ as usize
        },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_parseData),
            "::",
            stringify!(attribute_count)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_parseData>())).attributes as *const _ as usize },
        120usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_parseData),
            "::",
            stringify!(attributes)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_parseData>())).output_count as *const _ as usize
        },
        128usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_parseData),
            "::",
            stringify!(output_count)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_parseData>())).outputs as *const _ as usize },
        136usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_parseData),
            "::",
            stringify!(outputs)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_parseData>())).swizzle_count as *const _ as usize
        },
        144usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_parseData),
            "::",
            stringify!(swizzle_count)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_parseData>())).swizzles as *const _ as usize },
        152usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_parseData),
            "::",
            stringify!(swizzles)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_parseData>())).symbol_count as *const _ as usize
        },
        160usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_parseData),
            "::",
            stringify!(symbol_count)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_parseData>())).symbols as *const _ as usize },
        168usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_parseData),
            "::",
            stringify!(symbols)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_parseData>())).preshader as *const _ as usize },
        176usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_parseData),
            "::",
            stringify!(preshader)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_parseData>())).malloc as *const _ as usize },
        184usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_parseData),
            "::",
            stringify!(malloc)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_parseData>())).free as *const _ as usize },
        192usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_parseData),
            "::",
            stringify!(free)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_parseData>())).malloc_data as *const _ as usize
        },
        200usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_parseData),
            "::",
            stringify!(malloc_data)
        )
    );
}
extern "C" {
    pub fn MOJOSHADER_maxShaderModel(
        profile: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn MOJOSHADER_parse(
        profile: *const ::std::os::raw::c_char,
        mainfn: *const ::std::os::raw::c_char,
        tokenbuf: *const ::std::os::raw::c_uchar,
        bufsize: ::std::os::raw::c_uint,
        swiz: *const MOJOSHADER_swizzle,
        swizcount: ::std::os::raw::c_uint,
        smap: *const MOJOSHADER_samplerMap,
        smapcount: ::std::os::raw::c_uint,
        m: MOJOSHADER_malloc,
        f: MOJOSHADER_free,
        d: *mut ::std::os::raw::c_void,
    ) -> *const MOJOSHADER_parseData;
}
extern "C" {
    pub fn MOJOSHADER_freeParseData(data: *const MOJOSHADER_parseData);
}
extern "C" {
    pub fn MOJOSHADER_parsePreshader(
        buf: *const ::std::os::raw::c_uchar,
        len: ::std::os::raw::c_uint,
        m: MOJOSHADER_malloc,
        f: MOJOSHADER_free,
        d: *mut ::std::os::raw::c_void,
    ) -> *const MOJOSHADER_preshader;
}
extern "C" {
    pub fn MOJOSHADER_freePreshader(preshader: *const MOJOSHADER_preshader);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_preprocessorDefine {
    pub identifier: *const ::std::os::raw::c_char,
    pub definition: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_preprocessorDefine() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_preprocessorDefine>(),
        16usize,
        concat!("Size of: ", stringify!(MOJOSHADER_preprocessorDefine))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_preprocessorDefine>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_preprocessorDefine))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_preprocessorDefine>())).identifier as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_preprocessorDefine),
            "::",
            stringify!(identifier)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_preprocessorDefine>())).definition as *const _
                as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_preprocessorDefine),
            "::",
            stringify!(definition)
        )
    );
}
pub const MOJOSHADER_includeType_MOJOSHADER_INCLUDETYPE_LOCAL: MOJOSHADER_includeType = 0;
pub const MOJOSHADER_includeType_MOJOSHADER_INCLUDETYPE_SYSTEM: MOJOSHADER_includeType = 1;
pub type MOJOSHADER_includeType = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_preprocessData {
    pub error_count: ::std::os::raw::c_int,
    pub errors: *mut MOJOSHADER_error,
    pub output: *const ::std::os::raw::c_char,
    pub output_len: ::std::os::raw::c_int,
    pub malloc: MOJOSHADER_malloc,
    pub free: MOJOSHADER_free,
    pub malloc_data: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_preprocessData() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_preprocessData>(),
        56usize,
        concat!("Size of: ", stringify!(MOJOSHADER_preprocessData))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_preprocessData>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_preprocessData))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_preprocessData>())).error_count as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_preprocessData),
            "::",
            stringify!(error_count)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_preprocessData>())).errors as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_preprocessData),
            "::",
            stringify!(errors)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_preprocessData>())).output as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_preprocessData),
            "::",
            stringify!(output)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_preprocessData>())).output_len as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_preprocessData),
            "::",
            stringify!(output_len)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_preprocessData>())).malloc as *const _ as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_preprocessData),
            "::",
            stringify!(malloc)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_preprocessData>())).free as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_preprocessData),
            "::",
            stringify!(free)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_preprocessData>())).malloc_data as *const _ as usize
        },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_preprocessData),
            "::",
            stringify!(malloc_data)
        )
    );
}
pub type MOJOSHADER_includeOpen = ::std::option::Option<
    unsafe extern "C" fn(
        inctype: MOJOSHADER_includeType,
        fname: *const ::std::os::raw::c_char,
        parent: *const ::std::os::raw::c_char,
        outdata: *mut *const ::std::os::raw::c_char,
        outbytes: *mut ::std::os::raw::c_uint,
        m: MOJOSHADER_malloc,
        f: MOJOSHADER_free,
        d: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int,
>;
pub type MOJOSHADER_includeClose = ::std::option::Option<
    unsafe extern "C" fn(
        data: *const ::std::os::raw::c_char,
        m: MOJOSHADER_malloc,
        f: MOJOSHADER_free,
        d: *mut ::std::os::raw::c_void,
    ),
>;
extern "C" {
    pub fn MOJOSHADER_preprocess(
        filename: *const ::std::os::raw::c_char,
        source: *const ::std::os::raw::c_char,
        sourcelen: ::std::os::raw::c_uint,
        defines: *const MOJOSHADER_preprocessorDefine,
        define_count: ::std::os::raw::c_uint,
        include_open: MOJOSHADER_includeOpen,
        include_close: MOJOSHADER_includeClose,
        m: MOJOSHADER_malloc,
        f: MOJOSHADER_free,
        d: *mut ::std::os::raw::c_void,
    ) -> *const MOJOSHADER_preprocessData;
}
extern "C" {
    pub fn MOJOSHADER_freePreprocessData(data: *const MOJOSHADER_preprocessData);
}
extern "C" {
    pub fn MOJOSHADER_assemble(
        filename: *const ::std::os::raw::c_char,
        source: *const ::std::os::raw::c_char,
        sourcelen: ::std::os::raw::c_uint,
        comments: *mut *const ::std::os::raw::c_char,
        comment_count: ::std::os::raw::c_uint,
        symbols: *const MOJOSHADER_symbol,
        symbol_count: ::std::os::raw::c_uint,
        defines: *const MOJOSHADER_preprocessorDefine,
        define_count: ::std::os::raw::c_uint,
        include_open: MOJOSHADER_includeOpen,
        include_close: MOJOSHADER_includeClose,
        m: MOJOSHADER_malloc,
        f: MOJOSHADER_free,
        d: *mut ::std::os::raw::c_void,
    ) -> *const MOJOSHADER_parseData;
}
pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_NONE: MOJOSHADER_astDataTypeType = 0;
pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_BOOL: MOJOSHADER_astDataTypeType = 1;
pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_INT: MOJOSHADER_astDataTypeType = 2;
pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_UINT: MOJOSHADER_astDataTypeType = 3;
pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_FLOAT: MOJOSHADER_astDataTypeType = 4;
pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_FLOAT_SNORM:
    MOJOSHADER_astDataTypeType = 5;
pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_FLOAT_UNORM:
    MOJOSHADER_astDataTypeType = 6;
pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_HALF: MOJOSHADER_astDataTypeType = 7;
pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_DOUBLE: MOJOSHADER_astDataTypeType = 8;
pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_STRING: MOJOSHADER_astDataTypeType = 9;
pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_SAMPLER_1D:
    MOJOSHADER_astDataTypeType = 10;
pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_SAMPLER_2D:
    MOJOSHADER_astDataTypeType = 11;
pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_SAMPLER_3D:
    MOJOSHADER_astDataTypeType = 12;
pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_SAMPLER_CUBE:
    MOJOSHADER_astDataTypeType = 13;
pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_SAMPLER_STATE:
    MOJOSHADER_astDataTypeType = 14;
pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_SAMPLER_COMPARISON_STATE:
    MOJOSHADER_astDataTypeType = 15;
pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_STRUCT: MOJOSHADER_astDataTypeType =
    16;
pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_ARRAY: MOJOSHADER_astDataTypeType = 17;
pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_VECTOR: MOJOSHADER_astDataTypeType =
    18;
pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_MATRIX: MOJOSHADER_astDataTypeType =
    19;
pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_BUFFER: MOJOSHADER_astDataTypeType =
    20;
pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_FUNCTION: MOJOSHADER_astDataTypeType =
    21;
pub const MOJOSHADER_astDataTypeType_MOJOSHADER_AST_DATATYPE_USER: MOJOSHADER_astDataTypeType = 22;
pub type MOJOSHADER_astDataTypeType = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astDataTypeStructMember {
    pub datatype: *const MOJOSHADER_astDataType,
    pub identifier: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astDataTypeStructMember() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astDataTypeStructMember>(),
        16usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astDataTypeStructMember))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astDataTypeStructMember>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(MOJOSHADER_astDataTypeStructMember)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astDataTypeStructMember>())).datatype as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astDataTypeStructMember),
            "::",
            stringify!(datatype)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astDataTypeStructMember>())).identifier as *const _
                as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astDataTypeStructMember),
            "::",
            stringify!(identifier)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astDataTypeStruct {
    pub type_: MOJOSHADER_astDataTypeType,
    pub members: *const MOJOSHADER_astDataTypeStructMember,
    pub member_count: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astDataTypeStruct() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astDataTypeStruct>(),
        24usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astDataTypeStruct))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astDataTypeStruct>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_astDataTypeStruct))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astDataTypeStruct>())).type_ as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astDataTypeStruct),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astDataTypeStruct>())).members as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astDataTypeStruct),
            "::",
            stringify!(members)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astDataTypeStruct>())).member_count as *const _
                as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astDataTypeStruct),
            "::",
            stringify!(member_count)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astDataTypeArray {
    pub type_: MOJOSHADER_astDataTypeType,
    pub base: *const MOJOSHADER_astDataType,
    pub elements: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astDataTypeArray() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astDataTypeArray>(),
        24usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astDataTypeArray))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astDataTypeArray>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_astDataTypeArray))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astDataTypeArray>())).type_ as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astDataTypeArray),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astDataTypeArray>())).base as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astDataTypeArray),
            "::",
            stringify!(base)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astDataTypeArray>())).elements as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astDataTypeArray),
            "::",
            stringify!(elements)
        )
    );
}
pub type MOJOSHADER_astDataTypeVector = MOJOSHADER_astDataTypeArray;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astDataTypeMatrix {
    pub type_: MOJOSHADER_astDataTypeType,
    pub base: *const MOJOSHADER_astDataType,
    pub rows: ::std::os::raw::c_int,
    pub columns: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astDataTypeMatrix() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astDataTypeMatrix>(),
        24usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astDataTypeMatrix))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astDataTypeMatrix>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_astDataTypeMatrix))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astDataTypeMatrix>())).type_ as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astDataTypeMatrix),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astDataTypeMatrix>())).base as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astDataTypeMatrix),
            "::",
            stringify!(base)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astDataTypeMatrix>())).rows as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astDataTypeMatrix),
            "::",
            stringify!(rows)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astDataTypeMatrix>())).columns as *const _ as usize
        },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astDataTypeMatrix),
            "::",
            stringify!(columns)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astDataTypeBuffer {
    pub type_: MOJOSHADER_astDataTypeType,
    pub base: *const MOJOSHADER_astDataType,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astDataTypeBuffer() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astDataTypeBuffer>(),
        16usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astDataTypeBuffer))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astDataTypeBuffer>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_astDataTypeBuffer))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astDataTypeBuffer>())).type_ as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astDataTypeBuffer),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astDataTypeBuffer>())).base as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astDataTypeBuffer),
            "::",
            stringify!(base)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astDataTypeFunction {
    pub type_: MOJOSHADER_astDataTypeType,
    pub retval: *const MOJOSHADER_astDataType,
    pub params: *mut *const MOJOSHADER_astDataType,
    pub num_params: ::std::os::raw::c_int,
    pub intrinsic: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astDataTypeFunction() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astDataTypeFunction>(),
        32usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astDataTypeFunction))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astDataTypeFunction>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_astDataTypeFunction))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astDataTypeFunction>())).type_ as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astDataTypeFunction),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astDataTypeFunction>())).retval as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astDataTypeFunction),
            "::",
            stringify!(retval)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astDataTypeFunction>())).params as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astDataTypeFunction),
            "::",
            stringify!(params)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astDataTypeFunction>())).num_params as *const _
                as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astDataTypeFunction),
            "::",
            stringify!(num_params)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astDataTypeFunction>())).intrinsic as *const _
                as usize
        },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astDataTypeFunction),
            "::",
            stringify!(intrinsic)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astDataTypeUser {
    pub type_: MOJOSHADER_astDataTypeType,
    pub details: *const MOJOSHADER_astDataType,
    pub name: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astDataTypeUser() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astDataTypeUser>(),
        24usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astDataTypeUser))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astDataTypeUser>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_astDataTypeUser))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astDataTypeUser>())).type_ as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astDataTypeUser),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astDataTypeUser>())).details as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astDataTypeUser),
            "::",
            stringify!(details)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astDataTypeUser>())).name as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astDataTypeUser),
            "::",
            stringify!(name)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union MOJOSHADER_astDataType {
    pub type_: MOJOSHADER_astDataTypeType,
    pub array: MOJOSHADER_astDataTypeArray,
    pub structure: MOJOSHADER_astDataTypeStruct,
    pub vector: MOJOSHADER_astDataTypeVector,
    pub matrix: MOJOSHADER_astDataTypeMatrix,
    pub buffer: MOJOSHADER_astDataTypeBuffer,
    pub user: MOJOSHADER_astDataTypeUser,
    pub function: MOJOSHADER_astDataTypeFunction,
    _bindgen_union_align: [u64; 4usize],
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astDataType() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astDataType>(),
        32usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astDataType))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astDataType>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_astDataType))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astDataType>())).type_ as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astDataType),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astDataType>())).array as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astDataType),
            "::",
            stringify!(array)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astDataType>())).structure as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astDataType),
            "::",
            stringify!(structure)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astDataType>())).vector as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astDataType),
            "::",
            stringify!(vector)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astDataType>())).matrix as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astDataType),
            "::",
            stringify!(matrix)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astDataType>())).buffer as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astDataType),
            "::",
            stringify!(buffer)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astDataType>())).user as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astDataType),
            "::",
            stringify!(user)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astDataType>())).function as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astDataType),
            "::",
            stringify!(function)
        )
    );
}
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_START_RANGE: MOJOSHADER_astNodeType = 0;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_START_RANGE_UNARY: MOJOSHADER_astNodeType = 1;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_PREINCREMENT: MOJOSHADER_astNodeType = 2;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_PREDECREMENT: MOJOSHADER_astNodeType = 3;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_NEGATE: MOJOSHADER_astNodeType = 4;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_COMPLEMENT: MOJOSHADER_astNodeType = 5;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_NOT: MOJOSHADER_astNodeType = 6;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_POSTINCREMENT: MOJOSHADER_astNodeType = 7;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_POSTDECREMENT: MOJOSHADER_astNodeType = 8;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_CAST: MOJOSHADER_astNodeType = 9;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_END_RANGE_UNARY: MOJOSHADER_astNodeType = 10;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_START_RANGE_BINARY: MOJOSHADER_astNodeType = 11;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_COMMA: MOJOSHADER_astNodeType = 12;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_MULTIPLY: MOJOSHADER_astNodeType = 13;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_DIVIDE: MOJOSHADER_astNodeType = 14;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_MODULO: MOJOSHADER_astNodeType = 15;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_ADD: MOJOSHADER_astNodeType = 16;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_SUBTRACT: MOJOSHADER_astNodeType = 17;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_LSHIFT: MOJOSHADER_astNodeType = 18;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_RSHIFT: MOJOSHADER_astNodeType = 19;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_LESSTHAN: MOJOSHADER_astNodeType = 20;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_GREATERTHAN: MOJOSHADER_astNodeType = 21;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_LESSTHANOREQUAL: MOJOSHADER_astNodeType = 22;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_GREATERTHANOREQUAL: MOJOSHADER_astNodeType = 23;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_EQUAL: MOJOSHADER_astNodeType = 24;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_NOTEQUAL: MOJOSHADER_astNodeType = 25;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_BINARYAND: MOJOSHADER_astNodeType = 26;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_BINARYXOR: MOJOSHADER_astNodeType = 27;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_BINARYOR: MOJOSHADER_astNodeType = 28;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_LOGICALAND: MOJOSHADER_astNodeType = 29;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_LOGICALOR: MOJOSHADER_astNodeType = 30;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_ASSIGN: MOJOSHADER_astNodeType = 31;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_MULASSIGN: MOJOSHADER_astNodeType = 32;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_DIVASSIGN: MOJOSHADER_astNodeType = 33;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_MODASSIGN: MOJOSHADER_astNodeType = 34;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_ADDASSIGN: MOJOSHADER_astNodeType = 35;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_SUBASSIGN: MOJOSHADER_astNodeType = 36;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_LSHIFTASSIGN: MOJOSHADER_astNodeType = 37;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_RSHIFTASSIGN: MOJOSHADER_astNodeType = 38;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_ANDASSIGN: MOJOSHADER_astNodeType = 39;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_XORASSIGN: MOJOSHADER_astNodeType = 40;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_ORASSIGN: MOJOSHADER_astNodeType = 41;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_DEREF_ARRAY: MOJOSHADER_astNodeType = 42;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_END_RANGE_BINARY: MOJOSHADER_astNodeType = 43;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_START_RANGE_TERNARY: MOJOSHADER_astNodeType = 44;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_CONDITIONAL: MOJOSHADER_astNodeType = 45;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_END_RANGE_TERNARY: MOJOSHADER_astNodeType = 46;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_START_RANGE_DATA: MOJOSHADER_astNodeType = 47;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_IDENTIFIER: MOJOSHADER_astNodeType = 48;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_INT_LITERAL: MOJOSHADER_astNodeType = 49;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_FLOAT_LITERAL: MOJOSHADER_astNodeType = 50;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_STRING_LITERAL: MOJOSHADER_astNodeType = 51;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_BOOLEAN_LITERAL: MOJOSHADER_astNodeType = 52;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_END_RANGE_DATA: MOJOSHADER_astNodeType = 53;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_START_RANGE_MISC: MOJOSHADER_astNodeType = 54;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_DEREF_STRUCT: MOJOSHADER_astNodeType = 55;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_CALLFUNC: MOJOSHADER_astNodeType = 56;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_CONSTRUCTOR: MOJOSHADER_astNodeType = 57;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_END_RANGE_MISC: MOJOSHADER_astNodeType = 58;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_OP_END_RANGE: MOJOSHADER_astNodeType = 59;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_COMPUNIT_START_RANGE: MOJOSHADER_astNodeType = 60;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_COMPUNIT_FUNCTION: MOJOSHADER_astNodeType = 61;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_COMPUNIT_TYPEDEF: MOJOSHADER_astNodeType = 62;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_COMPUNIT_STRUCT: MOJOSHADER_astNodeType = 63;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_COMPUNIT_VARIABLE: MOJOSHADER_astNodeType = 64;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_COMPUNIT_END_RANGE: MOJOSHADER_astNodeType = 65;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_STATEMENT_START_RANGE: MOJOSHADER_astNodeType = 66;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_STATEMENT_EMPTY: MOJOSHADER_astNodeType = 67;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_STATEMENT_BREAK: MOJOSHADER_astNodeType = 68;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_STATEMENT_CONTINUE: MOJOSHADER_astNodeType = 69;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_STATEMENT_DISCARD: MOJOSHADER_astNodeType = 70;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_STATEMENT_BLOCK: MOJOSHADER_astNodeType = 71;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_STATEMENT_EXPRESSION: MOJOSHADER_astNodeType = 72;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_STATEMENT_IF: MOJOSHADER_astNodeType = 73;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_STATEMENT_SWITCH: MOJOSHADER_astNodeType = 74;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_STATEMENT_FOR: MOJOSHADER_astNodeType = 75;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_STATEMENT_DO: MOJOSHADER_astNodeType = 76;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_STATEMENT_WHILE: MOJOSHADER_astNodeType = 77;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_STATEMENT_RETURN: MOJOSHADER_astNodeType = 78;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_STATEMENT_TYPEDEF: MOJOSHADER_astNodeType = 79;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_STATEMENT_STRUCT: MOJOSHADER_astNodeType = 80;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_STATEMENT_VARDECL: MOJOSHADER_astNodeType = 81;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_STATEMENT_END_RANGE: MOJOSHADER_astNodeType = 82;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_MISC_START_RANGE: MOJOSHADER_astNodeType = 83;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_FUNCTION_PARAMS: MOJOSHADER_astNodeType = 84;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_FUNCTION_SIGNATURE: MOJOSHADER_astNodeType = 85;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_SCALAR_OR_ARRAY: MOJOSHADER_astNodeType = 86;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_TYPEDEF: MOJOSHADER_astNodeType = 87;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_PACK_OFFSET: MOJOSHADER_astNodeType = 88;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_VARIABLE_LOWLEVEL: MOJOSHADER_astNodeType = 89;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_ANNOTATION: MOJOSHADER_astNodeType = 90;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_VARIABLE_DECLARATION: MOJOSHADER_astNodeType = 91;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_STRUCT_DECLARATION: MOJOSHADER_astNodeType = 92;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_STRUCT_MEMBER: MOJOSHADER_astNodeType = 93;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_SWITCH_CASE: MOJOSHADER_astNodeType = 94;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_ARGUMENTS: MOJOSHADER_astNodeType = 95;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_MISC_END_RANGE: MOJOSHADER_astNodeType = 96;
pub const MOJOSHADER_astNodeType_MOJOSHADER_AST_END_RANGE: MOJOSHADER_astNodeType = 97;
pub type MOJOSHADER_astNodeType = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astNodeInfo {
    pub type_: MOJOSHADER_astNodeType,
    pub filename: *const ::std::os::raw::c_char,
    pub line: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astNodeInfo() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astNodeInfo>(),
        24usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astNodeInfo))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astNodeInfo>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_astNodeInfo))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNodeInfo>())).type_ as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNodeInfo),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNodeInfo>())).filename as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNodeInfo),
            "::",
            stringify!(filename)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNodeInfo>())).line as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNodeInfo),
            "::",
            stringify!(line)
        )
    );
}
pub const MOJOSHADER_astVariableAttributes_MOJOSHADER_AST_VARATTR_EXTERN:
    MOJOSHADER_astVariableAttributes = 1;
pub const MOJOSHADER_astVariableAttributes_MOJOSHADER_AST_VARATTR_NOINTERPOLATION:
    MOJOSHADER_astVariableAttributes = 2;
pub const MOJOSHADER_astVariableAttributes_MOJOSHADER_AST_VARATTR_SHARED:
    MOJOSHADER_astVariableAttributes = 4;
pub const MOJOSHADER_astVariableAttributes_MOJOSHADER_AST_VARATTR_STATIC:
    MOJOSHADER_astVariableAttributes = 8;
pub const MOJOSHADER_astVariableAttributes_MOJOSHADER_AST_VARATTR_UNIFORM:
    MOJOSHADER_astVariableAttributes = 16;
pub const MOJOSHADER_astVariableAttributes_MOJOSHADER_AST_VARATTR_VOLATILE:
    MOJOSHADER_astVariableAttributes = 32;
pub const MOJOSHADER_astVariableAttributes_MOJOSHADER_AST_VARATTR_CONST:
    MOJOSHADER_astVariableAttributes = 64;
pub const MOJOSHADER_astVariableAttributes_MOJOSHADER_AST_VARATTR_ROWMAJOR:
    MOJOSHADER_astVariableAttributes = 128;
pub const MOJOSHADER_astVariableAttributes_MOJOSHADER_AST_VARATTR_COLUMNMAJOR:
    MOJOSHADER_astVariableAttributes = 256;
pub type MOJOSHADER_astVariableAttributes = ::std::os::raw::c_uint;
pub const MOJOSHADER_astIfAttributes_MOJOSHADER_AST_IFATTR_NONE: MOJOSHADER_astIfAttributes = 0;
pub const MOJOSHADER_astIfAttributes_MOJOSHADER_AST_IFATTR_BRANCH: MOJOSHADER_astIfAttributes = 1;
pub const MOJOSHADER_astIfAttributes_MOJOSHADER_AST_IFATTR_FLATTEN: MOJOSHADER_astIfAttributes = 2;
pub const MOJOSHADER_astIfAttributes_MOJOSHADER_AST_IFATTR_IFALL: MOJOSHADER_astIfAttributes = 3;
pub const MOJOSHADER_astIfAttributes_MOJOSHADER_AST_IFATTR_IFANY: MOJOSHADER_astIfAttributes = 4;
pub const MOJOSHADER_astIfAttributes_MOJOSHADER_AST_IFATTR_PREDICATE: MOJOSHADER_astIfAttributes =
    5;
pub const MOJOSHADER_astIfAttributes_MOJOSHADER_AST_IFATTR_PREDICATEBLOCK:
    MOJOSHADER_astIfAttributes = 6;
pub type MOJOSHADER_astIfAttributes = ::std::os::raw::c_uint;
pub const MOJOSHADER_astSwitchAttributes_MOJOSHADER_AST_SWITCHATTR_NONE:
    MOJOSHADER_astSwitchAttributes = 0;
pub const MOJOSHADER_astSwitchAttributes_MOJOSHADER_AST_SWITCHATTR_FLATTEN:
    MOJOSHADER_astSwitchAttributes = 1;
pub const MOJOSHADER_astSwitchAttributes_MOJOSHADER_AST_SWITCHATTR_BRANCH:
    MOJOSHADER_astSwitchAttributes = 2;
pub const MOJOSHADER_astSwitchAttributes_MOJOSHADER_AST_SWITCHATTR_FORCECASE:
    MOJOSHADER_astSwitchAttributes = 3;
pub const MOJOSHADER_astSwitchAttributes_MOJOSHADER_AST_SWITCHATTR_CALL:
    MOJOSHADER_astSwitchAttributes = 4;
pub type MOJOSHADER_astSwitchAttributes = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astGeneric {
    pub ast: MOJOSHADER_astNodeInfo,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astGeneric() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astGeneric>(),
        24usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astGeneric))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astGeneric>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_astGeneric))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astGeneric>())).ast as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astGeneric),
            "::",
            stringify!(ast)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astExpression {
    pub ast: MOJOSHADER_astNodeInfo,
    pub datatype: *const MOJOSHADER_astDataType,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astExpression() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astExpression>(),
        32usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astExpression))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astExpression>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_astExpression))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astExpression>())).ast as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpression),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpression>())).datatype as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpression),
            "::",
            stringify!(datatype)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astArguments {
    pub ast: MOJOSHADER_astNodeInfo,
    pub argument: *mut MOJOSHADER_astExpression,
    pub next: *mut MOJOSHADER_astArguments,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astArguments() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astArguments>(),
        40usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astArguments))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astArguments>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_astArguments))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astArguments>())).ast as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astArguments),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astArguments>())).argument as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astArguments),
            "::",
            stringify!(argument)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astArguments>())).next as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astArguments),
            "::",
            stringify!(next)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astExpressionUnary {
    pub ast: MOJOSHADER_astNodeInfo,
    pub datatype: *const MOJOSHADER_astDataType,
    pub operand: *mut MOJOSHADER_astExpression,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astExpressionUnary() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astExpressionUnary>(),
        40usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astExpressionUnary))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astExpressionUnary>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_astExpressionUnary))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionUnary>())).ast as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionUnary),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionUnary>())).datatype as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionUnary),
            "::",
            stringify!(datatype)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionUnary>())).operand as *const _ as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionUnary),
            "::",
            stringify!(operand)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astExpressionBinary {
    pub ast: MOJOSHADER_astNodeInfo,
    pub datatype: *const MOJOSHADER_astDataType,
    pub left: *mut MOJOSHADER_astExpression,
    pub right: *mut MOJOSHADER_astExpression,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astExpressionBinary() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astExpressionBinary>(),
        48usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astExpressionBinary))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astExpressionBinary>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_astExpressionBinary))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionBinary>())).ast as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionBinary),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionBinary>())).datatype as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionBinary),
            "::",
            stringify!(datatype)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionBinary>())).left as *const _ as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionBinary),
            "::",
            stringify!(left)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionBinary>())).right as *const _ as usize
        },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionBinary),
            "::",
            stringify!(right)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astExpressionTernary {
    pub ast: MOJOSHADER_astNodeInfo,
    pub datatype: *const MOJOSHADER_astDataType,
    pub left: *mut MOJOSHADER_astExpression,
    pub center: *mut MOJOSHADER_astExpression,
    pub right: *mut MOJOSHADER_astExpression,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astExpressionTernary() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astExpressionTernary>(),
        56usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astExpressionTernary))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astExpressionTernary>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_astExpressionTernary))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionTernary>())).ast as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionTernary),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionTernary>())).datatype as *const _
                as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionTernary),
            "::",
            stringify!(datatype)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionTernary>())).left as *const _ as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionTernary),
            "::",
            stringify!(left)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionTernary>())).center as *const _ as usize
        },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionTernary),
            "::",
            stringify!(center)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionTernary>())).right as *const _ as usize
        },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionTernary),
            "::",
            stringify!(right)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astExpressionIdentifier {
    pub ast: MOJOSHADER_astNodeInfo,
    pub datatype: *const MOJOSHADER_astDataType,
    pub identifier: *const ::std::os::raw::c_char,
    pub index: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astExpressionIdentifier() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astExpressionIdentifier>(),
        48usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astExpressionIdentifier))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astExpressionIdentifier>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(MOJOSHADER_astExpressionIdentifier)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionIdentifier>())).ast as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionIdentifier),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionIdentifier>())).datatype as *const _
                as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionIdentifier),
            "::",
            stringify!(datatype)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionIdentifier>())).identifier as *const _
                as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionIdentifier),
            "::",
            stringify!(identifier)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionIdentifier>())).index as *const _
                as usize
        },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionIdentifier),
            "::",
            stringify!(index)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astExpressionIntLiteral {
    pub ast: MOJOSHADER_astNodeInfo,
    pub datatype: *const MOJOSHADER_astDataType,
    pub value: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astExpressionIntLiteral() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astExpressionIntLiteral>(),
        40usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astExpressionIntLiteral))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astExpressionIntLiteral>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(MOJOSHADER_astExpressionIntLiteral)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionIntLiteral>())).ast as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionIntLiteral),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionIntLiteral>())).datatype as *const _
                as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionIntLiteral),
            "::",
            stringify!(datatype)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionIntLiteral>())).value as *const _
                as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionIntLiteral),
            "::",
            stringify!(value)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astExpressionFloatLiteral {
    pub ast: MOJOSHADER_astNodeInfo,
    pub datatype: *const MOJOSHADER_astDataType,
    pub value: f64,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astExpressionFloatLiteral() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astExpressionFloatLiteral>(),
        40usize,
        concat!(
            "Size of: ",
            stringify!(MOJOSHADER_astExpressionFloatLiteral)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astExpressionFloatLiteral>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(MOJOSHADER_astExpressionFloatLiteral)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionFloatLiteral>())).ast as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionFloatLiteral),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionFloatLiteral>())).datatype as *const _
                as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionFloatLiteral),
            "::",
            stringify!(datatype)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionFloatLiteral>())).value as *const _
                as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionFloatLiteral),
            "::",
            stringify!(value)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astExpressionStringLiteral {
    pub ast: MOJOSHADER_astNodeInfo,
    pub datatype: *const MOJOSHADER_astDataType,
    pub string: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astExpressionStringLiteral() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astExpressionStringLiteral>(),
        40usize,
        concat!(
            "Size of: ",
            stringify!(MOJOSHADER_astExpressionStringLiteral)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astExpressionStringLiteral>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(MOJOSHADER_astExpressionStringLiteral)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionStringLiteral>())).ast as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionStringLiteral),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionStringLiteral>())).datatype as *const _
                as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionStringLiteral),
            "::",
            stringify!(datatype)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionStringLiteral>())).string as *const _
                as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionStringLiteral),
            "::",
            stringify!(string)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astExpressionBooleanLiteral {
    pub ast: MOJOSHADER_astNodeInfo,
    pub datatype: *const MOJOSHADER_astDataType,
    pub value: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astExpressionBooleanLiteral() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astExpressionBooleanLiteral>(),
        40usize,
        concat!(
            "Size of: ",
            stringify!(MOJOSHADER_astExpressionBooleanLiteral)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astExpressionBooleanLiteral>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(MOJOSHADER_astExpressionBooleanLiteral)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionBooleanLiteral>())).ast as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionBooleanLiteral),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionBooleanLiteral>())).datatype as *const _
                as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionBooleanLiteral),
            "::",
            stringify!(datatype)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionBooleanLiteral>())).value as *const _
                as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionBooleanLiteral),
            "::",
            stringify!(value)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astExpressionConstructor {
    pub ast: MOJOSHADER_astNodeInfo,
    pub datatype: *const MOJOSHADER_astDataType,
    pub args: *mut MOJOSHADER_astArguments,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astExpressionConstructor() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astExpressionConstructor>(),
        40usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astExpressionConstructor))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astExpressionConstructor>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(MOJOSHADER_astExpressionConstructor)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionConstructor>())).ast as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionConstructor),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionConstructor>())).datatype as *const _
                as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionConstructor),
            "::",
            stringify!(datatype)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionConstructor>())).args as *const _
                as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionConstructor),
            "::",
            stringify!(args)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astExpressionDerefStruct {
    pub ast: MOJOSHADER_astNodeInfo,
    pub datatype: *const MOJOSHADER_astDataType,
    pub identifier: *mut MOJOSHADER_astExpression,
    pub member: *const ::std::os::raw::c_char,
    pub isswizzle: ::std::os::raw::c_int,
    pub member_index: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astExpressionDerefStruct() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astExpressionDerefStruct>(),
        56usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astExpressionDerefStruct))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astExpressionDerefStruct>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(MOJOSHADER_astExpressionDerefStruct)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionDerefStruct>())).ast as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionDerefStruct),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionDerefStruct>())).datatype as *const _
                as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionDerefStruct),
            "::",
            stringify!(datatype)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionDerefStruct>())).identifier as *const _
                as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionDerefStruct),
            "::",
            stringify!(identifier)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionDerefStruct>())).member as *const _
                as usize
        },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionDerefStruct),
            "::",
            stringify!(member)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionDerefStruct>())).isswizzle as *const _
                as usize
        },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionDerefStruct),
            "::",
            stringify!(isswizzle)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionDerefStruct>())).member_index as *const _
                as usize
        },
        52usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionDerefStruct),
            "::",
            stringify!(member_index)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astExpressionCallFunction {
    pub ast: MOJOSHADER_astNodeInfo,
    pub datatype: *const MOJOSHADER_astDataType,
    pub identifier: *mut MOJOSHADER_astExpressionIdentifier,
    pub args: *mut MOJOSHADER_astArguments,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astExpressionCallFunction() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astExpressionCallFunction>(),
        48usize,
        concat!(
            "Size of: ",
            stringify!(MOJOSHADER_astExpressionCallFunction)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astExpressionCallFunction>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(MOJOSHADER_astExpressionCallFunction)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionCallFunction>())).ast as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionCallFunction),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionCallFunction>())).datatype as *const _
                as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionCallFunction),
            "::",
            stringify!(datatype)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionCallFunction>())).identifier as *const _
                as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionCallFunction),
            "::",
            stringify!(identifier)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionCallFunction>())).args as *const _
                as usize
        },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionCallFunction),
            "::",
            stringify!(args)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astExpressionCast {
    pub ast: MOJOSHADER_astNodeInfo,
    pub datatype: *const MOJOSHADER_astDataType,
    pub operand: *mut MOJOSHADER_astExpression,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astExpressionCast() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astExpressionCast>(),
        40usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astExpressionCast))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astExpressionCast>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_astExpressionCast))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionCast>())).ast as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionCast),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionCast>())).datatype as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionCast),
            "::",
            stringify!(datatype)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionCast>())).operand as *const _ as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionCast),
            "::",
            stringify!(operand)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astCompilationUnit {
    pub ast: MOJOSHADER_astNodeInfo,
    pub next: *mut MOJOSHADER_astCompilationUnit,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astCompilationUnit() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astCompilationUnit>(),
        32usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astCompilationUnit))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astCompilationUnit>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_astCompilationUnit))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astCompilationUnit>())).ast as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astCompilationUnit),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astCompilationUnit>())).next as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astCompilationUnit),
            "::",
            stringify!(next)
        )
    );
}
pub const MOJOSHADER_astFunctionStorageClass_MOJOSHADER_AST_FNSTORECLS_NONE:
    MOJOSHADER_astFunctionStorageClass = 0;
pub const MOJOSHADER_astFunctionStorageClass_MOJOSHADER_AST_FNSTORECLS_INLINE:
    MOJOSHADER_astFunctionStorageClass = 1;
pub type MOJOSHADER_astFunctionStorageClass = ::std::os::raw::c_uint;
pub const MOJOSHADER_astInputModifier_MOJOSHADER_AST_INPUTMOD_NONE: MOJOSHADER_astInputModifier = 0;
pub const MOJOSHADER_astInputModifier_MOJOSHADER_AST_INPUTMOD_IN: MOJOSHADER_astInputModifier = 1;
pub const MOJOSHADER_astInputModifier_MOJOSHADER_AST_INPUTMOD_OUT: MOJOSHADER_astInputModifier = 2;
pub const MOJOSHADER_astInputModifier_MOJOSHADER_AST_INPUTMOD_INOUT: MOJOSHADER_astInputModifier =
    3;
pub const MOJOSHADER_astInputModifier_MOJOSHADER_AST_INPUTMOD_UNIFORM: MOJOSHADER_astInputModifier =
    4;
pub type MOJOSHADER_astInputModifier = ::std::os::raw::c_uint;
pub const MOJOSHADER_astInterpolationModifier_MOJOSHADER_AST_INTERPMOD_NONE:
    MOJOSHADER_astInterpolationModifier = 0;
pub const MOJOSHADER_astInterpolationModifier_MOJOSHADER_AST_INTERPMOD_LINEAR:
    MOJOSHADER_astInterpolationModifier = 1;
pub const MOJOSHADER_astInterpolationModifier_MOJOSHADER_AST_INTERPMOD_CENTROID:
    MOJOSHADER_astInterpolationModifier = 2;
pub const MOJOSHADER_astInterpolationModifier_MOJOSHADER_AST_INTERPMOD_NOINTERPOLATION:
    MOJOSHADER_astInterpolationModifier = 3;
pub const MOJOSHADER_astInterpolationModifier_MOJOSHADER_AST_INTERPMOD_NOPERSPECTIVE:
    MOJOSHADER_astInterpolationModifier = 4;
pub const MOJOSHADER_astInterpolationModifier_MOJOSHADER_AST_INTERPMOD_SAMPLE:
    MOJOSHADER_astInterpolationModifier = 5;
pub type MOJOSHADER_astInterpolationModifier = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astFunctionParameters {
    pub ast: MOJOSHADER_astNodeInfo,
    pub datatype: *const MOJOSHADER_astDataType,
    pub input_modifier: MOJOSHADER_astInputModifier,
    pub identifier: *const ::std::os::raw::c_char,
    pub semantic: *const ::std::os::raw::c_char,
    pub interpolation_modifier: MOJOSHADER_astInterpolationModifier,
    pub initializer: *mut MOJOSHADER_astExpression,
    pub next: *mut MOJOSHADER_astFunctionParameters,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astFunctionParameters() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astFunctionParameters>(),
        80usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astFunctionParameters))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astFunctionParameters>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(MOJOSHADER_astFunctionParameters)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astFunctionParameters>())).ast as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astFunctionParameters),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astFunctionParameters>())).datatype as *const _
                as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astFunctionParameters),
            "::",
            stringify!(datatype)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astFunctionParameters>())).input_modifier as *const _
                as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astFunctionParameters),
            "::",
            stringify!(input_modifier)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astFunctionParameters>())).identifier as *const _
                as usize
        },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astFunctionParameters),
            "::",
            stringify!(identifier)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astFunctionParameters>())).semantic as *const _
                as usize
        },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astFunctionParameters),
            "::",
            stringify!(semantic)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astFunctionParameters>())).interpolation_modifier
                as *const _ as usize
        },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astFunctionParameters),
            "::",
            stringify!(interpolation_modifier)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astFunctionParameters>())).initializer as *const _
                as usize
        },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astFunctionParameters),
            "::",
            stringify!(initializer)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astFunctionParameters>())).next as *const _ as usize
        },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astFunctionParameters),
            "::",
            stringify!(next)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astFunctionSignature {
    pub ast: MOJOSHADER_astNodeInfo,
    pub datatype: *const MOJOSHADER_astDataType,
    pub identifier: *const ::std::os::raw::c_char,
    pub params: *mut MOJOSHADER_astFunctionParameters,
    pub storage_class: MOJOSHADER_astFunctionStorageClass,
    pub semantic: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astFunctionSignature() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astFunctionSignature>(),
        64usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astFunctionSignature))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astFunctionSignature>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_astFunctionSignature))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astFunctionSignature>())).ast as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astFunctionSignature),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astFunctionSignature>())).datatype as *const _
                as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astFunctionSignature),
            "::",
            stringify!(datatype)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astFunctionSignature>())).identifier as *const _
                as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astFunctionSignature),
            "::",
            stringify!(identifier)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astFunctionSignature>())).params as *const _ as usize
        },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astFunctionSignature),
            "::",
            stringify!(params)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astFunctionSignature>())).storage_class as *const _
                as usize
        },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astFunctionSignature),
            "::",
            stringify!(storage_class)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astFunctionSignature>())).semantic as *const _
                as usize
        },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astFunctionSignature),
            "::",
            stringify!(semantic)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astScalarOrArray {
    pub ast: MOJOSHADER_astNodeInfo,
    pub identifier: *const ::std::os::raw::c_char,
    pub isarray: ::std::os::raw::c_int,
    pub dimension: *mut MOJOSHADER_astExpression,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astScalarOrArray() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astScalarOrArray>(),
        48usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astScalarOrArray))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astScalarOrArray>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_astScalarOrArray))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astScalarOrArray>())).ast as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astScalarOrArray),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astScalarOrArray>())).identifier as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astScalarOrArray),
            "::",
            stringify!(identifier)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astScalarOrArray>())).isarray as *const _ as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astScalarOrArray),
            "::",
            stringify!(isarray)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astScalarOrArray>())).dimension as *const _ as usize
        },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astScalarOrArray),
            "::",
            stringify!(dimension)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astAnnotations {
    pub ast: MOJOSHADER_astNodeInfo,
    pub datatype: *const MOJOSHADER_astDataType,
    pub initializer: *mut MOJOSHADER_astExpression,
    pub next: *mut MOJOSHADER_astAnnotations,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astAnnotations() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astAnnotations>(),
        48usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astAnnotations))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astAnnotations>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_astAnnotations))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astAnnotations>())).ast as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astAnnotations),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astAnnotations>())).datatype as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astAnnotations),
            "::",
            stringify!(datatype)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astAnnotations>())).initializer as *const _ as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astAnnotations),
            "::",
            stringify!(initializer)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astAnnotations>())).next as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astAnnotations),
            "::",
            stringify!(next)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astPackOffset {
    pub ast: MOJOSHADER_astNodeInfo,
    pub ident1: *const ::std::os::raw::c_char,
    pub ident2: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astPackOffset() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astPackOffset>(),
        40usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astPackOffset))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astPackOffset>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_astPackOffset))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astPackOffset>())).ast as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astPackOffset),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astPackOffset>())).ident1 as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astPackOffset),
            "::",
            stringify!(ident1)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astPackOffset>())).ident2 as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astPackOffset),
            "::",
            stringify!(ident2)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astVariableLowLevel {
    pub ast: MOJOSHADER_astNodeInfo,
    pub packoffset: *mut MOJOSHADER_astPackOffset,
    pub register_name: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astVariableLowLevel() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astVariableLowLevel>(),
        40usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astVariableLowLevel))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astVariableLowLevel>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_astVariableLowLevel))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astVariableLowLevel>())).ast as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astVariableLowLevel),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astVariableLowLevel>())).packoffset as *const _
                as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astVariableLowLevel),
            "::",
            stringify!(packoffset)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astVariableLowLevel>())).register_name as *const _
                as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astVariableLowLevel),
            "::",
            stringify!(register_name)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astStructMembers {
    pub ast: MOJOSHADER_astNodeInfo,
    pub datatype: *const MOJOSHADER_astDataType,
    pub semantic: *const ::std::os::raw::c_char,
    pub details: *mut MOJOSHADER_astScalarOrArray,
    pub interpolation_mod: MOJOSHADER_astInterpolationModifier,
    pub next: *mut MOJOSHADER_astStructMembers,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astStructMembers() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astStructMembers>(),
        64usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astStructMembers))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astStructMembers>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_astStructMembers))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astStructMembers>())).ast as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astStructMembers),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astStructMembers>())).datatype as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astStructMembers),
            "::",
            stringify!(datatype)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astStructMembers>())).semantic as *const _ as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astStructMembers),
            "::",
            stringify!(semantic)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astStructMembers>())).details as *const _ as usize
        },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astStructMembers),
            "::",
            stringify!(details)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astStructMembers>())).interpolation_mod as *const _
                as usize
        },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astStructMembers),
            "::",
            stringify!(interpolation_mod)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astStructMembers>())).next as *const _ as usize
        },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astStructMembers),
            "::",
            stringify!(next)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astStructDeclaration {
    pub ast: MOJOSHADER_astNodeInfo,
    pub datatype: *const MOJOSHADER_astDataType,
    pub name: *const ::std::os::raw::c_char,
    pub members: *mut MOJOSHADER_astStructMembers,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astStructDeclaration() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astStructDeclaration>(),
        48usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astStructDeclaration))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astStructDeclaration>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_astStructDeclaration))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astStructDeclaration>())).ast as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astStructDeclaration),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astStructDeclaration>())).datatype as *const _
                as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astStructDeclaration),
            "::",
            stringify!(datatype)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astStructDeclaration>())).name as *const _ as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astStructDeclaration),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astStructDeclaration>())).members as *const _ as usize
        },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astStructDeclaration),
            "::",
            stringify!(members)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astVariableDeclaration {
    pub ast: MOJOSHADER_astNodeInfo,
    pub attributes: ::std::os::raw::c_int,
    pub datatype: *const MOJOSHADER_astDataType,
    pub anonymous_datatype: *mut MOJOSHADER_astStructDeclaration,
    pub details: *mut MOJOSHADER_astScalarOrArray,
    pub semantic: *const ::std::os::raw::c_char,
    pub annotations: *mut MOJOSHADER_astAnnotations,
    pub initializer: *mut MOJOSHADER_astExpression,
    pub lowlevel: *mut MOJOSHADER_astVariableLowLevel,
    pub next: *mut MOJOSHADER_astVariableDeclaration,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astVariableDeclaration() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astVariableDeclaration>(),
        96usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astVariableDeclaration))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astVariableDeclaration>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(MOJOSHADER_astVariableDeclaration)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astVariableDeclaration>())).ast as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astVariableDeclaration),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astVariableDeclaration>())).attributes as *const _
                as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astVariableDeclaration),
            "::",
            stringify!(attributes)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astVariableDeclaration>())).datatype as *const _
                as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astVariableDeclaration),
            "::",
            stringify!(datatype)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astVariableDeclaration>())).anonymous_datatype
                as *const _ as usize
        },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astVariableDeclaration),
            "::",
            stringify!(anonymous_datatype)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astVariableDeclaration>())).details as *const _
                as usize
        },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astVariableDeclaration),
            "::",
            stringify!(details)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astVariableDeclaration>())).semantic as *const _
                as usize
        },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astVariableDeclaration),
            "::",
            stringify!(semantic)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astVariableDeclaration>())).annotations as *const _
                as usize
        },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astVariableDeclaration),
            "::",
            stringify!(annotations)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astVariableDeclaration>())).initializer as *const _
                as usize
        },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astVariableDeclaration),
            "::",
            stringify!(initializer)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astVariableDeclaration>())).lowlevel as *const _
                as usize
        },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astVariableDeclaration),
            "::",
            stringify!(lowlevel)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astVariableDeclaration>())).next as *const _ as usize
        },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astVariableDeclaration),
            "::",
            stringify!(next)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astStatement {
    pub ast: MOJOSHADER_astNodeInfo,
    pub next: *mut MOJOSHADER_astStatement,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astStatement() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astStatement>(),
        32usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astStatement))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astStatement>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_astStatement))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astStatement>())).ast as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astStatement),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astStatement>())).next as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astStatement),
            "::",
            stringify!(next)
        )
    );
}
pub type MOJOSHADER_astEmptyStatement = MOJOSHADER_astStatement;
pub type MOJOSHADER_astBreakStatement = MOJOSHADER_astStatement;
pub type MOJOSHADER_astContinueStatement = MOJOSHADER_astStatement;
pub type MOJOSHADER_astDiscardStatement = MOJOSHADER_astStatement;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astBlockStatement {
    pub ast: MOJOSHADER_astNodeInfo,
    pub next: *mut MOJOSHADER_astStatement,
    pub statements: *mut MOJOSHADER_astStatement,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astBlockStatement() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astBlockStatement>(),
        40usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astBlockStatement))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astBlockStatement>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_astBlockStatement))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astBlockStatement>())).ast as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astBlockStatement),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astBlockStatement>())).next as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astBlockStatement),
            "::",
            stringify!(next)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astBlockStatement>())).statements as *const _ as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astBlockStatement),
            "::",
            stringify!(statements)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astReturnStatement {
    pub ast: MOJOSHADER_astNodeInfo,
    pub next: *mut MOJOSHADER_astStatement,
    pub expr: *mut MOJOSHADER_astExpression,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astReturnStatement() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astReturnStatement>(),
        40usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astReturnStatement))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astReturnStatement>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_astReturnStatement))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astReturnStatement>())).ast as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astReturnStatement),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astReturnStatement>())).next as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astReturnStatement),
            "::",
            stringify!(next)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astReturnStatement>())).expr as *const _ as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astReturnStatement),
            "::",
            stringify!(expr)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astExpressionStatement {
    pub ast: MOJOSHADER_astNodeInfo,
    pub next: *mut MOJOSHADER_astStatement,
    pub expr: *mut MOJOSHADER_astExpression,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astExpressionStatement() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astExpressionStatement>(),
        40usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astExpressionStatement))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astExpressionStatement>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(MOJOSHADER_astExpressionStatement)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionStatement>())).ast as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionStatement),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionStatement>())).next as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionStatement),
            "::",
            stringify!(next)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astExpressionStatement>())).expr as *const _ as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astExpressionStatement),
            "::",
            stringify!(expr)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astIfStatement {
    pub ast: MOJOSHADER_astNodeInfo,
    pub next: *mut MOJOSHADER_astStatement,
    pub attributes: ::std::os::raw::c_int,
    pub expr: *mut MOJOSHADER_astExpression,
    pub statement: *mut MOJOSHADER_astStatement,
    pub else_statement: *mut MOJOSHADER_astStatement,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astIfStatement() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astIfStatement>(),
        64usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astIfStatement))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astIfStatement>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_astIfStatement))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astIfStatement>())).ast as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astIfStatement),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astIfStatement>())).next as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astIfStatement),
            "::",
            stringify!(next)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astIfStatement>())).attributes as *const _ as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astIfStatement),
            "::",
            stringify!(attributes)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astIfStatement>())).expr as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astIfStatement),
            "::",
            stringify!(expr)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astIfStatement>())).statement as *const _ as usize
        },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astIfStatement),
            "::",
            stringify!(statement)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astIfStatement>())).else_statement as *const _
                as usize
        },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astIfStatement),
            "::",
            stringify!(else_statement)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astSwitchCases {
    pub ast: MOJOSHADER_astNodeInfo,
    pub expr: *mut MOJOSHADER_astExpression,
    pub statement: *mut MOJOSHADER_astStatement,
    pub next: *mut MOJOSHADER_astSwitchCases,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astSwitchCases() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astSwitchCases>(),
        48usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astSwitchCases))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astSwitchCases>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_astSwitchCases))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astSwitchCases>())).ast as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astSwitchCases),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astSwitchCases>())).expr as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astSwitchCases),
            "::",
            stringify!(expr)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astSwitchCases>())).statement as *const _ as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astSwitchCases),
            "::",
            stringify!(statement)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astSwitchCases>())).next as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astSwitchCases),
            "::",
            stringify!(next)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astSwitchStatement {
    pub ast: MOJOSHADER_astNodeInfo,
    pub next: *mut MOJOSHADER_astStatement,
    pub attributes: ::std::os::raw::c_int,
    pub expr: *mut MOJOSHADER_astExpression,
    pub cases: *mut MOJOSHADER_astSwitchCases,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astSwitchStatement() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astSwitchStatement>(),
        56usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astSwitchStatement))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astSwitchStatement>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_astSwitchStatement))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astSwitchStatement>())).ast as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astSwitchStatement),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astSwitchStatement>())).next as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astSwitchStatement),
            "::",
            stringify!(next)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astSwitchStatement>())).attributes as *const _
                as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astSwitchStatement),
            "::",
            stringify!(attributes)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astSwitchStatement>())).expr as *const _ as usize
        },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astSwitchStatement),
            "::",
            stringify!(expr)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astSwitchStatement>())).cases as *const _ as usize
        },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astSwitchStatement),
            "::",
            stringify!(cases)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astWhileStatement {
    pub ast: MOJOSHADER_astNodeInfo,
    pub next: *mut MOJOSHADER_astStatement,
    pub unroll: ::std::os::raw::c_int,
    pub expr: *mut MOJOSHADER_astExpression,
    pub statement: *mut MOJOSHADER_astStatement,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astWhileStatement() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astWhileStatement>(),
        56usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astWhileStatement))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astWhileStatement>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_astWhileStatement))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astWhileStatement>())).ast as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astWhileStatement),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astWhileStatement>())).next as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astWhileStatement),
            "::",
            stringify!(next)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astWhileStatement>())).unroll as *const _ as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astWhileStatement),
            "::",
            stringify!(unroll)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astWhileStatement>())).expr as *const _ as usize
        },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astWhileStatement),
            "::",
            stringify!(expr)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astWhileStatement>())).statement as *const _ as usize
        },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astWhileStatement),
            "::",
            stringify!(statement)
        )
    );
}
pub type MOJOSHADER_astDoStatement = MOJOSHADER_astWhileStatement;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astForStatement {
    pub ast: MOJOSHADER_astNodeInfo,
    pub next: *mut MOJOSHADER_astStatement,
    pub unroll: ::std::os::raw::c_int,
    pub var_decl: *mut MOJOSHADER_astVariableDeclaration,
    pub initializer: *mut MOJOSHADER_astExpression,
    pub looptest: *mut MOJOSHADER_astExpression,
    pub counter: *mut MOJOSHADER_astExpression,
    pub statement: *mut MOJOSHADER_astStatement,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astForStatement() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astForStatement>(),
        80usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astForStatement))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astForStatement>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_astForStatement))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astForStatement>())).ast as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astForStatement),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astForStatement>())).next as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astForStatement),
            "::",
            stringify!(next)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astForStatement>())).unroll as *const _ as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astForStatement),
            "::",
            stringify!(unroll)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astForStatement>())).var_decl as *const _ as usize
        },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astForStatement),
            "::",
            stringify!(var_decl)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astForStatement>())).initializer as *const _ as usize
        },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astForStatement),
            "::",
            stringify!(initializer)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astForStatement>())).looptest as *const _ as usize
        },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astForStatement),
            "::",
            stringify!(looptest)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astForStatement>())).counter as *const _ as usize
        },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astForStatement),
            "::",
            stringify!(counter)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astForStatement>())).statement as *const _ as usize
        },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astForStatement),
            "::",
            stringify!(statement)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astTypedef {
    pub ast: MOJOSHADER_astNodeInfo,
    pub datatype: *const MOJOSHADER_astDataType,
    pub isconst: ::std::os::raw::c_int,
    pub details: *mut MOJOSHADER_astScalarOrArray,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astTypedef() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astTypedef>(),
        48usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astTypedef))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astTypedef>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_astTypedef))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astTypedef>())).ast as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astTypedef),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astTypedef>())).datatype as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astTypedef),
            "::",
            stringify!(datatype)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astTypedef>())).isconst as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astTypedef),
            "::",
            stringify!(isconst)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astTypedef>())).details as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astTypedef),
            "::",
            stringify!(details)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astTypedefStatement {
    pub ast: MOJOSHADER_astNodeInfo,
    pub next: *mut MOJOSHADER_astStatement,
    pub type_info: *mut MOJOSHADER_astTypedef,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astTypedefStatement() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astTypedefStatement>(),
        40usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astTypedefStatement))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astTypedefStatement>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_astTypedefStatement))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astTypedefStatement>())).ast as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astTypedefStatement),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astTypedefStatement>())).next as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astTypedefStatement),
            "::",
            stringify!(next)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astTypedefStatement>())).type_info as *const _
                as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astTypedefStatement),
            "::",
            stringify!(type_info)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astVarDeclStatement {
    pub ast: MOJOSHADER_astNodeInfo,
    pub next: *mut MOJOSHADER_astStatement,
    pub declaration: *mut MOJOSHADER_astVariableDeclaration,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astVarDeclStatement() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astVarDeclStatement>(),
        40usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astVarDeclStatement))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astVarDeclStatement>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_astVarDeclStatement))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astVarDeclStatement>())).ast as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astVarDeclStatement),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astVarDeclStatement>())).next as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astVarDeclStatement),
            "::",
            stringify!(next)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astVarDeclStatement>())).declaration as *const _
                as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astVarDeclStatement),
            "::",
            stringify!(declaration)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astStructStatement {
    pub ast: MOJOSHADER_astNodeInfo,
    pub next: *mut MOJOSHADER_astStatement,
    pub struct_info: *mut MOJOSHADER_astStructDeclaration,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astStructStatement() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astStructStatement>(),
        40usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astStructStatement))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astStructStatement>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_astStructStatement))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astStructStatement>())).ast as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astStructStatement),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astStructStatement>())).next as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astStructStatement),
            "::",
            stringify!(next)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astStructStatement>())).struct_info as *const _
                as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astStructStatement),
            "::",
            stringify!(struct_info)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astCompilationUnitFunction {
    pub ast: MOJOSHADER_astNodeInfo,
    pub next: *mut MOJOSHADER_astCompilationUnit,
    pub declaration: *mut MOJOSHADER_astFunctionSignature,
    pub definition: *mut MOJOSHADER_astStatement,
    pub index: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astCompilationUnitFunction() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astCompilationUnitFunction>(),
        56usize,
        concat!(
            "Size of: ",
            stringify!(MOJOSHADER_astCompilationUnitFunction)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astCompilationUnitFunction>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(MOJOSHADER_astCompilationUnitFunction)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astCompilationUnitFunction>())).ast as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astCompilationUnitFunction),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astCompilationUnitFunction>())).next as *const _
                as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astCompilationUnitFunction),
            "::",
            stringify!(next)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astCompilationUnitFunction>())).declaration
                as *const _ as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astCompilationUnitFunction),
            "::",
            stringify!(declaration)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astCompilationUnitFunction>())).definition as *const _
                as usize
        },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astCompilationUnitFunction),
            "::",
            stringify!(definition)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astCompilationUnitFunction>())).index as *const _
                as usize
        },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astCompilationUnitFunction),
            "::",
            stringify!(index)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astCompilationUnitTypedef {
    pub ast: MOJOSHADER_astNodeInfo,
    pub next: *mut MOJOSHADER_astCompilationUnit,
    pub type_info: *mut MOJOSHADER_astTypedef,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astCompilationUnitTypedef() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astCompilationUnitTypedef>(),
        40usize,
        concat!(
            "Size of: ",
            stringify!(MOJOSHADER_astCompilationUnitTypedef)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astCompilationUnitTypedef>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(MOJOSHADER_astCompilationUnitTypedef)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astCompilationUnitTypedef>())).ast as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astCompilationUnitTypedef),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astCompilationUnitTypedef>())).next as *const _
                as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astCompilationUnitTypedef),
            "::",
            stringify!(next)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astCompilationUnitTypedef>())).type_info as *const _
                as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astCompilationUnitTypedef),
            "::",
            stringify!(type_info)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astCompilationUnitStruct {
    pub ast: MOJOSHADER_astNodeInfo,
    pub next: *mut MOJOSHADER_astCompilationUnit,
    pub struct_info: *mut MOJOSHADER_astStructDeclaration,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astCompilationUnitStruct() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astCompilationUnitStruct>(),
        40usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astCompilationUnitStruct))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astCompilationUnitStruct>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(MOJOSHADER_astCompilationUnitStruct)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astCompilationUnitStruct>())).ast as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astCompilationUnitStruct),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astCompilationUnitStruct>())).next as *const _
                as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astCompilationUnitStruct),
            "::",
            stringify!(next)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astCompilationUnitStruct>())).struct_info as *const _
                as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astCompilationUnitStruct),
            "::",
            stringify!(struct_info)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astCompilationUnitVariable {
    pub ast: MOJOSHADER_astNodeInfo,
    pub next: *mut MOJOSHADER_astCompilationUnit,
    pub declaration: *mut MOJOSHADER_astVariableDeclaration,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astCompilationUnitVariable() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astCompilationUnitVariable>(),
        40usize,
        concat!(
            "Size of: ",
            stringify!(MOJOSHADER_astCompilationUnitVariable)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astCompilationUnitVariable>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(MOJOSHADER_astCompilationUnitVariable)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astCompilationUnitVariable>())).ast as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astCompilationUnitVariable),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astCompilationUnitVariable>())).next as *const _
                as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astCompilationUnitVariable),
            "::",
            stringify!(next)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astCompilationUnitVariable>())).declaration
                as *const _ as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astCompilationUnitVariable),
            "::",
            stringify!(declaration)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union MOJOSHADER_astNode {
    pub ast: MOJOSHADER_astNodeInfo,
    pub generic: MOJOSHADER_astGeneric,
    pub expression: MOJOSHADER_astExpression,
    pub arguments: MOJOSHADER_astArguments,
    pub unary: MOJOSHADER_astExpressionUnary,
    pub binary: MOJOSHADER_astExpressionBinary,
    pub ternary: MOJOSHADER_astExpressionTernary,
    pub identifier: MOJOSHADER_astExpressionIdentifier,
    pub intliteral: MOJOSHADER_astExpressionIntLiteral,
    pub floatliteral: MOJOSHADER_astExpressionFloatLiteral,
    pub stringliteral: MOJOSHADER_astExpressionStringLiteral,
    pub boolliteral: MOJOSHADER_astExpressionBooleanLiteral,
    pub constructor: MOJOSHADER_astExpressionConstructor,
    pub derefstruct: MOJOSHADER_astExpressionDerefStruct,
    pub callfunc: MOJOSHADER_astExpressionCallFunction,
    pub cast: MOJOSHADER_astExpressionCast,
    pub compunit: MOJOSHADER_astCompilationUnit,
    pub params: MOJOSHADER_astFunctionParameters,
    pub funcsig: MOJOSHADER_astFunctionSignature,
    pub soa: MOJOSHADER_astScalarOrArray,
    pub annotations: MOJOSHADER_astAnnotations,
    pub packoffset: MOJOSHADER_astPackOffset,
    pub varlowlevel: MOJOSHADER_astVariableLowLevel,
    pub structmembers: MOJOSHADER_astStructMembers,
    pub structdecl: MOJOSHADER_astStructDeclaration,
    pub vardecl: MOJOSHADER_astVariableDeclaration,
    pub stmt: MOJOSHADER_astStatement,
    pub emptystmt: MOJOSHADER_astEmptyStatement,
    pub breakstmt: MOJOSHADER_astBreakStatement,
    pub contstmt: MOJOSHADER_astContinueStatement,
    pub discardstmt: MOJOSHADER_astDiscardStatement,
    pub blockstmt: MOJOSHADER_astBlockStatement,
    pub returnstmt: MOJOSHADER_astReturnStatement,
    pub exprstmt: MOJOSHADER_astExpressionStatement,
    pub ifstmt: MOJOSHADER_astIfStatement,
    pub cases: MOJOSHADER_astSwitchCases,
    pub switchstmt: MOJOSHADER_astSwitchStatement,
    pub whilestmt: MOJOSHADER_astWhileStatement,
    pub dostmt: MOJOSHADER_astDoStatement,
    pub forstmt: MOJOSHADER_astForStatement,
    pub typdef: MOJOSHADER_astTypedef,
    pub typedefstmt: MOJOSHADER_astTypedefStatement,
    pub vardeclstmt: MOJOSHADER_astVarDeclStatement,
    pub structstmt: MOJOSHADER_astStructStatement,
    pub funcunit: MOJOSHADER_astCompilationUnitFunction,
    pub typedefunit: MOJOSHADER_astCompilationUnitTypedef,
    pub structunit: MOJOSHADER_astCompilationUnitStruct,
    pub varunit: MOJOSHADER_astCompilationUnitVariable,
    _bindgen_union_align: [u64; 12usize],
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astNode() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astNode>(),
        96usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astNode))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astNode>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_astNode))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).ast as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).generic as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(generic)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).expression as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(expression)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).arguments as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(arguments)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).unary as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(unary)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).binary as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(binary)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).ternary as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(ternary)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).identifier as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(identifier)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).intliteral as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(intliteral)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).floatliteral as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(floatliteral)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astNode>())).stringliteral as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(stringliteral)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).boolliteral as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(boolliteral)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).constructor as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(constructor)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).derefstruct as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(derefstruct)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).callfunc as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(callfunc)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).cast as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(cast)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).compunit as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(compunit)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).params as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(params)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).funcsig as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(funcsig)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).soa as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(soa)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).annotations as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(annotations)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).packoffset as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(packoffset)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).varlowlevel as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(varlowlevel)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astNode>())).structmembers as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(structmembers)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).structdecl as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(structdecl)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).vardecl as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(vardecl)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).stmt as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(stmt)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).emptystmt as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(emptystmt)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).breakstmt as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(breakstmt)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).contstmt as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(contstmt)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).discardstmt as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(discardstmt)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).blockstmt as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(blockstmt)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).returnstmt as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(returnstmt)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).exprstmt as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(exprstmt)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).ifstmt as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(ifstmt)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).cases as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(cases)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).switchstmt as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(switchstmt)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).whilestmt as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(whilestmt)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).dostmt as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(dostmt)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).forstmt as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(forstmt)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).typdef as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(typdef)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).typedefstmt as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(typedefstmt)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).vardeclstmt as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(vardeclstmt)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).structstmt as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(structstmt)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).funcunit as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(funcunit)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).typedefunit as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(typedefunit)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).structunit as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(structunit)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astNode>())).varunit as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astNode),
            "::",
            stringify!(varunit)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_astData {
    pub error_count: ::std::os::raw::c_int,
    pub errors: *mut MOJOSHADER_error,
    pub source_profile: *const ::std::os::raw::c_char,
    pub ast: *const MOJOSHADER_astNode,
    pub malloc: MOJOSHADER_malloc,
    pub free: MOJOSHADER_free,
    pub malloc_data: *mut ::std::os::raw::c_void,
    pub opaque: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_astData() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_astData>(),
        64usize,
        concat!("Size of: ", stringify!(MOJOSHADER_astData))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_astData>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_astData))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astData>())).error_count as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astData),
            "::",
            stringify!(error_count)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astData>())).errors as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astData),
            "::",
            stringify!(errors)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_astData>())).source_profile as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astData),
            "::",
            stringify!(source_profile)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astData>())).ast as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astData),
            "::",
            stringify!(ast)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astData>())).malloc as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astData),
            "::",
            stringify!(malloc)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astData>())).free as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astData),
            "::",
            stringify!(free)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astData>())).malloc_data as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astData),
            "::",
            stringify!(malloc_data)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_astData>())).opaque as *const _ as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_astData),
            "::",
            stringify!(opaque)
        )
    );
}
extern "C" {
    pub fn MOJOSHADER_parseAst(
        srcprofile: *const ::std::os::raw::c_char,
        filename: *const ::std::os::raw::c_char,
        source: *const ::std::os::raw::c_char,
        sourcelen: ::std::os::raw::c_uint,
        defs: *const MOJOSHADER_preprocessorDefine,
        define_count: ::std::os::raw::c_uint,
        include_open: MOJOSHADER_includeOpen,
        include_close: MOJOSHADER_includeClose,
        m: MOJOSHADER_malloc,
        f: MOJOSHADER_free,
        d: *mut ::std::os::raw::c_void,
    ) -> *const MOJOSHADER_astData;
}
extern "C" {
    pub fn MOJOSHADER_freeAstData(data: *const MOJOSHADER_astData);
}
pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_START_RANGE_EXPR: MOJOSHADER_irNodeType = 0;
pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_CONSTANT: MOJOSHADER_irNodeType = 1;
pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_TEMP: MOJOSHADER_irNodeType = 2;
pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_BINOP: MOJOSHADER_irNodeType = 3;
pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_MEMORY: MOJOSHADER_irNodeType = 4;
pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_CALL: MOJOSHADER_irNodeType = 5;
pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_ESEQ: MOJOSHADER_irNodeType = 6;
pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_ARRAY: MOJOSHADER_irNodeType = 7;
pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_CONVERT: MOJOSHADER_irNodeType = 8;
pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_SWIZZLE: MOJOSHADER_irNodeType = 9;
pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_CONSTRUCT: MOJOSHADER_irNodeType = 10;
pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_END_RANGE_EXPR: MOJOSHADER_irNodeType = 11;
pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_START_RANGE_STMT: MOJOSHADER_irNodeType = 12;
pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_MOVE: MOJOSHADER_irNodeType = 13;
pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_EXPR_STMT: MOJOSHADER_irNodeType = 14;
pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_JUMP: MOJOSHADER_irNodeType = 15;
pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_CJUMP: MOJOSHADER_irNodeType = 16;
pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_SEQ: MOJOSHADER_irNodeType = 17;
pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_LABEL: MOJOSHADER_irNodeType = 18;
pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_DISCARD: MOJOSHADER_irNodeType = 19;
pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_END_RANGE_STMT: MOJOSHADER_irNodeType = 20;
pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_START_RANGE_MISC: MOJOSHADER_irNodeType = 21;
pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_EXPRLIST: MOJOSHADER_irNodeType = 22;
pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_END_RANGE_MISC: MOJOSHADER_irNodeType = 23;
pub const MOJOSHADER_irNodeType_MOJOSHADER_IR_END_RANGE: MOJOSHADER_irNodeType = 24;
pub type MOJOSHADER_irNodeType = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_irNodeInfo {
    pub type_: MOJOSHADER_irNodeType,
    pub filename: *const ::std::os::raw::c_char,
    pub line: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_irNodeInfo() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_irNodeInfo>(),
        24usize,
        concat!("Size of: ", stringify!(MOJOSHADER_irNodeInfo))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_irNodeInfo>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_irNodeInfo))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irNodeInfo>())).type_ as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irNodeInfo),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irNodeInfo>())).filename as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irNodeInfo),
            "::",
            stringify!(filename)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irNodeInfo>())).line as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irNodeInfo),
            "::",
            stringify!(line)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_irGeneric {
    pub ir: MOJOSHADER_irNodeInfo,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_irGeneric() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_irGeneric>(),
        24usize,
        concat!("Size of: ", stringify!(MOJOSHADER_irGeneric))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_irGeneric>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_irGeneric))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irGeneric>())).ir as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irGeneric),
            "::",
            stringify!(ir)
        )
    );
}
pub const MOJOSHADER_irBinOpType_MOJOSHADER_IR_BINOP_ADD: MOJOSHADER_irBinOpType = 0;
pub const MOJOSHADER_irBinOpType_MOJOSHADER_IR_BINOP_SUBTRACT: MOJOSHADER_irBinOpType = 1;
pub const MOJOSHADER_irBinOpType_MOJOSHADER_IR_BINOP_MULTIPLY: MOJOSHADER_irBinOpType = 2;
pub const MOJOSHADER_irBinOpType_MOJOSHADER_IR_BINOP_DIVIDE: MOJOSHADER_irBinOpType = 3;
pub const MOJOSHADER_irBinOpType_MOJOSHADER_IR_BINOP_MODULO: MOJOSHADER_irBinOpType = 4;
pub const MOJOSHADER_irBinOpType_MOJOSHADER_IR_BINOP_AND: MOJOSHADER_irBinOpType = 5;
pub const MOJOSHADER_irBinOpType_MOJOSHADER_IR_BINOP_OR: MOJOSHADER_irBinOpType = 6;
pub const MOJOSHADER_irBinOpType_MOJOSHADER_IR_BINOP_XOR: MOJOSHADER_irBinOpType = 7;
pub const MOJOSHADER_irBinOpType_MOJOSHADER_IR_BINOP_LSHIFT: MOJOSHADER_irBinOpType = 8;
pub const MOJOSHADER_irBinOpType_MOJOSHADER_IR_BINOP_RSHIFT: MOJOSHADER_irBinOpType = 9;
pub const MOJOSHADER_irBinOpType_MOJOSHADER_IR_BINOP_UNKNOWN: MOJOSHADER_irBinOpType = 10;
pub type MOJOSHADER_irBinOpType = ::std::os::raw::c_uint;
pub const MOJOSHADER_irConditionType_MOJOSHADER_IR_COND_EQL: MOJOSHADER_irConditionType = 0;
pub const MOJOSHADER_irConditionType_MOJOSHADER_IR_COND_NEQ: MOJOSHADER_irConditionType = 1;
pub const MOJOSHADER_irConditionType_MOJOSHADER_IR_COND_LT: MOJOSHADER_irConditionType = 2;
pub const MOJOSHADER_irConditionType_MOJOSHADER_IR_COND_GT: MOJOSHADER_irConditionType = 3;
pub const MOJOSHADER_irConditionType_MOJOSHADER_IR_COND_LEQ: MOJOSHADER_irConditionType = 4;
pub const MOJOSHADER_irConditionType_MOJOSHADER_IR_COND_GEQ: MOJOSHADER_irConditionType = 5;
pub const MOJOSHADER_irConditionType_MOJOSHADER_IR_COND_UNKNOWN: MOJOSHADER_irConditionType = 6;
pub type MOJOSHADER_irConditionType = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_irExprInfo {
    pub ir: MOJOSHADER_irNodeInfo,
    pub type_: MOJOSHADER_astDataTypeType,
    pub elements: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_irExprInfo() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_irExprInfo>(),
        32usize,
        concat!("Size of: ", stringify!(MOJOSHADER_irExprInfo))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_irExprInfo>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_irExprInfo))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irExprInfo>())).ir as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irExprInfo),
            "::",
            stringify!(ir)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irExprInfo>())).type_ as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irExprInfo),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irExprInfo>())).elements as *const _ as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irExprInfo),
            "::",
            stringify!(elements)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct MOJOSHADER_irConstant {
    pub info: MOJOSHADER_irExprInfo,
    pub value: MOJOSHADER_irConstant__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union MOJOSHADER_irConstant__bindgen_ty_1 {
    pub ival: [::std::os::raw::c_int; 16usize],
    pub fval: [f32; 16usize],
    _bindgen_union_align: [u32; 16usize],
}
#[test]
fn bindgen_test_layout_MOJOSHADER_irConstant__bindgen_ty_1() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_irConstant__bindgen_ty_1>(),
        64usize,
        concat!("Size of: ", stringify!(MOJOSHADER_irConstant__bindgen_ty_1))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_irConstant__bindgen_ty_1>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(MOJOSHADER_irConstant__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_irConstant__bindgen_ty_1>())).ival as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irConstant__bindgen_ty_1),
            "::",
            stringify!(ival)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_irConstant__bindgen_ty_1>())).fval as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irConstant__bindgen_ty_1),
            "::",
            stringify!(fval)
        )
    );
}
#[test]
fn bindgen_test_layout_MOJOSHADER_irConstant() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_irConstant>(),
        96usize,
        concat!("Size of: ", stringify!(MOJOSHADER_irConstant))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_irConstant>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_irConstant))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irConstant>())).info as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irConstant),
            "::",
            stringify!(info)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irConstant>())).value as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irConstant),
            "::",
            stringify!(value)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_irTemp {
    pub info: MOJOSHADER_irExprInfo,
    pub index: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_irTemp() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_irTemp>(),
        40usize,
        concat!("Size of: ", stringify!(MOJOSHADER_irTemp))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_irTemp>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_irTemp))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irTemp>())).info as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irTemp),
            "::",
            stringify!(info)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irTemp>())).index as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irTemp),
            "::",
            stringify!(index)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_irBinOp {
    pub info: MOJOSHADER_irExprInfo,
    pub op: MOJOSHADER_irBinOpType,
    pub left: *mut MOJOSHADER_irExpression,
    pub right: *mut MOJOSHADER_irExpression,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_irBinOp() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_irBinOp>(),
        56usize,
        concat!("Size of: ", stringify!(MOJOSHADER_irBinOp))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_irBinOp>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_irBinOp))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irBinOp>())).info as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irBinOp),
            "::",
            stringify!(info)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irBinOp>())).op as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irBinOp),
            "::",
            stringify!(op)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irBinOp>())).left as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irBinOp),
            "::",
            stringify!(left)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irBinOp>())).right as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irBinOp),
            "::",
            stringify!(right)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_irMemory {
    pub info: MOJOSHADER_irExprInfo,
    pub index: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_irMemory() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_irMemory>(),
        40usize,
        concat!("Size of: ", stringify!(MOJOSHADER_irMemory))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_irMemory>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_irMemory))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irMemory>())).info as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irMemory),
            "::",
            stringify!(info)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irMemory>())).index as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irMemory),
            "::",
            stringify!(index)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_irCall {
    pub info: MOJOSHADER_irExprInfo,
    pub index: ::std::os::raw::c_int,
    pub args: *mut MOJOSHADER_irExprList,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_irCall() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_irCall>(),
        48usize,
        concat!("Size of: ", stringify!(MOJOSHADER_irCall))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_irCall>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_irCall))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irCall>())).info as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irCall),
            "::",
            stringify!(info)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irCall>())).index as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irCall),
            "::",
            stringify!(index)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irCall>())).args as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irCall),
            "::",
            stringify!(args)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_irESeq {
    pub info: MOJOSHADER_irExprInfo,
    pub stmt: *mut MOJOSHADER_irStatement,
    pub expr: *mut MOJOSHADER_irExpression,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_irESeq() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_irESeq>(),
        48usize,
        concat!("Size of: ", stringify!(MOJOSHADER_irESeq))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_irESeq>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_irESeq))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irESeq>())).info as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irESeq),
            "::",
            stringify!(info)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irESeq>())).stmt as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irESeq),
            "::",
            stringify!(stmt)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irESeq>())).expr as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irESeq),
            "::",
            stringify!(expr)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_irArray {
    pub info: MOJOSHADER_irExprInfo,
    pub array: *mut MOJOSHADER_irExpression,
    pub element: *mut MOJOSHADER_irExpression,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_irArray() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_irArray>(),
        48usize,
        concat!("Size of: ", stringify!(MOJOSHADER_irArray))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_irArray>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_irArray))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irArray>())).info as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irArray),
            "::",
            stringify!(info)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irArray>())).array as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irArray),
            "::",
            stringify!(array)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irArray>())).element as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irArray),
            "::",
            stringify!(element)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_irConvert {
    pub info: MOJOSHADER_irExprInfo,
    pub expr: *mut MOJOSHADER_irExpression,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_irConvert() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_irConvert>(),
        40usize,
        concat!("Size of: ", stringify!(MOJOSHADER_irConvert))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_irConvert>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_irConvert))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irConvert>())).info as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irConvert),
            "::",
            stringify!(info)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irConvert>())).expr as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irConvert),
            "::",
            stringify!(expr)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_irSwizzle {
    pub info: MOJOSHADER_irExprInfo,
    pub expr: *mut MOJOSHADER_irExpression,
    pub channels: [::std::os::raw::c_char; 4usize],
}
#[test]
fn bindgen_test_layout_MOJOSHADER_irSwizzle() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_irSwizzle>(),
        48usize,
        concat!("Size of: ", stringify!(MOJOSHADER_irSwizzle))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_irSwizzle>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_irSwizzle))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irSwizzle>())).info as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irSwizzle),
            "::",
            stringify!(info)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irSwizzle>())).expr as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irSwizzle),
            "::",
            stringify!(expr)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irSwizzle>())).channels as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irSwizzle),
            "::",
            stringify!(channels)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_irConstruct {
    pub info: MOJOSHADER_irExprInfo,
    pub args: *mut MOJOSHADER_irExprList,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_irConstruct() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_irConstruct>(),
        40usize,
        concat!("Size of: ", stringify!(MOJOSHADER_irConstruct))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_irConstruct>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_irConstruct))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irConstruct>())).info as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irConstruct),
            "::",
            stringify!(info)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irConstruct>())).args as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irConstruct),
            "::",
            stringify!(args)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union MOJOSHADER_irExpression {
    pub ir: MOJOSHADER_irNodeInfo,
    pub info: MOJOSHADER_irExprInfo,
    pub constant: MOJOSHADER_irConstant,
    pub temp: MOJOSHADER_irTemp,
    pub binop: MOJOSHADER_irBinOp,
    pub memory: MOJOSHADER_irMemory,
    pub call: MOJOSHADER_irCall,
    pub eseq: MOJOSHADER_irESeq,
    pub array: MOJOSHADER_irArray,
    pub convert: MOJOSHADER_irConvert,
    pub swizzle: MOJOSHADER_irSwizzle,
    pub construct: MOJOSHADER_irConstruct,
    _bindgen_union_align: [u64; 12usize],
}
#[test]
fn bindgen_test_layout_MOJOSHADER_irExpression() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_irExpression>(),
        96usize,
        concat!("Size of: ", stringify!(MOJOSHADER_irExpression))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_irExpression>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_irExpression))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irExpression>())).ir as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irExpression),
            "::",
            stringify!(ir)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irExpression>())).info as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irExpression),
            "::",
            stringify!(info)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_irExpression>())).constant as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irExpression),
            "::",
            stringify!(constant)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irExpression>())).temp as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irExpression),
            "::",
            stringify!(temp)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irExpression>())).binop as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irExpression),
            "::",
            stringify!(binop)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irExpression>())).memory as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irExpression),
            "::",
            stringify!(memory)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irExpression>())).call as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irExpression),
            "::",
            stringify!(call)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irExpression>())).eseq as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irExpression),
            "::",
            stringify!(eseq)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irExpression>())).array as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irExpression),
            "::",
            stringify!(array)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irExpression>())).convert as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irExpression),
            "::",
            stringify!(convert)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irExpression>())).swizzle as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irExpression),
            "::",
            stringify!(swizzle)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_irExpression>())).construct as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irExpression),
            "::",
            stringify!(construct)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_irMove {
    pub ir: MOJOSHADER_irNodeInfo,
    pub dst: *mut MOJOSHADER_irExpression,
    pub src: *mut MOJOSHADER_irExpression,
    pub writemask: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_irMove() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_irMove>(),
        48usize,
        concat!("Size of: ", stringify!(MOJOSHADER_irMove))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_irMove>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_irMove))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irMove>())).ir as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irMove),
            "::",
            stringify!(ir)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irMove>())).dst as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irMove),
            "::",
            stringify!(dst)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irMove>())).src as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irMove),
            "::",
            stringify!(src)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irMove>())).writemask as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irMove),
            "::",
            stringify!(writemask)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_irExprStmt {
    pub ir: MOJOSHADER_irNodeInfo,
    pub expr: *mut MOJOSHADER_irExpression,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_irExprStmt() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_irExprStmt>(),
        32usize,
        concat!("Size of: ", stringify!(MOJOSHADER_irExprStmt))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_irExprStmt>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_irExprStmt))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irExprStmt>())).ir as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irExprStmt),
            "::",
            stringify!(ir)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irExprStmt>())).expr as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irExprStmt),
            "::",
            stringify!(expr)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_irJump {
    pub ir: MOJOSHADER_irNodeInfo,
    pub label: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_irJump() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_irJump>(),
        32usize,
        concat!("Size of: ", stringify!(MOJOSHADER_irJump))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_irJump>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_irJump))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irJump>())).ir as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irJump),
            "::",
            stringify!(ir)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irJump>())).label as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irJump),
            "::",
            stringify!(label)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_irCJump {
    pub ir: MOJOSHADER_irNodeInfo,
    pub cond: MOJOSHADER_irConditionType,
    pub left: *mut MOJOSHADER_irExpression,
    pub right: *mut MOJOSHADER_irExpression,
    pub iftrue: ::std::os::raw::c_int,
    pub iffalse: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_irCJump() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_irCJump>(),
        56usize,
        concat!("Size of: ", stringify!(MOJOSHADER_irCJump))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_irCJump>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_irCJump))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irCJump>())).ir as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irCJump),
            "::",
            stringify!(ir)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irCJump>())).cond as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irCJump),
            "::",
            stringify!(cond)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irCJump>())).left as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irCJump),
            "::",
            stringify!(left)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irCJump>())).right as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irCJump),
            "::",
            stringify!(right)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irCJump>())).iftrue as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irCJump),
            "::",
            stringify!(iftrue)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irCJump>())).iffalse as *const _ as usize },
        52usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irCJump),
            "::",
            stringify!(iffalse)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_irSeq {
    pub ir: MOJOSHADER_irNodeInfo,
    pub first: *mut MOJOSHADER_irStatement,
    pub next: *mut MOJOSHADER_irStatement,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_irSeq() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_irSeq>(),
        40usize,
        concat!("Size of: ", stringify!(MOJOSHADER_irSeq))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_irSeq>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_irSeq))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irSeq>())).ir as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irSeq),
            "::",
            stringify!(ir)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irSeq>())).first as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irSeq),
            "::",
            stringify!(first)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irSeq>())).next as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irSeq),
            "::",
            stringify!(next)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_irLabel {
    pub ir: MOJOSHADER_irNodeInfo,
    pub index: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_irLabel() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_irLabel>(),
        32usize,
        concat!("Size of: ", stringify!(MOJOSHADER_irLabel))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_irLabel>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_irLabel))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irLabel>())).ir as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irLabel),
            "::",
            stringify!(ir)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irLabel>())).index as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irLabel),
            "::",
            stringify!(index)
        )
    );
}
pub type MOJOSHADER_irDiscard = MOJOSHADER_irGeneric;
#[repr(C)]
#[derive(Copy, Clone)]
pub union MOJOSHADER_irStatement {
    pub ir: MOJOSHADER_irNodeInfo,
    pub generic: MOJOSHADER_irGeneric,
    pub move_: MOJOSHADER_irMove,
    pub expr: MOJOSHADER_irExprStmt,
    pub jump: MOJOSHADER_irJump,
    pub cjump: MOJOSHADER_irCJump,
    pub seq: MOJOSHADER_irSeq,
    pub label: MOJOSHADER_irLabel,
    pub discard: MOJOSHADER_irDiscard,
    _bindgen_union_align: [u64; 7usize],
}
#[test]
fn bindgen_test_layout_MOJOSHADER_irStatement() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_irStatement>(),
        56usize,
        concat!("Size of: ", stringify!(MOJOSHADER_irStatement))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_irStatement>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_irStatement))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irStatement>())).ir as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irStatement),
            "::",
            stringify!(ir)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irStatement>())).generic as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irStatement),
            "::",
            stringify!(generic)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irStatement>())).move_ as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irStatement),
            "::",
            stringify!(move_)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irStatement>())).expr as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irStatement),
            "::",
            stringify!(expr)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irStatement>())).jump as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irStatement),
            "::",
            stringify!(jump)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irStatement>())).cjump as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irStatement),
            "::",
            stringify!(cjump)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irStatement>())).seq as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irStatement),
            "::",
            stringify!(seq)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irStatement>())).label as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irStatement),
            "::",
            stringify!(label)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irStatement>())).discard as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irStatement),
            "::",
            stringify!(discard)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_irExprList {
    pub ir: MOJOSHADER_irNodeInfo,
    pub expr: *mut MOJOSHADER_irExpression,
    pub next: *mut MOJOSHADER_irExprList,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_irExprList() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_irExprList>(),
        40usize,
        concat!("Size of: ", stringify!(MOJOSHADER_irExprList))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_irExprList>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_irExprList))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irExprList>())).ir as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irExprList),
            "::",
            stringify!(ir)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irExprList>())).expr as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irExprList),
            "::",
            stringify!(expr)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irExprList>())).next as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irExprList),
            "::",
            stringify!(next)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union MOJOSHADER_irMisc {
    pub ir: MOJOSHADER_irNodeInfo,
    pub generic: MOJOSHADER_irGeneric,
    pub exprlist: MOJOSHADER_irExprList,
    _bindgen_union_align: [u64; 5usize],
}
#[test]
fn bindgen_test_layout_MOJOSHADER_irMisc() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_irMisc>(),
        40usize,
        concat!("Size of: ", stringify!(MOJOSHADER_irMisc))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_irMisc>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_irMisc))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irMisc>())).ir as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irMisc),
            "::",
            stringify!(ir)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irMisc>())).generic as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irMisc),
            "::",
            stringify!(generic)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irMisc>())).exprlist as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irMisc),
            "::",
            stringify!(exprlist)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union MOJOSHADER_irNode {
    pub ir: MOJOSHADER_irNodeInfo,
    pub generic: MOJOSHADER_irGeneric,
    pub expr: MOJOSHADER_irExpression,
    pub stmt: MOJOSHADER_irStatement,
    pub misc: MOJOSHADER_irMisc,
    _bindgen_union_align: [u64; 12usize],
}
#[test]
fn bindgen_test_layout_MOJOSHADER_irNode() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_irNode>(),
        96usize,
        concat!("Size of: ", stringify!(MOJOSHADER_irNode))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_irNode>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_irNode))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irNode>())).ir as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irNode),
            "::",
            stringify!(ir)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irNode>())).generic as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irNode),
            "::",
            stringify!(generic)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irNode>())).expr as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irNode),
            "::",
            stringify!(expr)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irNode>())).stmt as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irNode),
            "::",
            stringify!(stmt)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_irNode>())).misc as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_irNode),
            "::",
            stringify!(misc)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_compileData {
    pub error_count: ::std::os::raw::c_int,
    pub errors: *mut MOJOSHADER_error,
    pub warning_count: ::std::os::raw::c_int,
    pub warnings: *mut MOJOSHADER_error,
    pub source_profile: *const ::std::os::raw::c_char,
    pub output: *const ::std::os::raw::c_char,
    pub output_len: ::std::os::raw::c_int,
    pub symbol_count: ::std::os::raw::c_int,
    pub symbols: *mut MOJOSHADER_symbol,
    pub malloc: MOJOSHADER_malloc,
    pub free: MOJOSHADER_free,
    pub malloc_data: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_compileData() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_compileData>(),
        88usize,
        concat!("Size of: ", stringify!(MOJOSHADER_compileData))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_compileData>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_compileData))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_compileData>())).error_count as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_compileData),
            "::",
            stringify!(error_count)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_compileData>())).errors as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_compileData),
            "::",
            stringify!(errors)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_compileData>())).warning_count as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_compileData),
            "::",
            stringify!(warning_count)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_compileData>())).warnings as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_compileData),
            "::",
            stringify!(warnings)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_compileData>())).source_profile as *const _ as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_compileData),
            "::",
            stringify!(source_profile)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_compileData>())).output as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_compileData),
            "::",
            stringify!(output)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_compileData>())).output_len as *const _ as usize
        },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_compileData),
            "::",
            stringify!(output_len)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_compileData>())).symbol_count as *const _ as usize
        },
        52usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_compileData),
            "::",
            stringify!(symbol_count)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_compileData>())).symbols as *const _ as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_compileData),
            "::",
            stringify!(symbols)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_compileData>())).malloc as *const _ as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_compileData),
            "::",
            stringify!(malloc)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_compileData>())).free as *const _ as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_compileData),
            "::",
            stringify!(free)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_compileData>())).malloc_data as *const _ as usize
        },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_compileData),
            "::",
            stringify!(malloc_data)
        )
    );
}
extern "C" {
    pub fn MOJOSHADER_compile(
        srcprofile: *const ::std::os::raw::c_char,
        filename: *const ::std::os::raw::c_char,
        source: *const ::std::os::raw::c_char,
        sourcelen: ::std::os::raw::c_uint,
        defs: *const MOJOSHADER_preprocessorDefine,
        define_count: ::std::os::raw::c_uint,
        include_open: MOJOSHADER_includeOpen,
        include_close: MOJOSHADER_includeClose,
        m: MOJOSHADER_malloc,
        f: MOJOSHADER_free,
        d: *mut ::std::os::raw::c_void,
    ) -> *const MOJOSHADER_compileData;
}
extern "C" {
    pub fn MOJOSHADER_freeCompileData(data: *const MOJOSHADER_compileData);
}
pub type MOJOSHADER_glGetProcAddress = ::std::option::Option<
    unsafe extern "C" fn(
        fnname: *const ::std::os::raw::c_char,
        data: *mut ::std::os::raw::c_void,
    ) -> *mut ::std::os::raw::c_void,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_glContext {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_glShader {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_glProgram {
    _unused: [u8; 0],
}
extern "C" {
    pub fn MOJOSHADER_glAvailableProfiles(
        lookup: MOJOSHADER_glGetProcAddress,
        lookup_d: *mut ::std::os::raw::c_void,
        profs: *mut *const ::std::os::raw::c_char,
        size: ::std::os::raw::c_int,
        m: MOJOSHADER_malloc,
        f: MOJOSHADER_free,
        malloc_d: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn MOJOSHADER_glBestProfile(
        lookup: MOJOSHADER_glGetProcAddress,
        lookup_d: *mut ::std::os::raw::c_void,
        m: MOJOSHADER_malloc,
        f: MOJOSHADER_free,
        malloc_d: *mut ::std::os::raw::c_void,
    ) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn MOJOSHADER_glCreateContext(
        profile: *const ::std::os::raw::c_char,
        lookup: MOJOSHADER_glGetProcAddress,
        lookup_d: *mut ::std::os::raw::c_void,
        m: MOJOSHADER_malloc,
        f: MOJOSHADER_free,
        malloc_d: *mut ::std::os::raw::c_void,
    ) -> *mut MOJOSHADER_glContext;
}
extern "C" {
    pub fn MOJOSHADER_glMakeContextCurrent(ctx: *mut MOJOSHADER_glContext);
}
extern "C" {
    pub fn MOJOSHADER_glGetError() -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn MOJOSHADER_glMaxUniforms(shader_type: MOJOSHADER_shaderType) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn MOJOSHADER_glCompileShader(
        tokenbuf: *const ::std::os::raw::c_uchar,
        bufsize: ::std::os::raw::c_uint,
        swiz: *const MOJOSHADER_swizzle,
        swizcount: ::std::os::raw::c_uint,
        smap: *const MOJOSHADER_samplerMap,
        smapcount: ::std::os::raw::c_uint,
    ) -> *mut MOJOSHADER_glShader;
}
extern "C" {
    pub fn MOJOSHADER_glShaderAddRef(shader: *mut MOJOSHADER_glShader);
}
extern "C" {
    pub fn MOJOSHADER_glGetShaderParseData(
        shader: *mut MOJOSHADER_glShader,
    ) -> *const MOJOSHADER_parseData;
}
extern "C" {
    pub fn MOJOSHADER_glLinkProgram(
        vshader: *mut MOJOSHADER_glShader,
        pshader: *mut MOJOSHADER_glShader,
    ) -> *mut MOJOSHADER_glProgram;
}
extern "C" {
    pub fn MOJOSHADER_glBindProgram(program: *mut MOJOSHADER_glProgram);
}
extern "C" {
    pub fn MOJOSHADER_glBindShaders(
        vshader: *mut MOJOSHADER_glShader,
        pshader: *mut MOJOSHADER_glShader,
    );
}
extern "C" {
    pub fn MOJOSHADER_glGetBoundShaders(
        vshader: *mut *mut MOJOSHADER_glShader,
        pshader: *mut *mut MOJOSHADER_glShader,
    );
}
extern "C" {
    pub fn MOJOSHADER_glSetVertexShaderUniformF(
        idx: ::std::os::raw::c_uint,
        data: *const f32,
        vec4count: ::std::os::raw::c_uint,
    );
}
extern "C" {
    pub fn MOJOSHADER_glGetVertexShaderUniformF(
        idx: ::std::os::raw::c_uint,
        data: *mut f32,
        vec4count: ::std::os::raw::c_uint,
    );
}
extern "C" {
    pub fn MOJOSHADER_glSetVertexShaderUniformI(
        idx: ::std::os::raw::c_uint,
        data: *const ::std::os::raw::c_int,
        ivec4count: ::std::os::raw::c_uint,
    );
}
extern "C" {
    pub fn MOJOSHADER_glGetVertexShaderUniformI(
        idx: ::std::os::raw::c_uint,
        data: *mut ::std::os::raw::c_int,
        ivec4count: ::std::os::raw::c_uint,
    );
}
extern "C" {
    pub fn MOJOSHADER_glSetVertexShaderUniformB(
        idx: ::std::os::raw::c_uint,
        data: *const ::std::os::raw::c_int,
        bcount: ::std::os::raw::c_uint,
    );
}
extern "C" {
    pub fn MOJOSHADER_glGetVertexShaderUniformB(
        idx: ::std::os::raw::c_uint,
        data: *mut ::std::os::raw::c_int,
        bcount: ::std::os::raw::c_uint,
    );
}
extern "C" {
    pub fn MOJOSHADER_glSetPixelShaderUniformF(
        idx: ::std::os::raw::c_uint,
        data: *const f32,
        vec4count: ::std::os::raw::c_uint,
    );
}
extern "C" {
    pub fn MOJOSHADER_glGetPixelShaderUniformF(
        idx: ::std::os::raw::c_uint,
        data: *mut f32,
        vec4count: ::std::os::raw::c_uint,
    );
}
extern "C" {
    pub fn MOJOSHADER_glSetPixelShaderUniformI(
        idx: ::std::os::raw::c_uint,
        data: *const ::std::os::raw::c_int,
        ivec4count: ::std::os::raw::c_uint,
    );
}
extern "C" {
    pub fn MOJOSHADER_glGetPixelShaderUniformI(
        idx: ::std::os::raw::c_uint,
        data: *mut ::std::os::raw::c_int,
        ivec4count: ::std::os::raw::c_uint,
    );
}
extern "C" {
    pub fn MOJOSHADER_glSetPixelShaderUniformB(
        idx: ::std::os::raw::c_uint,
        data: *const ::std::os::raw::c_int,
        bcount: ::std::os::raw::c_uint,
    );
}
extern "C" {
    pub fn MOJOSHADER_glGetPixelShaderUniformB(
        idx: ::std::os::raw::c_uint,
        data: *mut ::std::os::raw::c_int,
        bcount: ::std::os::raw::c_uint,
    );
}
extern "C" {
    pub fn MOJOSHADER_glMapUniformBufferMemory(
        vsf: *mut *mut f32,
        vsi: *mut *mut ::std::os::raw::c_int,
        vsb: *mut *mut ::std::os::raw::c_uchar,
        psf: *mut *mut f32,
        psi: *mut *mut ::std::os::raw::c_int,
        psb: *mut *mut ::std::os::raw::c_uchar,
    );
}
extern "C" {
    pub fn MOJOSHADER_glUnmapUniformBufferMemory();
}
extern "C" {
    pub fn MOJOSHADER_glSetLegacyBumpMapEnv(
        sampler: ::std::os::raw::c_uint,
        mat00: f32,
        mat01: f32,
        mat10: f32,
        mat11: f32,
        lscale: f32,
        loffset: f32,
    );
}
extern "C" {
    pub fn MOJOSHADER_glGetVertexAttribLocation(
        usage: MOJOSHADER_usage,
        index: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn MOJOSHADER_glSetVertexAttribute(
        usage: MOJOSHADER_usage,
        index: ::std::os::raw::c_int,
        size: ::std::os::raw::c_uint,
        type_: MOJOSHADER_attributeType,
        normalized: ::std::os::raw::c_int,
        stride: ::std::os::raw::c_uint,
        ptr: *const ::std::os::raw::c_void,
    );
}
extern "C" {
    pub fn MOJOSHADER_glSetVertexAttribDivisor(
        usage: MOJOSHADER_usage,
        index: ::std::os::raw::c_int,
        divisor: ::std::os::raw::c_uint,
    );
}
extern "C" {
    pub fn MOJOSHADER_glProgramReady();
}
extern "C" {
    pub fn MOJOSHADER_glProgramViewportInfo(
        viewportW: ::std::os::raw::c_int,
        viewportH: ::std::os::raw::c_int,
        backbufferW: ::std::os::raw::c_int,
        backbufferH: ::std::os::raw::c_int,
        renderTargetBound: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn MOJOSHADER_glDeleteProgram(program: *mut MOJOSHADER_glProgram);
}
extern "C" {
    pub fn MOJOSHADER_glDeleteShader(shader: *mut MOJOSHADER_glShader);
}
extern "C" {
    pub fn MOJOSHADER_glDestroyContext(ctx: *mut MOJOSHADER_glContext);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_mtlContext {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_mtlShader {
    _unused: [u8; 0],
}
extern "C" {
    pub fn MOJOSHADER_mtlCreateContext(
        mtlDevice: *mut ::std::os::raw::c_void,
        m: MOJOSHADER_malloc,
        f: MOJOSHADER_free,
        malloc_d: *mut ::std::os::raw::c_void,
    ) -> *mut MOJOSHADER_mtlContext;
}
extern "C" {
    pub fn MOJOSHADER_mtlMakeContextCurrent(ctx: *mut MOJOSHADER_mtlContext);
}
extern "C" {
    pub fn MOJOSHADER_mtlCompileShader(
        mainfn: *const ::std::os::raw::c_char,
        tokenbuf: *const ::std::os::raw::c_uchar,
        bufsize: ::std::os::raw::c_uint,
        swiz: *const MOJOSHADER_swizzle,
        swizcount: ::std::os::raw::c_uint,
        smap: *const MOJOSHADER_samplerMap,
        smapcount: ::std::os::raw::c_uint,
    ) -> *mut MOJOSHADER_mtlShader;
}
extern "C" {
    pub fn MOJOSHADER_mtlShaderAddRef(shader: *mut MOJOSHADER_mtlShader);
}
extern "C" {
    pub fn MOJOSHADER_mtlGetShaderParseData(
        shader: *mut MOJOSHADER_mtlShader,
    ) -> *const MOJOSHADER_parseData;
}
extern "C" {
    pub fn MOJOSHADER_mtlBindShaders(
        vshader: *mut MOJOSHADER_mtlShader,
        pshader: *mut MOJOSHADER_mtlShader,
    );
}
extern "C" {
    pub fn MOJOSHADER_mtlGetBoundShaders(
        vshader: *mut *mut MOJOSHADER_mtlShader,
        pshader: *mut *mut MOJOSHADER_mtlShader,
    );
}
extern "C" {
    pub fn MOJOSHADER_mtlMapUniformBufferMemory(
        vsf: *mut *mut f32,
        vsi: *mut *mut ::std::os::raw::c_int,
        vsb: *mut *mut ::std::os::raw::c_uchar,
        psf: *mut *mut f32,
        psi: *mut *mut ::std::os::raw::c_int,
        psb: *mut *mut ::std::os::raw::c_uchar,
    );
}
extern "C" {
    pub fn MOJOSHADER_mtlUnmapUniformBufferMemory();
}
extern "C" {
    pub fn MOJOSHADER_mtlGetUniformData(
        buf: *mut *mut ::std::os::raw::c_void,
        voff: *mut ::std::os::raw::c_int,
        poff: *mut ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn MOJOSHADER_mtlGetFunctionHandle(
        shader: *mut MOJOSHADER_mtlShader,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn MOJOSHADER_mtlEndFrame();
}
extern "C" {
    pub fn MOJOSHADER_mtlGetVertexAttribLocation(
        vert: *mut MOJOSHADER_mtlShader,
        usage: MOJOSHADER_usage,
        index: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn MOJOSHADER_mtlGetError() -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn MOJOSHADER_mtlDeleteLibrary(library: *mut ::std::os::raw::c_void);
}
extern "C" {
    pub fn MOJOSHADER_mtlDeleteShader(shader: *mut MOJOSHADER_mtlShader);
}
extern "C" {
    pub fn MOJOSHADER_mtlDestroyContext(_ctx: *mut MOJOSHADER_mtlContext);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct VkInstance_T {
    _unused: [u8; 0],
}
pub type VkInstance = *mut VkInstance_T;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct VkDevice_T {
    _unused: [u8; 0],
}
pub type VkDevice = *mut VkDevice_T;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct VkPhysicalDevice_T {
    _unused: [u8; 0],
}
pub type VkPhysicalDevice = *mut VkPhysicalDevice_T;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct VkBuffer_T {
    _unused: [u8; 0],
}
pub type VkBuffer = *mut VkBuffer_T;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct VkShaderModule_T {
    _unused: [u8; 0],
}
pub type VkShaderModule = *mut VkShaderModule_T;
pub type PFN_MOJOSHADER_vkVoidFunction = ::std::option::Option<unsafe extern "C" fn()>;
pub type PFN_MOJOSHADER_vkGetDeviceProcAddr = ::std::option::Option<
    unsafe extern "C" fn(
        device: VkDevice,
        pName: *const ::std::os::raw::c_char,
    ) -> PFN_MOJOSHADER_vkVoidFunction,
>;
pub type PFN_MOJOSHADER_vkGetInstanceProcAddr = ::std::option::Option<
    unsafe extern "C" fn(
        instance: VkInstance,
        pName: *const ::std::os::raw::c_char,
    ) -> PFN_MOJOSHADER_vkVoidFunction,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_vkContext {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_vkShader {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_vkProgram {
    _unused: [u8; 0],
}
extern "C" {
    pub fn MOJOSHADER_vkCreateContext(
        instance: *mut VkInstance,
        physical_device: *mut VkPhysicalDevice,
        logical_device: *mut VkDevice,
        instance_lookup: PFN_MOJOSHADER_vkGetInstanceProcAddr,
        lookup: PFN_MOJOSHADER_vkGetDeviceProcAddr,
        graphics_queue_family_index: ::std::os::raw::c_uint,
        max_uniform_buffer_range: ::std::os::raw::c_uint,
        min_uniform_buffer_offset_alignment: ::std::os::raw::c_uint,
        m: MOJOSHADER_malloc,
        f: MOJOSHADER_free,
        malloc_d: *mut ::std::os::raw::c_void,
    ) -> *mut MOJOSHADER_vkContext;
}
extern "C" {
    pub fn MOJOSHADER_vkMakeContextCurrent(_ctx: *mut MOJOSHADER_vkContext);
}
extern "C" {
    pub fn MOJOSHADER_vkGetError() -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn MOJOSHADER_vkDestroyContext(ctx: *mut MOJOSHADER_vkContext);
}
extern "C" {
    pub fn MOJOSHADER_vkCompileShader(
        mainfn: *const ::std::os::raw::c_char,
        tokenbuf: *const ::std::os::raw::c_uchar,
        bufsize: ::std::os::raw::c_uint,
        swiz: *const MOJOSHADER_swizzle,
        swizcount: ::std::os::raw::c_uint,
        smap: *const MOJOSHADER_samplerMap,
        smapcount: ::std::os::raw::c_uint,
    ) -> *mut MOJOSHADER_vkShader;
}
extern "C" {
    pub fn MOJOSHADER_vkShaderAddRef(shader: *mut MOJOSHADER_vkShader);
}
extern "C" {
    pub fn MOJOSHADER_vkDeleteShader(shader: *mut MOJOSHADER_vkShader);
}
extern "C" {
    pub fn MOJOSHADER_vkGetShaderParseData(
        shader: *mut MOJOSHADER_vkShader,
    ) -> *const MOJOSHADER_parseData;
}
extern "C" {
    pub fn MOJOSHADER_vkLinkProgram(
        vshader: *mut MOJOSHADER_vkShader,
        pshader: *mut MOJOSHADER_vkShader,
    ) -> *mut MOJOSHADER_vkProgram;
}
extern "C" {
    pub fn MOJOSHADER_vkBindProgram(program: *mut MOJOSHADER_vkProgram);
}
extern "C" {
    pub fn MOJOSHADER_vkDeleteProgram(program: *mut MOJOSHADER_vkProgram);
}
extern "C" {
    pub fn MOJOSHADER_vkBindShaders(
        vshader: *mut MOJOSHADER_vkShader,
        pshader: *mut MOJOSHADER_vkShader,
    );
}
extern "C" {
    pub fn MOJOSHADER_vkGetBoundShaders(
        vshader: *mut *mut MOJOSHADER_vkShader,
        pshader: *mut *mut MOJOSHADER_vkShader,
    );
}
extern "C" {
    pub fn MOJOSHADER_vkMapUniformBufferMemory(
        vsf: *mut *mut f32,
        vsi: *mut *mut ::std::os::raw::c_int,
        vsb: *mut *mut ::std::os::raw::c_uchar,
        psf: *mut *mut f32,
        psi: *mut *mut ::std::os::raw::c_int,
        psb: *mut *mut ::std::os::raw::c_uchar,
    );
}
extern "C" {
    pub fn MOJOSHADER_vkUnmapUniformBufferMemory();
}
extern "C" {
    pub fn MOJOSHADER_vkGetUniformBuffers(
        vbuf: *mut VkBuffer,
        voff: *mut ::std::os::raw::c_ulonglong,
        vsize: *mut ::std::os::raw::c_ulonglong,
        pbuf: *mut VkBuffer,
        poff: *mut ::std::os::raw::c_ulonglong,
        psize: *mut ::std::os::raw::c_ulonglong,
    );
}
extern "C" {
    pub fn MOJOSHADER_vkEndFrame();
}
extern "C" {
    pub fn MOJOSHADER_vkGetVertexAttribLocation(
        vert: *mut MOJOSHADER_vkShader,
        usage: MOJOSHADER_usage,
        index: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn MOJOSHADER_vkGetShaderModules(
        vmodule: *mut VkShaderModule,
        pmodule: *mut VkShaderModule,
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_d3d11Shader {
    _unused: [u8; 0],
}
extern "C" {
    pub fn MOJOSHADER_d3d11CreateContext(
        device: *mut ::std::os::raw::c_void,
        deviceContext: *mut ::std::os::raw::c_void,
        m: MOJOSHADER_malloc,
        f: MOJOSHADER_free,
        malloc_d: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn MOJOSHADER_d3d11GetError() -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn MOJOSHADER_d3d11CompileShader(
        mainfn: *const ::std::os::raw::c_char,
        tokenbuf: *const ::std::os::raw::c_uchar,
        bufsize: ::std::os::raw::c_uint,
        swiz: *const MOJOSHADER_swizzle,
        swizcount: ::std::os::raw::c_uint,
        smap: *const MOJOSHADER_samplerMap,
        smapcount: ::std::os::raw::c_uint,
    ) -> *mut MOJOSHADER_d3d11Shader;
}
extern "C" {
    pub fn MOJOSHADER_d3d11ShaderAddRef(shader: *mut MOJOSHADER_d3d11Shader);
}
extern "C" {
    pub fn MOJOSHADER_d3d11GetShaderParseData(
        shader: *mut MOJOSHADER_d3d11Shader,
    ) -> *const MOJOSHADER_parseData;
}
extern "C" {
    pub fn MOJOSHADER_d3d11BindShaders(
        vshader: *mut MOJOSHADER_d3d11Shader,
        pshader: *mut MOJOSHADER_d3d11Shader,
    );
}
extern "C" {
    pub fn MOJOSHADER_d3d11GetBoundShaders(
        vshader: *mut *mut MOJOSHADER_d3d11Shader,
        pshader: *mut *mut MOJOSHADER_d3d11Shader,
    );
}
extern "C" {
    pub fn MOJOSHADER_d3d11MapUniformBufferMemory(
        vsf: *mut *mut f32,
        vsi: *mut *mut ::std::os::raw::c_int,
        vsb: *mut *mut ::std::os::raw::c_uchar,
        psf: *mut *mut f32,
        psi: *mut *mut ::std::os::raw::c_int,
        psb: *mut *mut ::std::os::raw::c_uchar,
    );
}
extern "C" {
    pub fn MOJOSHADER_d3d11UnmapUniformBufferMemory();
}
extern "C" {
    pub fn MOJOSHADER_d3d11GetVertexAttribLocation(
        vert: *mut MOJOSHADER_d3d11Shader,
        usage: MOJOSHADER_usage,
        index: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn MOJOSHADER_d3d11CompileVertexShader(
        inputLayoutHash: ::std::os::raw::c_ulonglong,
        elements: *mut ::std::os::raw::c_void,
        elementCount: ::std::os::raw::c_int,
        bytecode: *mut *mut ::std::os::raw::c_void,
        bytecodeLength: *mut ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn MOJOSHADER_d3d11ProgramReady(inputLayoutHash: ::std::os::raw::c_ulonglong);
}
extern "C" {
    pub fn MOJOSHADER_d3d11DeleteShader(shader: *mut MOJOSHADER_d3d11Shader);
}
extern "C" {
    pub fn MOJOSHADER_d3d11DestroyContext();
}
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_ZENABLE: MOJOSHADER_renderStateType = 0;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_FILLMODE: MOJOSHADER_renderStateType = 1;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_SHADEMODE: MOJOSHADER_renderStateType = 2;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_ZWRITEENABLE: MOJOSHADER_renderStateType = 3;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_ALPHATESTENABLE: MOJOSHADER_renderStateType = 4;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_LASTPIXEL: MOJOSHADER_renderStateType = 5;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_SRCBLEND: MOJOSHADER_renderStateType = 6;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_DESTBLEND: MOJOSHADER_renderStateType = 7;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_CULLMODE: MOJOSHADER_renderStateType = 8;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_ZFUNC: MOJOSHADER_renderStateType = 9;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_ALPHAREF: MOJOSHADER_renderStateType = 10;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_ALPHAFUNC: MOJOSHADER_renderStateType = 11;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_DITHERENABLE: MOJOSHADER_renderStateType = 12;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_ALPHABLENDENABLE: MOJOSHADER_renderStateType =
    13;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_FOGENABLE: MOJOSHADER_renderStateType = 14;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_SPECULARENABLE: MOJOSHADER_renderStateType = 15;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_FOGCOLOR: MOJOSHADER_renderStateType = 16;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_FOGTABLEMODE: MOJOSHADER_renderStateType = 17;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_FOGSTART: MOJOSHADER_renderStateType = 18;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_FOGEND: MOJOSHADER_renderStateType = 19;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_FOGDENSITY: MOJOSHADER_renderStateType = 20;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_RANGEFOGENABLE: MOJOSHADER_renderStateType = 21;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_STENCILENABLE: MOJOSHADER_renderStateType = 22;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_STENCILFAIL: MOJOSHADER_renderStateType = 23;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_STENCILZFAIL: MOJOSHADER_renderStateType = 24;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_STENCILPASS: MOJOSHADER_renderStateType = 25;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_STENCILFUNC: MOJOSHADER_renderStateType = 26;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_STENCILREF: MOJOSHADER_renderStateType = 27;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_STENCILMASK: MOJOSHADER_renderStateType = 28;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_STENCILWRITEMASK: MOJOSHADER_renderStateType =
    29;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_TEXTUREFACTOR: MOJOSHADER_renderStateType = 30;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_WRAP0: MOJOSHADER_renderStateType = 31;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_WRAP1: MOJOSHADER_renderStateType = 32;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_WRAP2: MOJOSHADER_renderStateType = 33;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_WRAP3: MOJOSHADER_renderStateType = 34;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_WRAP4: MOJOSHADER_renderStateType = 35;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_WRAP5: MOJOSHADER_renderStateType = 36;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_WRAP6: MOJOSHADER_renderStateType = 37;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_WRAP7: MOJOSHADER_renderStateType = 38;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_WRAP8: MOJOSHADER_renderStateType = 39;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_WRAP9: MOJOSHADER_renderStateType = 40;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_WRAP10: MOJOSHADER_renderStateType = 41;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_WRAP11: MOJOSHADER_renderStateType = 42;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_WRAP12: MOJOSHADER_renderStateType = 43;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_WRAP13: MOJOSHADER_renderStateType = 44;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_WRAP14: MOJOSHADER_renderStateType = 45;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_WRAP15: MOJOSHADER_renderStateType = 46;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_CLIPPING: MOJOSHADER_renderStateType = 47;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_LIGHTING: MOJOSHADER_renderStateType = 48;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_AMBIENT: MOJOSHADER_renderStateType = 49;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_FOGVERTEXMODE: MOJOSHADER_renderStateType = 50;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_COLORVERTEX: MOJOSHADER_renderStateType = 51;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_LOCALVIEWER: MOJOSHADER_renderStateType = 52;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_NORMALIZENORMALS: MOJOSHADER_renderStateType =
    53;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_DIFFUSEMATERIALSOURCE:
    MOJOSHADER_renderStateType = 54;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_SPECULARMATERIALSOURCE:
    MOJOSHADER_renderStateType = 55;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_AMBIENTMATERIALSOURCE:
    MOJOSHADER_renderStateType = 56;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_EMISSIVEMATERIALSOURCE:
    MOJOSHADER_renderStateType = 57;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_VERTEXBLEND: MOJOSHADER_renderStateType = 58;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_CLIPPLANEENABLE: MOJOSHADER_renderStateType = 59;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_POINTSIZE: MOJOSHADER_renderStateType = 60;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_POINTSIZE_MIN: MOJOSHADER_renderStateType = 61;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_POINTSPRITEENABLE: MOJOSHADER_renderStateType =
    62;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_POINTSCALEENABLE: MOJOSHADER_renderStateType =
    63;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_POINTSCALE_A: MOJOSHADER_renderStateType = 64;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_POINTSCALE_B: MOJOSHADER_renderStateType = 65;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_POINTSCALE_C: MOJOSHADER_renderStateType = 66;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_MULTISAMPLEANTIALIAS:
    MOJOSHADER_renderStateType = 67;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_MULTISAMPLEMASK: MOJOSHADER_renderStateType = 68;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_PATCHEDGESTYLE: MOJOSHADER_renderStateType = 69;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_DEBUGMONITORTOKEN: MOJOSHADER_renderStateType =
    70;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_POINTSIZE_MAX: MOJOSHADER_renderStateType = 71;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_INDEXEDVERTEXBLENDENABLE:
    MOJOSHADER_renderStateType = 72;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_COLORWRITEENABLE: MOJOSHADER_renderStateType =
    73;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_TWEENFACTOR: MOJOSHADER_renderStateType = 74;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_BLENDOP: MOJOSHADER_renderStateType = 75;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_POSITIONDEGREE: MOJOSHADER_renderStateType = 76;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_NORMALDEGREE: MOJOSHADER_renderStateType = 77;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_SCISSORTESTENABLE: MOJOSHADER_renderStateType =
    78;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_SLOPESCALEDEPTHBIAS: MOJOSHADER_renderStateType =
    79;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_ANTIALIASEDLINEENABLE:
    MOJOSHADER_renderStateType = 80;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_MINTESSELLATIONLEVEL:
    MOJOSHADER_renderStateType = 81;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_MAXTESSELLATIONLEVEL:
    MOJOSHADER_renderStateType = 82;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_ADAPTIVETESS_X: MOJOSHADER_renderStateType = 83;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_ADAPTIVETESS_Y: MOJOSHADER_renderStateType = 84;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_ADAPTIVETESS_Z: MOJOSHADER_renderStateType = 85;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_ADAPTIVETESS_W: MOJOSHADER_renderStateType = 86;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_ENABLEADAPTIVETESSELLATION:
    MOJOSHADER_renderStateType = 87;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_TWOSIDEDSTENCILMODE: MOJOSHADER_renderStateType =
    88;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_CCW_STENCILFAIL: MOJOSHADER_renderStateType = 89;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_CCW_STENCILZFAIL: MOJOSHADER_renderStateType =
    90;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_CCW_STENCILPASS: MOJOSHADER_renderStateType = 91;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_CCW_STENCILFUNC: MOJOSHADER_renderStateType = 92;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_COLORWRITEENABLE1: MOJOSHADER_renderStateType =
    93;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_COLORWRITEENABLE2: MOJOSHADER_renderStateType =
    94;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_COLORWRITEENABLE3: MOJOSHADER_renderStateType =
    95;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_BLENDFACTOR: MOJOSHADER_renderStateType = 96;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_SRGBWRITEENABLE: MOJOSHADER_renderStateType = 97;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_DEPTHBIAS: MOJOSHADER_renderStateType = 98;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_SEPARATEALPHABLENDENABLE:
    MOJOSHADER_renderStateType = 99;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_SRCBLENDALPHA: MOJOSHADER_renderStateType = 100;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_DESTBLENDALPHA: MOJOSHADER_renderStateType = 101;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_BLENDOPALPHA: MOJOSHADER_renderStateType = 102;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_VERTEXSHADER: MOJOSHADER_renderStateType = 146;
pub const MOJOSHADER_renderStateType_MOJOSHADER_RS_PIXELSHADER: MOJOSHADER_renderStateType = 147;
pub type MOJOSHADER_renderStateType = ::std::os::raw::c_uint;
pub const MOJOSHADER_zBufferType_MOJOSHADER_ZB_FALSE: MOJOSHADER_zBufferType = 0;
pub const MOJOSHADER_zBufferType_MOJOSHADER_ZB_TRUE: MOJOSHADER_zBufferType = 1;
pub const MOJOSHADER_zBufferType_MOJOSHADER_ZB_USEW: MOJOSHADER_zBufferType = 2;
pub type MOJOSHADER_zBufferType = ::std::os::raw::c_uint;
pub const MOJOSHADER_fillMode_MOJOSHADER_FILL_POINT: MOJOSHADER_fillMode = 1;
pub const MOJOSHADER_fillMode_MOJOSHADER_FILL_WIREFRAME: MOJOSHADER_fillMode = 2;
pub const MOJOSHADER_fillMode_MOJOSHADER_FILL_SOLID: MOJOSHADER_fillMode = 3;
pub type MOJOSHADER_fillMode = ::std::os::raw::c_uint;
pub const MOJOSHADER_shadeMode_MOJOSHADER_SHADE_FLAT: MOJOSHADER_shadeMode = 1;
pub const MOJOSHADER_shadeMode_MOJOSHADER_SHADE_GOURAUD: MOJOSHADER_shadeMode = 2;
pub const MOJOSHADER_shadeMode_MOJOSHADER_SHADE_PHONG: MOJOSHADER_shadeMode = 3;
pub type MOJOSHADER_shadeMode = ::std::os::raw::c_uint;
pub const MOJOSHADER_blendMode_MOJOSHADER_BLEND_ZERO: MOJOSHADER_blendMode = 1;
pub const MOJOSHADER_blendMode_MOJOSHADER_BLEND_ONE: MOJOSHADER_blendMode = 2;
pub const MOJOSHADER_blendMode_MOJOSHADER_BLEND_SRCCOLOR: MOJOSHADER_blendMode = 3;
pub const MOJOSHADER_blendMode_MOJOSHADER_BLEND_INVSRCCOLOR: MOJOSHADER_blendMode = 4;
pub const MOJOSHADER_blendMode_MOJOSHADER_BLEND_SRCALPHA: MOJOSHADER_blendMode = 5;
pub const MOJOSHADER_blendMode_MOJOSHADER_BLEND_INVSRCALPHA: MOJOSHADER_blendMode = 6;
pub const MOJOSHADER_blendMode_MOJOSHADER_BLEND_DESTALPHA: MOJOSHADER_blendMode = 7;
pub const MOJOSHADER_blendMode_MOJOSHADER_BLEND_INVDESTALPHA: MOJOSHADER_blendMode = 8;
pub const MOJOSHADER_blendMode_MOJOSHADER_BLEND_DESTCOLOR: MOJOSHADER_blendMode = 9;
pub const MOJOSHADER_blendMode_MOJOSHADER_BLEND_INVDESTCOLOR: MOJOSHADER_blendMode = 10;
pub const MOJOSHADER_blendMode_MOJOSHADER_BLEND_SRCALPHASAT: MOJOSHADER_blendMode = 11;
pub const MOJOSHADER_blendMode_MOJOSHADER_BLEND_BOTHSRCALPHA: MOJOSHADER_blendMode = 12;
pub const MOJOSHADER_blendMode_MOJOSHADER_BLEND_BOTHINVSRCALPHA: MOJOSHADER_blendMode = 13;
pub const MOJOSHADER_blendMode_MOJOSHADER_BLEND_BLENDFACTOR: MOJOSHADER_blendMode = 14;
pub const MOJOSHADER_blendMode_MOJOSHADER_BLEND_INVBLENDFACTOR: MOJOSHADER_blendMode = 15;
pub const MOJOSHADER_blendMode_MOJOSHADER_BLEND_SRCCOLOR2: MOJOSHADER_blendMode = 16;
pub const MOJOSHADER_blendMode_MOJOSHADER_BLEND_INVSRCCOLOR2: MOJOSHADER_blendMode = 17;
pub type MOJOSHADER_blendMode = ::std::os::raw::c_uint;
pub const MOJOSHADER_cullMode_MOJOSHADER_CULL_NONE: MOJOSHADER_cullMode = 1;
pub const MOJOSHADER_cullMode_MOJOSHADER_CULL_CW: MOJOSHADER_cullMode = 2;
pub const MOJOSHADER_cullMode_MOJOSHADER_CULL_CCW: MOJOSHADER_cullMode = 3;
pub type MOJOSHADER_cullMode = ::std::os::raw::c_uint;
pub const MOJOSHADER_compareFunc_MOJOSHADER_CMP_NEVER: MOJOSHADER_compareFunc = 1;
pub const MOJOSHADER_compareFunc_MOJOSHADER_CMP_LESS: MOJOSHADER_compareFunc = 2;
pub const MOJOSHADER_compareFunc_MOJOSHADER_CMP_EQUAL: MOJOSHADER_compareFunc = 3;
pub const MOJOSHADER_compareFunc_MOJOSHADER_CMP_LESSEQUAL: MOJOSHADER_compareFunc = 4;
pub const MOJOSHADER_compareFunc_MOJOSHADER_CMP_GREATER: MOJOSHADER_compareFunc = 5;
pub const MOJOSHADER_compareFunc_MOJOSHADER_CMP_NOTEQUAL: MOJOSHADER_compareFunc = 6;
pub const MOJOSHADER_compareFunc_MOJOSHADER_CMP_GREATEREQUAL: MOJOSHADER_compareFunc = 7;
pub const MOJOSHADER_compareFunc_MOJOSHADER_CMP_ALWAYS: MOJOSHADER_compareFunc = 8;
pub type MOJOSHADER_compareFunc = ::std::os::raw::c_uint;
pub const MOJOSHADER_fogMode_MOJOSHADER_FOG_NONE: MOJOSHADER_fogMode = 0;
pub const MOJOSHADER_fogMode_MOJOSHADER_FOG_EXP: MOJOSHADER_fogMode = 1;
pub const MOJOSHADER_fogMode_MOJOSHADER_FOG_EXP2: MOJOSHADER_fogMode = 2;
pub const MOJOSHADER_fogMode_MOJOSHADER_FOG_LINEAR: MOJOSHADER_fogMode = 3;
pub type MOJOSHADER_fogMode = ::std::os::raw::c_uint;
pub const MOJOSHADER_stencilOp_MOJOSHADER_STENCILOP_KEEP: MOJOSHADER_stencilOp = 1;
pub const MOJOSHADER_stencilOp_MOJOSHADER_STENCILOP_ZERO: MOJOSHADER_stencilOp = 2;
pub const MOJOSHADER_stencilOp_MOJOSHADER_STENCILOP_REPLACE: MOJOSHADER_stencilOp = 3;
pub const MOJOSHADER_stencilOp_MOJOSHADER_STENCILOP_INCRSAT: MOJOSHADER_stencilOp = 4;
pub const MOJOSHADER_stencilOp_MOJOSHADER_STENCILOP_DECRSAT: MOJOSHADER_stencilOp = 5;
pub const MOJOSHADER_stencilOp_MOJOSHADER_STENCILOP_INVERT: MOJOSHADER_stencilOp = 6;
pub const MOJOSHADER_stencilOp_MOJOSHADER_STENCILOP_INCR: MOJOSHADER_stencilOp = 7;
pub const MOJOSHADER_stencilOp_MOJOSHADER_STENCILOP_DECR: MOJOSHADER_stencilOp = 8;
pub type MOJOSHADER_stencilOp = ::std::os::raw::c_uint;
pub const MOJOSHADER_materialColorSource_MOJOSHADER_MCS_MATERIAL: MOJOSHADER_materialColorSource =
    0;
pub const MOJOSHADER_materialColorSource_MOJOSHADER_MCS_COLOR1: MOJOSHADER_materialColorSource = 1;
pub const MOJOSHADER_materialColorSource_MOJOSHADER_MCS_COLOR2: MOJOSHADER_materialColorSource = 2;
pub type MOJOSHADER_materialColorSource = ::std::os::raw::c_uint;
pub const MOJOSHADER_vertexBlendFlags_MOJOSHADER_VBF_DISABLE: MOJOSHADER_vertexBlendFlags = 0;
pub const MOJOSHADER_vertexBlendFlags_MOJOSHADER_VBF_1WEIGHTS: MOJOSHADER_vertexBlendFlags = 1;
pub const MOJOSHADER_vertexBlendFlags_MOJOSHADER_VBF_2WEIGHTS: MOJOSHADER_vertexBlendFlags = 2;
pub const MOJOSHADER_vertexBlendFlags_MOJOSHADER_VBF_3WEIGHTS: MOJOSHADER_vertexBlendFlags = 3;
pub const MOJOSHADER_vertexBlendFlags_MOJOSHADER_VBF_TWEENING: MOJOSHADER_vertexBlendFlags = 255;
pub const MOJOSHADER_vertexBlendFlags_MOJOSHADER_VBF_0WEIGHTS: MOJOSHADER_vertexBlendFlags = 256;
pub type MOJOSHADER_vertexBlendFlags = ::std::os::raw::c_uint;
pub const MOJOSHADER_patchedEdgeStyle_MOJOSHADER_PATCHEDGE_DISCRETE: MOJOSHADER_patchedEdgeStyle =
    0;
pub const MOJOSHADER_patchedEdgeStyle_MOJOSHADER_PATCHEDGE_CONTINUOUS: MOJOSHADER_patchedEdgeStyle =
    1;
pub type MOJOSHADER_patchedEdgeStyle = ::std::os::raw::c_uint;
pub const MOJOSHADER_debugMonitorTokens_MOJOSHADER_DMT_ENABLE: MOJOSHADER_debugMonitorTokens = 0;
pub const MOJOSHADER_debugMonitorTokens_MOJOSHADER_DMT_DISABLE: MOJOSHADER_debugMonitorTokens = 1;
pub type MOJOSHADER_debugMonitorTokens = ::std::os::raw::c_uint;
pub const MOJOSHADER_blendOp_MOJOSHADER_BLENDOP_ADD: MOJOSHADER_blendOp = 1;
pub const MOJOSHADER_blendOp_MOJOSHADER_BLENDOP_SUBTRACT: MOJOSHADER_blendOp = 2;
pub const MOJOSHADER_blendOp_MOJOSHADER_BLENDOP_REVSUBTRACT: MOJOSHADER_blendOp = 3;
pub const MOJOSHADER_blendOp_MOJOSHADER_BLENDOP_MIN: MOJOSHADER_blendOp = 4;
pub const MOJOSHADER_blendOp_MOJOSHADER_BLENDOP_MAX: MOJOSHADER_blendOp = 5;
pub type MOJOSHADER_blendOp = ::std::os::raw::c_uint;
pub const MOJOSHADER_degreeType_MOJOSHADER_DEGREE_LINEAR: MOJOSHADER_degreeType = 1;
pub const MOJOSHADER_degreeType_MOJOSHADER_DEGREE_QUADRATIC: MOJOSHADER_degreeType = 2;
pub const MOJOSHADER_degreeType_MOJOSHADER_DEGREE_CUBIC: MOJOSHADER_degreeType = 3;
pub const MOJOSHADER_degreeType_MOJOSHADER_DEGREE_QUINTIC: MOJOSHADER_degreeType = 5;
pub type MOJOSHADER_degreeType = ::std::os::raw::c_uint;
pub const MOJOSHADER_samplerStateType_MOJOSHADER_SAMP_UNKNOWN0: MOJOSHADER_samplerStateType = 0;
pub const MOJOSHADER_samplerStateType_MOJOSHADER_SAMP_UNKNOWN1: MOJOSHADER_samplerStateType = 1;
pub const MOJOSHADER_samplerStateType_MOJOSHADER_SAMP_UNKNOWN2: MOJOSHADER_samplerStateType = 2;
pub const MOJOSHADER_samplerStateType_MOJOSHADER_SAMP_UNKNOWN3: MOJOSHADER_samplerStateType = 3;
pub const MOJOSHADER_samplerStateType_MOJOSHADER_SAMP_TEXTURE: MOJOSHADER_samplerStateType = 4;
pub const MOJOSHADER_samplerStateType_MOJOSHADER_SAMP_ADDRESSU: MOJOSHADER_samplerStateType = 5;
pub const MOJOSHADER_samplerStateType_MOJOSHADER_SAMP_ADDRESSV: MOJOSHADER_samplerStateType = 6;
pub const MOJOSHADER_samplerStateType_MOJOSHADER_SAMP_ADDRESSW: MOJOSHADER_samplerStateType = 7;
pub const MOJOSHADER_samplerStateType_MOJOSHADER_SAMP_BORDERCOLOR: MOJOSHADER_samplerStateType = 8;
pub const MOJOSHADER_samplerStateType_MOJOSHADER_SAMP_MAGFILTER: MOJOSHADER_samplerStateType = 9;
pub const MOJOSHADER_samplerStateType_MOJOSHADER_SAMP_MINFILTER: MOJOSHADER_samplerStateType = 10;
pub const MOJOSHADER_samplerStateType_MOJOSHADER_SAMP_MIPFILTER: MOJOSHADER_samplerStateType = 11;
pub const MOJOSHADER_samplerStateType_MOJOSHADER_SAMP_MIPMAPLODBIAS: MOJOSHADER_samplerStateType =
    12;
pub const MOJOSHADER_samplerStateType_MOJOSHADER_SAMP_MAXMIPLEVEL: MOJOSHADER_samplerStateType = 13;
pub const MOJOSHADER_samplerStateType_MOJOSHADER_SAMP_MAXANISOTROPY: MOJOSHADER_samplerStateType =
    14;
pub const MOJOSHADER_samplerStateType_MOJOSHADER_SAMP_SRGBTEXTURE: MOJOSHADER_samplerStateType = 15;
pub const MOJOSHADER_samplerStateType_MOJOSHADER_SAMP_ELEMENTINDEX: MOJOSHADER_samplerStateType =
    16;
pub const MOJOSHADER_samplerStateType_MOJOSHADER_SAMP_DMAPOFFSET: MOJOSHADER_samplerStateType = 17;
pub type MOJOSHADER_samplerStateType = ::std::os::raw::c_uint;
pub const MOJOSHADER_textureAddress_MOJOSHADER_TADDRESS_WRAP: MOJOSHADER_textureAddress = 1;
pub const MOJOSHADER_textureAddress_MOJOSHADER_TADDRESS_MIRROR: MOJOSHADER_textureAddress = 2;
pub const MOJOSHADER_textureAddress_MOJOSHADER_TADDRESS_CLAMP: MOJOSHADER_textureAddress = 3;
pub const MOJOSHADER_textureAddress_MOJOSHADER_TADDRESS_BORDER: MOJOSHADER_textureAddress = 4;
pub const MOJOSHADER_textureAddress_MOJOSHADER_TADDRESS_MIRRORONCE: MOJOSHADER_textureAddress = 5;
pub type MOJOSHADER_textureAddress = ::std::os::raw::c_uint;
pub const MOJOSHADER_textureFilterType_MOJOSHADER_TEXTUREFILTER_NONE: MOJOSHADER_textureFilterType =
    0;
pub const MOJOSHADER_textureFilterType_MOJOSHADER_TEXTUREFILTER_POINT:
    MOJOSHADER_textureFilterType = 1;
pub const MOJOSHADER_textureFilterType_MOJOSHADER_TEXTUREFILTER_LINEAR:
    MOJOSHADER_textureFilterType = 2;
pub const MOJOSHADER_textureFilterType_MOJOSHADER_TEXTUREFILTER_ANISOTROPIC:
    MOJOSHADER_textureFilterType = 3;
pub const MOJOSHADER_textureFilterType_MOJOSHADER_TEXTUREFILTER_PYRAMIDALQUAD:
    MOJOSHADER_textureFilterType = 4;
pub const MOJOSHADER_textureFilterType_MOJOSHADER_TEXTUREFILTER_GAUSSIANQUAD:
    MOJOSHADER_textureFilterType = 5;
pub const MOJOSHADER_textureFilterType_MOJOSHADER_TEXTUREFILTER_CONVOLUTIONMONO:
    MOJOSHADER_textureFilterType = 6;
pub type MOJOSHADER_textureFilterType = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct MOJOSHADER_effectValue {
    pub name: *const ::std::os::raw::c_char,
    pub semantic: *const ::std::os::raw::c_char,
    pub type_: MOJOSHADER_symbolTypeInfo,
    pub value_count: ::std::os::raw::c_uint,
    pub __bindgen_anon_1: MOJOSHADER_effectValue__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union MOJOSHADER_effectValue__bindgen_ty_1 {
    pub values: *mut ::std::os::raw::c_void,
    pub valuesI: *mut ::std::os::raw::c_int,
    pub valuesF: *mut f32,
    pub valuesZBT: *mut MOJOSHADER_zBufferType,
    pub valuesFiM: *mut MOJOSHADER_fillMode,
    pub valuesSM: *mut MOJOSHADER_shadeMode,
    pub valuesBM: *mut MOJOSHADER_blendMode,
    pub valuesCM: *mut MOJOSHADER_cullMode,
    pub valuesCF: *mut MOJOSHADER_compareFunc,
    pub valuesFoM: *mut MOJOSHADER_fogMode,
    pub valuesSO: *mut MOJOSHADER_stencilOp,
    pub valuesMCS: *mut MOJOSHADER_materialColorSource,
    pub valuesVBF: *mut MOJOSHADER_vertexBlendFlags,
    pub valuesPES: *mut MOJOSHADER_patchedEdgeStyle,
    pub valuesDMT: *mut MOJOSHADER_debugMonitorTokens,
    pub valuesBO: *mut MOJOSHADER_blendOp,
    pub valuesDT: *mut MOJOSHADER_degreeType,
    pub valuesTA: *mut MOJOSHADER_textureAddress,
    pub valuesTFT: *mut MOJOSHADER_textureFilterType,
    pub valuesSS: *mut MOJOSHADER_effectSamplerState,
    _bindgen_union_align: u64,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_effectValue__bindgen_ty_1() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_effectValue__bindgen_ty_1>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(MOJOSHADER_effectValue__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_effectValue__bindgen_ty_1>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(MOJOSHADER_effectValue__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectValue__bindgen_ty_1>())).values as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectValue__bindgen_ty_1),
            "::",
            stringify!(values)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectValue__bindgen_ty_1>())).valuesI as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectValue__bindgen_ty_1),
            "::",
            stringify!(valuesI)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectValue__bindgen_ty_1>())).valuesF as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectValue__bindgen_ty_1),
            "::",
            stringify!(valuesF)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectValue__bindgen_ty_1>())).valuesZBT as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectValue__bindgen_ty_1),
            "::",
            stringify!(valuesZBT)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectValue__bindgen_ty_1>())).valuesFiM as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectValue__bindgen_ty_1),
            "::",
            stringify!(valuesFiM)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectValue__bindgen_ty_1>())).valuesSM as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectValue__bindgen_ty_1),
            "::",
            stringify!(valuesSM)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectValue__bindgen_ty_1>())).valuesBM as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectValue__bindgen_ty_1),
            "::",
            stringify!(valuesBM)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectValue__bindgen_ty_1>())).valuesCM as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectValue__bindgen_ty_1),
            "::",
            stringify!(valuesCM)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectValue__bindgen_ty_1>())).valuesCF as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectValue__bindgen_ty_1),
            "::",
            stringify!(valuesCF)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectValue__bindgen_ty_1>())).valuesFoM as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectValue__bindgen_ty_1),
            "::",
            stringify!(valuesFoM)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectValue__bindgen_ty_1>())).valuesSO as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectValue__bindgen_ty_1),
            "::",
            stringify!(valuesSO)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectValue__bindgen_ty_1>())).valuesMCS as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectValue__bindgen_ty_1),
            "::",
            stringify!(valuesMCS)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectValue__bindgen_ty_1>())).valuesVBF as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectValue__bindgen_ty_1),
            "::",
            stringify!(valuesVBF)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectValue__bindgen_ty_1>())).valuesPES as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectValue__bindgen_ty_1),
            "::",
            stringify!(valuesPES)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectValue__bindgen_ty_1>())).valuesDMT as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectValue__bindgen_ty_1),
            "::",
            stringify!(valuesDMT)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectValue__bindgen_ty_1>())).valuesBO as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectValue__bindgen_ty_1),
            "::",
            stringify!(valuesBO)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectValue__bindgen_ty_1>())).valuesDT as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectValue__bindgen_ty_1),
            "::",
            stringify!(valuesDT)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectValue__bindgen_ty_1>())).valuesTA as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectValue__bindgen_ty_1),
            "::",
            stringify!(valuesTA)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectValue__bindgen_ty_1>())).valuesTFT as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectValue__bindgen_ty_1),
            "::",
            stringify!(valuesTFT)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectValue__bindgen_ty_1>())).valuesSS as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectValue__bindgen_ty_1),
            "::",
            stringify!(valuesSS)
        )
    );
}
#[test]
fn bindgen_test_layout_MOJOSHADER_effectValue() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_effectValue>(),
        64usize,
        concat!("Size of: ", stringify!(MOJOSHADER_effectValue))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_effectValue>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_effectValue))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_effectValue>())).name as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectValue),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_effectValue>())).semantic as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectValue),
            "::",
            stringify!(semantic)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_effectValue>())).type_ as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectValue),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectValue>())).value_count as *const _ as usize
        },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectValue),
            "::",
            stringify!(value_count)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct MOJOSHADER_effectState {
    pub type_: MOJOSHADER_renderStateType,
    pub value: MOJOSHADER_effectValue,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_effectState() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_effectState>(),
        72usize,
        concat!("Size of: ", stringify!(MOJOSHADER_effectState))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_effectState>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_effectState))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_effectState>())).type_ as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectState),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_effectState>())).value as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectState),
            "::",
            stringify!(value)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct MOJOSHADER_effectSamplerState {
    pub type_: MOJOSHADER_samplerStateType,
    pub value: MOJOSHADER_effectValue,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_effectSamplerState() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_effectSamplerState>(),
        72usize,
        concat!("Size of: ", stringify!(MOJOSHADER_effectSamplerState))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_effectSamplerState>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_effectSamplerState))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectSamplerState>())).type_ as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectSamplerState),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectSamplerState>())).value as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectSamplerState),
            "::",
            stringify!(value)
        )
    );
}
pub type MOJOSHADER_effectAnnotation = MOJOSHADER_effectValue;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct MOJOSHADER_effectParam {
    pub value: MOJOSHADER_effectValue,
    pub annotation_count: ::std::os::raw::c_uint,
    pub annotations: *mut MOJOSHADER_effectAnnotation,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_effectParam() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_effectParam>(),
        80usize,
        concat!("Size of: ", stringify!(MOJOSHADER_effectParam))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_effectParam>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_effectParam))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_effectParam>())).value as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectParam),
            "::",
            stringify!(value)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectParam>())).annotation_count as *const _ as usize
        },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectParam),
            "::",
            stringify!(annotation_count)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectParam>())).annotations as *const _ as usize
        },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectParam),
            "::",
            stringify!(annotations)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_effectPass {
    pub name: *const ::std::os::raw::c_char,
    pub state_count: ::std::os::raw::c_uint,
    pub states: *mut MOJOSHADER_effectState,
    pub annotation_count: ::std::os::raw::c_uint,
    pub annotations: *mut MOJOSHADER_effectAnnotation,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_effectPass() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_effectPass>(),
        40usize,
        concat!("Size of: ", stringify!(MOJOSHADER_effectPass))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_effectPass>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_effectPass))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_effectPass>())).name as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectPass),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectPass>())).state_count as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectPass),
            "::",
            stringify!(state_count)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_effectPass>())).states as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectPass),
            "::",
            stringify!(states)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectPass>())).annotation_count as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectPass),
            "::",
            stringify!(annotation_count)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectPass>())).annotations as *const _ as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectPass),
            "::",
            stringify!(annotations)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_effectTechnique {
    pub name: *const ::std::os::raw::c_char,
    pub pass_count: ::std::os::raw::c_uint,
    pub passes: *mut MOJOSHADER_effectPass,
    pub annotation_count: ::std::os::raw::c_uint,
    pub annotations: *mut MOJOSHADER_effectAnnotation,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_effectTechnique() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_effectTechnique>(),
        40usize,
        concat!("Size of: ", stringify!(MOJOSHADER_effectTechnique))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_effectTechnique>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_effectTechnique))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_effectTechnique>())).name as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectTechnique),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectTechnique>())).pass_count as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectTechnique),
            "::",
            stringify!(pass_count)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectTechnique>())).passes as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectTechnique),
            "::",
            stringify!(passes)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectTechnique>())).annotation_count as *const _
                as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectTechnique),
            "::",
            stringify!(annotation_count)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectTechnique>())).annotations as *const _ as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectTechnique),
            "::",
            stringify!(annotations)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct MOJOSHADER_effectShader {
    pub type_: MOJOSHADER_symbolType,
    pub technique: ::std::os::raw::c_uint,
    pub pass: ::std::os::raw::c_uint,
    pub is_preshader: ::std::os::raw::c_uint,
    pub preshader_param_count: ::std::os::raw::c_uint,
    pub preshader_params: *mut ::std::os::raw::c_uint,
    pub param_count: ::std::os::raw::c_uint,
    pub params: *mut ::std::os::raw::c_uint,
    pub sampler_count: ::std::os::raw::c_uint,
    pub samplers: *mut MOJOSHADER_samplerStateRegister,
    pub __bindgen_anon_1: MOJOSHADER_effectShader__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union MOJOSHADER_effectShader__bindgen_ty_1 {
    pub shader: *mut ::std::os::raw::c_void,
    pub preshader: *const MOJOSHADER_preshader,
    _bindgen_union_align: u64,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_effectShader__bindgen_ty_1() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_effectShader__bindgen_ty_1>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(MOJOSHADER_effectShader__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_effectShader__bindgen_ty_1>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(MOJOSHADER_effectShader__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectShader__bindgen_ty_1>())).shader as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectShader__bindgen_ty_1),
            "::",
            stringify!(shader)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectShader__bindgen_ty_1>())).preshader as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectShader__bindgen_ty_1),
            "::",
            stringify!(preshader)
        )
    );
}
#[test]
fn bindgen_test_layout_MOJOSHADER_effectShader() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_effectShader>(),
        72usize,
        concat!("Size of: ", stringify!(MOJOSHADER_effectShader))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_effectShader>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_effectShader))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_effectShader>())).type_ as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectShader),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectShader>())).technique as *const _ as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectShader),
            "::",
            stringify!(technique)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_effectShader>())).pass as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectShader),
            "::",
            stringify!(pass)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectShader>())).is_preshader as *const _ as usize
        },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectShader),
            "::",
            stringify!(is_preshader)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectShader>())).preshader_param_count as *const _
                as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectShader),
            "::",
            stringify!(preshader_param_count)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectShader>())).preshader_params as *const _
                as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectShader),
            "::",
            stringify!(preshader_params)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectShader>())).param_count as *const _ as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectShader),
            "::",
            stringify!(param_count)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_effectShader>())).params as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectShader),
            "::",
            stringify!(params)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectShader>())).sampler_count as *const _ as usize
        },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectShader),
            "::",
            stringify!(sampler_count)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectShader>())).samplers as *const _ as usize
        },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectShader),
            "::",
            stringify!(samplers)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_effectSamplerMap {
    pub type_: MOJOSHADER_symbolType,
    pub name: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_effectSamplerMap() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_effectSamplerMap>(),
        16usize,
        concat!("Size of: ", stringify!(MOJOSHADER_effectSamplerMap))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_effectSamplerMap>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_effectSamplerMap))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectSamplerMap>())).type_ as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectSamplerMap),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectSamplerMap>())).name as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectSamplerMap),
            "::",
            stringify!(name)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_effectString {
    pub type_: MOJOSHADER_symbolType,
    pub string: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_effectString() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_effectString>(),
        16usize,
        concat!("Size of: ", stringify!(MOJOSHADER_effectString))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_effectString>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_effectString))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_effectString>())).type_ as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectString),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_effectString>())).string as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectString),
            "::",
            stringify!(string)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_effectTexture {
    pub type_: MOJOSHADER_symbolType,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_effectTexture() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_effectTexture>(),
        4usize,
        concat!("Size of: ", stringify!(MOJOSHADER_effectTexture))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_effectTexture>(),
        4usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_effectTexture))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_effectTexture>())).type_ as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectTexture),
            "::",
            stringify!(type_)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union MOJOSHADER_effectObject {
    pub type_: MOJOSHADER_symbolType,
    pub __bindgen_anon_1: MOJOSHADER_effectObject__bindgen_ty_1,
    _bindgen_union_align: [u64; 9usize],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union MOJOSHADER_effectObject__bindgen_ty_1 {
    pub shader: MOJOSHADER_effectShader,
    pub mapping: MOJOSHADER_effectSamplerMap,
    pub string: MOJOSHADER_effectString,
    pub texture: MOJOSHADER_effectTexture,
    _bindgen_union_align: [u64; 9usize],
}
#[test]
fn bindgen_test_layout_MOJOSHADER_effectObject__bindgen_ty_1() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_effectObject__bindgen_ty_1>(),
        72usize,
        concat!(
            "Size of: ",
            stringify!(MOJOSHADER_effectObject__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_effectObject__bindgen_ty_1>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(MOJOSHADER_effectObject__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectObject__bindgen_ty_1>())).shader as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectObject__bindgen_ty_1),
            "::",
            stringify!(shader)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectObject__bindgen_ty_1>())).mapping as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectObject__bindgen_ty_1),
            "::",
            stringify!(mapping)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectObject__bindgen_ty_1>())).string as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectObject__bindgen_ty_1),
            "::",
            stringify!(string)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectObject__bindgen_ty_1>())).texture as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectObject__bindgen_ty_1),
            "::",
            stringify!(texture)
        )
    );
}
#[test]
fn bindgen_test_layout_MOJOSHADER_effectObject() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_effectObject>(),
        72usize,
        concat!("Size of: ", stringify!(MOJOSHADER_effectObject))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_effectObject>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_effectObject))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_effectObject>())).type_ as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectObject),
            "::",
            stringify!(type_)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_samplerStateRegister {
    pub sampler_name: *const ::std::os::raw::c_char,
    pub sampler_register: ::std::os::raw::c_uint,
    pub sampler_state_count: ::std::os::raw::c_uint,
    pub sampler_states: *const MOJOSHADER_effectSamplerState,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_samplerStateRegister() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_samplerStateRegister>(),
        24usize,
        concat!("Size of: ", stringify!(MOJOSHADER_samplerStateRegister))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_samplerStateRegister>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_samplerStateRegister))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_samplerStateRegister>())).sampler_name as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_samplerStateRegister),
            "::",
            stringify!(sampler_name)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_samplerStateRegister>())).sampler_register as *const _
                as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_samplerStateRegister),
            "::",
            stringify!(sampler_register)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_samplerStateRegister>())).sampler_state_count
                as *const _ as usize
        },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_samplerStateRegister),
            "::",
            stringify!(sampler_state_count)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_samplerStateRegister>())).sampler_states as *const _
                as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_samplerStateRegister),
            "::",
            stringify!(sampler_states)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_effectStateChanges {
    pub render_state_change_count: ::std::os::raw::c_uint,
    pub render_state_changes: *const MOJOSHADER_effectState,
    pub sampler_state_change_count: ::std::os::raw::c_uint,
    pub sampler_state_changes: *const MOJOSHADER_samplerStateRegister,
    pub vertex_sampler_state_change_count: ::std::os::raw::c_uint,
    pub vertex_sampler_state_changes: *const MOJOSHADER_samplerStateRegister,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_effectStateChanges() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_effectStateChanges>(),
        48usize,
        concat!("Size of: ", stringify!(MOJOSHADER_effectStateChanges))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_effectStateChanges>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_effectStateChanges))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectStateChanges>())).render_state_change_count
                as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectStateChanges),
            "::",
            stringify!(render_state_change_count)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectStateChanges>())).render_state_changes
                as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectStateChanges),
            "::",
            stringify!(render_state_changes)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectStateChanges>())).sampler_state_change_count
                as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectStateChanges),
            "::",
            stringify!(sampler_state_change_count)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectStateChanges>())).sampler_state_changes
                as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectStateChanges),
            "::",
            stringify!(sampler_state_changes)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectStateChanges>()))
                .vertex_sampler_state_change_count as *const _ as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectStateChanges),
            "::",
            stringify!(vertex_sampler_state_change_count)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectStateChanges>())).vertex_sampler_state_changes
                as *const _ as usize
        },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectStateChanges),
            "::",
            stringify!(vertex_sampler_state_changes)
        )
    );
}
pub type MOJOSHADER_compileShaderFunc = ::std::option::Option<
    unsafe extern "C" fn(
        mainfn: *const ::std::os::raw::c_char,
        tokenbuf: *const ::std::os::raw::c_uchar,
        bufsize: ::std::os::raw::c_uint,
        swiz: *const MOJOSHADER_swizzle,
        swizcount: ::std::os::raw::c_uint,
        smap: *const MOJOSHADER_samplerMap,
        smapcount: ::std::os::raw::c_uint,
    ) -> *mut ::std::os::raw::c_void,
>;
pub type MOJOSHADER_shaderAddRefFunc =
    ::std::option::Option<unsafe extern "C" fn(shader: *mut ::std::os::raw::c_void)>;
pub type MOJOSHADER_deleteShaderFunc =
    ::std::option::Option<unsafe extern "C" fn(shader: *mut ::std::os::raw::c_void)>;
pub type MOJOSHADER_getParseDataFunc = ::std::option::Option<
    unsafe extern "C" fn(shader: *mut ::std::os::raw::c_void) -> *mut MOJOSHADER_parseData,
>;
pub type MOJOSHADER_bindShadersFunc = ::std::option::Option<
    unsafe extern "C" fn(
        vshader: *mut ::std::os::raw::c_void,
        pshader: *mut ::std::os::raw::c_void,
    ),
>;
pub type MOJOSHADER_getBoundShadersFunc = ::std::option::Option<
    unsafe extern "C" fn(
        vshader: *mut *mut ::std::os::raw::c_void,
        pshader: *mut *mut ::std::os::raw::c_void,
    ),
>;
pub type MOJOSHADER_mapUniformBufferMemoryFunc = ::std::option::Option<
    unsafe extern "C" fn(
        vsf: *mut *mut f32,
        vsi: *mut *mut ::std::os::raw::c_int,
        vsb: *mut *mut ::std::os::raw::c_uchar,
        psf: *mut *mut f32,
        psi: *mut *mut ::std::os::raw::c_int,
        psb: *mut *mut ::std::os::raw::c_uchar,
    ),
>;
pub type MOJOSHADER_unmapUniformBufferMemoryFunc = ::std::option::Option<unsafe extern "C" fn()>;
pub type MOJOSHADER_getErrorFunc =
    ::std::option::Option<unsafe extern "C" fn() -> *const ::std::os::raw::c_char>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_effectShaderContext {
    pub compileShader: MOJOSHADER_compileShaderFunc,
    pub shaderAddRef: MOJOSHADER_shaderAddRefFunc,
    pub deleteShader: MOJOSHADER_deleteShaderFunc,
    pub getParseData: MOJOSHADER_getParseDataFunc,
    pub bindShaders: MOJOSHADER_bindShadersFunc,
    pub getBoundShaders: MOJOSHADER_getBoundShadersFunc,
    pub mapUniformBufferMemory: MOJOSHADER_mapUniformBufferMemoryFunc,
    pub unmapUniformBufferMemory: MOJOSHADER_unmapUniformBufferMemoryFunc,
    pub getError: MOJOSHADER_getErrorFunc,
    pub m: MOJOSHADER_malloc,
    pub f: MOJOSHADER_free,
    pub malloc_data: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_effectShaderContext() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_effectShaderContext>(),
        96usize,
        concat!("Size of: ", stringify!(MOJOSHADER_effectShaderContext))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_effectShaderContext>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_effectShaderContext))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectShaderContext>())).compileShader as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectShaderContext),
            "::",
            stringify!(compileShader)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectShaderContext>())).shaderAddRef as *const _
                as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectShaderContext),
            "::",
            stringify!(shaderAddRef)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectShaderContext>())).deleteShader as *const _
                as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectShaderContext),
            "::",
            stringify!(deleteShader)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectShaderContext>())).getParseData as *const _
                as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectShaderContext),
            "::",
            stringify!(getParseData)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectShaderContext>())).bindShaders as *const _
                as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectShaderContext),
            "::",
            stringify!(bindShaders)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectShaderContext>())).getBoundShaders as *const _
                as usize
        },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectShaderContext),
            "::",
            stringify!(getBoundShaders)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectShaderContext>())).mapUniformBufferMemory
                as *const _ as usize
        },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectShaderContext),
            "::",
            stringify!(mapUniformBufferMemory)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectShaderContext>())).unmapUniformBufferMemory
                as *const _ as usize
        },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectShaderContext),
            "::",
            stringify!(unmapUniformBufferMemory)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectShaderContext>())).getError as *const _ as usize
        },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectShaderContext),
            "::",
            stringify!(getError)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectShaderContext>())).m as *const _ as usize
        },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectShaderContext),
            "::",
            stringify!(m)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectShaderContext>())).f as *const _ as usize
        },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectShaderContext),
            "::",
            stringify!(f)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effectShaderContext>())).malloc_data as *const _
                as usize
        },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effectShaderContext),
            "::",
            stringify!(malloc_data)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MOJOSHADER_effect {
    pub error_count: ::std::os::raw::c_int,
    pub errors: *mut MOJOSHADER_error,
    pub param_count: ::std::os::raw::c_int,
    pub params: *mut MOJOSHADER_effectParam,
    pub technique_count: ::std::os::raw::c_int,
    pub techniques: *mut MOJOSHADER_effectTechnique,
    pub object_count: ::std::os::raw::c_int,
    pub objects: *mut MOJOSHADER_effectObject,
    pub current_technique: *const MOJOSHADER_effectTechnique,
    pub current_pass: ::std::os::raw::c_int,
    pub restore_shader_state: ::std::os::raw::c_int,
    pub state_changes: *mut MOJOSHADER_effectStateChanges,
    pub current_vert_raw: *mut MOJOSHADER_effectShader,
    pub current_pixl_raw: *mut MOJOSHADER_effectShader,
    pub current_vert: *mut ::std::os::raw::c_void,
    pub current_pixl: *mut ::std::os::raw::c_void,
    pub prev_vertex_shader: *mut ::std::os::raw::c_void,
    pub prev_pixel_shader: *mut ::std::os::raw::c_void,
    pub ctx: MOJOSHADER_effectShaderContext,
}
#[test]
fn bindgen_test_layout_MOJOSHADER_effect() {
    assert_eq!(
        ::std::mem::size_of::<MOJOSHADER_effect>(),
        232usize,
        concat!("Size of: ", stringify!(MOJOSHADER_effect))
    );
    assert_eq!(
        ::std::mem::align_of::<MOJOSHADER_effect>(),
        8usize,
        concat!("Alignment of ", stringify!(MOJOSHADER_effect))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_effect>())).error_count as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effect),
            "::",
            stringify!(error_count)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_effect>())).errors as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effect),
            "::",
            stringify!(errors)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_effect>())).param_count as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effect),
            "::",
            stringify!(param_count)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_effect>())).params as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effect),
            "::",
            stringify!(params)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effect>())).technique_count as *const _ as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effect),
            "::",
            stringify!(technique_count)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_effect>())).techniques as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effect),
            "::",
            stringify!(techniques)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_effect>())).object_count as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effect),
            "::",
            stringify!(object_count)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_effect>())).objects as *const _ as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effect),
            "::",
            stringify!(objects)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effect>())).current_technique as *const _ as usize
        },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effect),
            "::",
            stringify!(current_technique)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_effect>())).current_pass as *const _ as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effect),
            "::",
            stringify!(current_pass)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effect>())).restore_shader_state as *const _ as usize
        },
        76usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effect),
            "::",
            stringify!(restore_shader_state)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_effect>())).state_changes as *const _ as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effect),
            "::",
            stringify!(state_changes)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effect>())).current_vert_raw as *const _ as usize
        },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effect),
            "::",
            stringify!(current_vert_raw)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effect>())).current_pixl_raw as *const _ as usize
        },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effect),
            "::",
            stringify!(current_pixl_raw)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_effect>())).current_vert as *const _ as usize },
        104usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effect),
            "::",
            stringify!(current_vert)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_effect>())).current_pixl as *const _ as usize },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effect),
            "::",
            stringify!(current_pixl)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effect>())).prev_vertex_shader as *const _ as usize
        },
        120usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effect),
            "::",
            stringify!(prev_vertex_shader)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<MOJOSHADER_effect>())).prev_pixel_shader as *const _ as usize
        },
        128usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effect),
            "::",
            stringify!(prev_pixel_shader)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<MOJOSHADER_effect>())).ctx as *const _ as usize },
        136usize,
        concat!(
            "Offset of field: ",
            stringify!(MOJOSHADER_effect),
            "::",
            stringify!(ctx)
        )
    );
}
extern "C" {
    pub fn MOJOSHADER_compileEffect(
        tokenbuf: *const ::std::os::raw::c_uchar,
        bufsize: ::std::os::raw::c_uint,
        swiz: *const MOJOSHADER_swizzle,
        swizcount: ::std::os::raw::c_uint,
        smap: *const MOJOSHADER_samplerMap,
        smapcount: ::std::os::raw::c_uint,
        ctx: *const MOJOSHADER_effectShaderContext,
    ) -> *mut MOJOSHADER_effect;
}
extern "C" {
    pub fn MOJOSHADER_deleteEffect(effect: *const MOJOSHADER_effect);
}
extern "C" {
    pub fn MOJOSHADER_cloneEffect(effect: *const MOJOSHADER_effect) -> *mut MOJOSHADER_effect;
}
extern "C" {
    pub fn MOJOSHADER_effectSetRawValueHandle(
        parameter: *const MOJOSHADER_effectParam,
        data: *const ::std::os::raw::c_void,
        offset: ::std::os::raw::c_uint,
        len: ::std::os::raw::c_uint,
    );
}
extern "C" {
    pub fn MOJOSHADER_effectSetRawValueName(
        effect: *const MOJOSHADER_effect,
        name: *const ::std::os::raw::c_char,
        data: *const ::std::os::raw::c_void,
        offset: ::std::os::raw::c_uint,
        len: ::std::os::raw::c_uint,
    );
}
extern "C" {
    pub fn MOJOSHADER_effectGetCurrentTechnique(
        effect: *const MOJOSHADER_effect,
    ) -> *const MOJOSHADER_effectTechnique;
}
extern "C" {
    pub fn MOJOSHADER_effectSetTechnique(
        effect: *mut MOJOSHADER_effect,
        technique: *const MOJOSHADER_effectTechnique,
    );
}
extern "C" {
    pub fn MOJOSHADER_effectFindNextValidTechnique(
        effect: *const MOJOSHADER_effect,
        technique: *const MOJOSHADER_effectTechnique,
    ) -> *const MOJOSHADER_effectTechnique;
}
extern "C" {
    pub fn MOJOSHADER_effectBegin(
        effect: *mut MOJOSHADER_effect,
        numPasses: *mut ::std::os::raw::c_uint,
        saveShaderState: ::std::os::raw::c_int,
        stateChanges: *mut MOJOSHADER_effectStateChanges,
    );
}
extern "C" {
    pub fn MOJOSHADER_effectBeginPass(effect: *mut MOJOSHADER_effect, pass: ::std::os::raw::c_uint);
}
extern "C" {
    pub fn MOJOSHADER_effectCommitChanges(effect: *mut MOJOSHADER_effect);
}
extern "C" {
    pub fn MOJOSHADER_effectEndPass(effect: *mut MOJOSHADER_effect);
}
extern "C" {
    pub fn MOJOSHADER_effectEnd(effect: *mut MOJOSHADER_effect);
}
extern "C" {
    pub fn MOJOSHADER_mtlCompileLibrary(
        effect: *mut MOJOSHADER_effect,
    ) -> *mut ::std::os::raw::c_void;
}