/* automatically generated by rust-bindgen */

pub type va_list = __builtin_va_list;
pub type csh = usize;
pub const CS_ARCH_ARM: cs_arch = 0;
pub const CS_ARCH_ARM64: cs_arch = 1;
pub const CS_ARCH_MIPS: cs_arch = 2;
pub const CS_ARCH_X86: cs_arch = 3;
pub const CS_ARCH_PPC: cs_arch = 4;
pub const CS_ARCH_SPARC: cs_arch = 5;
pub const CS_ARCH_SYSZ: cs_arch = 6;
pub const CS_ARCH_XCORE: cs_arch = 7;
pub const CS_ARCH_MAX: cs_arch = 8;
pub const CS_ARCH_ALL: cs_arch = 65535;
pub type cs_arch = ::std::os::raw::c_uint;
pub const CS_MODE_LITTLE_ENDIAN: cs_mode = 0;
pub const CS_MODE_ARM: cs_mode = 0;
pub const CS_MODE_16: cs_mode = 2;
pub const CS_MODE_32: cs_mode = 4;
pub const CS_MODE_64: cs_mode = 8;
pub const CS_MODE_THUMB: cs_mode = 16;
pub const CS_MODE_MCLASS: cs_mode = 32;
pub const CS_MODE_V8: cs_mode = 64;
pub const CS_MODE_MICRO: cs_mode = 16;
pub const CS_MODE_MIPS3: cs_mode = 32;
pub const CS_MODE_MIPS32R6: cs_mode = 64;
pub const CS_MODE_MIPSGP64: cs_mode = 128;
pub const CS_MODE_V9: cs_mode = 16;
pub const CS_MODE_BIG_ENDIAN: cs_mode = -2147483648;
pub const CS_MODE_MIPS32: cs_mode = 4;
pub const CS_MODE_MIPS64: cs_mode = 8;
pub type cs_mode = ::std::os::raw::c_int;
pub type cs_malloc_t =
    ::std::option::Option<unsafe extern "C" fn(size: usize)
                              -> *mut ::std::os::raw::c_void>;
pub type cs_calloc_t =
    ::std::option::Option<unsafe extern "C" fn(nmemb: usize, size: usize)
                              -> *mut ::std::os::raw::c_void>;
pub type cs_realloc_t =
    ::std::option::Option<unsafe extern "C" fn(ptr:
                                                   *mut ::std::os::raw::c_void,
                                               size: usize)
                              -> *mut ::std::os::raw::c_void>;
pub type cs_free_t =
    ::std::option::Option<unsafe extern "C" fn(ptr:
                                                   *mut ::std::os::raw::c_void)>;
pub type cs_vsnprintf_t =
    ::std::option::Option<unsafe extern "C" fn(str:
                                                   *mut ::std::os::raw::c_char,
                                               size: usize,
                                               format:
                                                   *const ::std::os::raw::c_char,
                                               ap: *mut __va_list_tag)
                              -> ::std::os::raw::c_int>;
#[repr(C)]
#[derive(Debug, Copy)]
pub struct cs_opt_mem {
    pub malloc: cs_malloc_t,
    pub calloc: cs_calloc_t,
    pub realloc: cs_realloc_t,
    pub free: cs_free_t,
    pub vsnprintf: cs_vsnprintf_t,
}
#[test]
fn bindgen_test_layout_cs_opt_mem() {
    assert_eq!(::std::mem::size_of::<cs_opt_mem>() , 40usize , concat ! (
               "Size of: " , stringify ! ( cs_opt_mem ) ));
    assert_eq! (::std::mem::align_of::<cs_opt_mem>() , 8usize , concat ! (
                "Alignment of " , stringify ! ( cs_opt_mem ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_opt_mem ) ) . malloc as * const _ as
                usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_opt_mem ) , "::" ,
                stringify ! ( malloc ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_opt_mem ) ) . calloc as * const _ as
                usize } , 8usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_opt_mem ) , "::" ,
                stringify ! ( calloc ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_opt_mem ) ) . realloc as * const _ as
                usize } , 16usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_opt_mem ) , "::" ,
                stringify ! ( realloc ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_opt_mem ) ) . free as * const _ as
                usize } , 24usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_opt_mem ) , "::" ,
                stringify ! ( free ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_opt_mem ) ) . vsnprintf as * const _
                as usize } , 32usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_opt_mem ) , "::" ,
                stringify ! ( vsnprintf ) ));
}
impl Clone for cs_opt_mem {
    fn clone(&self) -> Self { *self }
}
pub const CS_OPT_SYNTAX: cs_opt_type = 1;
pub const CS_OPT_DETAIL: cs_opt_type = 2;
pub const CS_OPT_MODE: cs_opt_type = 3;
pub const CS_OPT_MEM: cs_opt_type = 4;
pub const CS_OPT_SKIPDATA: cs_opt_type = 5;
pub const CS_OPT_SKIPDATA_SETUP: cs_opt_type = 6;
pub type cs_opt_type = ::std::os::raw::c_uint;
pub const CS_OPT_OFF: cs_opt_value = 0;
pub const CS_OPT_ON: cs_opt_value = 3;
pub const CS_OPT_SYNTAX_DEFAULT: cs_opt_value = 0;
pub const CS_OPT_SYNTAX_INTEL: cs_opt_value = 1;
pub const CS_OPT_SYNTAX_ATT: cs_opt_value = 2;
pub const CS_OPT_SYNTAX_NOREGNAME: cs_opt_value = 3;
pub type cs_opt_value = ::std::os::raw::c_uint;
pub const CS_OP_INVALID: cs_op_type = 0;
pub const CS_OP_REG: cs_op_type = 1;
pub const CS_OP_IMM: cs_op_type = 2;
pub const CS_OP_MEM: cs_op_type = 3;
pub const CS_OP_FP: cs_op_type = 4;
pub type cs_op_type = ::std::os::raw::c_uint;
pub const CS_GRP_INVALID: cs_group_type = 0;
pub const CS_GRP_JUMP: cs_group_type = 1;
pub const CS_GRP_CALL: cs_group_type = 2;
pub const CS_GRP_RET: cs_group_type = 3;
pub const CS_GRP_INT: cs_group_type = 4;
pub const CS_GRP_IRET: cs_group_type = 5;
pub type cs_group_type = ::std::os::raw::c_uint;
pub type cs_skipdata_cb_t =
    ::std::option::Option<unsafe extern "C" fn(code: *const u8,
                                               code_size: usize,
                                               offset: usize,
                                               user_data:
                                                   *mut ::std::os::raw::c_void)
                              -> usize>;
#[repr(C)]
#[derive(Debug, Copy)]
pub struct cs_opt_skipdata {
    pub mnemonic: *const ::std::os::raw::c_char,
    pub callback: cs_skipdata_cb_t,
    pub user_data: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_cs_opt_skipdata() {
    assert_eq!(::std::mem::size_of::<cs_opt_skipdata>() , 24usize , concat ! (
               "Size of: " , stringify ! ( cs_opt_skipdata ) ));
    assert_eq! (::std::mem::align_of::<cs_opt_skipdata>() , 8usize , concat !
                ( "Alignment of " , stringify ! ( cs_opt_skipdata ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_opt_skipdata ) ) . mnemonic as * const
                _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_opt_skipdata ) ,
                "::" , stringify ! ( mnemonic ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_opt_skipdata ) ) . callback as * const
                _ as usize } , 8usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_opt_skipdata ) ,
                "::" , stringify ! ( callback ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_opt_skipdata ) ) . user_data as *
                const _ as usize } , 16usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_opt_skipdata ) ,
                "::" , stringify ! ( user_data ) ));
}
impl Clone for cs_opt_skipdata {
    fn clone(&self) -> Self { *self }
}
pub const ARM_SFT_INVALID: arm_shifter = 0;
pub const ARM_SFT_ASR: arm_shifter = 1;
pub const ARM_SFT_LSL: arm_shifter = 2;
pub const ARM_SFT_LSR: arm_shifter = 3;
pub const ARM_SFT_ROR: arm_shifter = 4;
pub const ARM_SFT_RRX: arm_shifter = 5;
pub const ARM_SFT_ASR_REG: arm_shifter = 6;
pub const ARM_SFT_LSL_REG: arm_shifter = 7;
pub const ARM_SFT_LSR_REG: arm_shifter = 8;
pub const ARM_SFT_ROR_REG: arm_shifter = 9;
pub const ARM_SFT_RRX_REG: arm_shifter = 10;
pub type arm_shifter = ::std::os::raw::c_uint;
pub const ARM_CC_INVALID: arm_cc = 0;
pub const ARM_CC_EQ: arm_cc = 1;
pub const ARM_CC_NE: arm_cc = 2;
pub const ARM_CC_HS: arm_cc = 3;
pub const ARM_CC_LO: arm_cc = 4;
pub const ARM_CC_MI: arm_cc = 5;
pub const ARM_CC_PL: arm_cc = 6;
pub const ARM_CC_VS: arm_cc = 7;
pub const ARM_CC_VC: arm_cc = 8;
pub const ARM_CC_HI: arm_cc = 9;
pub const ARM_CC_LS: arm_cc = 10;
pub const ARM_CC_GE: arm_cc = 11;
pub const ARM_CC_LT: arm_cc = 12;
pub const ARM_CC_GT: arm_cc = 13;
pub const ARM_CC_LE: arm_cc = 14;
pub const ARM_CC_AL: arm_cc = 15;
pub type arm_cc = ::std::os::raw::c_uint;
pub const ARM_MB_INVALID: arm_mem_barrier = 0;
pub const ARM_MB_RESERVED_0: arm_mem_barrier = 1;
pub const ARM_MB_OSHLD: arm_mem_barrier = 2;
pub const ARM_MB_OSHST: arm_mem_barrier = 3;
pub const ARM_MB_OSH: arm_mem_barrier = 4;
pub const ARM_MB_RESERVED_4: arm_mem_barrier = 5;
pub const ARM_MB_NSHLD: arm_mem_barrier = 6;
pub const ARM_MB_NSHST: arm_mem_barrier = 7;
pub const ARM_MB_NSH: arm_mem_barrier = 8;
pub const ARM_MB_RESERVED_8: arm_mem_barrier = 9;
pub const ARM_MB_ISHLD: arm_mem_barrier = 10;
pub const ARM_MB_ISHST: arm_mem_barrier = 11;
pub const ARM_MB_ISH: arm_mem_barrier = 12;
pub const ARM_MB_RESERVED_12: arm_mem_barrier = 13;
pub const ARM_MB_LD: arm_mem_barrier = 14;
pub const ARM_MB_ST: arm_mem_barrier = 15;
pub const ARM_MB_SY: arm_mem_barrier = 16;
pub type arm_mem_barrier = ::std::os::raw::c_uint;
pub const ARM_OP_INVALID: arm_op_type = 0;
pub const ARM_OP_REG: arm_op_type = 1;
pub const ARM_OP_IMM: arm_op_type = 2;
pub const ARM_OP_MEM: arm_op_type = 3;
pub const ARM_OP_FP: arm_op_type = 4;
pub const ARM_OP_CIMM: arm_op_type = 64;
pub const ARM_OP_PIMM: arm_op_type = 65;
pub const ARM_OP_SETEND: arm_op_type = 66;
pub const ARM_OP_SYSREG: arm_op_type = 67;
pub type arm_op_type = ::std::os::raw::c_uint;
pub const ARM_SETEND_INVALID: arm_setend_type = 0;
pub const ARM_SETEND_BE: arm_setend_type = 1;
pub const ARM_SETEND_LE: arm_setend_type = 2;
pub type arm_setend_type = ::std::os::raw::c_uint;
pub const ARM_CPSMODE_INVALID: arm_cpsmode_type = 0;
pub const ARM_CPSMODE_IE: arm_cpsmode_type = 2;
pub const ARM_CPSMODE_ID: arm_cpsmode_type = 3;
pub type arm_cpsmode_type = ::std::os::raw::c_uint;
pub const ARM_CPSFLAG_INVALID: arm_cpsflag_type = 0;
pub const ARM_CPSFLAG_F: arm_cpsflag_type = 1;
pub const ARM_CPSFLAG_I: arm_cpsflag_type = 2;
pub const ARM_CPSFLAG_A: arm_cpsflag_type = 4;
pub const ARM_CPSFLAG_NONE: arm_cpsflag_type = 16;
pub type arm_cpsflag_type = ::std::os::raw::c_uint;
pub const ARM_VECTORDATA_INVALID: arm_vectordata_type = 0;
pub const ARM_VECTORDATA_I8: arm_vectordata_type = 1;
pub const ARM_VECTORDATA_I16: arm_vectordata_type = 2;
pub const ARM_VECTORDATA_I32: arm_vectordata_type = 3;
pub const ARM_VECTORDATA_I64: arm_vectordata_type = 4;
pub const ARM_VECTORDATA_S8: arm_vectordata_type = 5;
pub const ARM_VECTORDATA_S16: arm_vectordata_type = 6;
pub const ARM_VECTORDATA_S32: arm_vectordata_type = 7;
pub const ARM_VECTORDATA_S64: arm_vectordata_type = 8;
pub const ARM_VECTORDATA_U8: arm_vectordata_type = 9;
pub const ARM_VECTORDATA_U16: arm_vectordata_type = 10;
pub const ARM_VECTORDATA_U32: arm_vectordata_type = 11;
pub const ARM_VECTORDATA_U64: arm_vectordata_type = 12;
pub const ARM_VECTORDATA_P8: arm_vectordata_type = 13;
pub const ARM_VECTORDATA_F32: arm_vectordata_type = 14;
pub const ARM_VECTORDATA_F64: arm_vectordata_type = 15;
pub const ARM_VECTORDATA_F16F64: arm_vectordata_type = 16;
pub const ARM_VECTORDATA_F64F16: arm_vectordata_type = 17;
pub const ARM_VECTORDATA_F32F16: arm_vectordata_type = 18;
pub const ARM_VECTORDATA_F16F32: arm_vectordata_type = 19;
pub const ARM_VECTORDATA_F64F32: arm_vectordata_type = 20;
pub const ARM_VECTORDATA_F32F64: arm_vectordata_type = 21;
pub const ARM_VECTORDATA_S32F32: arm_vectordata_type = 22;
pub const ARM_VECTORDATA_U32F32: arm_vectordata_type = 23;
pub const ARM_VECTORDATA_F32S32: arm_vectordata_type = 24;
pub const ARM_VECTORDATA_F32U32: arm_vectordata_type = 25;
pub const ARM_VECTORDATA_F64S16: arm_vectordata_type = 26;
pub const ARM_VECTORDATA_F32S16: arm_vectordata_type = 27;
pub const ARM_VECTORDATA_F64S32: arm_vectordata_type = 28;
pub const ARM_VECTORDATA_S16F64: arm_vectordata_type = 29;
pub const ARM_VECTORDATA_S16F32: arm_vectordata_type = 30;
pub const ARM_VECTORDATA_S32F64: arm_vectordata_type = 31;
pub const ARM_VECTORDATA_U16F64: arm_vectordata_type = 32;
pub const ARM_VECTORDATA_U16F32: arm_vectordata_type = 33;
pub const ARM_VECTORDATA_U32F64: arm_vectordata_type = 34;
pub const ARM_VECTORDATA_F64U16: arm_vectordata_type = 35;
pub const ARM_VECTORDATA_F32U16: arm_vectordata_type = 36;
pub const ARM_VECTORDATA_F64U32: arm_vectordata_type = 37;
pub type arm_vectordata_type = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy)]
pub struct arm_op_mem {
    pub base: ::std::os::raw::c_uint,
    pub index: ::std::os::raw::c_uint,
    pub scale: ::std::os::raw::c_int,
    pub disp: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_arm_op_mem() {
    assert_eq!(::std::mem::size_of::<arm_op_mem>() , 16usize , concat ! (
               "Size of: " , stringify ! ( arm_op_mem ) ));
    assert_eq! (::std::mem::align_of::<arm_op_mem>() , 4usize , concat ! (
                "Alignment of " , stringify ! ( arm_op_mem ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const arm_op_mem ) ) . base as * const _ as
                usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( arm_op_mem ) , "::" ,
                stringify ! ( base ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const arm_op_mem ) ) . index as * const _ as
                usize } , 4usize , concat ! (
                "Alignment of field: " , stringify ! ( arm_op_mem ) , "::" ,
                stringify ! ( index ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const arm_op_mem ) ) . scale as * const _ as
                usize } , 8usize , concat ! (
                "Alignment of field: " , stringify ! ( arm_op_mem ) , "::" ,
                stringify ! ( scale ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const arm_op_mem ) ) . disp as * const _ as
                usize } , 12usize , concat ! (
                "Alignment of field: " , stringify ! ( arm_op_mem ) , "::" ,
                stringify ! ( disp ) ));
}
impl Clone for arm_op_mem {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Copy)]
pub struct cs_arm_op {
    pub vector_index: ::std::os::raw::c_int,
    pub shift: cs_arm_op__bindgen_ty_1,
    pub type_: arm_op_type,
    pub __bindgen_anon_1: cs_arm_op__bindgen_ty_2,
    pub subtracted: bool,
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct cs_arm_op__bindgen_ty_1 {
    pub type_: arm_shifter,
    pub value: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_cs_arm_op__bindgen_ty_1() {
    assert_eq!(::std::mem::size_of::<cs_arm_op__bindgen_ty_1>() , 8usize ,
               concat ! (
               "Size of: " , stringify ! ( cs_arm_op__bindgen_ty_1 ) ));
    assert_eq! (::std::mem::align_of::<cs_arm_op__bindgen_ty_1>() , 4usize ,
                concat ! (
                "Alignment of " , stringify ! ( cs_arm_op__bindgen_ty_1 ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm_op__bindgen_ty_1 ) ) . type_ as *
                const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_arm_op__bindgen_ty_1
                ) , "::" , stringify ! ( type_ ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm_op__bindgen_ty_1 ) ) . value as *
                const _ as usize } , 4usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_arm_op__bindgen_ty_1
                ) , "::" , stringify ! ( value ) ));
}
impl Clone for cs_arm_op__bindgen_ty_1 {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Copy)]
pub union cs_arm_op__bindgen_ty_2 {
    pub reg: ::std::os::raw::c_uint,
    pub imm: i32,
    pub fp: f64,
    pub mem: arm_op_mem,
    pub setend: arm_setend_type,
}
#[test]
fn bindgen_test_layout_cs_arm_op__bindgen_ty_2() {
    assert_eq!(::std::mem::size_of::<cs_arm_op__bindgen_ty_2>() , 16usize ,
               concat ! (
               "Size of: " , stringify ! ( cs_arm_op__bindgen_ty_2 ) ));
    assert_eq! (::std::mem::align_of::<cs_arm_op__bindgen_ty_2>() , 8usize ,
                concat ! (
                "Alignment of " , stringify ! ( cs_arm_op__bindgen_ty_2 ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm_op__bindgen_ty_2 ) ) . reg as *
                const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_arm_op__bindgen_ty_2
                ) , "::" , stringify ! ( reg ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm_op__bindgen_ty_2 ) ) . imm as *
                const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_arm_op__bindgen_ty_2
                ) , "::" , stringify ! ( imm ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm_op__bindgen_ty_2 ) ) . fp as *
                const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_arm_op__bindgen_ty_2
                ) , "::" , stringify ! ( fp ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm_op__bindgen_ty_2 ) ) . mem as *
                const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_arm_op__bindgen_ty_2
                ) , "::" , stringify ! ( mem ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm_op__bindgen_ty_2 ) ) . setend as *
                const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_arm_op__bindgen_ty_2
                ) , "::" , stringify ! ( setend ) ));
}
impl Clone for cs_arm_op__bindgen_ty_2 {
    fn clone(&self) -> Self { *self }
}
#[test]
fn bindgen_test_layout_cs_arm_op() {
    assert_eq!(::std::mem::size_of::<cs_arm_op>() , 40usize , concat ! (
               "Size of: " , stringify ! ( cs_arm_op ) ));
    assert_eq! (::std::mem::align_of::<cs_arm_op>() , 8usize , concat ! (
                "Alignment of " , stringify ! ( cs_arm_op ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm_op ) ) . vector_index as * const _
                as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_arm_op ) , "::" ,
                stringify ! ( vector_index ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm_op ) ) . shift as * const _ as
                usize } , 4usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_arm_op ) , "::" ,
                stringify ! ( shift ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm_op ) ) . type_ as * const _ as
                usize } , 12usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_arm_op ) , "::" ,
                stringify ! ( type_ ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm_op ) ) . subtracted as * const _
                as usize } , 32usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_arm_op ) , "::" ,
                stringify ! ( subtracted ) ));
}
impl Clone for cs_arm_op {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
pub struct cs_arm {
    pub usermode: bool,
    pub vector_size: ::std::os::raw::c_int,
    pub vector_data: arm_vectordata_type,
    pub cps_mode: arm_cpsmode_type,
    pub cps_flag: arm_cpsflag_type,
    pub cc: arm_cc,
    pub update_flags: bool,
    pub writeback: bool,
    pub mem_barrier: arm_mem_barrier,
    pub op_count: u8,
    pub operands: [cs_arm_op; 36usize],
}
#[test]
fn bindgen_test_layout_cs_arm() {
    assert_eq!(::std::mem::size_of::<cs_arm>() , 1480usize , concat ! (
               "Size of: " , stringify ! ( cs_arm ) ));
    assert_eq! (::std::mem::align_of::<cs_arm>() , 8usize , concat ! (
                "Alignment of " , stringify ! ( cs_arm ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm ) ) . usermode as * const _ as
                usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_arm ) , "::" ,
                stringify ! ( usermode ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm ) ) . vector_size as * const _ as
                usize } , 4usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_arm ) , "::" ,
                stringify ! ( vector_size ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm ) ) . vector_data as * const _ as
                usize } , 8usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_arm ) , "::" ,
                stringify ! ( vector_data ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm ) ) . cps_mode as * const _ as
                usize } , 12usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_arm ) , "::" ,
                stringify ! ( cps_mode ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm ) ) . cps_flag as * const _ as
                usize } , 16usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_arm ) , "::" ,
                stringify ! ( cps_flag ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm ) ) . cc as * const _ as usize } ,
                20usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_arm ) , "::" ,
                stringify ! ( cc ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm ) ) . update_flags as * const _ as
                usize } , 24usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_arm ) , "::" ,
                stringify ! ( update_flags ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm ) ) . writeback as * const _ as
                usize } , 25usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_arm ) , "::" ,
                stringify ! ( writeback ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm ) ) . mem_barrier as * const _ as
                usize } , 28usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_arm ) , "::" ,
                stringify ! ( mem_barrier ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm ) ) . op_count as * const _ as
                usize } , 32usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_arm ) , "::" ,
                stringify ! ( op_count ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm ) ) . operands as * const _ as
                usize } , 40usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_arm ) , "::" ,
                stringify ! ( operands ) ));
}
pub const ARM64_SFT_INVALID: arm64_shifter = 0;
pub const ARM64_SFT_LSL: arm64_shifter = 1;
pub const ARM64_SFT_MSL: arm64_shifter = 2;
pub const ARM64_SFT_LSR: arm64_shifter = 3;
pub const ARM64_SFT_ASR: arm64_shifter = 4;
pub const ARM64_SFT_ROR: arm64_shifter = 5;
pub type arm64_shifter = ::std::os::raw::c_uint;
pub const ARM64_EXT_INVALID: arm64_extender = 0;
pub const ARM64_EXT_UXTB: arm64_extender = 1;
pub const ARM64_EXT_UXTH: arm64_extender = 2;
pub const ARM64_EXT_UXTW: arm64_extender = 3;
pub const ARM64_EXT_UXTX: arm64_extender = 4;
pub const ARM64_EXT_SXTB: arm64_extender = 5;
pub const ARM64_EXT_SXTH: arm64_extender = 6;
pub const ARM64_EXT_SXTW: arm64_extender = 7;
pub const ARM64_EXT_SXTX: arm64_extender = 8;
pub type arm64_extender = ::std::os::raw::c_uint;
pub const ARM64_CC_INVALID: arm64_cc = 0;
pub const ARM64_CC_EQ: arm64_cc = 1;
pub const ARM64_CC_NE: arm64_cc = 2;
pub const ARM64_CC_HS: arm64_cc = 3;
pub const ARM64_CC_LO: arm64_cc = 4;
pub const ARM64_CC_MI: arm64_cc = 5;
pub const ARM64_CC_PL: arm64_cc = 6;
pub const ARM64_CC_VS: arm64_cc = 7;
pub const ARM64_CC_VC: arm64_cc = 8;
pub const ARM64_CC_HI: arm64_cc = 9;
pub const ARM64_CC_LS: arm64_cc = 10;
pub const ARM64_CC_GE: arm64_cc = 11;
pub const ARM64_CC_LT: arm64_cc = 12;
pub const ARM64_CC_GT: arm64_cc = 13;
pub const ARM64_CC_LE: arm64_cc = 14;
pub const ARM64_CC_AL: arm64_cc = 15;
pub const ARM64_CC_NV: arm64_cc = 16;
pub type arm64_cc = ::std::os::raw::c_uint;
pub const ARM64_PSTATE_INVALID: arm64_pstate = 0;
pub const ARM64_PSTATE_SPSEL: arm64_pstate = 5;
pub const ARM64_PSTATE_DAIFSET: arm64_pstate = 30;
pub const ARM64_PSTATE_DAIFCLR: arm64_pstate = 31;
pub type arm64_pstate = ::std::os::raw::c_uint;
pub const ARM64_VAS_INVALID: arm64_vas = 0;
pub const ARM64_VAS_8B: arm64_vas = 1;
pub const ARM64_VAS_16B: arm64_vas = 2;
pub const ARM64_VAS_4H: arm64_vas = 3;
pub const ARM64_VAS_8H: arm64_vas = 4;
pub const ARM64_VAS_2S: arm64_vas = 5;
pub const ARM64_VAS_4S: arm64_vas = 6;
pub const ARM64_VAS_1D: arm64_vas = 7;
pub const ARM64_VAS_2D: arm64_vas = 8;
pub const ARM64_VAS_1Q: arm64_vas = 9;
pub type arm64_vas = ::std::os::raw::c_uint;
pub const ARM64_VESS_INVALID: arm64_vess = 0;
pub const ARM64_VESS_B: arm64_vess = 1;
pub const ARM64_VESS_H: arm64_vess = 2;
pub const ARM64_VESS_S: arm64_vess = 3;
pub const ARM64_VESS_D: arm64_vess = 4;
pub type arm64_vess = ::std::os::raw::c_uint;
pub const ARM64_BARRIER_INVALID: arm64_barrier_op = 0;
pub const ARM64_BARRIER_OSHLD: arm64_barrier_op = 1;
pub const ARM64_BARRIER_OSHST: arm64_barrier_op = 2;
pub const ARM64_BARRIER_OSH: arm64_barrier_op = 3;
pub const ARM64_BARRIER_NSHLD: arm64_barrier_op = 5;
pub const ARM64_BARRIER_NSHST: arm64_barrier_op = 6;
pub const ARM64_BARRIER_NSH: arm64_barrier_op = 7;
pub const ARM64_BARRIER_ISHLD: arm64_barrier_op = 9;
pub const ARM64_BARRIER_ISHST: arm64_barrier_op = 10;
pub const ARM64_BARRIER_ISH: arm64_barrier_op = 11;
pub const ARM64_BARRIER_LD: arm64_barrier_op = 13;
pub const ARM64_BARRIER_ST: arm64_barrier_op = 14;
pub const ARM64_BARRIER_SY: arm64_barrier_op = 15;
pub type arm64_barrier_op = ::std::os::raw::c_uint;
pub const ARM64_OP_INVALID: arm64_op_type = 0;
pub const ARM64_OP_REG: arm64_op_type = 1;
pub const ARM64_OP_IMM: arm64_op_type = 2;
pub const ARM64_OP_MEM: arm64_op_type = 3;
pub const ARM64_OP_FP: arm64_op_type = 4;
pub const ARM64_OP_CIMM: arm64_op_type = 64;
pub const ARM64_OP_REG_MRS: arm64_op_type = 65;
pub const ARM64_OP_REG_MSR: arm64_op_type = 66;
pub const ARM64_OP_PSTATE: arm64_op_type = 67;
pub const ARM64_OP_SYS: arm64_op_type = 68;
pub const ARM64_OP_PREFETCH: arm64_op_type = 69;
pub const ARM64_OP_BARRIER: arm64_op_type = 70;
pub type arm64_op_type = ::std::os::raw::c_uint;
pub const ARM64_PRFM_INVALID: arm64_prefetch_op = 0;
pub const ARM64_PRFM_PLDL1KEEP: arm64_prefetch_op = 1;
pub const ARM64_PRFM_PLDL1STRM: arm64_prefetch_op = 2;
pub const ARM64_PRFM_PLDL2KEEP: arm64_prefetch_op = 3;
pub const ARM64_PRFM_PLDL2STRM: arm64_prefetch_op = 4;
pub const ARM64_PRFM_PLDL3KEEP: arm64_prefetch_op = 5;
pub const ARM64_PRFM_PLDL3STRM: arm64_prefetch_op = 6;
pub const ARM64_PRFM_PLIL1KEEP: arm64_prefetch_op = 9;
pub const ARM64_PRFM_PLIL1STRM: arm64_prefetch_op = 10;
pub const ARM64_PRFM_PLIL2KEEP: arm64_prefetch_op = 11;
pub const ARM64_PRFM_PLIL2STRM: arm64_prefetch_op = 12;
pub const ARM64_PRFM_PLIL3KEEP: arm64_prefetch_op = 13;
pub const ARM64_PRFM_PLIL3STRM: arm64_prefetch_op = 14;
pub const ARM64_PRFM_PSTL1KEEP: arm64_prefetch_op = 17;
pub const ARM64_PRFM_PSTL1STRM: arm64_prefetch_op = 18;
pub const ARM64_PRFM_PSTL2KEEP: arm64_prefetch_op = 19;
pub const ARM64_PRFM_PSTL2STRM: arm64_prefetch_op = 20;
pub const ARM64_PRFM_PSTL3KEEP: arm64_prefetch_op = 21;
pub const ARM64_PRFM_PSTL3STRM: arm64_prefetch_op = 22;
pub type arm64_prefetch_op = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy)]
pub struct arm64_op_mem {
    pub base: ::std::os::raw::c_uint,
    pub index: ::std::os::raw::c_uint,
    pub disp: i32,
}
#[test]
fn bindgen_test_layout_arm64_op_mem() {
    assert_eq!(::std::mem::size_of::<arm64_op_mem>() , 12usize , concat ! (
               "Size of: " , stringify ! ( arm64_op_mem ) ));
    assert_eq! (::std::mem::align_of::<arm64_op_mem>() , 4usize , concat ! (
                "Alignment of " , stringify ! ( arm64_op_mem ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const arm64_op_mem ) ) . base as * const _ as
                usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( arm64_op_mem ) , "::" ,
                stringify ! ( base ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const arm64_op_mem ) ) . index as * const _ as
                usize } , 4usize , concat ! (
                "Alignment of field: " , stringify ! ( arm64_op_mem ) , "::" ,
                stringify ! ( index ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const arm64_op_mem ) ) . disp as * const _ as
                usize } , 8usize , concat ! (
                "Alignment of field: " , stringify ! ( arm64_op_mem ) , "::" ,
                stringify ! ( disp ) ));
}
impl Clone for arm64_op_mem {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Copy)]
pub struct cs_arm64_op {
    pub vector_index: ::std::os::raw::c_int,
    pub vas: arm64_vas,
    pub vess: arm64_vess,
    pub shift: cs_arm64_op__bindgen_ty_1,
    pub ext: arm64_extender,
    pub type_: arm64_op_type,
    pub __bindgen_anon_1: cs_arm64_op__bindgen_ty_2,
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct cs_arm64_op__bindgen_ty_1 {
    pub type_: arm64_shifter,
    pub value: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_cs_arm64_op__bindgen_ty_1() {
    assert_eq!(::std::mem::size_of::<cs_arm64_op__bindgen_ty_1>() , 8usize ,
               concat ! (
               "Size of: " , stringify ! ( cs_arm64_op__bindgen_ty_1 ) ));
    assert_eq! (::std::mem::align_of::<cs_arm64_op__bindgen_ty_1>() , 4usize ,
                concat ! (
                "Alignment of " , stringify ! ( cs_arm64_op__bindgen_ty_1 )
                ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm64_op__bindgen_ty_1 ) ) . type_ as
                * const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! (
                cs_arm64_op__bindgen_ty_1 ) , "::" , stringify ! ( type_ ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm64_op__bindgen_ty_1 ) ) . value as
                * const _ as usize } , 4usize , concat ! (
                "Alignment of field: " , stringify ! (
                cs_arm64_op__bindgen_ty_1 ) , "::" , stringify ! ( value ) ));
}
impl Clone for cs_arm64_op__bindgen_ty_1 {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Copy)]
pub union cs_arm64_op__bindgen_ty_2 {
    pub reg: ::std::os::raw::c_uint,
    pub imm: i64,
    pub fp: f64,
    pub mem: arm64_op_mem,
    pub pstate: arm64_pstate,
    pub sys: ::std::os::raw::c_uint,
    pub prefetch: arm64_prefetch_op,
    pub barrier: arm64_barrier_op,
}
#[test]
fn bindgen_test_layout_cs_arm64_op__bindgen_ty_2() {
    assert_eq!(::std::mem::size_of::<cs_arm64_op__bindgen_ty_2>() , 16usize ,
               concat ! (
               "Size of: " , stringify ! ( cs_arm64_op__bindgen_ty_2 ) ));
    assert_eq! (::std::mem::align_of::<cs_arm64_op__bindgen_ty_2>() , 8usize ,
                concat ! (
                "Alignment of " , stringify ! ( cs_arm64_op__bindgen_ty_2 )
                ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm64_op__bindgen_ty_2 ) ) . reg as *
                const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! (
                cs_arm64_op__bindgen_ty_2 ) , "::" , stringify ! ( reg ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm64_op__bindgen_ty_2 ) ) . imm as *
                const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! (
                cs_arm64_op__bindgen_ty_2 ) , "::" , stringify ! ( imm ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm64_op__bindgen_ty_2 ) ) . fp as *
                const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! (
                cs_arm64_op__bindgen_ty_2 ) , "::" , stringify ! ( fp ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm64_op__bindgen_ty_2 ) ) . mem as *
                const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! (
                cs_arm64_op__bindgen_ty_2 ) , "::" , stringify ! ( mem ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm64_op__bindgen_ty_2 ) ) . pstate as
                * const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! (
                cs_arm64_op__bindgen_ty_2 ) , "::" , stringify ! ( pstate )
                ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm64_op__bindgen_ty_2 ) ) . sys as *
                const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! (
                cs_arm64_op__bindgen_ty_2 ) , "::" , stringify ! ( sys ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm64_op__bindgen_ty_2 ) ) . prefetch
                as * const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! (
                cs_arm64_op__bindgen_ty_2 ) , "::" , stringify ! ( prefetch )
                ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm64_op__bindgen_ty_2 ) ) . barrier
                as * const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! (
                cs_arm64_op__bindgen_ty_2 ) , "::" , stringify ! ( barrier )
                ));
}
impl Clone for cs_arm64_op__bindgen_ty_2 {
    fn clone(&self) -> Self { *self }
}
#[test]
fn bindgen_test_layout_cs_arm64_op() {
    assert_eq!(::std::mem::size_of::<cs_arm64_op>() , 48usize , concat ! (
               "Size of: " , stringify ! ( cs_arm64_op ) ));
    assert_eq! (::std::mem::align_of::<cs_arm64_op>() , 8usize , concat ! (
                "Alignment of " , stringify ! ( cs_arm64_op ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm64_op ) ) . vector_index as * const
                _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_arm64_op ) , "::" ,
                stringify ! ( vector_index ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm64_op ) ) . vas as * const _ as
                usize } , 4usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_arm64_op ) , "::" ,
                stringify ! ( vas ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm64_op ) ) . vess as * const _ as
                usize } , 8usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_arm64_op ) , "::" ,
                stringify ! ( vess ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm64_op ) ) . shift as * const _ as
                usize } , 12usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_arm64_op ) , "::" ,
                stringify ! ( shift ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm64_op ) ) . ext as * const _ as
                usize } , 20usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_arm64_op ) , "::" ,
                stringify ! ( ext ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm64_op ) ) . type_ as * const _ as
                usize } , 24usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_arm64_op ) , "::" ,
                stringify ! ( type_ ) ));
}
impl Clone for cs_arm64_op {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Copy)]
pub struct cs_arm64 {
    pub cc: arm64_cc,
    pub update_flags: bool,
    pub writeback: bool,
    pub op_count: u8,
    pub operands: [cs_arm64_op; 8usize],
}
#[test]
fn bindgen_test_layout_cs_arm64() {
    assert_eq!(::std::mem::size_of::<cs_arm64>() , 392usize , concat ! (
               "Size of: " , stringify ! ( cs_arm64 ) ));
    assert_eq! (::std::mem::align_of::<cs_arm64>() , 8usize , concat ! (
                "Alignment of " , stringify ! ( cs_arm64 ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm64 ) ) . cc as * const _ as usize }
                , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_arm64 ) , "::" ,
                stringify ! ( cc ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm64 ) ) . update_flags as * const _
                as usize } , 4usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_arm64 ) , "::" ,
                stringify ! ( update_flags ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm64 ) ) . writeback as * const _ as
                usize } , 5usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_arm64 ) , "::" ,
                stringify ! ( writeback ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm64 ) ) . op_count as * const _ as
                usize } , 6usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_arm64 ) , "::" ,
                stringify ! ( op_count ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_arm64 ) ) . operands as * const _ as
                usize } , 8usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_arm64 ) , "::" ,
                stringify ! ( operands ) ));
}
impl Clone for cs_arm64 {
    fn clone(&self) -> Self { *self }
}
pub const MIPS_OP_INVALID: mips_op_type = 0;
pub const MIPS_OP_REG: mips_op_type = 1;
pub const MIPS_OP_IMM: mips_op_type = 2;
pub const MIPS_OP_MEM: mips_op_type = 3;
pub type mips_op_type = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy)]
pub struct mips_op_mem {
    pub base: ::std::os::raw::c_uint,
    pub disp: i64,
}
#[test]
fn bindgen_test_layout_mips_op_mem() {
    assert_eq!(::std::mem::size_of::<mips_op_mem>() , 16usize , concat ! (
               "Size of: " , stringify ! ( mips_op_mem ) ));
    assert_eq! (::std::mem::align_of::<mips_op_mem>() , 8usize , concat ! (
                "Alignment of " , stringify ! ( mips_op_mem ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const mips_op_mem ) ) . base as * const _ as
                usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( mips_op_mem ) , "::" ,
                stringify ! ( base ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const mips_op_mem ) ) . disp as * const _ as
                usize } , 8usize , concat ! (
                "Alignment of field: " , stringify ! ( mips_op_mem ) , "::" ,
                stringify ! ( disp ) ));
}
impl Clone for mips_op_mem {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Copy)]
pub struct cs_mips_op {
    pub type_: mips_op_type,
    pub __bindgen_anon_1: cs_mips_op__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy)]
pub union cs_mips_op__bindgen_ty_1 {
    pub reg: ::std::os::raw::c_uint,
    pub imm: i64,
    pub mem: mips_op_mem,
}
#[test]
fn bindgen_test_layout_cs_mips_op__bindgen_ty_1() {
    assert_eq!(::std::mem::size_of::<cs_mips_op__bindgen_ty_1>() , 16usize ,
               concat ! (
               "Size of: " , stringify ! ( cs_mips_op__bindgen_ty_1 ) ));
    assert_eq! (::std::mem::align_of::<cs_mips_op__bindgen_ty_1>() , 8usize ,
                concat ! (
                "Alignment of " , stringify ! ( cs_mips_op__bindgen_ty_1 ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_mips_op__bindgen_ty_1 ) ) . reg as *
                const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! (
                cs_mips_op__bindgen_ty_1 ) , "::" , stringify ! ( reg ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_mips_op__bindgen_ty_1 ) ) . imm as *
                const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! (
                cs_mips_op__bindgen_ty_1 ) , "::" , stringify ! ( imm ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_mips_op__bindgen_ty_1 ) ) . mem as *
                const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! (
                cs_mips_op__bindgen_ty_1 ) , "::" , stringify ! ( mem ) ));
}
impl Clone for cs_mips_op__bindgen_ty_1 {
    fn clone(&self) -> Self { *self }
}
#[test]
fn bindgen_test_layout_cs_mips_op() {
    assert_eq!(::std::mem::size_of::<cs_mips_op>() , 24usize , concat ! (
               "Size of: " , stringify ! ( cs_mips_op ) ));
    assert_eq! (::std::mem::align_of::<cs_mips_op>() , 8usize , concat ! (
                "Alignment of " , stringify ! ( cs_mips_op ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_mips_op ) ) . type_ as * const _ as
                usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_mips_op ) , "::" ,
                stringify ! ( type_ ) ));
}
impl Clone for cs_mips_op {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Copy)]
pub struct cs_mips {
    pub op_count: u8,
    pub operands: [cs_mips_op; 8usize],
}
#[test]
fn bindgen_test_layout_cs_mips() {
    assert_eq!(::std::mem::size_of::<cs_mips>() , 200usize , concat ! (
               "Size of: " , stringify ! ( cs_mips ) ));
    assert_eq! (::std::mem::align_of::<cs_mips>() , 8usize , concat ! (
                "Alignment of " , stringify ! ( cs_mips ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_mips ) ) . op_count as * const _ as
                usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_mips ) , "::" ,
                stringify ! ( op_count ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_mips ) ) . operands as * const _ as
                usize } , 8usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_mips ) , "::" ,
                stringify ! ( operands ) ));
}
impl Clone for cs_mips {
    fn clone(&self) -> Self { *self }
}
pub const PPC_BC_INVALID: ppc_bc = 0;
pub const PPC_BC_LT: ppc_bc = 12;
pub const PPC_BC_LE: ppc_bc = 36;
pub const PPC_BC_EQ: ppc_bc = 76;
pub const PPC_BC_GE: ppc_bc = 4;
pub const PPC_BC_GT: ppc_bc = 44;
pub const PPC_BC_NE: ppc_bc = 68;
pub const PPC_BC_UN: ppc_bc = 108;
pub const PPC_BC_NU: ppc_bc = 100;
pub const PPC_BC_SO: ppc_bc = 140;
pub const PPC_BC_NS: ppc_bc = 132;
pub type ppc_bc = ::std::os::raw::c_uint;
pub const PPC_BH_INVALID: ppc_bh = 0;
pub const PPC_BH_PLUS: ppc_bh = 1;
pub const PPC_BH_MINUS: ppc_bh = 2;
pub type ppc_bh = ::std::os::raw::c_uint;
pub const PPC_OP_INVALID: ppc_op_type = 0;
pub const PPC_OP_REG: ppc_op_type = 1;
pub const PPC_OP_IMM: ppc_op_type = 2;
pub const PPC_OP_MEM: ppc_op_type = 3;
pub const PPC_OP_CRX: ppc_op_type = 64;
pub type ppc_op_type = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy)]
pub struct ppc_op_mem {
    pub base: ::std::os::raw::c_uint,
    pub disp: i32,
}
#[test]
fn bindgen_test_layout_ppc_op_mem() {
    assert_eq!(::std::mem::size_of::<ppc_op_mem>() , 8usize , concat ! (
               "Size of: " , stringify ! ( ppc_op_mem ) ));
    assert_eq! (::std::mem::align_of::<ppc_op_mem>() , 4usize , concat ! (
                "Alignment of " , stringify ! ( ppc_op_mem ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const ppc_op_mem ) ) . base as * const _ as
                usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( ppc_op_mem ) , "::" ,
                stringify ! ( base ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const ppc_op_mem ) ) . disp as * const _ as
                usize } , 4usize , concat ! (
                "Alignment of field: " , stringify ! ( ppc_op_mem ) , "::" ,
                stringify ! ( disp ) ));
}
impl Clone for ppc_op_mem {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct ppc_op_crx {
    pub scale: ::std::os::raw::c_uint,
    pub reg: ::std::os::raw::c_uint,
    pub cond: ppc_bc,
}
#[test]
fn bindgen_test_layout_ppc_op_crx() {
    assert_eq!(::std::mem::size_of::<ppc_op_crx>() , 12usize , concat ! (
               "Size of: " , stringify ! ( ppc_op_crx ) ));
    assert_eq! (::std::mem::align_of::<ppc_op_crx>() , 4usize , concat ! (
                "Alignment of " , stringify ! ( ppc_op_crx ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const ppc_op_crx ) ) . scale as * const _ as
                usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( ppc_op_crx ) , "::" ,
                stringify ! ( scale ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const ppc_op_crx ) ) . reg as * const _ as
                usize } , 4usize , concat ! (
                "Alignment of field: " , stringify ! ( ppc_op_crx ) , "::" ,
                stringify ! ( reg ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const ppc_op_crx ) ) . cond as * const _ as
                usize } , 8usize , concat ! (
                "Alignment of field: " , stringify ! ( ppc_op_crx ) , "::" ,
                stringify ! ( cond ) ));
}
impl Clone for ppc_op_crx {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Copy)]
pub struct cs_ppc_op {
    pub type_: ppc_op_type,
    pub __bindgen_anon_1: cs_ppc_op__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy)]
pub union cs_ppc_op__bindgen_ty_1 {
    pub reg: ::std::os::raw::c_uint,
    pub imm: i32,
    pub mem: ppc_op_mem,
    pub crx: ppc_op_crx,
}
#[test]
fn bindgen_test_layout_cs_ppc_op__bindgen_ty_1() {
    assert_eq!(::std::mem::size_of::<cs_ppc_op__bindgen_ty_1>() , 12usize ,
               concat ! (
               "Size of: " , stringify ! ( cs_ppc_op__bindgen_ty_1 ) ));
    assert_eq! (::std::mem::align_of::<cs_ppc_op__bindgen_ty_1>() , 4usize ,
                concat ! (
                "Alignment of " , stringify ! ( cs_ppc_op__bindgen_ty_1 ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_ppc_op__bindgen_ty_1 ) ) . reg as *
                const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_ppc_op__bindgen_ty_1
                ) , "::" , stringify ! ( reg ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_ppc_op__bindgen_ty_1 ) ) . imm as *
                const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_ppc_op__bindgen_ty_1
                ) , "::" , stringify ! ( imm ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_ppc_op__bindgen_ty_1 ) ) . mem as *
                const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_ppc_op__bindgen_ty_1
                ) , "::" , stringify ! ( mem ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_ppc_op__bindgen_ty_1 ) ) . crx as *
                const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_ppc_op__bindgen_ty_1
                ) , "::" , stringify ! ( crx ) ));
}
impl Clone for cs_ppc_op__bindgen_ty_1 {
    fn clone(&self) -> Self { *self }
}
#[test]
fn bindgen_test_layout_cs_ppc_op() {
    assert_eq!(::std::mem::size_of::<cs_ppc_op>() , 16usize , concat ! (
               "Size of: " , stringify ! ( cs_ppc_op ) ));
    assert_eq! (::std::mem::align_of::<cs_ppc_op>() , 4usize , concat ! (
                "Alignment of " , stringify ! ( cs_ppc_op ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_ppc_op ) ) . type_ as * const _ as
                usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_ppc_op ) , "::" ,
                stringify ! ( type_ ) ));
}
impl Clone for cs_ppc_op {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Copy)]
pub struct cs_ppc {
    pub bc: ppc_bc,
    pub bh: ppc_bh,
    pub update_cr0: bool,
    pub op_count: u8,
    pub operands: [cs_ppc_op; 8usize],
}
#[test]
fn bindgen_test_layout_cs_ppc() {
    assert_eq!(::std::mem::size_of::<cs_ppc>() , 140usize , concat ! (
               "Size of: " , stringify ! ( cs_ppc ) ));
    assert_eq! (::std::mem::align_of::<cs_ppc>() , 4usize , concat ! (
                "Alignment of " , stringify ! ( cs_ppc ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_ppc ) ) . bc as * const _ as usize } ,
                0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_ppc ) , "::" ,
                stringify ! ( bc ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_ppc ) ) . bh as * const _ as usize } ,
                4usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_ppc ) , "::" ,
                stringify ! ( bh ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_ppc ) ) . update_cr0 as * const _ as
                usize } , 8usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_ppc ) , "::" ,
                stringify ! ( update_cr0 ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_ppc ) ) . op_count as * const _ as
                usize } , 9usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_ppc ) , "::" ,
                stringify ! ( op_count ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_ppc ) ) . operands as * const _ as
                usize } , 12usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_ppc ) , "::" ,
                stringify ! ( operands ) ));
}
impl Clone for cs_ppc {
    fn clone(&self) -> Self { *self }
}
pub const SPARC_CC_INVALID: sparc_cc = 0;
pub const SPARC_CC_ICC_A: sparc_cc = 264;
pub const SPARC_CC_ICC_N: sparc_cc = 256;
pub const SPARC_CC_ICC_NE: sparc_cc = 265;
pub const SPARC_CC_ICC_E: sparc_cc = 257;
pub const SPARC_CC_ICC_G: sparc_cc = 266;
pub const SPARC_CC_ICC_LE: sparc_cc = 258;
pub const SPARC_CC_ICC_GE: sparc_cc = 267;
pub const SPARC_CC_ICC_L: sparc_cc = 259;
pub const SPARC_CC_ICC_GU: sparc_cc = 268;
pub const SPARC_CC_ICC_LEU: sparc_cc = 260;
pub const SPARC_CC_ICC_CC: sparc_cc = 269;
pub const SPARC_CC_ICC_CS: sparc_cc = 261;
pub const SPARC_CC_ICC_POS: sparc_cc = 270;
pub const SPARC_CC_ICC_NEG: sparc_cc = 262;
pub const SPARC_CC_ICC_VC: sparc_cc = 271;
pub const SPARC_CC_ICC_VS: sparc_cc = 263;
pub const SPARC_CC_FCC_A: sparc_cc = 280;
pub const SPARC_CC_FCC_N: sparc_cc = 272;
pub const SPARC_CC_FCC_U: sparc_cc = 279;
pub const SPARC_CC_FCC_G: sparc_cc = 278;
pub const SPARC_CC_FCC_UG: sparc_cc = 277;
pub const SPARC_CC_FCC_L: sparc_cc = 276;
pub const SPARC_CC_FCC_UL: sparc_cc = 275;
pub const SPARC_CC_FCC_LG: sparc_cc = 274;
pub const SPARC_CC_FCC_NE: sparc_cc = 273;
pub const SPARC_CC_FCC_E: sparc_cc = 281;
pub const SPARC_CC_FCC_UE: sparc_cc = 282;
pub const SPARC_CC_FCC_GE: sparc_cc = 283;
pub const SPARC_CC_FCC_UGE: sparc_cc = 284;
pub const SPARC_CC_FCC_LE: sparc_cc = 285;
pub const SPARC_CC_FCC_ULE: sparc_cc = 286;
pub const SPARC_CC_FCC_O: sparc_cc = 287;
pub type sparc_cc = ::std::os::raw::c_uint;
pub const SPARC_HINT_INVALID: sparc_hint = 0;
pub const SPARC_HINT_A: sparc_hint = 1;
pub const SPARC_HINT_PT: sparc_hint = 2;
pub const SPARC_HINT_PN: sparc_hint = 4;
pub type sparc_hint = ::std::os::raw::c_uint;
pub const SPARC_OP_INVALID: sparc_op_type = 0;
pub const SPARC_OP_REG: sparc_op_type = 1;
pub const SPARC_OP_IMM: sparc_op_type = 2;
pub const SPARC_OP_MEM: sparc_op_type = 3;
pub type sparc_op_type = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy)]
pub struct sparc_op_mem {
    pub base: u8,
    pub index: u8,
    pub disp: i32,
}
#[test]
fn bindgen_test_layout_sparc_op_mem() {
    assert_eq!(::std::mem::size_of::<sparc_op_mem>() , 8usize , concat ! (
               "Size of: " , stringify ! ( sparc_op_mem ) ));
    assert_eq! (::std::mem::align_of::<sparc_op_mem>() , 4usize , concat ! (
                "Alignment of " , stringify ! ( sparc_op_mem ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const sparc_op_mem ) ) . base as * const _ as
                usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( sparc_op_mem ) , "::" ,
                stringify ! ( base ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const sparc_op_mem ) ) . index as * const _ as
                usize } , 1usize , concat ! (
                "Alignment of field: " , stringify ! ( sparc_op_mem ) , "::" ,
                stringify ! ( index ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const sparc_op_mem ) ) . disp as * const _ as
                usize } , 4usize , concat ! (
                "Alignment of field: " , stringify ! ( sparc_op_mem ) , "::" ,
                stringify ! ( disp ) ));
}
impl Clone for sparc_op_mem {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Copy)]
pub struct cs_sparc_op {
    pub type_: sparc_op_type,
    pub __bindgen_anon_1: cs_sparc_op__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy)]
pub union cs_sparc_op__bindgen_ty_1 {
    pub reg: ::std::os::raw::c_uint,
    pub imm: i32,
    pub mem: sparc_op_mem,
}
#[test]
fn bindgen_test_layout_cs_sparc_op__bindgen_ty_1() {
    assert_eq!(::std::mem::size_of::<cs_sparc_op__bindgen_ty_1>() , 8usize ,
               concat ! (
               "Size of: " , stringify ! ( cs_sparc_op__bindgen_ty_1 ) ));
    assert_eq! (::std::mem::align_of::<cs_sparc_op__bindgen_ty_1>() , 4usize ,
                concat ! (
                "Alignment of " , stringify ! ( cs_sparc_op__bindgen_ty_1 )
                ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_sparc_op__bindgen_ty_1 ) ) . reg as *
                const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! (
                cs_sparc_op__bindgen_ty_1 ) , "::" , stringify ! ( reg ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_sparc_op__bindgen_ty_1 ) ) . imm as *
                const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! (
                cs_sparc_op__bindgen_ty_1 ) , "::" , stringify ! ( imm ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_sparc_op__bindgen_ty_1 ) ) . mem as *
                const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! (
                cs_sparc_op__bindgen_ty_1 ) , "::" , stringify ! ( mem ) ));
}
impl Clone for cs_sparc_op__bindgen_ty_1 {
    fn clone(&self) -> Self { *self }
}
#[test]
fn bindgen_test_layout_cs_sparc_op() {
    assert_eq!(::std::mem::size_of::<cs_sparc_op>() , 12usize , concat ! (
               "Size of: " , stringify ! ( cs_sparc_op ) ));
    assert_eq! (::std::mem::align_of::<cs_sparc_op>() , 4usize , concat ! (
                "Alignment of " , stringify ! ( cs_sparc_op ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_sparc_op ) ) . type_ as * const _ as
                usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_sparc_op ) , "::" ,
                stringify ! ( type_ ) ));
}
impl Clone for cs_sparc_op {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Copy)]
pub struct cs_sparc {
    pub cc: sparc_cc,
    pub hint: sparc_hint,
    pub op_count: u8,
    pub operands: [cs_sparc_op; 4usize],
}
#[test]
fn bindgen_test_layout_cs_sparc() {
    assert_eq!(::std::mem::size_of::<cs_sparc>() , 60usize , concat ! (
               "Size of: " , stringify ! ( cs_sparc ) ));
    assert_eq! (::std::mem::align_of::<cs_sparc>() , 4usize , concat ! (
                "Alignment of " , stringify ! ( cs_sparc ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_sparc ) ) . cc as * const _ as usize }
                , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_sparc ) , "::" ,
                stringify ! ( cc ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_sparc ) ) . hint as * const _ as usize
                } , 4usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_sparc ) , "::" ,
                stringify ! ( hint ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_sparc ) ) . op_count as * const _ as
                usize } , 8usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_sparc ) , "::" ,
                stringify ! ( op_count ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_sparc ) ) . operands as * const _ as
                usize } , 12usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_sparc ) , "::" ,
                stringify ! ( operands ) ));
}
impl Clone for cs_sparc {
    fn clone(&self) -> Self { *self }
}
pub const SYSZ_CC_INVALID: sysz_cc = 0;
pub const SYSZ_CC_O: sysz_cc = 1;
pub const SYSZ_CC_H: sysz_cc = 2;
pub const SYSZ_CC_NLE: sysz_cc = 3;
pub const SYSZ_CC_L: sysz_cc = 4;
pub const SYSZ_CC_NHE: sysz_cc = 5;
pub const SYSZ_CC_LH: sysz_cc = 6;
pub const SYSZ_CC_NE: sysz_cc = 7;
pub const SYSZ_CC_E: sysz_cc = 8;
pub const SYSZ_CC_NLH: sysz_cc = 9;
pub const SYSZ_CC_HE: sysz_cc = 10;
pub const SYSZ_CC_NL: sysz_cc = 11;
pub const SYSZ_CC_LE: sysz_cc = 12;
pub const SYSZ_CC_NH: sysz_cc = 13;
pub const SYSZ_CC_NO: sysz_cc = 14;
pub type sysz_cc = ::std::os::raw::c_uint;
pub const SYSZ_OP_INVALID: sysz_op_type = 0;
pub const SYSZ_OP_REG: sysz_op_type = 1;
pub const SYSZ_OP_IMM: sysz_op_type = 2;
pub const SYSZ_OP_MEM: sysz_op_type = 3;
pub const SYSZ_OP_ACREG: sysz_op_type = 64;
pub type sysz_op_type = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy)]
pub struct sysz_op_mem {
    pub base: u8,
    pub index: u8,
    pub length: u64,
    pub disp: i64,
}
#[test]
fn bindgen_test_layout_sysz_op_mem() {
    assert_eq!(::std::mem::size_of::<sysz_op_mem>() , 24usize , concat ! (
               "Size of: " , stringify ! ( sysz_op_mem ) ));
    assert_eq! (::std::mem::align_of::<sysz_op_mem>() , 8usize , concat ! (
                "Alignment of " , stringify ! ( sysz_op_mem ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const sysz_op_mem ) ) . base as * const _ as
                usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( sysz_op_mem ) , "::" ,
                stringify ! ( base ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const sysz_op_mem ) ) . index as * const _ as
                usize } , 1usize , concat ! (
                "Alignment of field: " , stringify ! ( sysz_op_mem ) , "::" ,
                stringify ! ( index ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const sysz_op_mem ) ) . length as * const _ as
                usize } , 8usize , concat ! (
                "Alignment of field: " , stringify ! ( sysz_op_mem ) , "::" ,
                stringify ! ( length ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const sysz_op_mem ) ) . disp as * const _ as
                usize } , 16usize , concat ! (
                "Alignment of field: " , stringify ! ( sysz_op_mem ) , "::" ,
                stringify ! ( disp ) ));
}
impl Clone for sysz_op_mem {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Copy)]
pub struct cs_sysz_op {
    pub type_: sysz_op_type,
    pub __bindgen_anon_1: cs_sysz_op__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy)]
pub union cs_sysz_op__bindgen_ty_1 {
    pub reg: ::std::os::raw::c_uint,
    pub imm: i64,
    pub mem: sysz_op_mem,
}
#[test]
fn bindgen_test_layout_cs_sysz_op__bindgen_ty_1() {
    assert_eq!(::std::mem::size_of::<cs_sysz_op__bindgen_ty_1>() , 24usize ,
               concat ! (
               "Size of: " , stringify ! ( cs_sysz_op__bindgen_ty_1 ) ));
    assert_eq! (::std::mem::align_of::<cs_sysz_op__bindgen_ty_1>() , 8usize ,
                concat ! (
                "Alignment of " , stringify ! ( cs_sysz_op__bindgen_ty_1 ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_sysz_op__bindgen_ty_1 ) ) . reg as *
                const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! (
                cs_sysz_op__bindgen_ty_1 ) , "::" , stringify ! ( reg ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_sysz_op__bindgen_ty_1 ) ) . imm as *
                const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! (
                cs_sysz_op__bindgen_ty_1 ) , "::" , stringify ! ( imm ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_sysz_op__bindgen_ty_1 ) ) . mem as *
                const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! (
                cs_sysz_op__bindgen_ty_1 ) , "::" , stringify ! ( mem ) ));
}
impl Clone for cs_sysz_op__bindgen_ty_1 {
    fn clone(&self) -> Self { *self }
}
#[test]
fn bindgen_test_layout_cs_sysz_op() {
    assert_eq!(::std::mem::size_of::<cs_sysz_op>() , 32usize , concat ! (
               "Size of: " , stringify ! ( cs_sysz_op ) ));
    assert_eq! (::std::mem::align_of::<cs_sysz_op>() , 8usize , concat ! (
                "Alignment of " , stringify ! ( cs_sysz_op ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_sysz_op ) ) . type_ as * const _ as
                usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_sysz_op ) , "::" ,
                stringify ! ( type_ ) ));
}
impl Clone for cs_sysz_op {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Copy)]
pub struct cs_sysz {
    pub cc: sysz_cc,
    pub op_count: u8,
    pub operands: [cs_sysz_op; 6usize],
}
#[test]
fn bindgen_test_layout_cs_sysz() {
    assert_eq!(::std::mem::size_of::<cs_sysz>() , 200usize , concat ! (
               "Size of: " , stringify ! ( cs_sysz ) ));
    assert_eq! (::std::mem::align_of::<cs_sysz>() , 8usize , concat ! (
                "Alignment of " , stringify ! ( cs_sysz ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_sysz ) ) . cc as * const _ as usize }
                , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_sysz ) , "::" ,
                stringify ! ( cc ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_sysz ) ) . op_count as * const _ as
                usize } , 4usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_sysz ) , "::" ,
                stringify ! ( op_count ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_sysz ) ) . operands as * const _ as
                usize } , 8usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_sysz ) , "::" ,
                stringify ! ( operands ) ));
}
impl Clone for cs_sysz {
    fn clone(&self) -> Self { *self }
}
pub const X86_REG_INVALID: x86_reg = 0;
pub const X86_REG_AH: x86_reg = 1;
pub const X86_REG_AL: x86_reg = 2;
pub const X86_REG_AX: x86_reg = 3;
pub const X86_REG_BH: x86_reg = 4;
pub const X86_REG_BL: x86_reg = 5;
pub const X86_REG_BP: x86_reg = 6;
pub const X86_REG_BPL: x86_reg = 7;
pub const X86_REG_BX: x86_reg = 8;
pub const X86_REG_CH: x86_reg = 9;
pub const X86_REG_CL: x86_reg = 10;
pub const X86_REG_CS: x86_reg = 11;
pub const X86_REG_CX: x86_reg = 12;
pub const X86_REG_DH: x86_reg = 13;
pub const X86_REG_DI: x86_reg = 14;
pub const X86_REG_DIL: x86_reg = 15;
pub const X86_REG_DL: x86_reg = 16;
pub const X86_REG_DS: x86_reg = 17;
pub const X86_REG_DX: x86_reg = 18;
pub const X86_REG_EAX: x86_reg = 19;
pub const X86_REG_EBP: x86_reg = 20;
pub const X86_REG_EBX: x86_reg = 21;
pub const X86_REG_ECX: x86_reg = 22;
pub const X86_REG_EDI: x86_reg = 23;
pub const X86_REG_EDX: x86_reg = 24;
pub const X86_REG_EFLAGS: x86_reg = 25;
pub const X86_REG_EIP: x86_reg = 26;
pub const X86_REG_EIZ: x86_reg = 27;
pub const X86_REG_ES: x86_reg = 28;
pub const X86_REG_ESI: x86_reg = 29;
pub const X86_REG_ESP: x86_reg = 30;
pub const X86_REG_FPSW: x86_reg = 31;
pub const X86_REG_FS: x86_reg = 32;
pub const X86_REG_GS: x86_reg = 33;
pub const X86_REG_IP: x86_reg = 34;
pub const X86_REG_RAX: x86_reg = 35;
pub const X86_REG_RBP: x86_reg = 36;
pub const X86_REG_RBX: x86_reg = 37;
pub const X86_REG_RCX: x86_reg = 38;
pub const X86_REG_RDI: x86_reg = 39;
pub const X86_REG_RDX: x86_reg = 40;
pub const X86_REG_RIP: x86_reg = 41;
pub const X86_REG_RIZ: x86_reg = 42;
pub const X86_REG_RSI: x86_reg = 43;
pub const X86_REG_RSP: x86_reg = 44;
pub const X86_REG_SI: x86_reg = 45;
pub const X86_REG_SIL: x86_reg = 46;
pub const X86_REG_SP: x86_reg = 47;
pub const X86_REG_SPL: x86_reg = 48;
pub const X86_REG_SS: x86_reg = 49;
pub const X86_REG_CR0: x86_reg = 50;
pub const X86_REG_CR1: x86_reg = 51;
pub const X86_REG_CR2: x86_reg = 52;
pub const X86_REG_CR3: x86_reg = 53;
pub const X86_REG_CR4: x86_reg = 54;
pub const X86_REG_CR5: x86_reg = 55;
pub const X86_REG_CR6: x86_reg = 56;
pub const X86_REG_CR7: x86_reg = 57;
pub const X86_REG_CR8: x86_reg = 58;
pub const X86_REG_CR9: x86_reg = 59;
pub const X86_REG_CR10: x86_reg = 60;
pub const X86_REG_CR11: x86_reg = 61;
pub const X86_REG_CR12: x86_reg = 62;
pub const X86_REG_CR13: x86_reg = 63;
pub const X86_REG_CR14: x86_reg = 64;
pub const X86_REG_CR15: x86_reg = 65;
pub const X86_REG_DR0: x86_reg = 66;
pub const X86_REG_DR1: x86_reg = 67;
pub const X86_REG_DR2: x86_reg = 68;
pub const X86_REG_DR3: x86_reg = 69;
pub const X86_REG_DR4: x86_reg = 70;
pub const X86_REG_DR5: x86_reg = 71;
pub const X86_REG_DR6: x86_reg = 72;
pub const X86_REG_DR7: x86_reg = 73;
pub const X86_REG_FP0: x86_reg = 74;
pub const X86_REG_FP1: x86_reg = 75;
pub const X86_REG_FP2: x86_reg = 76;
pub const X86_REG_FP3: x86_reg = 77;
pub const X86_REG_FP4: x86_reg = 78;
pub const X86_REG_FP5: x86_reg = 79;
pub const X86_REG_FP6: x86_reg = 80;
pub const X86_REG_FP7: x86_reg = 81;
pub const X86_REG_K0: x86_reg = 82;
pub const X86_REG_K1: x86_reg = 83;
pub const X86_REG_K2: x86_reg = 84;
pub const X86_REG_K3: x86_reg = 85;
pub const X86_REG_K4: x86_reg = 86;
pub const X86_REG_K5: x86_reg = 87;
pub const X86_REG_K6: x86_reg = 88;
pub const X86_REG_K7: x86_reg = 89;
pub const X86_REG_MM0: x86_reg = 90;
pub const X86_REG_MM1: x86_reg = 91;
pub const X86_REG_MM2: x86_reg = 92;
pub const X86_REG_MM3: x86_reg = 93;
pub const X86_REG_MM4: x86_reg = 94;
pub const X86_REG_MM5: x86_reg = 95;
pub const X86_REG_MM6: x86_reg = 96;
pub const X86_REG_MM7: x86_reg = 97;
pub const X86_REG_R8: x86_reg = 98;
pub const X86_REG_R9: x86_reg = 99;
pub const X86_REG_R10: x86_reg = 100;
pub const X86_REG_R11: x86_reg = 101;
pub const X86_REG_R12: x86_reg = 102;
pub const X86_REG_R13: x86_reg = 103;
pub const X86_REG_R14: x86_reg = 104;
pub const X86_REG_R15: x86_reg = 105;
pub const X86_REG_ST0: x86_reg = 106;
pub const X86_REG_ST1: x86_reg = 107;
pub const X86_REG_ST2: x86_reg = 108;
pub const X86_REG_ST3: x86_reg = 109;
pub const X86_REG_ST4: x86_reg = 110;
pub const X86_REG_ST5: x86_reg = 111;
pub const X86_REG_ST6: x86_reg = 112;
pub const X86_REG_ST7: x86_reg = 113;
pub const X86_REG_XMM0: x86_reg = 114;
pub const X86_REG_XMM1: x86_reg = 115;
pub const X86_REG_XMM2: x86_reg = 116;
pub const X86_REG_XMM3: x86_reg = 117;
pub const X86_REG_XMM4: x86_reg = 118;
pub const X86_REG_XMM5: x86_reg = 119;
pub const X86_REG_XMM6: x86_reg = 120;
pub const X86_REG_XMM7: x86_reg = 121;
pub const X86_REG_XMM8: x86_reg = 122;
pub const X86_REG_XMM9: x86_reg = 123;
pub const X86_REG_XMM10: x86_reg = 124;
pub const X86_REG_XMM11: x86_reg = 125;
pub const X86_REG_XMM12: x86_reg = 126;
pub const X86_REG_XMM13: x86_reg = 127;
pub const X86_REG_XMM14: x86_reg = 128;
pub const X86_REG_XMM15: x86_reg = 129;
pub const X86_REG_XMM16: x86_reg = 130;
pub const X86_REG_XMM17: x86_reg = 131;
pub const X86_REG_XMM18: x86_reg = 132;
pub const X86_REG_XMM19: x86_reg = 133;
pub const X86_REG_XMM20: x86_reg = 134;
pub const X86_REG_XMM21: x86_reg = 135;
pub const X86_REG_XMM22: x86_reg = 136;
pub const X86_REG_XMM23: x86_reg = 137;
pub const X86_REG_XMM24: x86_reg = 138;
pub const X86_REG_XMM25: x86_reg = 139;
pub const X86_REG_XMM26: x86_reg = 140;
pub const X86_REG_XMM27: x86_reg = 141;
pub const X86_REG_XMM28: x86_reg = 142;
pub const X86_REG_XMM29: x86_reg = 143;
pub const X86_REG_XMM30: x86_reg = 144;
pub const X86_REG_XMM31: x86_reg = 145;
pub const X86_REG_YMM0: x86_reg = 146;
pub const X86_REG_YMM1: x86_reg = 147;
pub const X86_REG_YMM2: x86_reg = 148;
pub const X86_REG_YMM3: x86_reg = 149;
pub const X86_REG_YMM4: x86_reg = 150;
pub const X86_REG_YMM5: x86_reg = 151;
pub const X86_REG_YMM6: x86_reg = 152;
pub const X86_REG_YMM7: x86_reg = 153;
pub const X86_REG_YMM8: x86_reg = 154;
pub const X86_REG_YMM9: x86_reg = 155;
pub const X86_REG_YMM10: x86_reg = 156;
pub const X86_REG_YMM11: x86_reg = 157;
pub const X86_REG_YMM12: x86_reg = 158;
pub const X86_REG_YMM13: x86_reg = 159;
pub const X86_REG_YMM14: x86_reg = 160;
pub const X86_REG_YMM15: x86_reg = 161;
pub const X86_REG_YMM16: x86_reg = 162;
pub const X86_REG_YMM17: x86_reg = 163;
pub const X86_REG_YMM18: x86_reg = 164;
pub const X86_REG_YMM19: x86_reg = 165;
pub const X86_REG_YMM20: x86_reg = 166;
pub const X86_REG_YMM21: x86_reg = 167;
pub const X86_REG_YMM22: x86_reg = 168;
pub const X86_REG_YMM23: x86_reg = 169;
pub const X86_REG_YMM24: x86_reg = 170;
pub const X86_REG_YMM25: x86_reg = 171;
pub const X86_REG_YMM26: x86_reg = 172;
pub const X86_REG_YMM27: x86_reg = 173;
pub const X86_REG_YMM28: x86_reg = 174;
pub const X86_REG_YMM29: x86_reg = 175;
pub const X86_REG_YMM30: x86_reg = 176;
pub const X86_REG_YMM31: x86_reg = 177;
pub const X86_REG_ZMM0: x86_reg = 178;
pub const X86_REG_ZMM1: x86_reg = 179;
pub const X86_REG_ZMM2: x86_reg = 180;
pub const X86_REG_ZMM3: x86_reg = 181;
pub const X86_REG_ZMM4: x86_reg = 182;
pub const X86_REG_ZMM5: x86_reg = 183;
pub const X86_REG_ZMM6: x86_reg = 184;
pub const X86_REG_ZMM7: x86_reg = 185;
pub const X86_REG_ZMM8: x86_reg = 186;
pub const X86_REG_ZMM9: x86_reg = 187;
pub const X86_REG_ZMM10: x86_reg = 188;
pub const X86_REG_ZMM11: x86_reg = 189;
pub const X86_REG_ZMM12: x86_reg = 190;
pub const X86_REG_ZMM13: x86_reg = 191;
pub const X86_REG_ZMM14: x86_reg = 192;
pub const X86_REG_ZMM15: x86_reg = 193;
pub const X86_REG_ZMM16: x86_reg = 194;
pub const X86_REG_ZMM17: x86_reg = 195;
pub const X86_REG_ZMM18: x86_reg = 196;
pub const X86_REG_ZMM19: x86_reg = 197;
pub const X86_REG_ZMM20: x86_reg = 198;
pub const X86_REG_ZMM21: x86_reg = 199;
pub const X86_REG_ZMM22: x86_reg = 200;
pub const X86_REG_ZMM23: x86_reg = 201;
pub const X86_REG_ZMM24: x86_reg = 202;
pub const X86_REG_ZMM25: x86_reg = 203;
pub const X86_REG_ZMM26: x86_reg = 204;
pub const X86_REG_ZMM27: x86_reg = 205;
pub const X86_REG_ZMM28: x86_reg = 206;
pub const X86_REG_ZMM29: x86_reg = 207;
pub const X86_REG_ZMM30: x86_reg = 208;
pub const X86_REG_ZMM31: x86_reg = 209;
pub const X86_REG_R8B: x86_reg = 210;
pub const X86_REG_R9B: x86_reg = 211;
pub const X86_REG_R10B: x86_reg = 212;
pub const X86_REG_R11B: x86_reg = 213;
pub const X86_REG_R12B: x86_reg = 214;
pub const X86_REG_R13B: x86_reg = 215;
pub const X86_REG_R14B: x86_reg = 216;
pub const X86_REG_R15B: x86_reg = 217;
pub const X86_REG_R8D: x86_reg = 218;
pub const X86_REG_R9D: x86_reg = 219;
pub const X86_REG_R10D: x86_reg = 220;
pub const X86_REG_R11D: x86_reg = 221;
pub const X86_REG_R12D: x86_reg = 222;
pub const X86_REG_R13D: x86_reg = 223;
pub const X86_REG_R14D: x86_reg = 224;
pub const X86_REG_R15D: x86_reg = 225;
pub const X86_REG_R8W: x86_reg = 226;
pub const X86_REG_R9W: x86_reg = 227;
pub const X86_REG_R10W: x86_reg = 228;
pub const X86_REG_R11W: x86_reg = 229;
pub const X86_REG_R12W: x86_reg = 230;
pub const X86_REG_R13W: x86_reg = 231;
pub const X86_REG_R14W: x86_reg = 232;
pub const X86_REG_R15W: x86_reg = 233;
pub const X86_REG_ENDING: x86_reg = 234;
pub type x86_reg = ::std::os::raw::c_uint;
pub const X86_OP_INVALID: x86_op_type = 0;
pub const X86_OP_REG: x86_op_type = 1;
pub const X86_OP_IMM: x86_op_type = 2;
pub const X86_OP_MEM: x86_op_type = 3;
pub const X86_OP_FP: x86_op_type = 4;
pub type x86_op_type = ::std::os::raw::c_uint;
pub const X86_AVX_BCAST_INVALID: x86_avx_bcast = 0;
pub const X86_AVX_BCAST_2: x86_avx_bcast = 1;
pub const X86_AVX_BCAST_4: x86_avx_bcast = 2;
pub const X86_AVX_BCAST_8: x86_avx_bcast = 3;
pub const X86_AVX_BCAST_16: x86_avx_bcast = 4;
pub type x86_avx_bcast = ::std::os::raw::c_uint;
pub const X86_SSE_CC_INVALID: x86_sse_cc = 0;
pub const X86_SSE_CC_EQ: x86_sse_cc = 1;
pub const X86_SSE_CC_LT: x86_sse_cc = 2;
pub const X86_SSE_CC_LE: x86_sse_cc = 3;
pub const X86_SSE_CC_UNORD: x86_sse_cc = 4;
pub const X86_SSE_CC_NEQ: x86_sse_cc = 5;
pub const X86_SSE_CC_NLT: x86_sse_cc = 6;
pub const X86_SSE_CC_NLE: x86_sse_cc = 7;
pub const X86_SSE_CC_ORD: x86_sse_cc = 8;
pub const X86_SSE_CC_EQ_UQ: x86_sse_cc = 9;
pub const X86_SSE_CC_NGE: x86_sse_cc = 10;
pub const X86_SSE_CC_NGT: x86_sse_cc = 11;
pub const X86_SSE_CC_FALSE: x86_sse_cc = 12;
pub const X86_SSE_CC_NEQ_OQ: x86_sse_cc = 13;
pub const X86_SSE_CC_GE: x86_sse_cc = 14;
pub const X86_SSE_CC_GT: x86_sse_cc = 15;
pub const X86_SSE_CC_TRUE: x86_sse_cc = 16;
pub type x86_sse_cc = ::std::os::raw::c_uint;
pub const X86_AVX_CC_INVALID: x86_avx_cc = 0;
pub const X86_AVX_CC_EQ: x86_avx_cc = 1;
pub const X86_AVX_CC_LT: x86_avx_cc = 2;
pub const X86_AVX_CC_LE: x86_avx_cc = 3;
pub const X86_AVX_CC_UNORD: x86_avx_cc = 4;
pub const X86_AVX_CC_NEQ: x86_avx_cc = 5;
pub const X86_AVX_CC_NLT: x86_avx_cc = 6;
pub const X86_AVX_CC_NLE: x86_avx_cc = 7;
pub const X86_AVX_CC_ORD: x86_avx_cc = 8;
pub const X86_AVX_CC_EQ_UQ: x86_avx_cc = 9;
pub const X86_AVX_CC_NGE: x86_avx_cc = 10;
pub const X86_AVX_CC_NGT: x86_avx_cc = 11;
pub const X86_AVX_CC_FALSE: x86_avx_cc = 12;
pub const X86_AVX_CC_NEQ_OQ: x86_avx_cc = 13;
pub const X86_AVX_CC_GE: x86_avx_cc = 14;
pub const X86_AVX_CC_GT: x86_avx_cc = 15;
pub const X86_AVX_CC_TRUE: x86_avx_cc = 16;
pub const X86_AVX_CC_EQ_OS: x86_avx_cc = 17;
pub const X86_AVX_CC_LT_OQ: x86_avx_cc = 18;
pub const X86_AVX_CC_LE_OQ: x86_avx_cc = 19;
pub const X86_AVX_CC_UNORD_S: x86_avx_cc = 20;
pub const X86_AVX_CC_NEQ_US: x86_avx_cc = 21;
pub const X86_AVX_CC_NLT_UQ: x86_avx_cc = 22;
pub const X86_AVX_CC_NLE_UQ: x86_avx_cc = 23;
pub const X86_AVX_CC_ORD_S: x86_avx_cc = 24;
pub const X86_AVX_CC_EQ_US: x86_avx_cc = 25;
pub const X86_AVX_CC_NGE_UQ: x86_avx_cc = 26;
pub const X86_AVX_CC_NGT_UQ: x86_avx_cc = 27;
pub const X86_AVX_CC_FALSE_OS: x86_avx_cc = 28;
pub const X86_AVX_CC_NEQ_OS: x86_avx_cc = 29;
pub const X86_AVX_CC_GE_OQ: x86_avx_cc = 30;
pub const X86_AVX_CC_GT_OQ: x86_avx_cc = 31;
pub const X86_AVX_CC_TRUE_US: x86_avx_cc = 32;
pub type x86_avx_cc = ::std::os::raw::c_uint;
pub const X86_AVX_RM_INVALID: x86_avx_rm = 0;
pub const X86_AVX_RM_RN: x86_avx_rm = 1;
pub const X86_AVX_RM_RD: x86_avx_rm = 2;
pub const X86_AVX_RM_RU: x86_avx_rm = 3;
pub const X86_AVX_RM_RZ: x86_avx_rm = 4;
pub type x86_avx_rm = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy)]
pub struct x86_op_mem {
    pub segment: ::std::os::raw::c_uint,
    pub base: ::std::os::raw::c_uint,
    pub index: ::std::os::raw::c_uint,
    pub scale: ::std::os::raw::c_int,
    pub disp: i64,
}
#[test]
fn bindgen_test_layout_x86_op_mem() {
    assert_eq!(::std::mem::size_of::<x86_op_mem>() , 24usize , concat ! (
               "Size of: " , stringify ! ( x86_op_mem ) ));
    assert_eq! (::std::mem::align_of::<x86_op_mem>() , 8usize , concat ! (
                "Alignment of " , stringify ! ( x86_op_mem ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const x86_op_mem ) ) . segment as * const _ as
                usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( x86_op_mem ) , "::" ,
                stringify ! ( segment ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const x86_op_mem ) ) . base as * const _ as
                usize } , 4usize , concat ! (
                "Alignment of field: " , stringify ! ( x86_op_mem ) , "::" ,
                stringify ! ( base ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const x86_op_mem ) ) . index as * const _ as
                usize } , 8usize , concat ! (
                "Alignment of field: " , stringify ! ( x86_op_mem ) , "::" ,
                stringify ! ( index ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const x86_op_mem ) ) . scale as * const _ as
                usize } , 12usize , concat ! (
                "Alignment of field: " , stringify ! ( x86_op_mem ) , "::" ,
                stringify ! ( scale ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const x86_op_mem ) ) . disp as * const _ as
                usize } , 16usize , concat ! (
                "Alignment of field: " , stringify ! ( x86_op_mem ) , "::" ,
                stringify ! ( disp ) ));
}
impl Clone for x86_op_mem {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Copy)]
pub struct cs_x86_op {
    pub type_: x86_op_type,
    pub __bindgen_anon_1: cs_x86_op__bindgen_ty_1,
    pub size: u8,
    pub avx_bcast: x86_avx_bcast,
    pub avx_zero_opmask: bool,
}
#[repr(C)]
#[derive(Copy)]
pub union cs_x86_op__bindgen_ty_1 {
    pub reg: x86_reg,
    pub imm: i64,
    pub fp: f64,
    pub mem: x86_op_mem,
}
#[test]
fn bindgen_test_layout_cs_x86_op__bindgen_ty_1() {
    assert_eq!(::std::mem::size_of::<cs_x86_op__bindgen_ty_1>() , 24usize ,
               concat ! (
               "Size of: " , stringify ! ( cs_x86_op__bindgen_ty_1 ) ));
    assert_eq! (::std::mem::align_of::<cs_x86_op__bindgen_ty_1>() , 8usize ,
                concat ! (
                "Alignment of " , stringify ! ( cs_x86_op__bindgen_ty_1 ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_x86_op__bindgen_ty_1 ) ) . reg as *
                const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_x86_op__bindgen_ty_1
                ) , "::" , stringify ! ( reg ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_x86_op__bindgen_ty_1 ) ) . imm as *
                const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_x86_op__bindgen_ty_1
                ) , "::" , stringify ! ( imm ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_x86_op__bindgen_ty_1 ) ) . fp as *
                const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_x86_op__bindgen_ty_1
                ) , "::" , stringify ! ( fp ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_x86_op__bindgen_ty_1 ) ) . mem as *
                const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_x86_op__bindgen_ty_1
                ) , "::" , stringify ! ( mem ) ));
}
impl Clone for cs_x86_op__bindgen_ty_1 {
    fn clone(&self) -> Self { *self }
}
#[test]
fn bindgen_test_layout_cs_x86_op() {
    assert_eq!(::std::mem::size_of::<cs_x86_op>() , 48usize , concat ! (
               "Size of: " , stringify ! ( cs_x86_op ) ));
    assert_eq! (::std::mem::align_of::<cs_x86_op>() , 8usize , concat ! (
                "Alignment of " , stringify ! ( cs_x86_op ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_x86_op ) ) . type_ as * const _ as
                usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_x86_op ) , "::" ,
                stringify ! ( type_ ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_x86_op ) ) . size as * const _ as
                usize } , 32usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_x86_op ) , "::" ,
                stringify ! ( size ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_x86_op ) ) . avx_bcast as * const _ as
                usize } , 36usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_x86_op ) , "::" ,
                stringify ! ( avx_bcast ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_x86_op ) ) . avx_zero_opmask as *
                const _ as usize } , 40usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_x86_op ) , "::" ,
                stringify ! ( avx_zero_opmask ) ));
}
impl Clone for cs_x86_op {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Copy)]
pub struct cs_x86 {
    pub prefix: [u8; 4usize],
    pub opcode: [u8; 4usize],
    pub rex: u8,
    pub addr_size: u8,
    pub modrm: u8,
    pub sib: u8,
    pub disp: i32,
    pub sib_index: x86_reg,
    pub sib_scale: i8,
    pub sib_base: x86_reg,
    pub sse_cc: x86_sse_cc,
    pub avx_cc: x86_avx_cc,
    pub avx_sae: bool,
    pub avx_rm: x86_avx_rm,
    pub op_count: u8,
    pub operands: [cs_x86_op; 8usize],
}
#[test]
fn bindgen_test_layout_cs_x86() {
    assert_eq!(::std::mem::size_of::<cs_x86>() , 432usize , concat ! (
               "Size of: " , stringify ! ( cs_x86 ) ));
    assert_eq! (::std::mem::align_of::<cs_x86>() , 8usize , concat ! (
                "Alignment of " , stringify ! ( cs_x86 ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_x86 ) ) . prefix as * const _ as usize
                } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_x86 ) , "::" ,
                stringify ! ( prefix ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_x86 ) ) . opcode as * const _ as usize
                } , 4usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_x86 ) , "::" ,
                stringify ! ( opcode ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_x86 ) ) . rex as * const _ as usize }
                , 8usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_x86 ) , "::" ,
                stringify ! ( rex ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_x86 ) ) . addr_size as * const _ as
                usize } , 9usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_x86 ) , "::" ,
                stringify ! ( addr_size ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_x86 ) ) . modrm as * const _ as usize
                } , 10usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_x86 ) , "::" ,
                stringify ! ( modrm ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_x86 ) ) . sib as * const _ as usize }
                , 11usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_x86 ) , "::" ,
                stringify ! ( sib ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_x86 ) ) . disp as * const _ as usize }
                , 12usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_x86 ) , "::" ,
                stringify ! ( disp ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_x86 ) ) . sib_index as * const _ as
                usize } , 16usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_x86 ) , "::" ,
                stringify ! ( sib_index ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_x86 ) ) . sib_scale as * const _ as
                usize } , 20usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_x86 ) , "::" ,
                stringify ! ( sib_scale ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_x86 ) ) . sib_base as * const _ as
                usize } , 24usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_x86 ) , "::" ,
                stringify ! ( sib_base ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_x86 ) ) . sse_cc as * const _ as usize
                } , 28usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_x86 ) , "::" ,
                stringify ! ( sse_cc ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_x86 ) ) . avx_cc as * const _ as usize
                } , 32usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_x86 ) , "::" ,
                stringify ! ( avx_cc ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_x86 ) ) . avx_sae as * const _ as
                usize } , 36usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_x86 ) , "::" ,
                stringify ! ( avx_sae ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_x86 ) ) . avx_rm as * const _ as usize
                } , 40usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_x86 ) , "::" ,
                stringify ! ( avx_rm ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_x86 ) ) . op_count as * const _ as
                usize } , 44usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_x86 ) , "::" ,
                stringify ! ( op_count ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_x86 ) ) . operands as * const _ as
                usize } , 48usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_x86 ) , "::" ,
                stringify ! ( operands ) ));
}
impl Clone for cs_x86 {
    fn clone(&self) -> Self { *self }
}
pub const XCORE_OP_INVALID: xcore_op_type = 0;
pub const XCORE_OP_REG: xcore_op_type = 1;
pub const XCORE_OP_IMM: xcore_op_type = 2;
pub const XCORE_OP_MEM: xcore_op_type = 3;
pub type xcore_op_type = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy)]
pub struct xcore_op_mem {
    pub base: u8,
    pub index: u8,
    pub disp: i32,
    pub direct: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_xcore_op_mem() {
    assert_eq!(::std::mem::size_of::<xcore_op_mem>() , 12usize , concat ! (
               "Size of: " , stringify ! ( xcore_op_mem ) ));
    assert_eq! (::std::mem::align_of::<xcore_op_mem>() , 4usize , concat ! (
                "Alignment of " , stringify ! ( xcore_op_mem ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const xcore_op_mem ) ) . base as * const _ as
                usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( xcore_op_mem ) , "::" ,
                stringify ! ( base ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const xcore_op_mem ) ) . index as * const _ as
                usize } , 1usize , concat ! (
                "Alignment of field: " , stringify ! ( xcore_op_mem ) , "::" ,
                stringify ! ( index ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const xcore_op_mem ) ) . disp as * const _ as
                usize } , 4usize , concat ! (
                "Alignment of field: " , stringify ! ( xcore_op_mem ) , "::" ,
                stringify ! ( disp ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const xcore_op_mem ) ) . direct as * const _ as
                usize } , 8usize , concat ! (
                "Alignment of field: " , stringify ! ( xcore_op_mem ) , "::" ,
                stringify ! ( direct ) ));
}
impl Clone for xcore_op_mem {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Copy)]
pub struct cs_xcore_op {
    pub type_: xcore_op_type,
    pub __bindgen_anon_1: cs_xcore_op__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy)]
pub union cs_xcore_op__bindgen_ty_1 {
    pub reg: ::std::os::raw::c_uint,
    pub imm: i32,
    pub mem: xcore_op_mem,
}
#[test]
fn bindgen_test_layout_cs_xcore_op__bindgen_ty_1() {
    assert_eq!(::std::mem::size_of::<cs_xcore_op__bindgen_ty_1>() , 12usize ,
               concat ! (
               "Size of: " , stringify ! ( cs_xcore_op__bindgen_ty_1 ) ));
    assert_eq! (::std::mem::align_of::<cs_xcore_op__bindgen_ty_1>() , 4usize ,
                concat ! (
                "Alignment of " , stringify ! ( cs_xcore_op__bindgen_ty_1 )
                ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_xcore_op__bindgen_ty_1 ) ) . reg as *
                const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! (
                cs_xcore_op__bindgen_ty_1 ) , "::" , stringify ! ( reg ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_xcore_op__bindgen_ty_1 ) ) . imm as *
                const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! (
                cs_xcore_op__bindgen_ty_1 ) , "::" , stringify ! ( imm ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_xcore_op__bindgen_ty_1 ) ) . mem as *
                const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! (
                cs_xcore_op__bindgen_ty_1 ) , "::" , stringify ! ( mem ) ));
}
impl Clone for cs_xcore_op__bindgen_ty_1 {
    fn clone(&self) -> Self { *self }
}
#[test]
fn bindgen_test_layout_cs_xcore_op() {
    assert_eq!(::std::mem::size_of::<cs_xcore_op>() , 16usize , concat ! (
               "Size of: " , stringify ! ( cs_xcore_op ) ));
    assert_eq! (::std::mem::align_of::<cs_xcore_op>() , 4usize , concat ! (
                "Alignment of " , stringify ! ( cs_xcore_op ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_xcore_op ) ) . type_ as * const _ as
                usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_xcore_op ) , "::" ,
                stringify ! ( type_ ) ));
}
impl Clone for cs_xcore_op {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Copy)]
pub struct cs_xcore {
    pub op_count: u8,
    pub operands: [cs_xcore_op; 8usize],
}
#[test]
fn bindgen_test_layout_cs_xcore() {
    assert_eq!(::std::mem::size_of::<cs_xcore>() , 132usize , concat ! (
               "Size of: " , stringify ! ( cs_xcore ) ));
    assert_eq! (::std::mem::align_of::<cs_xcore>() , 4usize , concat ! (
                "Alignment of " , stringify ! ( cs_xcore ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_xcore ) ) . op_count as * const _ as
                usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_xcore ) , "::" ,
                stringify ! ( op_count ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_xcore ) ) . operands as * const _ as
                usize } , 4usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_xcore ) , "::" ,
                stringify ! ( operands ) ));
}
impl Clone for cs_xcore {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
pub struct cs_detail {
    pub regs_read: [u8; 12usize],
    pub regs_read_count: u8,
    pub regs_write: [u8; 20usize],
    pub regs_write_count: u8,
    pub groups: [u8; 8usize],
    pub groups_count: u8,
    pub __bindgen_anon_1: cs_detail__bindgen_ty_1,
}
#[repr(C)]
pub union cs_detail__bindgen_ty_1 {
    pub x86: cs_x86,
    pub arm64: cs_arm64,
    pub arm: cs_arm,
    pub mips: cs_mips,
    pub ppc: cs_ppc,
    pub sparc: cs_sparc,
    pub sysz: cs_sysz,
    pub xcore: cs_xcore,
}
#[test]
fn bindgen_test_layout_cs_detail__bindgen_ty_1() {
    assert_eq!(::std::mem::size_of::<cs_detail__bindgen_ty_1>() , 1480usize ,
               concat ! (
               "Size of: " , stringify ! ( cs_detail__bindgen_ty_1 ) ));
    assert_eq! (::std::mem::align_of::<cs_detail__bindgen_ty_1>() , 8usize ,
                concat ! (
                "Alignment of " , stringify ! ( cs_detail__bindgen_ty_1 ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_detail__bindgen_ty_1 ) ) . x86 as *
                const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_detail__bindgen_ty_1
                ) , "::" , stringify ! ( x86 ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_detail__bindgen_ty_1 ) ) . arm64 as *
                const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_detail__bindgen_ty_1
                ) , "::" , stringify ! ( arm64 ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_detail__bindgen_ty_1 ) ) . arm as *
                const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_detail__bindgen_ty_1
                ) , "::" , stringify ! ( arm ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_detail__bindgen_ty_1 ) ) . mips as *
                const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_detail__bindgen_ty_1
                ) , "::" , stringify ! ( mips ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_detail__bindgen_ty_1 ) ) . ppc as *
                const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_detail__bindgen_ty_1
                ) , "::" , stringify ! ( ppc ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_detail__bindgen_ty_1 ) ) . sparc as *
                const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_detail__bindgen_ty_1
                ) , "::" , stringify ! ( sparc ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_detail__bindgen_ty_1 ) ) . sysz as *
                const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_detail__bindgen_ty_1
                ) , "::" , stringify ! ( sysz ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_detail__bindgen_ty_1 ) ) . xcore as *
                const _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_detail__bindgen_ty_1
                ) , "::" , stringify ! ( xcore ) ));
}
#[test]
fn bindgen_test_layout_cs_detail() {
    assert_eq!(::std::mem::size_of::<cs_detail>() , 1528usize , concat ! (
               "Size of: " , stringify ! ( cs_detail ) ));
    assert_eq! (::std::mem::align_of::<cs_detail>() , 8usize , concat ! (
                "Alignment of " , stringify ! ( cs_detail ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_detail ) ) . regs_read as * const _ as
                usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_detail ) , "::" ,
                stringify ! ( regs_read ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_detail ) ) . regs_read_count as *
                const _ as usize } , 12usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_detail ) , "::" ,
                stringify ! ( regs_read_count ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_detail ) ) . regs_write as * const _
                as usize } , 13usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_detail ) , "::" ,
                stringify ! ( regs_write ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_detail ) ) . regs_write_count as *
                const _ as usize } , 33usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_detail ) , "::" ,
                stringify ! ( regs_write_count ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_detail ) ) . groups as * const _ as
                usize } , 34usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_detail ) , "::" ,
                stringify ! ( groups ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_detail ) ) . groups_count as * const _
                as usize } , 42usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_detail ) , "::" ,
                stringify ! ( groups_count ) ));
}
#[repr(C)]
pub struct cs_insn {
    pub id: ::std::os::raw::c_uint,
    pub address: u64,
    pub size: u16,
    pub bytes: [u8; 16usize],
    pub mnemonic: [::std::os::raw::c_char; 32usize],
    pub op_str: [::std::os::raw::c_char; 160usize],
    pub detail: *mut cs_detail,
}
#[test]
fn bindgen_test_layout_cs_insn() {
    assert_eq!(::std::mem::size_of::<cs_insn>() , 240usize , concat ! (
               "Size of: " , stringify ! ( cs_insn ) ));
    assert_eq! (::std::mem::align_of::<cs_insn>() , 8usize , concat ! (
                "Alignment of " , stringify ! ( cs_insn ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_insn ) ) . id as * const _ as usize }
                , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_insn ) , "::" ,
                stringify ! ( id ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_insn ) ) . address as * const _ as
                usize } , 8usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_insn ) , "::" ,
                stringify ! ( address ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_insn ) ) . size as * const _ as usize
                } , 16usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_insn ) , "::" ,
                stringify ! ( size ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_insn ) ) . bytes as * const _ as usize
                } , 18usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_insn ) , "::" ,
                stringify ! ( bytes ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_insn ) ) . mnemonic as * const _ as
                usize } , 34usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_insn ) , "::" ,
                stringify ! ( mnemonic ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_insn ) ) . op_str as * const _ as
                usize } , 66usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_insn ) , "::" ,
                stringify ! ( op_str ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const cs_insn ) ) . detail as * const _ as
                usize } , 232usize , concat ! (
                "Alignment of field: " , stringify ! ( cs_insn ) , "::" ,
                stringify ! ( detail ) ));
}
pub const CS_ERR_OK: cs_err = 0;
pub const CS_ERR_MEM: cs_err = 1;
pub const CS_ERR_ARCH: cs_err = 2;
pub const CS_ERR_HANDLE: cs_err = 3;
pub const CS_ERR_CSH: cs_err = 4;
pub const CS_ERR_MODE: cs_err = 5;
pub const CS_ERR_OPTION: cs_err = 6;
pub const CS_ERR_DETAIL: cs_err = 7;
pub const CS_ERR_MEMSETUP: cs_err = 8;
pub const CS_ERR_VERSION: cs_err = 9;
pub const CS_ERR_DIET: cs_err = 10;
pub const CS_ERR_SKIPDATA: cs_err = 11;
pub const CS_ERR_X86_ATT: cs_err = 12;
pub const CS_ERR_X86_INTEL: cs_err = 13;
pub type cs_err = ::std::os::raw::c_uint;
extern "C" {
    pub fn cs_version(major: *mut ::std::os::raw::c_int,
                      minor: *mut ::std::os::raw::c_int)
     -> ::std::os::raw::c_uint;
}
extern "C" {
    pub fn cs_support(query: ::std::os::raw::c_int) -> bool;
}
extern "C" {
    pub fn cs_open(arch: cs_arch, mode: cs_mode, handle: *mut csh) -> cs_err;
}
extern "C" {
    pub fn cs_close(handle: *mut csh) -> cs_err;
}
extern "C" {
    pub fn cs_option(handle: csh, type_: cs_opt_type, value: usize) -> cs_err;
}
extern "C" {
    pub fn cs_errno(handle: csh) -> cs_err;
}
extern "C" {
    pub fn cs_strerror(code: cs_err) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn cs_disasm(handle: csh, code: *const u8, code_size: usize,
                     address: u64, count: usize, insn: *mut *mut cs_insn)
     -> usize;
}
extern "C" {
    pub fn cs_disasm_ex(handle: csh, code: *const u8, code_size: usize,
                        address: u64, count: usize, insn: *mut *mut cs_insn)
     -> usize;
}
extern "C" {
    pub fn cs_free(insn: *mut cs_insn, count: usize);
}
extern "C" {
    pub fn cs_malloc(handle: csh) -> *mut cs_insn;
}
extern "C" {
    pub fn cs_disasm_iter(handle: csh, code: *mut *const u8, size: *mut usize,
                          address: *mut u64, insn: *mut cs_insn) -> bool;
}
extern "C" {
    pub fn cs_reg_name(handle: csh, reg_id: ::std::os::raw::c_uint)
     -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn cs_insn_name(handle: csh, insn_id: ::std::os::raw::c_uint)
     -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn cs_group_name(handle: csh, group_id: ::std::os::raw::c_uint)
     -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn cs_insn_group(handle: csh, insn: *const cs_insn,
                         group_id: ::std::os::raw::c_uint) -> bool;
}
extern "C" {
    pub fn cs_reg_read(handle: csh, insn: *const cs_insn,
                       reg_id: ::std::os::raw::c_uint) -> bool;
}
extern "C" {
    pub fn cs_reg_write(handle: csh, insn: *const cs_insn,
                        reg_id: ::std::os::raw::c_uint) -> bool;
}
extern "C" {
    pub fn cs_op_count(handle: csh, insn: *const cs_insn,
                       op_type: ::std::os::raw::c_uint)
     -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn cs_op_index(handle: csh, insn: *const cs_insn,
                       op_type: ::std::os::raw::c_uint,
                       position: ::std::os::raw::c_uint)
     -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct __va_list_tag {
    pub gp_offset: ::std::os::raw::c_uint,
    pub fp_offset: ::std::os::raw::c_uint,
    pub overflow_arg_area: *mut ::std::os::raw::c_void,
    pub reg_save_area: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout___va_list_tag() {
    assert_eq!(::std::mem::size_of::<__va_list_tag>() , 24usize , concat ! (
               "Size of: " , stringify ! ( __va_list_tag ) ));
    assert_eq! (::std::mem::align_of::<__va_list_tag>() , 8usize , concat ! (
                "Alignment of " , stringify ! ( __va_list_tag ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const __va_list_tag ) ) . gp_offset as * const
                _ as usize } , 0usize , concat ! (
                "Alignment of field: " , stringify ! ( __va_list_tag ) , "::"
                , stringify ! ( gp_offset ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const __va_list_tag ) ) . fp_offset as * const
                _ as usize } , 4usize , concat ! (
                "Alignment of field: " , stringify ! ( __va_list_tag ) , "::"
                , stringify ! ( fp_offset ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const __va_list_tag ) ) . overflow_arg_area as
                * const _ as usize } , 8usize , concat ! (
                "Alignment of field: " , stringify ! ( __va_list_tag ) , "::"
                , stringify ! ( overflow_arg_area ) ));
    assert_eq! (unsafe {
                & ( * ( 0 as * const __va_list_tag ) ) . reg_save_area as *
                const _ as usize } , 16usize , concat ! (
                "Alignment of field: " , stringify ! ( __va_list_tag ) , "::"
                , stringify ! ( reg_save_area ) ));
}
impl Clone for __va_list_tag {
    fn clone(&self) -> Self { *self }
}
pub type __builtin_va_list = [__va_list_tag; 1usize];