/* automatically generated by rust-bindgen */

#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct __BindgenBitfieldUnit<Storage, Align>
where
    Storage: AsRef<[u8]> + AsMut<[u8]>,
{
    storage: Storage,
    align: [Align; 0],
}
impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
where
    Storage: AsRef<[u8]> + AsMut<[u8]>,
{
    #[inline]
    pub fn new(storage: Storage) -> Self {
        Self { storage, align: [] }
    }
    #[inline]
    pub fn get_bit(&self, index: usize) -> bool {
        debug_assert!(index / 8 < self.storage.as_ref().len());
        let byte_index = index / 8;
        let byte = self.storage.as_ref()[byte_index];
        let bit_index = if cfg!(target_endian = "big") {
            7 - (index % 8)
        } else {
            index % 8
        };
        let mask = 1 << bit_index;
        byte & mask == mask
    }
    #[inline]
    pub fn set_bit(&mut self, index: usize, val: bool) {
        debug_assert!(index / 8 < self.storage.as_ref().len());
        let byte_index = index / 8;
        let byte = &mut self.storage.as_mut()[byte_index];
        let bit_index = if cfg!(target_endian = "big") {
            7 - (index % 8)
        } else {
            index % 8
        };
        let mask = 1 << bit_index;
        if val {
            *byte |= mask;
        } else {
            *byte &= !mask;
        }
    }
    #[inline]
    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
        debug_assert!(bit_width <= 64);
        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
        debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
        let mut val = 0;
        for i in 0..(bit_width as usize) {
            if self.get_bit(i + bit_offset) {
                let index = if cfg!(target_endian = "big") {
                    bit_width as usize - 1 - i
                } else {
                    i
                };
                val |= 1 << index;
            }
        }
        val
    }
    #[inline]
    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
        debug_assert!(bit_width <= 64);
        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
        debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
        for i in 0..(bit_width as usize) {
            let mask = 1 << i;
            let val_bit_is_set = val & mask == mask;
            let index = if cfg!(target_endian = "big") {
                bit_width as usize - 1 - i
            } else {
                i
            };
            self.set_bit(index + bit_offset, val_bit_is_set);
        }
    }
}
#[repr(C)]
#[derive(Default)]
pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
impl<T> __IncompleteArrayField<T> {
    #[inline]
    pub fn new() -> Self {
        __IncompleteArrayField(::std::marker::PhantomData, [])
    }
    #[inline]
    pub unsafe fn as_ptr(&self) -> *const T {
        ::std::mem::transmute(self)
    }
    #[inline]
    pub unsafe fn as_mut_ptr(&mut self) -> *mut T {
        ::std::mem::transmute(self)
    }
    #[inline]
    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
        ::std::slice::from_raw_parts(self.as_ptr(), len)
    }
    #[inline]
    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
    }
}
impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        fmt.write_str("__IncompleteArrayField")
    }
}
impl<T> ::std::clone::Clone for __IncompleteArrayField<T> {
    #[inline]
    fn clone(&self) -> Self {
        Self::new()
    }
}
pub const MRB_INT_BIT: u32 = 64;
pub const MRB_PRIo: &'static [u8; 3usize] = b"lo\0";
pub const MRB_PRId: &'static [u8; 3usize] = b"ld\0";
pub const MRB_PRIx: &'static [u8; 3usize] = b"lx\0";
pub const MRB_FL_OBJ_IS_FROZEN: u32 = 1048576;
pub const MRB_FIXNUM_SHIFT: u32 = 0;
pub const MRB_SYMBOL_MAX: u32 = 4294967295;
pub const MRB_EACH_OBJ_OK: u32 = 0;
pub const MRB_EACH_OBJ_BREAK: u32 = 1;
pub const MRB_GC_ARENA_SIZE: u32 = 100;
pub const MRUBY_RUBY_VERSION: &'static [u8; 4usize] = b"2.0\0";
pub const MRUBY_RUBY_ENGINE: &'static [u8; 6usize] = b"mruby\0";
pub const MRUBY_RELEASE_MAJOR: u32 = 2;
pub const MRUBY_RELEASE_MINOR: u32 = 0;
pub const MRUBY_RELEASE_TEENY: u32 = 1;
pub const MRUBY_RELEASE_NO: u32 = 20001;
pub const MRUBY_RELEASE_YEAR: u32 = 2019;
pub const MRUBY_RELEASE_MONTH: u32 = 4;
pub const MRUBY_RELEASE_DAY: u32 = 4;
pub const MRUBY_BIRTH_YEAR: u32 = 2010;
pub const MRUBY_AUTHOR: &'static [u8; 17usize] = b"mruby developers\0";
pub const MRB_FIXED_STATE_ATEXIT_STACK_SIZE: u32 = 5;
pub const MRB_METHOD_CACHE_SIZE: u32 = 128;
pub const MRB_ARY_EMBED_MASK: u32 = 7;
pub const MRB_ARY_SHARED: u32 = 256;
pub const MRB_FL_CLASS_IS_PREPENDED: u32 = 524288;
pub const MRB_FL_CLASS_IS_ORIGIN: u32 = 262144;
pub const MRB_FL_CLASS_IS_INHERITED: u32 = 131072;
pub const MRB_INSTANCE_TT_MASK: u32 = 255;
pub const MRB_PARSER_TOKBUF_MAX: u32 = 65534;
pub const MRB_PARSER_TOKBUF_SIZE: u32 = 256;
pub const MRB_ISEQ_NO_FREE: u32 = 1;
pub const MRB_DUMP_OK: u32 = 0;
pub const MRB_DUMP_GENERAL_FAILURE: i32 = -1;
pub const MRB_DUMP_WRITE_FAULT: i32 = -2;
pub const MRB_DUMP_READ_FAULT: i32 = -3;
pub const MRB_DUMP_CRC_ERROR: i32 = -4;
pub const MRB_DUMP_INVALID_FILE_HEADER: i32 = -5;
pub const MRB_DUMP_INVALID_IREP: i32 = -6;
pub const MRB_DUMP_INVALID_ARGUMENT: i32 = -7;
pub const MRB_DUMP_NULL_SYM_LEN: u32 = 65535;
pub const MRB_DUMP_DEFAULT_STR_LEN: u32 = 128;
pub const MRB_HASH_DEFAULT: u32 = 1;
pub const MRB_HASH_PROC_DEFAULT: u32 = 2;
pub const MRB_ENV_STACK_UNSHARED: u32 = 1048576;
pub const MRB_PROC_CFUNC_FL: u32 = 128;
pub const MRB_PROC_STRICT: u32 = 256;
pub const MRB_PROC_ORPHAN: u32 = 512;
pub const MRB_PROC_ENVSET: u32 = 1024;
pub const MRB_PROC_SCOPE: u32 = 2048;
pub const REGEXP_CLASS: &'static [u8; 7usize] = b"Regexp\0";
pub const MRB_STR_SHARED: u32 = 1;
pub const MRB_STR_FSHARED: u32 = 2;
pub const MRB_STR_NOFREE: u32 = 4;
pub const MRB_STR_POOL: u32 = 8;
pub const MRB_STR_ASCII: u32 = 16;
pub const MRB_STR_EMBED: u32 = 32;
pub const MRB_STR_EMBED_LEN_MASK: u32 = 1984;
pub const MRB_STR_EMBED_LEN_SHIFT: u32 = 6;
pub type va_list = __builtin_va_list;
pub type __uint8_t = ::std::os::raw::c_uchar;
pub type __uint16_t = ::std::os::raw::c_ushort;
pub type __uint32_t = ::std::os::raw::c_uint;
pub type __int64_t = ::std::os::raw::c_long;
pub type mrb_sym = u32;
pub type mrb_bool = u8;
pub type mrb_int = i64;
extern "C" {
    pub fn mrb_float_read(
        arg1: *const ::std::os::raw::c_char,
        arg2: *mut *mut ::std::os::raw::c_char,
    ) -> f64;
}
pub type mrb_float = f64;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum mrb_vtype {
    MRB_TT_FALSE = 0,
    MRB_TT_FREE = 1,
    MRB_TT_TRUE = 2,
    MRB_TT_FIXNUM = 3,
    MRB_TT_SYMBOL = 4,
    MRB_TT_UNDEF = 5,
    MRB_TT_FLOAT = 6,
    MRB_TT_CPTR = 7,
    MRB_TT_OBJECT = 8,
    MRB_TT_CLASS = 9,
    MRB_TT_MODULE = 10,
    MRB_TT_ICLASS = 11,
    MRB_TT_SCLASS = 12,
    MRB_TT_PROC = 13,
    MRB_TT_ARRAY = 14,
    MRB_TT_HASH = 15,
    MRB_TT_STRING = 16,
    MRB_TT_RANGE = 17,
    MRB_TT_EXCEPTION = 18,
    MRB_TT_FILE = 19,
    MRB_TT_ENV = 20,
    MRB_TT_DATA = 21,
    MRB_TT_FIBER = 22,
    MRB_TT_ISTRUCT = 23,
    MRB_TT_BREAK = 24,
    MRB_TT_MAXDEFINE = 25,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RBasic {
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u32>,
    pub c: *mut RClass,
    pub gcnext: *mut RBasic,
}
impl RBasic {
    #[inline]
    pub fn tt(&self) -> mrb_vtype {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
    }
    #[inline]
    pub fn set_tt(&mut self, val: mrb_vtype) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 8u8, val as u64)
        }
    }
    #[inline]
    pub fn color(&self) -> u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 3u8) as u32) }
    }
    #[inline]
    pub fn set_color(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(8usize, 3u8, val as u64)
        }
    }
    #[inline]
    pub fn flags(&self) -> u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 21u8) as u32) }
    }
    #[inline]
    pub fn set_flags(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(11usize, 21u8, val as u64)
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        tt: mrb_vtype,
        color: u32,
        flags: u32,
    ) -> __BindgenBitfieldUnit<[u8; 4usize], u32> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u32> =
            Default::default();
        __bindgen_bitfield_unit.set(0usize, 8u8, {
            let tt: u32 = unsafe { ::std::mem::transmute(tt) };
            tt as u64
        });
        __bindgen_bitfield_unit.set(8usize, 3u8, {
            let color: u32 = unsafe { ::std::mem::transmute(color) };
            color as u64
        });
        __bindgen_bitfield_unit.set(11usize, 21u8, {
            let flags: u32 = unsafe { ::std::mem::transmute(flags) };
            flags as u64
        });
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RObject {
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u32>,
    pub c: *mut RClass,
    pub gcnext: *mut RBasic,
    pub iv: *mut iv_tbl,
}
impl RObject {
    #[inline]
    pub fn tt(&self) -> mrb_vtype {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
    }
    #[inline]
    pub fn set_tt(&mut self, val: mrb_vtype) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 8u8, val as u64)
        }
    }
    #[inline]
    pub fn color(&self) -> u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 3u8) as u32) }
    }
    #[inline]
    pub fn set_color(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(8usize, 3u8, val as u64)
        }
    }
    #[inline]
    pub fn flags(&self) -> u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 21u8) as u32) }
    }
    #[inline]
    pub fn set_flags(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(11usize, 21u8, val as u64)
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        tt: mrb_vtype,
        color: u32,
        flags: u32,
    ) -> __BindgenBitfieldUnit<[u8; 4usize], u32> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u32> =
            Default::default();
        __bindgen_bitfield_unit.set(0usize, 8u8, {
            let tt: u32 = unsafe { ::std::mem::transmute(tt) };
            tt as u64
        });
        __bindgen_bitfield_unit.set(8usize, 3u8, {
            let color: u32 = unsafe { ::std::mem::transmute(color) };
            color as u64
        });
        __bindgen_bitfield_unit.set(11usize, 21u8, {
            let flags: u32 = unsafe { ::std::mem::transmute(flags) };
            flags as u64
        });
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RFiber {
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u32>,
    pub c: *mut RClass,
    pub gcnext: *mut RBasic,
    pub cxt: *mut mrb_context,
}
impl RFiber {
    #[inline]
    pub fn tt(&self) -> mrb_vtype {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
    }
    #[inline]
    pub fn set_tt(&mut self, val: mrb_vtype) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 8u8, val as u64)
        }
    }
    #[inline]
    pub fn color(&self) -> u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 3u8) as u32) }
    }
    #[inline]
    pub fn set_color(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(8usize, 3u8, val as u64)
        }
    }
    #[inline]
    pub fn flags(&self) -> u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 21u8) as u32) }
    }
    #[inline]
    pub fn set_flags(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(11usize, 21u8, val as u64)
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        tt: mrb_vtype,
        color: u32,
        flags: u32,
    ) -> __BindgenBitfieldUnit<[u8; 4usize], u32> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u32> =
            Default::default();
        __bindgen_bitfield_unit.set(0usize, 8u8, {
            let tt: u32 = unsafe { ::std::mem::transmute(tt) };
            tt as u64
        });
        __bindgen_bitfield_unit.set(8usize, 3u8, {
            let color: u32 = unsafe { ::std::mem::transmute(color) };
            color as u64
        });
        __bindgen_bitfield_unit.set(11usize, 21u8, {
            let flags: u32 = unsafe { ::std::mem::transmute(flags) };
            flags as u64
        });
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct mrb_value {
    pub value: mrb_value__bindgen_ty_1,
    pub tt: mrb_vtype,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union mrb_value__bindgen_ty_1 {
    pub f: mrb_float,
    pub p: *mut ::std::os::raw::c_void,
    pub i: mrb_int,
    pub sym: mrb_sym,
    _bindgen_union_align: u64,
}
pub type mrb_each_object_callback = ::std::option::Option<
    unsafe extern "C" fn(
        mrb: *mut mrb_state,
        obj: *mut RBasic,
        data: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int,
>;
extern "C" {
    pub fn mrb_objspace_each_objects(
        mrb: *mut mrb_state,
        callback: mrb_each_object_callback,
        data: *mut ::std::os::raw::c_void,
    );
}
extern "C" {
    pub fn mrb_free_context(mrb: *mut mrb_state, c: *mut mrb_context);
}
pub const mrb_gc_state_MRB_GC_STATE_ROOT: mrb_gc_state = 0;
pub const mrb_gc_state_MRB_GC_STATE_MARK: mrb_gc_state = 1;
pub const mrb_gc_state_MRB_GC_STATE_SWEEP: mrb_gc_state = 2;
pub type mrb_gc_state = u32;
#[repr(C)]
#[derive(Debug)]
pub struct mrb_heap_page {
    pub freelist: *mut RBasic,
    pub prev: *mut mrb_heap_page,
    pub next: *mut mrb_heap_page,
    pub free_next: *mut mrb_heap_page,
    pub free_prev: *mut mrb_heap_page,
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
    pub objects: __IncompleteArrayField<*mut ::std::os::raw::c_void>,
    pub __bindgen_padding_0: [u8; 7usize],
}
impl mrb_heap_page {
    #[inline]
    pub fn old(&self) -> mrb_bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_old(&mut self, val: mrb_bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn new_bitfield_1(old: mrb_bool) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> =
            Default::default();
        __bindgen_bitfield_unit.set(0usize, 1u8, {
            let old: u8 = unsafe { ::std::mem::transmute(old) };
            old as u64
        });
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mrb_gc {
    pub heaps: *mut mrb_heap_page,
    pub sweeps: *mut mrb_heap_page,
    pub free_heaps: *mut mrb_heap_page,
    pub live: usize,
    pub arena: *mut *mut RBasic,
    pub arena_capa: ::std::os::raw::c_int,
    pub arena_idx: ::std::os::raw::c_int,
    pub state: mrb_gc_state,
    pub current_white_part: ::std::os::raw::c_int,
    pub gray_list: *mut RBasic,
    pub atomic_gray_list: *mut RBasic,
    pub live_after_mark: usize,
    pub threshold: usize,
    pub interval_ratio: ::std::os::raw::c_int,
    pub step_ratio: ::std::os::raw::c_int,
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
    pub majorgc_old_threshold: usize,
}
impl mrb_gc {
    #[inline]
    pub fn iterating(&self) -> mrb_bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_iterating(&mut self, val: mrb_bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn disabled(&self) -> mrb_bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_disabled(&mut self, val: mrb_bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(1usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn full(&self) -> mrb_bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_full(&mut self, val: mrb_bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(2usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn generational(&self) -> mrb_bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_generational(&mut self, val: mrb_bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(3usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn out_of_memory(&self) -> mrb_bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_out_of_memory(&mut self, val: mrb_bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(4usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        iterating: mrb_bool,
        disabled: mrb_bool,
        full: mrb_bool,
        generational: mrb_bool,
        out_of_memory: mrb_bool,
    ) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> =
            Default::default();
        __bindgen_bitfield_unit.set(0usize, 1u8, {
            let iterating: u8 = unsafe { ::std::mem::transmute(iterating) };
            iterating as u64
        });
        __bindgen_bitfield_unit.set(1usize, 1u8, {
            let disabled: u8 = unsafe { ::std::mem::transmute(disabled) };
            disabled as u64
        });
        __bindgen_bitfield_unit.set(2usize, 1u8, {
            let full: u8 = unsafe { ::std::mem::transmute(full) };
            full as u64
        });
        __bindgen_bitfield_unit.set(3usize, 1u8, {
            let generational: u8 = unsafe { ::std::mem::transmute(generational) };
            generational as u64
        });
        __bindgen_bitfield_unit.set(4usize, 1u8, {
            let out_of_memory: u8 = unsafe { ::std::mem::transmute(out_of_memory) };
            out_of_memory as u64
        });
        __bindgen_bitfield_unit
    }
}
extern "C" {
    pub fn mrb_object_dead_p(mrb: *mut mrb_state, object: *mut RBasic) -> mrb_bool;
}
pub type mrb_code = u8;
pub type mrb_aspec = u32;
pub type mrb_allocf = ::std::option::Option<
    unsafe extern "C" fn(
        mrb: *mut mrb_state,
        arg1: *mut ::std::os::raw::c_void,
        arg2: usize,
        ud: *mut ::std::os::raw::c_void,
    ) -> *mut ::std::os::raw::c_void,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mrb_callinfo {
    pub mid: mrb_sym,
    pub proc_: *mut RProc,
    pub stackent: *mut mrb_value,
    pub ridx: u16,
    pub epos: u16,
    pub env: *mut REnv,
    pub pc: *mut mrb_code,
    pub err: *mut mrb_code,
    pub argc: ::std::os::raw::c_int,
    pub acc: ::std::os::raw::c_int,
    pub target_class: *mut RClass,
}
pub const mrb_fiber_state_MRB_FIBER_CREATED: mrb_fiber_state = 0;
pub const mrb_fiber_state_MRB_FIBER_RUNNING: mrb_fiber_state = 1;
pub const mrb_fiber_state_MRB_FIBER_RESUMED: mrb_fiber_state = 2;
pub const mrb_fiber_state_MRB_FIBER_SUSPENDED: mrb_fiber_state = 3;
pub const mrb_fiber_state_MRB_FIBER_TRANSFERRED: mrb_fiber_state = 4;
pub const mrb_fiber_state_MRB_FIBER_TERMINATED: mrb_fiber_state = 5;
pub type mrb_fiber_state = u32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mrb_context {
    pub prev: *mut mrb_context,
    pub stack: *mut mrb_value,
    pub stbase: *mut mrb_value,
    pub stend: *mut mrb_value,
    pub ci: *mut mrb_callinfo,
    pub cibase: *mut mrb_callinfo,
    pub ciend: *mut mrb_callinfo,
    pub rescue: *mut u16,
    pub rsize: u16,
    pub ensure: *mut *mut RProc,
    pub esize: u16,
    pub eidx: u16,
    pub status: mrb_fiber_state,
    pub vmexec: mrb_bool,
    pub fib: *mut RFiber,
}
pub type mrb_func_t =
    ::std::option::Option<unsafe extern "C" fn(mrb: *mut mrb_state, arg1: mrb_value) -> mrb_value>;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct mrb_method_t {
    pub func_p: mrb_bool,
    pub __bindgen_anon_1: mrb_method_t__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union mrb_method_t__bindgen_ty_1 {
    pub proc_: *mut RProc,
    pub func: mrb_func_t,
    _bindgen_union_align: u64,
}
pub type mrb_atexit_func = ::std::option::Option<unsafe extern "C" fn(arg1: *mut mrb_state)>;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct mrb_state {
    pub jmp: *mut mrb_jmpbuf,
    pub allocf: mrb_allocf,
    pub allocf_ud: *mut ::std::os::raw::c_void,
    pub c: *mut mrb_context,
    pub root_c: *mut mrb_context,
    pub globals: *mut iv_tbl,
    pub exc: *mut RObject,
    pub top_self: *mut RObject,
    pub object_class: *mut RClass,
    pub class_class: *mut RClass,
    pub module_class: *mut RClass,
    pub proc_class: *mut RClass,
    pub string_class: *mut RClass,
    pub array_class: *mut RClass,
    pub hash_class: *mut RClass,
    pub range_class: *mut RClass,
    pub float_class: *mut RClass,
    pub fixnum_class: *mut RClass,
    pub true_class: *mut RClass,
    pub false_class: *mut RClass,
    pub nil_class: *mut RClass,
    pub symbol_class: *mut RClass,
    pub kernel_module: *mut RClass,
    pub gc: mrb_gc,
    pub symidx: mrb_sym,
    pub symtbl: *mut symbol_name,
    pub symhash: [mrb_sym; 256usize],
    pub symcapa: usize,
    pub symbuf: [::std::os::raw::c_char; 8usize],
    pub eException_class: *mut RClass,
    pub eStandardError_class: *mut RClass,
    pub nomem_err: *mut RObject,
    pub stack_err: *mut RObject,
    pub ud: *mut ::std::os::raw::c_void,
    pub atexit_stack: *mut mrb_atexit_func,
    pub atexit_stack_len: u16,
    pub ecall_nest: u16,
}
extern "C" {
    pub fn mrb_define_class(
        mrb: *mut mrb_state,
        name: *const ::std::os::raw::c_char,
        super_: *mut RClass,
    ) -> *mut RClass;
}
extern "C" {
    pub fn mrb_define_module(
        arg1: *mut mrb_state,
        arg2: *const ::std::os::raw::c_char,
    ) -> *mut RClass;
}
extern "C" {
    pub fn mrb_singleton_class(arg1: *mut mrb_state, arg2: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_include_module(arg1: *mut mrb_state, arg2: *mut RClass, arg3: *mut RClass);
}
extern "C" {
    pub fn mrb_prepend_module(arg1: *mut mrb_state, arg2: *mut RClass, arg3: *mut RClass);
}
extern "C" {
    pub fn mrb_define_method(
        mrb: *mut mrb_state,
        cla: *mut RClass,
        name: *const ::std::os::raw::c_char,
        func: mrb_func_t,
        aspec: mrb_aspec,
    );
}
extern "C" {
    pub fn mrb_define_class_method(
        arg1: *mut mrb_state,
        arg2: *mut RClass,
        arg3: *const ::std::os::raw::c_char,
        arg4: mrb_func_t,
        arg5: mrb_aspec,
    );
}
extern "C" {
    pub fn mrb_define_singleton_method(
        arg1: *mut mrb_state,
        arg2: *mut RObject,
        arg3: *const ::std::os::raw::c_char,
        arg4: mrb_func_t,
        arg5: mrb_aspec,
    );
}
extern "C" {
    pub fn mrb_define_module_function(
        arg1: *mut mrb_state,
        arg2: *mut RClass,
        arg3: *const ::std::os::raw::c_char,
        arg4: mrb_func_t,
        arg5: mrb_aspec,
    );
}
extern "C" {
    pub fn mrb_define_const(
        arg1: *mut mrb_state,
        arg2: *mut RClass,
        name: *const ::std::os::raw::c_char,
        arg3: mrb_value,
    );
}
extern "C" {
    pub fn mrb_undef_method(
        arg1: *mut mrb_state,
        arg2: *mut RClass,
        arg3: *const ::std::os::raw::c_char,
    );
}
extern "C" {
    pub fn mrb_undef_method_id(arg1: *mut mrb_state, arg2: *mut RClass, arg3: mrb_sym);
}
extern "C" {
    pub fn mrb_undef_class_method(
        arg1: *mut mrb_state,
        arg2: *mut RClass,
        arg3: *const ::std::os::raw::c_char,
    );
}
extern "C" {
    pub fn mrb_obj_new(
        mrb: *mut mrb_state,
        c: *mut RClass,
        argc: mrb_int,
        argv: *const mrb_value,
    ) -> mrb_value;
}
extern "C" {
    pub fn mrb_class_new(mrb: *mut mrb_state, super_: *mut RClass) -> *mut RClass;
}
extern "C" {
    pub fn mrb_module_new(mrb: *mut mrb_state) -> *mut RClass;
}
extern "C" {
    pub fn mrb_class_defined(mrb: *mut mrb_state, name: *const ::std::os::raw::c_char) -> mrb_bool;
}
extern "C" {
    pub fn mrb_class_get(mrb: *mut mrb_state, name: *const ::std::os::raw::c_char) -> *mut RClass;
}
extern "C" {
    pub fn mrb_exc_get(mrb: *mut mrb_state, name: *const ::std::os::raw::c_char) -> *mut RClass;
}
extern "C" {
    pub fn mrb_class_defined_under(
        mrb: *mut mrb_state,
        outer: *mut RClass,
        name: *const ::std::os::raw::c_char,
    ) -> mrb_bool;
}
extern "C" {
    pub fn mrb_class_get_under(
        mrb: *mut mrb_state,
        outer: *mut RClass,
        name: *const ::std::os::raw::c_char,
    ) -> *mut RClass;
}
extern "C" {
    pub fn mrb_module_get(mrb: *mut mrb_state, name: *const ::std::os::raw::c_char) -> *mut RClass;
}
extern "C" {
    pub fn mrb_module_get_under(
        mrb: *mut mrb_state,
        outer: *mut RClass,
        name: *const ::std::os::raw::c_char,
    ) -> *mut RClass;
}
extern "C" {
    pub fn mrb_notimplement(arg1: *mut mrb_state);
}
extern "C" {
    pub fn mrb_notimplement_m(arg1: *mut mrb_state, arg2: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_obj_dup(mrb: *mut mrb_state, obj: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_obj_respond_to(mrb: *mut mrb_state, c: *mut RClass, mid: mrb_sym) -> mrb_bool;
}
extern "C" {
    pub fn mrb_define_class_under(
        mrb: *mut mrb_state,
        outer: *mut RClass,
        name: *const ::std::os::raw::c_char,
        super_: *mut RClass,
    ) -> *mut RClass;
}
extern "C" {
    pub fn mrb_define_module_under(
        mrb: *mut mrb_state,
        outer: *mut RClass,
        name: *const ::std::os::raw::c_char,
    ) -> *mut RClass;
}
pub type mrb_args_format = *const ::std::os::raw::c_char;
extern "C" {
    pub fn mrb_get_args(mrb: *mut mrb_state, format: mrb_args_format, ...) -> mrb_int;
}
extern "C" {
    pub fn mrb_get_argc(mrb: *mut mrb_state) -> mrb_int;
}
extern "C" {
    pub fn mrb_get_argv(mrb: *mut mrb_state) -> *mut mrb_value;
}
extern "C" {
    pub fn mrb_funcall(
        arg1: *mut mrb_state,
        arg2: mrb_value,
        arg3: *const ::std::os::raw::c_char,
        arg4: mrb_int,
        ...
    ) -> mrb_value;
}
extern "C" {
    pub fn mrb_funcall_argv(
        arg1: *mut mrb_state,
        arg2: mrb_value,
        arg3: mrb_sym,
        arg4: mrb_int,
        arg5: *const mrb_value,
    ) -> mrb_value;
}
extern "C" {
    pub fn mrb_funcall_with_block(
        arg1: *mut mrb_state,
        arg2: mrb_value,
        arg3: mrb_sym,
        arg4: mrb_int,
        arg5: *const mrb_value,
        arg6: mrb_value,
    ) -> mrb_value;
}
extern "C" {
    pub fn mrb_intern_cstr(arg1: *mut mrb_state, arg2: *const ::std::os::raw::c_char) -> mrb_sym;
}
extern "C" {
    pub fn mrb_intern(
        arg1: *mut mrb_state,
        arg2: *const ::std::os::raw::c_char,
        arg3: usize,
    ) -> mrb_sym;
}
extern "C" {
    pub fn mrb_intern_static(
        arg1: *mut mrb_state,
        arg2: *const ::std::os::raw::c_char,
        arg3: usize,
    ) -> mrb_sym;
}
extern "C" {
    pub fn mrb_intern_str(arg1: *mut mrb_state, arg2: mrb_value) -> mrb_sym;
}
extern "C" {
    pub fn mrb_check_intern_cstr(
        arg1: *mut mrb_state,
        arg2: *const ::std::os::raw::c_char,
    ) -> mrb_value;
}
extern "C" {
    pub fn mrb_check_intern(
        arg1: *mut mrb_state,
        arg2: *const ::std::os::raw::c_char,
        arg3: usize,
    ) -> mrb_value;
}
extern "C" {
    pub fn mrb_check_intern_str(arg1: *mut mrb_state, arg2: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_sym2name(arg1: *mut mrb_state, arg2: mrb_sym) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn mrb_sym2name_len(
        arg1: *mut mrb_state,
        arg2: mrb_sym,
        arg3: *mut mrb_int,
    ) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn mrb_sym2str(arg1: *mut mrb_state, arg2: mrb_sym) -> mrb_value;
}
extern "C" {
    pub fn mrb_malloc(arg1: *mut mrb_state, arg2: usize) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn mrb_calloc(
        arg1: *mut mrb_state,
        arg2: usize,
        arg3: usize,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn mrb_realloc(
        arg1: *mut mrb_state,
        arg2: *mut ::std::os::raw::c_void,
        arg3: usize,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn mrb_realloc_simple(
        arg1: *mut mrb_state,
        arg2: *mut ::std::os::raw::c_void,
        arg3: usize,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn mrb_malloc_simple(arg1: *mut mrb_state, arg2: usize) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn mrb_obj_alloc(arg1: *mut mrb_state, arg2: mrb_vtype, arg3: *mut RClass) -> *mut RBasic;
}
extern "C" {
    pub fn mrb_free(arg1: *mut mrb_state, arg2: *mut ::std::os::raw::c_void);
}
extern "C" {
    pub fn mrb_str_new(
        mrb: *mut mrb_state,
        p: *const ::std::os::raw::c_char,
        len: usize,
    ) -> mrb_value;
}
extern "C" {
    pub fn mrb_str_new_cstr(arg1: *mut mrb_state, arg2: *const ::std::os::raw::c_char)
        -> mrb_value;
}
extern "C" {
    pub fn mrb_str_new_static(
        mrb: *mut mrb_state,
        p: *const ::std::os::raw::c_char,
        len: usize,
    ) -> mrb_value;
}
extern "C" {
    pub fn mrb_open() -> *mut mrb_state;
}
extern "C" {
    pub fn mrb_open_allocf(f: mrb_allocf, ud: *mut ::std::os::raw::c_void) -> *mut mrb_state;
}
extern "C" {
    pub fn mrb_open_core(f: mrb_allocf, ud: *mut ::std::os::raw::c_void) -> *mut mrb_state;
}
extern "C" {
    pub fn mrb_close(mrb: *mut mrb_state);
}
extern "C" {
    pub fn mrb_default_allocf(
        arg1: *mut mrb_state,
        arg2: *mut ::std::os::raw::c_void,
        arg3: usize,
        arg4: *mut ::std::os::raw::c_void,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn mrb_top_self(arg1: *mut mrb_state) -> mrb_value;
}
extern "C" {
    pub fn mrb_run(arg1: *mut mrb_state, arg2: *mut RProc, arg3: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_top_run(
        arg1: *mut mrb_state,
        arg2: *mut RProc,
        arg3: mrb_value,
        arg4: ::std::os::raw::c_uint,
    ) -> mrb_value;
}
extern "C" {
    pub fn mrb_vm_run(
        arg1: *mut mrb_state,
        arg2: *mut RProc,
        arg3: mrb_value,
        arg4: ::std::os::raw::c_uint,
    ) -> mrb_value;
}
extern "C" {
    pub fn mrb_vm_exec(arg1: *mut mrb_state, arg2: *mut RProc, arg3: *mut mrb_code) -> mrb_value;
}
extern "C" {
    pub fn mrb_p(arg1: *mut mrb_state, arg2: mrb_value);
}
extern "C" {
    pub fn mrb_obj_id(obj: mrb_value) -> mrb_int;
}
extern "C" {
    pub fn mrb_obj_to_sym(mrb: *mut mrb_state, name: mrb_value) -> mrb_sym;
}
extern "C" {
    pub fn mrb_obj_eq(arg1: *mut mrb_state, arg2: mrb_value, arg3: mrb_value) -> mrb_bool;
}
extern "C" {
    pub fn mrb_obj_equal(arg1: *mut mrb_state, arg2: mrb_value, arg3: mrb_value) -> mrb_bool;
}
extern "C" {
    pub fn mrb_equal(mrb: *mut mrb_state, obj1: mrb_value, obj2: mrb_value) -> mrb_bool;
}
extern "C" {
    pub fn mrb_convert_to_integer(mrb: *mut mrb_state, val: mrb_value, base: mrb_int) -> mrb_value;
}
extern "C" {
    pub fn mrb_Integer(mrb: *mut mrb_state, val: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_Float(mrb: *mut mrb_state, val: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_inspect(mrb: *mut mrb_state, obj: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_eql(mrb: *mut mrb_state, obj1: mrb_value, obj2: mrb_value) -> mrb_bool;
}
extern "C" {
    pub fn mrb_garbage_collect(arg1: *mut mrb_state);
}
extern "C" {
    pub fn mrb_full_gc(arg1: *mut mrb_state);
}
extern "C" {
    pub fn mrb_incremental_gc(arg1: *mut mrb_state);
}
extern "C" {
    pub fn mrb_gc_mark(arg1: *mut mrb_state, arg2: *mut RBasic);
}
extern "C" {
    pub fn mrb_field_write_barrier(arg1: *mut mrb_state, arg2: *mut RBasic, arg3: *mut RBasic);
}
extern "C" {
    pub fn mrb_write_barrier(arg1: *mut mrb_state, arg2: *mut RBasic);
}
extern "C" {
    pub fn mrb_check_convert_type(
        mrb: *mut mrb_state,
        val: mrb_value,
        type_: mrb_vtype,
        tname: *const ::std::os::raw::c_char,
        method: *const ::std::os::raw::c_char,
    ) -> mrb_value;
}
extern "C" {
    pub fn mrb_any_to_s(mrb: *mut mrb_state, obj: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_obj_classname(mrb: *mut mrb_state, obj: mrb_value) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn mrb_obj_class(mrb: *mut mrb_state, obj: mrb_value) -> *mut RClass;
}
extern "C" {
    pub fn mrb_class_path(mrb: *mut mrb_state, c: *mut RClass) -> mrb_value;
}
extern "C" {
    pub fn mrb_convert_type(
        mrb: *mut mrb_state,
        val: mrb_value,
        type_: mrb_vtype,
        tname: *const ::std::os::raw::c_char,
        method: *const ::std::os::raw::c_char,
    ) -> mrb_value;
}
extern "C" {
    pub fn mrb_obj_is_kind_of(mrb: *mut mrb_state, obj: mrb_value, c: *mut RClass) -> mrb_bool;
}
extern "C" {
    pub fn mrb_obj_inspect(mrb: *mut mrb_state, self_: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_obj_clone(mrb: *mut mrb_state, self_: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_exc_new(
        mrb: *mut mrb_state,
        c: *mut RClass,
        ptr: *const ::std::os::raw::c_char,
        len: usize,
    ) -> mrb_value;
}
extern "C" {
    pub fn mrb_exc_raise(mrb: *mut mrb_state, exc: mrb_value);
}
extern "C" {
    pub fn mrb_raise(mrb: *mut mrb_state, c: *mut RClass, msg: *const ::std::os::raw::c_char);
}
extern "C" {
    pub fn mrb_raisef(mrb: *mut mrb_state, c: *mut RClass, fmt: *const ::std::os::raw::c_char, ...);
}
extern "C" {
    pub fn mrb_name_error(
        mrb: *mut mrb_state,
        id: mrb_sym,
        fmt: *const ::std::os::raw::c_char,
        ...
    );
}
extern "C" {
    pub fn mrb_frozen_error(mrb: *mut mrb_state, frozen_obj: *mut ::std::os::raw::c_void);
}
extern "C" {
    pub fn mrb_warn(mrb: *mut mrb_state, fmt: *const ::std::os::raw::c_char, ...);
}
extern "C" {
    pub fn mrb_bug(mrb: *mut mrb_state, fmt: *const ::std::os::raw::c_char, ...);
}
extern "C" {
    pub fn mrb_print_backtrace(mrb: *mut mrb_state);
}
extern "C" {
    pub fn mrb_print_error(mrb: *mut mrb_state);
}
extern "C" {
    pub fn mrb_vformat(
        mrb: *mut mrb_state,
        format: *const ::std::os::raw::c_char,
        ap: *mut __va_list_tag,
    ) -> mrb_value;
}
extern "C" {
    pub fn mrb_yield(mrb: *mut mrb_state, b: mrb_value, arg: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_yield_argv(
        mrb: *mut mrb_state,
        b: mrb_value,
        argc: mrb_int,
        argv: *const mrb_value,
    ) -> mrb_value;
}
extern "C" {
    pub fn mrb_yield_with_class(
        mrb: *mut mrb_state,
        b: mrb_value,
        argc: mrb_int,
        argv: *const mrb_value,
        self_: mrb_value,
        c: *mut RClass,
    ) -> mrb_value;
}
extern "C" {
    pub fn mrb_yield_cont(
        mrb: *mut mrb_state,
        b: mrb_value,
        self_: mrb_value,
        argc: mrb_int,
        argv: *const mrb_value,
    ) -> mrb_value;
}
extern "C" {
    pub fn mrb_gc_protect(mrb: *mut mrb_state, obj: mrb_value);
}
extern "C" {
    pub fn mrb_gc_register(mrb: *mut mrb_state, obj: mrb_value);
}
extern "C" {
    pub fn mrb_gc_unregister(mrb: *mut mrb_state, obj: mrb_value);
}
extern "C" {
    pub fn mrb_to_int(mrb: *mut mrb_state, val: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_to_str(mrb: *mut mrb_state, val: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_check_type(mrb: *mut mrb_state, x: mrb_value, t: mrb_vtype);
}
extern "C" {
    pub fn mrb_define_alias(
        mrb: *mut mrb_state,
        c: *mut RClass,
        a: *const ::std::os::raw::c_char,
        b: *const ::std::os::raw::c_char,
    );
}
extern "C" {
    pub fn mrb_class_name(mrb: *mut mrb_state, klass: *mut RClass)
        -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn mrb_define_global_const(
        mrb: *mut mrb_state,
        name: *const ::std::os::raw::c_char,
        val: mrb_value,
    );
}
extern "C" {
    pub fn mrb_attr_get(mrb: *mut mrb_state, obj: mrb_value, id: mrb_sym) -> mrb_value;
}
extern "C" {
    pub fn mrb_respond_to(mrb: *mut mrb_state, obj: mrb_value, mid: mrb_sym) -> mrb_bool;
}
extern "C" {
    pub fn mrb_obj_is_instance_of(mrb: *mut mrb_state, obj: mrb_value, c: *mut RClass) -> mrb_bool;
}
extern "C" {
    pub fn mrb_func_basic_p(
        mrb: *mut mrb_state,
        obj: mrb_value,
        mid: mrb_sym,
        func: mrb_func_t,
    ) -> mrb_bool;
}
extern "C" {
    pub fn mrb_fiber_resume(
        mrb: *mut mrb_state,
        fib: mrb_value,
        argc: mrb_int,
        argv: *const mrb_value,
    ) -> mrb_value;
}
extern "C" {
    pub fn mrb_fiber_yield(mrb: *mut mrb_state, argc: mrb_int, argv: *const mrb_value)
        -> mrb_value;
}
extern "C" {
    pub fn mrb_fiber_alive_p(mrb: *mut mrb_state, fib: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_stack_extend(arg1: *mut mrb_state, arg2: mrb_int);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mrb_pool {
    _unused: [u8; 0],
}
extern "C" {
    pub fn mrb_pool_open(arg1: *mut mrb_state) -> *mut mrb_pool;
}
extern "C" {
    pub fn mrb_pool_close(arg1: *mut mrb_pool);
}
extern "C" {
    pub fn mrb_pool_alloc(arg1: *mut mrb_pool, arg2: usize) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn mrb_pool_realloc(
        arg1: *mut mrb_pool,
        arg2: *mut ::std::os::raw::c_void,
        oldlen: usize,
        newlen: usize,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn mrb_pool_can_realloc(
        arg1: *mut mrb_pool,
        arg2: *mut ::std::os::raw::c_void,
        arg3: usize,
    ) -> mrb_bool;
}
extern "C" {
    pub fn mrb_alloca(mrb: *mut mrb_state, arg1: usize) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn mrb_state_atexit(mrb: *mut mrb_state, func: mrb_atexit_func);
}
extern "C" {
    pub fn mrb_show_version(mrb: *mut mrb_state);
}
extern "C" {
    pub fn mrb_show_copyright(mrb: *mut mrb_state);
}
extern "C" {
    pub fn mrb_format(mrb: *mut mrb_state, format: *const ::std::os::raw::c_char, ...)
        -> mrb_value;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mrb_shared_array {
    pub refcnt: ::std::os::raw::c_int,
    pub len: mrb_int,
    pub ptr: *mut mrb_value,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct RArray {
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u32>,
    pub c: *mut RClass,
    pub gcnext: *mut RBasic,
    pub as_: RArray__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union RArray__bindgen_ty_1 {
    pub heap: RArray__bindgen_ty_1__bindgen_ty_1,
    _bindgen_union_align: [u64; 3usize],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct RArray__bindgen_ty_1__bindgen_ty_1 {
    pub len: mrb_int,
    pub aux: RArray__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
    pub ptr: *mut mrb_value,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union RArray__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
    pub capa: mrb_int,
    pub shared: *mut mrb_shared_array,
    _bindgen_union_align: u64,
}
impl RArray {
    #[inline]
    pub fn tt(&self) -> mrb_vtype {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
    }
    #[inline]
    pub fn set_tt(&mut self, val: mrb_vtype) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 8u8, val as u64)
        }
    }
    #[inline]
    pub fn color(&self) -> u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 3u8) as u32) }
    }
    #[inline]
    pub fn set_color(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(8usize, 3u8, val as u64)
        }
    }
    #[inline]
    pub fn flags(&self) -> u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 21u8) as u32) }
    }
    #[inline]
    pub fn set_flags(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(11usize, 21u8, val as u64)
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        tt: mrb_vtype,
        color: u32,
        flags: u32,
    ) -> __BindgenBitfieldUnit<[u8; 4usize], u32> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u32> =
            Default::default();
        __bindgen_bitfield_unit.set(0usize, 8u8, {
            let tt: u32 = unsafe { ::std::mem::transmute(tt) };
            tt as u64
        });
        __bindgen_bitfield_unit.set(8usize, 3u8, {
            let color: u32 = unsafe { ::std::mem::transmute(color) };
            color as u64
        });
        __bindgen_bitfield_unit.set(11usize, 21u8, {
            let flags: u32 = unsafe { ::std::mem::transmute(flags) };
            flags as u64
        });
        __bindgen_bitfield_unit
    }
}
extern "C" {
    pub fn mrb_ary_decref(arg1: *mut mrb_state, arg2: *mut mrb_shared_array);
}
extern "C" {
    pub fn mrb_ary_modify(arg1: *mut mrb_state, arg2: *mut RArray);
}
extern "C" {
    pub fn mrb_ary_new_capa(arg1: *mut mrb_state, arg2: mrb_int) -> mrb_value;
}
extern "C" {
    pub fn mrb_ary_new(mrb: *mut mrb_state) -> mrb_value;
}
extern "C" {
    pub fn mrb_ary_new_from_values(
        mrb: *mut mrb_state,
        size: mrb_int,
        vals: *const mrb_value,
    ) -> mrb_value;
}
extern "C" {
    pub fn mrb_assoc_new(mrb: *mut mrb_state, car: mrb_value, cdr: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_ary_concat(mrb: *mut mrb_state, self_: mrb_value, other: mrb_value);
}
extern "C" {
    pub fn mrb_ary_splat(mrb: *mut mrb_state, value: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_ary_push(mrb: *mut mrb_state, array: mrb_value, value: mrb_value);
}
extern "C" {
    pub fn mrb_ary_pop(mrb: *mut mrb_state, ary: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_ary_ref(mrb: *mut mrb_state, ary: mrb_value, n: mrb_int) -> mrb_value;
}
extern "C" {
    pub fn mrb_ary_set(mrb: *mut mrb_state, ary: mrb_value, n: mrb_int, val: mrb_value);
}
extern "C" {
    pub fn mrb_ary_replace(mrb: *mut mrb_state, self_: mrb_value, other: mrb_value);
}
extern "C" {
    pub fn mrb_ensure_array_type(mrb: *mut mrb_state, self_: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_check_array_type(mrb: *mut mrb_state, self_: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_ary_unshift(mrb: *mut mrb_state, self_: mrb_value, item: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_ary_entry(ary: mrb_value, offset: mrb_int) -> mrb_value;
}
extern "C" {
    pub fn mrb_ary_splice(
        mrb: *mut mrb_state,
        self_: mrb_value,
        head: mrb_int,
        len: mrb_int,
        rpl: mrb_value,
    ) -> mrb_value;
}
extern "C" {
    pub fn mrb_ary_shift(mrb: *mut mrb_state, self_: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_ary_clear(mrb: *mut mrb_state, self_: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_ary_join(mrb: *mut mrb_state, ary: mrb_value, sep: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_ary_resize(mrb: *mut mrb_state, ary: mrb_value, new_len: mrb_int) -> mrb_value;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RClass {
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u32>,
    pub c: *mut RClass,
    pub gcnext: *mut RBasic,
    pub iv: *mut iv_tbl,
    pub mt: *mut kh_mt,
    pub super_: *mut RClass,
}
impl RClass {
    #[inline]
    pub fn tt(&self) -> mrb_vtype {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
    }
    #[inline]
    pub fn set_tt(&mut self, val: mrb_vtype) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 8u8, val as u64)
        }
    }
    #[inline]
    pub fn color(&self) -> u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 3u8) as u32) }
    }
    #[inline]
    pub fn set_color(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(8usize, 3u8, val as u64)
        }
    }
    #[inline]
    pub fn flags(&self) -> u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 21u8) as u32) }
    }
    #[inline]
    pub fn set_flags(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(11usize, 21u8, val as u64)
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        tt: mrb_vtype,
        color: u32,
        flags: u32,
    ) -> __BindgenBitfieldUnit<[u8; 4usize], u32> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u32> =
            Default::default();
        __bindgen_bitfield_unit.set(0usize, 8u8, {
            let tt: u32 = unsafe { ::std::mem::transmute(tt) };
            tt as u64
        });
        __bindgen_bitfield_unit.set(8usize, 3u8, {
            let color: u32 = unsafe { ::std::mem::transmute(color) };
            color as u64
        });
        __bindgen_bitfield_unit.set(11usize, 21u8, {
            let flags: u32 = unsafe { ::std::mem::transmute(flags) };
            flags as u64
        });
        __bindgen_bitfield_unit
    }
}
extern "C" {
    pub fn mrb_define_class_id(
        arg1: *mut mrb_state,
        arg2: mrb_sym,
        arg3: *mut RClass,
    ) -> *mut RClass;
}
extern "C" {
    pub fn mrb_define_module_id(arg1: *mut mrb_state, arg2: mrb_sym) -> *mut RClass;
}
extern "C" {
    pub fn mrb_vm_define_class(
        arg1: *mut mrb_state,
        arg2: mrb_value,
        arg3: mrb_value,
        arg4: mrb_sym,
    ) -> *mut RClass;
}
extern "C" {
    pub fn mrb_vm_define_module(
        arg1: *mut mrb_state,
        arg2: mrb_value,
        arg3: mrb_sym,
    ) -> *mut RClass;
}
extern "C" {
    pub fn mrb_define_method_raw(
        arg1: *mut mrb_state,
        arg2: *mut RClass,
        arg3: mrb_sym,
        arg4: mrb_method_t,
    );
}
extern "C" {
    pub fn mrb_define_method_id(
        mrb: *mut mrb_state,
        c: *mut RClass,
        mid: mrb_sym,
        func: mrb_func_t,
        aspec: mrb_aspec,
    );
}
extern "C" {
    pub fn mrb_alias_method(arg1: *mut mrb_state, c: *mut RClass, a: mrb_sym, b: mrb_sym);
}
extern "C" {
    pub fn mrb_method_search_vm(
        arg1: *mut mrb_state,
        arg2: *mut *mut RClass,
        arg3: mrb_sym,
    ) -> mrb_method_t;
}
extern "C" {
    pub fn mrb_method_search(
        arg1: *mut mrb_state,
        arg2: *mut RClass,
        arg3: mrb_sym,
    ) -> mrb_method_t;
}
extern "C" {
    pub fn mrb_class_real(cl: *mut RClass) -> *mut RClass;
}
extern "C" {
    pub fn mrb_instance_new(mrb: *mut mrb_state, cv: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_class_name_class(
        arg1: *mut mrb_state,
        arg2: *mut RClass,
        arg3: *mut RClass,
        arg4: mrb_sym,
    );
}
extern "C" {
    pub fn mrb_const_name_p(
        arg1: *mut mrb_state,
        arg2: *const ::std::os::raw::c_char,
        arg3: mrb_int,
    ) -> mrb_bool;
}
extern "C" {
    pub fn mrb_class_find_path(arg1: *mut mrb_state, arg2: *mut RClass) -> mrb_value;
}
extern "C" {
    pub fn mrb_gc_mark_mt(arg1: *mut mrb_state, arg2: *mut RClass);
}
extern "C" {
    pub fn mrb_gc_mark_mt_size(arg1: *mut mrb_state, arg2: *mut RClass) -> usize;
}
extern "C" {
    pub fn mrb_gc_free_mt(arg1: *mut mrb_state, arg2: *mut RClass);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mrbc_context {
    pub syms: *mut mrb_sym,
    pub slen: ::std::os::raw::c_int,
    pub filename: *mut ::std::os::raw::c_char,
    pub lineno: ::std::os::raw::c_short,
    pub partial_hook: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut mrb_parser_state) -> ::std::os::raw::c_int,
    >,
    pub partial_data: *mut ::std::os::raw::c_void,
    pub target_class: *mut RClass,
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
    pub parser_nerr: usize,
}
impl mrbc_context {
    #[inline]
    pub fn capture_errors(&self) -> mrb_bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_capture_errors(&mut self, val: mrb_bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn dump_result(&self) -> mrb_bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_dump_result(&mut self, val: mrb_bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(1usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn no_exec(&self) -> mrb_bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_no_exec(&mut self, val: mrb_bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(2usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn keep_lv(&self) -> mrb_bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_keep_lv(&mut self, val: mrb_bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(3usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn no_optimize(&self) -> mrb_bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_no_optimize(&mut self, val: mrb_bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(4usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn on_eval(&self) -> mrb_bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_on_eval(&mut self, val: mrb_bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(5usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        capture_errors: mrb_bool,
        dump_result: mrb_bool,
        no_exec: mrb_bool,
        keep_lv: mrb_bool,
        no_optimize: mrb_bool,
        on_eval: mrb_bool,
    ) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> =
            Default::default();
        __bindgen_bitfield_unit.set(0usize, 1u8, {
            let capture_errors: u8 = unsafe { ::std::mem::transmute(capture_errors) };
            capture_errors as u64
        });
        __bindgen_bitfield_unit.set(1usize, 1u8, {
            let dump_result: u8 = unsafe { ::std::mem::transmute(dump_result) };
            dump_result as u64
        });
        __bindgen_bitfield_unit.set(2usize, 1u8, {
            let no_exec: u8 = unsafe { ::std::mem::transmute(no_exec) };
            no_exec as u64
        });
        __bindgen_bitfield_unit.set(3usize, 1u8, {
            let keep_lv: u8 = unsafe { ::std::mem::transmute(keep_lv) };
            keep_lv as u64
        });
        __bindgen_bitfield_unit.set(4usize, 1u8, {
            let no_optimize: u8 = unsafe { ::std::mem::transmute(no_optimize) };
            no_optimize as u64
        });
        __bindgen_bitfield_unit.set(5usize, 1u8, {
            let on_eval: u8 = unsafe { ::std::mem::transmute(on_eval) };
            on_eval as u64
        });
        __bindgen_bitfield_unit
    }
}
extern "C" {
    pub fn mrbc_context_new(mrb: *mut mrb_state) -> *mut mrbc_context;
}
extern "C" {
    pub fn mrbc_context_free(mrb: *mut mrb_state, cxt: *mut mrbc_context);
}
extern "C" {
    pub fn mrbc_filename(
        mrb: *mut mrb_state,
        c: *mut mrbc_context,
        s: *const ::std::os::raw::c_char,
    ) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn mrbc_partial_hook(
        mrb: *mut mrb_state,
        c: *mut mrbc_context,
        partial_hook: ::std::option::Option<
            unsafe extern "C" fn(arg1: *mut mrb_parser_state) -> ::std::os::raw::c_int,
        >,
        data: *mut ::std::os::raw::c_void,
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mrb_ast_node {
    pub car: *mut mrb_ast_node,
    pub cdr: *mut mrb_ast_node,
    pub lineno: u16,
    pub filename_index: u16,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum mrb_lex_state_enum {
    EXPR_BEG = 0,
    EXPR_END = 1,
    EXPR_ENDARG = 2,
    EXPR_ENDFN = 3,
    EXPR_ARG = 4,
    EXPR_CMDARG = 5,
    EXPR_MID = 6,
    EXPR_FNAME = 7,
    EXPR_DOT = 8,
    EXPR_CLASS = 9,
    EXPR_VALUE = 10,
    EXPR_MAX_STATE = 11,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mrb_parser_message {
    pub lineno: ::std::os::raw::c_int,
    pub column: ::std::os::raw::c_int,
    pub message: *mut ::std::os::raw::c_char,
}
pub const mrb_string_type_str_not_parsing: mrb_string_type = 0;
pub const mrb_string_type_str_squote: mrb_string_type = 1;
pub const mrb_string_type_str_dquote: mrb_string_type = 3;
pub const mrb_string_type_str_regexp: mrb_string_type = 7;
pub const mrb_string_type_str_sword: mrb_string_type = 41;
pub const mrb_string_type_str_dword: mrb_string_type = 43;
pub const mrb_string_type_str_ssym: mrb_string_type = 17;
pub const mrb_string_type_str_ssymbols: mrb_string_type = 49;
pub const mrb_string_type_str_dsymbols: mrb_string_type = 51;
pub const mrb_string_type_str_heredoc: mrb_string_type = 65;
pub const mrb_string_type_str_xquote: mrb_string_type = 131;
pub type mrb_string_type = u32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mrb_parser_heredoc_info {
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
    pub type_: mrb_string_type,
    pub term: *const ::std::os::raw::c_char,
    pub term_len: ::std::os::raw::c_int,
    pub doc: *mut mrb_ast_node,
}
impl mrb_parser_heredoc_info {
    #[inline]
    pub fn allow_indent(&self) -> mrb_bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_allow_indent(&mut self, val: mrb_bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn line_head(&self) -> mrb_bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_line_head(&mut self, val: mrb_bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(1usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        allow_indent: mrb_bool,
        line_head: mrb_bool,
    ) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> =
            Default::default();
        __bindgen_bitfield_unit.set(0usize, 1u8, {
            let allow_indent: u8 = unsafe { ::std::mem::transmute(allow_indent) };
            allow_indent as u64
        });
        __bindgen_bitfield_unit.set(1usize, 1u8, {
            let line_head: u8 = unsafe { ::std::mem::transmute(line_head) };
            line_head as u64
        });
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct mrb_parser_state {
    pub mrb: *mut mrb_state,
    pub pool: *mut mrb_pool,
    pub cells: *mut mrb_ast_node,
    pub s: *const ::std::os::raw::c_char,
    pub send: *const ::std::os::raw::c_char,
    pub cxt: *mut mrbc_context,
    pub filename_sym: mrb_sym,
    pub lineno: ::std::os::raw::c_int,
    pub column: ::std::os::raw::c_int,
    pub lstate: mrb_lex_state_enum,
    pub lex_strterm: *mut mrb_ast_node,
    pub cond_stack: ::std::os::raw::c_uint,
    pub cmdarg_stack: ::std::os::raw::c_uint,
    pub paren_nest: ::std::os::raw::c_int,
    pub lpar_beg: ::std::os::raw::c_int,
    pub in_def: ::std::os::raw::c_int,
    pub in_single: ::std::os::raw::c_int,
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
    pub locals: *mut mrb_ast_node,
    pub pb: *mut mrb_ast_node,
    pub tokbuf: *mut ::std::os::raw::c_char,
    pub buf: [::std::os::raw::c_char; 256usize],
    pub tidx: ::std::os::raw::c_int,
    pub tsiz: ::std::os::raw::c_int,
    pub all_heredocs: *mut mrb_ast_node,
    pub heredocs_from_nextline: *mut mrb_ast_node,
    pub parsing_heredoc: *mut mrb_ast_node,
    pub lex_strterm_before_heredoc: *mut mrb_ast_node,
    pub ylval: *mut ::std::os::raw::c_void,
    pub nerr: usize,
    pub nwarn: usize,
    pub tree: *mut mrb_ast_node,
    pub _bitfield_2: __BindgenBitfieldUnit<[u8; 1usize], u8>,
    pub error_buffer: [mrb_parser_message; 10usize],
    pub warn_buffer: [mrb_parser_message; 10usize],
    pub filename_table: *mut mrb_sym,
    pub filename_table_length: u16,
    pub current_filename_index: u16,
    pub jmp: *mut mrb_jmpbuf,
}
impl mrb_parser_state {
    #[inline]
    pub fn cmd_start(&self) -> mrb_bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_cmd_start(&mut self, val: mrb_bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn new_bitfield_1(cmd_start: mrb_bool) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> =
            Default::default();
        __bindgen_bitfield_unit.set(0usize, 1u8, {
            let cmd_start: u8 = unsafe { ::std::mem::transmute(cmd_start) };
            cmd_start as u64
        });
        __bindgen_bitfield_unit
    }
    #[inline]
    pub fn no_optimize(&self) -> mrb_bool {
        unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_no_optimize(&mut self, val: mrb_bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_2.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn on_eval(&self) -> mrb_bool {
        unsafe { ::std::mem::transmute(self._bitfield_2.get(1usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_on_eval(&mut self, val: mrb_bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_2.set(1usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn capture_errors(&self) -> mrb_bool {
        unsafe { ::std::mem::transmute(self._bitfield_2.get(2usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_capture_errors(&mut self, val: mrb_bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_2.set(2usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn new_bitfield_2(
        no_optimize: mrb_bool,
        on_eval: mrb_bool,
        capture_errors: mrb_bool,
    ) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> =
            Default::default();
        __bindgen_bitfield_unit.set(0usize, 1u8, {
            let no_optimize: u8 = unsafe { ::std::mem::transmute(no_optimize) };
            no_optimize as u64
        });
        __bindgen_bitfield_unit.set(1usize, 1u8, {
            let on_eval: u8 = unsafe { ::std::mem::transmute(on_eval) };
            on_eval as u64
        });
        __bindgen_bitfield_unit.set(2usize, 1u8, {
            let capture_errors: u8 = unsafe { ::std::mem::transmute(capture_errors) };
            capture_errors as u64
        });
        __bindgen_bitfield_unit
    }
}
extern "C" {
    pub fn mrb_parser_new(arg1: *mut mrb_state) -> *mut mrb_parser_state;
}
extern "C" {
    pub fn mrb_parser_free(arg1: *mut mrb_parser_state);
}
extern "C" {
    pub fn mrb_parser_parse(arg1: *mut mrb_parser_state, arg2: *mut mrbc_context);
}
extern "C" {
    pub fn mrb_parser_set_filename(
        arg1: *mut mrb_parser_state,
        arg2: *const ::std::os::raw::c_char,
    );
}
extern "C" {
    pub fn mrb_parser_get_filename(arg1: *mut mrb_parser_state, idx: u16) -> mrb_sym;
}
extern "C" {
    pub fn mrb_parse_string(
        arg1: *mut mrb_state,
        arg2: *const ::std::os::raw::c_char,
        arg3: *mut mrbc_context,
    ) -> *mut mrb_parser_state;
}
extern "C" {
    pub fn mrb_parse_nstring(
        arg1: *mut mrb_state,
        arg2: *const ::std::os::raw::c_char,
        arg3: usize,
        arg4: *mut mrbc_context,
    ) -> *mut mrb_parser_state;
}
extern "C" {
    pub fn mrb_generate_code(arg1: *mut mrb_state, arg2: *mut mrb_parser_state) -> *mut RProc;
}
extern "C" {
    pub fn mrb_load_exec(
        mrb: *mut mrb_state,
        p: *mut mrb_parser_state,
        c: *mut mrbc_context,
    ) -> mrb_value;
}
extern "C" {
    pub fn mrb_load_string(mrb: *mut mrb_state, s: *const ::std::os::raw::c_char) -> mrb_value;
}
extern "C" {
    pub fn mrb_load_nstring(
        mrb: *mut mrb_state,
        s: *const ::std::os::raw::c_char,
        len: usize,
    ) -> mrb_value;
}
extern "C" {
    pub fn mrb_load_string_cxt(
        mrb: *mut mrb_state,
        s: *const ::std::os::raw::c_char,
        cxt: *mut mrbc_context,
    ) -> mrb_value;
}
extern "C" {
    pub fn mrb_load_nstring_cxt(
        mrb: *mut mrb_state,
        s: *const ::std::os::raw::c_char,
        len: usize,
        cxt: *mut mrbc_context,
    ) -> mrb_value;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mrb_data_type {
    pub struct_name: *const ::std::os::raw::c_char,
    pub dfree: ::std::option::Option<
        unsafe extern "C" fn(mrb: *mut mrb_state, arg1: *mut ::std::os::raw::c_void),
    >,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RData {
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u32>,
    pub c: *mut RClass,
    pub gcnext: *mut RBasic,
    pub iv: *mut iv_tbl,
    pub type_: *const mrb_data_type,
    pub data: *mut ::std::os::raw::c_void,
}
impl RData {
    #[inline]
    pub fn tt(&self) -> mrb_vtype {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
    }
    #[inline]
    pub fn set_tt(&mut self, val: mrb_vtype) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 8u8, val as u64)
        }
    }
    #[inline]
    pub fn color(&self) -> u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 3u8) as u32) }
    }
    #[inline]
    pub fn set_color(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(8usize, 3u8, val as u64)
        }
    }
    #[inline]
    pub fn flags(&self) -> u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 21u8) as u32) }
    }
    #[inline]
    pub fn set_flags(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(11usize, 21u8, val as u64)
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        tt: mrb_vtype,
        color: u32,
        flags: u32,
    ) -> __BindgenBitfieldUnit<[u8; 4usize], u32> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u32> =
            Default::default();
        __bindgen_bitfield_unit.set(0usize, 8u8, {
            let tt: u32 = unsafe { ::std::mem::transmute(tt) };
            tt as u64
        });
        __bindgen_bitfield_unit.set(8usize, 3u8, {
            let color: u32 = unsafe { ::std::mem::transmute(color) };
            color as u64
        });
        __bindgen_bitfield_unit.set(11usize, 21u8, {
            let flags: u32 = unsafe { ::std::mem::transmute(flags) };
            flags as u64
        });
        __bindgen_bitfield_unit
    }
}
extern "C" {
    pub fn mrb_data_object_alloc(
        mrb: *mut mrb_state,
        klass: *mut RClass,
        datap: *mut ::std::os::raw::c_void,
        type_: *const mrb_data_type,
    ) -> *mut RData;
}
extern "C" {
    pub fn mrb_data_check_type(mrb: *mut mrb_state, arg1: mrb_value, arg2: *const mrb_data_type);
}
extern "C" {
    pub fn mrb_data_get_ptr(
        mrb: *mut mrb_state,
        arg1: mrb_value,
        arg2: *const mrb_data_type,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn mrb_data_check_get_ptr(
        mrb: *mut mrb_state,
        arg1: mrb_value,
        arg2: *const mrb_data_type,
    ) -> *mut ::std::os::raw::c_void;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mrb_locals {
    pub name: mrb_sym,
    pub r: u16,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mrb_irep {
    pub nlocals: u16,
    pub nregs: u16,
    pub flags: u8,
    pub iseq: *mut mrb_code,
    pub pool: *mut mrb_value,
    pub syms: *mut mrb_sym,
    pub reps: *mut *mut mrb_irep,
    pub lv: *mut mrb_locals,
    pub debug_info: *mut mrb_irep_debug_info,
    pub ilen: u16,
    pub plen: u16,
    pub slen: u16,
    pub rlen: u16,
    pub refcnt: u32,
}
extern "C" {
    pub fn mrb_add_irep(mrb: *mut mrb_state) -> *mut mrb_irep;
}
extern "C" {
    pub fn mrb_load_irep(arg1: *mut mrb_state, arg2: *const u8) -> mrb_value;
}
extern "C" {
    pub fn mrb_load_irep_buf(
        arg1: *mut mrb_state,
        arg2: *const ::std::os::raw::c_void,
        arg3: usize,
    ) -> mrb_value;
}
extern "C" {
    pub fn mrb_load_irep_cxt(
        arg1: *mut mrb_state,
        arg2: *const u8,
        arg3: *mut mrbc_context,
    ) -> mrb_value;
}
extern "C" {
    pub fn mrb_load_irep_buf_cxt(
        arg1: *mut mrb_state,
        arg2: *const ::std::os::raw::c_void,
        arg3: usize,
        arg4: *mut mrbc_context,
    ) -> mrb_value;
}
extern "C" {
    pub fn mrb_irep_free(arg1: *mut mrb_state, arg2: *mut mrb_irep);
}
extern "C" {
    pub fn mrb_irep_incref(arg1: *mut mrb_state, arg2: *mut mrb_irep);
}
extern "C" {
    pub fn mrb_irep_decref(arg1: *mut mrb_state, arg2: *mut mrb_irep);
}
extern "C" {
    pub fn mrb_irep_cutref(arg1: *mut mrb_state, arg2: *mut mrb_irep);
}
extern "C" {
    pub fn mrb_irep_remove_lv(mrb: *mut mrb_state, irep: *mut mrb_irep);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mrb_insn_data {
    pub insn: u8,
    pub a: u16,
    pub b: u16,
    pub c: u8,
}
extern "C" {
    pub fn mrb_decode_insn(pc: *mut mrb_code) -> mrb_insn_data;
}
extern "C" {
    pub fn mrb_dump_irep(
        mrb: *mut mrb_state,
        irep: *mut mrb_irep,
        flags: u8,
        bin: *mut *mut u8,
        bin_size: *mut usize,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mrb_read_irep(arg1: *mut mrb_state, arg2: *const u8) -> *mut mrb_irep;
}
extern "C" {
    pub fn mrb_read_irep_buf(
        arg1: *mut mrb_state,
        arg2: *const ::std::os::raw::c_void,
        arg3: usize,
    ) -> *mut mrb_irep;
}
extern "C" {
    pub fn mrb_sys_fail(mrb: *mut mrb_state, mesg: *const ::std::os::raw::c_char);
}
extern "C" {
    pub fn mrb_exc_new_str(mrb: *mut mrb_state, c: *mut RClass, str: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_make_exception(
        mrb: *mut mrb_state,
        argc: mrb_int,
        argv: *const mrb_value,
    ) -> mrb_value;
}
extern "C" {
    pub fn mrb_exc_backtrace(mrb: *mut mrb_state, exc: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_get_backtrace(mrb: *mut mrb_state) -> mrb_value;
}
extern "C" {
    pub fn mrb_no_method_error(
        mrb: *mut mrb_state,
        id: mrb_sym,
        args: mrb_value,
        fmt: *const ::std::os::raw::c_char,
        ...
    );
}
extern "C" {
    pub fn mrb_f_raise(arg1: *mut mrb_state, arg2: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_protect(
        mrb: *mut mrb_state,
        body: mrb_func_t,
        data: mrb_value,
        state: *mut mrb_bool,
    ) -> mrb_value;
}
extern "C" {
    pub fn mrb_ensure(
        mrb: *mut mrb_state,
        body: mrb_func_t,
        b_data: mrb_value,
        ensure: mrb_func_t,
        e_data: mrb_value,
    ) -> mrb_value;
}
extern "C" {
    pub fn mrb_rescue(
        mrb: *mut mrb_state,
        body: mrb_func_t,
        b_data: mrb_value,
        rescue: mrb_func_t,
        r_data: mrb_value,
    ) -> mrb_value;
}
extern "C" {
    pub fn mrb_rescue_exceptions(
        mrb: *mut mrb_state,
        body: mrb_func_t,
        b_data: mrb_value,
        rescue: mrb_func_t,
        r_data: mrb_value,
        len: mrb_int,
        classes: *mut *mut RClass,
    ) -> mrb_value;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RHash {
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u32>,
    pub c: *mut RClass,
    pub gcnext: *mut RBasic,
    pub iv: *mut iv_tbl,
    pub ht: *mut htable,
}
impl RHash {
    #[inline]
    pub fn tt(&self) -> mrb_vtype {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
    }
    #[inline]
    pub fn set_tt(&mut self, val: mrb_vtype) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 8u8, val as u64)
        }
    }
    #[inline]
    pub fn color(&self) -> u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 3u8) as u32) }
    }
    #[inline]
    pub fn set_color(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(8usize, 3u8, val as u64)
        }
    }
    #[inline]
    pub fn flags(&self) -> u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 21u8) as u32) }
    }
    #[inline]
    pub fn set_flags(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(11usize, 21u8, val as u64)
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        tt: mrb_vtype,
        color: u32,
        flags: u32,
    ) -> __BindgenBitfieldUnit<[u8; 4usize], u32> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u32> =
            Default::default();
        __bindgen_bitfield_unit.set(0usize, 8u8, {
            let tt: u32 = unsafe { ::std::mem::transmute(tt) };
            tt as u64
        });
        __bindgen_bitfield_unit.set(8usize, 3u8, {
            let color: u32 = unsafe { ::std::mem::transmute(color) };
            color as u64
        });
        __bindgen_bitfield_unit.set(11usize, 21u8, {
            let flags: u32 = unsafe { ::std::mem::transmute(flags) };
            flags as u64
        });
        __bindgen_bitfield_unit
    }
}
extern "C" {
    pub fn mrb_hash_new_capa(arg1: *mut mrb_state, arg2: mrb_int) -> mrb_value;
}
extern "C" {
    pub fn mrb_ensure_hash_type(mrb: *mut mrb_state, hash: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_check_hash_type(mrb: *mut mrb_state, hash: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_hash_new(mrb: *mut mrb_state) -> mrb_value;
}
extern "C" {
    pub fn mrb_hash_set(mrb: *mut mrb_state, hash: mrb_value, key: mrb_value, val: mrb_value);
}
extern "C" {
    pub fn mrb_hash_get(mrb: *mut mrb_state, hash: mrb_value, key: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_hash_fetch(
        mrb: *mut mrb_state,
        hash: mrb_value,
        key: mrb_value,
        def: mrb_value,
    ) -> mrb_value;
}
extern "C" {
    pub fn mrb_hash_delete_key(mrb: *mut mrb_state, hash: mrb_value, key: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_hash_keys(mrb: *mut mrb_state, hash: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_hash_key_p(mrb: *mut mrb_state, hash: mrb_value, key: mrb_value) -> mrb_bool;
}
extern "C" {
    pub fn mrb_hash_empty_p(mrb: *mut mrb_state, self_: mrb_value) -> mrb_bool;
}
extern "C" {
    pub fn mrb_hash_values(mrb: *mut mrb_state, hash: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_hash_clear(mrb: *mut mrb_state, hash: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_hash_size(mrb: *mut mrb_state, hash: mrb_value) -> mrb_int;
}
extern "C" {
    pub fn mrb_hash_dup(mrb: *mut mrb_state, hash: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_hash_merge(mrb: *mut mrb_state, hash1: mrb_value, hash2: mrb_value);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct mrb_hash_value {
    pub v: mrb_value,
    pub n: mrb_int,
}
extern "C" {
    pub fn mrb_gc_mark_hash(arg1: *mut mrb_state, arg2: *mut RHash);
}
extern "C" {
    pub fn mrb_gc_mark_hash_size(arg1: *mut mrb_state, arg2: *mut RHash) -> usize;
}
extern "C" {
    pub fn mrb_gc_free_hash(arg1: *mut mrb_state, arg2: *mut RHash);
}
pub type mrb_hash_foreach_func = ::std::option::Option<
    unsafe extern "C" fn(
        mrb: *mut mrb_state,
        key: mrb_value,
        val: mrb_value,
        data: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int,
>;
extern "C" {
    pub fn mrb_hash_foreach(
        mrb: *mut mrb_state,
        hash: *mut RHash,
        func: mrb_hash_foreach_func,
        p: *mut ::std::os::raw::c_void,
    );
}
pub type khint_t = u32;
extern "C" {
    pub fn mrb_flo_to_fixnum(mrb: *mut mrb_state, val: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_fixnum_to_str(mrb: *mut mrb_state, x: mrb_value, base: mrb_int) -> mrb_value;
}
extern "C" {
    pub fn mrb_float_to_str(
        mrb: *mut mrb_state,
        x: mrb_value,
        fmt: *const ::std::os::raw::c_char,
    ) -> mrb_value;
}
extern "C" {
    pub fn mrb_to_flo(mrb: *mut mrb_state, x: mrb_value) -> mrb_float;
}
extern "C" {
    pub fn mrb_int_value(mrb: *mut mrb_state, f: mrb_float) -> mrb_value;
}
extern "C" {
    pub fn mrb_num_plus(mrb: *mut mrb_state, x: mrb_value, y: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_num_minus(mrb: *mut mrb_state, x: mrb_value, y: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_num_mul(mrb: *mut mrb_state, x: mrb_value, y: mrb_value) -> mrb_value;
}
pub const mrb_insn_OP_NOP: mrb_insn = 0;
pub const mrb_insn_OP_MOVE: mrb_insn = 1;
pub const mrb_insn_OP_LOADL: mrb_insn = 2;
pub const mrb_insn_OP_LOADI: mrb_insn = 3;
pub const mrb_insn_OP_LOADINEG: mrb_insn = 4;
pub const mrb_insn_OP_LOADI__1: mrb_insn = 5;
pub const mrb_insn_OP_LOADI_0: mrb_insn = 6;
pub const mrb_insn_OP_LOADI_1: mrb_insn = 7;
pub const mrb_insn_OP_LOADI_2: mrb_insn = 8;
pub const mrb_insn_OP_LOADI_3: mrb_insn = 9;
pub const mrb_insn_OP_LOADI_4: mrb_insn = 10;
pub const mrb_insn_OP_LOADI_5: mrb_insn = 11;
pub const mrb_insn_OP_LOADI_6: mrb_insn = 12;
pub const mrb_insn_OP_LOADI_7: mrb_insn = 13;
pub const mrb_insn_OP_LOADSYM: mrb_insn = 14;
pub const mrb_insn_OP_LOADNIL: mrb_insn = 15;
pub const mrb_insn_OP_LOADSELF: mrb_insn = 16;
pub const mrb_insn_OP_LOADT: mrb_insn = 17;
pub const mrb_insn_OP_LOADF: mrb_insn = 18;
pub const mrb_insn_OP_GETGV: mrb_insn = 19;
pub const mrb_insn_OP_SETGV: mrb_insn = 20;
pub const mrb_insn_OP_GETSV: mrb_insn = 21;
pub const mrb_insn_OP_SETSV: mrb_insn = 22;
pub const mrb_insn_OP_GETIV: mrb_insn = 23;
pub const mrb_insn_OP_SETIV: mrb_insn = 24;
pub const mrb_insn_OP_GETCV: mrb_insn = 25;
pub const mrb_insn_OP_SETCV: mrb_insn = 26;
pub const mrb_insn_OP_GETCONST: mrb_insn = 27;
pub const mrb_insn_OP_SETCONST: mrb_insn = 28;
pub const mrb_insn_OP_GETMCNST: mrb_insn = 29;
pub const mrb_insn_OP_SETMCNST: mrb_insn = 30;
pub const mrb_insn_OP_GETUPVAR: mrb_insn = 31;
pub const mrb_insn_OP_SETUPVAR: mrb_insn = 32;
pub const mrb_insn_OP_JMP: mrb_insn = 33;
pub const mrb_insn_OP_JMPIF: mrb_insn = 34;
pub const mrb_insn_OP_JMPNOT: mrb_insn = 35;
pub const mrb_insn_OP_JMPNIL: mrb_insn = 36;
pub const mrb_insn_OP_ONERR: mrb_insn = 37;
pub const mrb_insn_OP_EXCEPT: mrb_insn = 38;
pub const mrb_insn_OP_RESCUE: mrb_insn = 39;
pub const mrb_insn_OP_POPERR: mrb_insn = 40;
pub const mrb_insn_OP_RAISE: mrb_insn = 41;
pub const mrb_insn_OP_EPUSH: mrb_insn = 42;
pub const mrb_insn_OP_EPOP: mrb_insn = 43;
pub const mrb_insn_OP_SENDV: mrb_insn = 44;
pub const mrb_insn_OP_SENDVB: mrb_insn = 45;
pub const mrb_insn_OP_SEND: mrb_insn = 46;
pub const mrb_insn_OP_SENDB: mrb_insn = 47;
pub const mrb_insn_OP_CALL: mrb_insn = 48;
pub const mrb_insn_OP_SUPER: mrb_insn = 49;
pub const mrb_insn_OP_ARGARY: mrb_insn = 50;
pub const mrb_insn_OP_ENTER: mrb_insn = 51;
pub const mrb_insn_OP_KEY_P: mrb_insn = 52;
pub const mrb_insn_OP_KEYEND: mrb_insn = 53;
pub const mrb_insn_OP_KARG: mrb_insn = 54;
pub const mrb_insn_OP_RETURN: mrb_insn = 55;
pub const mrb_insn_OP_RETURN_BLK: mrb_insn = 56;
pub const mrb_insn_OP_BREAK: mrb_insn = 57;
pub const mrb_insn_OP_BLKPUSH: mrb_insn = 58;
pub const mrb_insn_OP_ADD: mrb_insn = 59;
pub const mrb_insn_OP_ADDI: mrb_insn = 60;
pub const mrb_insn_OP_SUB: mrb_insn = 61;
pub const mrb_insn_OP_SUBI: mrb_insn = 62;
pub const mrb_insn_OP_MUL: mrb_insn = 63;
pub const mrb_insn_OP_DIV: mrb_insn = 64;
pub const mrb_insn_OP_EQ: mrb_insn = 65;
pub const mrb_insn_OP_LT: mrb_insn = 66;
pub const mrb_insn_OP_LE: mrb_insn = 67;
pub const mrb_insn_OP_GT: mrb_insn = 68;
pub const mrb_insn_OP_GE: mrb_insn = 69;
pub const mrb_insn_OP_ARRAY: mrb_insn = 70;
pub const mrb_insn_OP_ARRAY2: mrb_insn = 71;
pub const mrb_insn_OP_ARYCAT: mrb_insn = 72;
pub const mrb_insn_OP_ARYPUSH: mrb_insn = 73;
pub const mrb_insn_OP_ARYDUP: mrb_insn = 74;
pub const mrb_insn_OP_AREF: mrb_insn = 75;
pub const mrb_insn_OP_ASET: mrb_insn = 76;
pub const mrb_insn_OP_APOST: mrb_insn = 77;
pub const mrb_insn_OP_INTERN: mrb_insn = 78;
pub const mrb_insn_OP_STRING: mrb_insn = 79;
pub const mrb_insn_OP_STRCAT: mrb_insn = 80;
pub const mrb_insn_OP_HASH: mrb_insn = 81;
pub const mrb_insn_OP_HASHADD: mrb_insn = 82;
pub const mrb_insn_OP_HASHCAT: mrb_insn = 83;
pub const mrb_insn_OP_LAMBDA: mrb_insn = 84;
pub const mrb_insn_OP_BLOCK: mrb_insn = 85;
pub const mrb_insn_OP_METHOD: mrb_insn = 86;
pub const mrb_insn_OP_RANGE_INC: mrb_insn = 87;
pub const mrb_insn_OP_RANGE_EXC: mrb_insn = 88;
pub const mrb_insn_OP_OCLASS: mrb_insn = 89;
pub const mrb_insn_OP_CLASS: mrb_insn = 90;
pub const mrb_insn_OP_MODULE: mrb_insn = 91;
pub const mrb_insn_OP_EXEC: mrb_insn = 92;
pub const mrb_insn_OP_DEF: mrb_insn = 93;
pub const mrb_insn_OP_ALIAS: mrb_insn = 94;
pub const mrb_insn_OP_UNDEF: mrb_insn = 95;
pub const mrb_insn_OP_SCLASS: mrb_insn = 96;
pub const mrb_insn_OP_TCLASS: mrb_insn = 97;
pub const mrb_insn_OP_DEBUG: mrb_insn = 98;
pub const mrb_insn_OP_ERR: mrb_insn = 99;
pub const mrb_insn_OP_EXT1: mrb_insn = 100;
pub const mrb_insn_OP_EXT2: mrb_insn = 101;
pub const mrb_insn_OP_EXT3: mrb_insn = 102;
pub const mrb_insn_OP_STOP: mrb_insn = 103;
pub type mrb_insn = u32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct REnv {
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u32>,
    pub c: *mut RClass,
    pub gcnext: *mut RBasic,
    pub stack: *mut mrb_value,
    pub cxt: *mut mrb_context,
    pub mid: mrb_sym,
}
impl REnv {
    #[inline]
    pub fn tt(&self) -> mrb_vtype {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
    }
    #[inline]
    pub fn set_tt(&mut self, val: mrb_vtype) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 8u8, val as u64)
        }
    }
    #[inline]
    pub fn color(&self) -> u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 3u8) as u32) }
    }
    #[inline]
    pub fn set_color(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(8usize, 3u8, val as u64)
        }
    }
    #[inline]
    pub fn flags(&self) -> u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 21u8) as u32) }
    }
    #[inline]
    pub fn set_flags(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(11usize, 21u8, val as u64)
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        tt: mrb_vtype,
        color: u32,
        flags: u32,
    ) -> __BindgenBitfieldUnit<[u8; 4usize], u32> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u32> =
            Default::default();
        __bindgen_bitfield_unit.set(0usize, 8u8, {
            let tt: u32 = unsafe { ::std::mem::transmute(tt) };
            tt as u64
        });
        __bindgen_bitfield_unit.set(8usize, 3u8, {
            let color: u32 = unsafe { ::std::mem::transmute(color) };
            color as u64
        });
        __bindgen_bitfield_unit.set(11usize, 21u8, {
            let flags: u32 = unsafe { ::std::mem::transmute(flags) };
            flags as u64
        });
        __bindgen_bitfield_unit
    }
}
extern "C" {
    pub fn mrb_env_unshare(arg1: *mut mrb_state, arg2: *mut REnv);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct RProc {
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u32>,
    pub c: *mut RClass,
    pub gcnext: *mut RBasic,
    pub body: RProc__bindgen_ty_1,
    pub upper: *mut RProc,
    pub e: RProc__bindgen_ty_2,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union RProc__bindgen_ty_1 {
    pub irep: *mut mrb_irep,
    pub func: mrb_func_t,
    _bindgen_union_align: u64,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union RProc__bindgen_ty_2 {
    pub target_class: *mut RClass,
    pub env: *mut REnv,
    _bindgen_union_align: u64,
}
impl RProc {
    #[inline]
    pub fn tt(&self) -> mrb_vtype {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
    }
    #[inline]
    pub fn set_tt(&mut self, val: mrb_vtype) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 8u8, val as u64)
        }
    }
    #[inline]
    pub fn color(&self) -> u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 3u8) as u32) }
    }
    #[inline]
    pub fn set_color(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(8usize, 3u8, val as u64)
        }
    }
    #[inline]
    pub fn flags(&self) -> u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 21u8) as u32) }
    }
    #[inline]
    pub fn set_flags(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(11usize, 21u8, val as u64)
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        tt: mrb_vtype,
        color: u32,
        flags: u32,
    ) -> __BindgenBitfieldUnit<[u8; 4usize], u32> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u32> =
            Default::default();
        __bindgen_bitfield_unit.set(0usize, 8u8, {
            let tt: u32 = unsafe { ::std::mem::transmute(tt) };
            tt as u64
        });
        __bindgen_bitfield_unit.set(8usize, 3u8, {
            let color: u32 = unsafe { ::std::mem::transmute(color) };
            color as u64
        });
        __bindgen_bitfield_unit.set(11usize, 21u8, {
            let flags: u32 = unsafe { ::std::mem::transmute(flags) };
            flags as u64
        });
        __bindgen_bitfield_unit
    }
}
extern "C" {
    pub fn mrb_proc_new(arg1: *mut mrb_state, arg2: *mut mrb_irep) -> *mut RProc;
}
extern "C" {
    pub fn mrb_closure_new(arg1: *mut mrb_state, arg2: *mut mrb_irep) -> *mut RProc;
}
extern "C" {
    pub fn mrb_proc_new_cfunc(arg1: *mut mrb_state, arg2: mrb_func_t) -> *mut RProc;
}
extern "C" {
    pub fn mrb_closure_new_cfunc(
        mrb: *mut mrb_state,
        func: mrb_func_t,
        nlocals: ::std::os::raw::c_int,
    ) -> *mut RProc;
}
extern "C" {
    pub fn mrb_proc_copy(a: *mut RProc, b: *mut RProc);
}
extern "C" {
    pub fn mrb_proc_arity(p: *const RProc) -> mrb_int;
}
extern "C" {
    pub fn mrb_f_send(mrb: *mut mrb_state, self_: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_proc_new_cfunc_with_env(
        arg1: *mut mrb_state,
        arg2: mrb_func_t,
        arg3: mrb_int,
        arg4: *const mrb_value,
    ) -> *mut RProc;
}
extern "C" {
    pub fn mrb_proc_cfunc_env_get(arg1: *mut mrb_state, arg2: mrb_int) -> mrb_value;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct kh_mt {
    pub n_buckets: khint_t,
    pub size: khint_t,
    pub n_occupied: khint_t,
    pub ed_flags: *mut u8,
    pub keys: *mut mrb_sym,
    pub vals: *mut mrb_method_t,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct mrb_range_edges {
    pub beg: mrb_value,
    pub end: mrb_value,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RRange {
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u32>,
    pub c: *mut RClass,
    pub gcnext: *mut RBasic,
    pub edges: *mut mrb_range_edges,
    pub excl: mrb_bool,
}
impl RRange {
    #[inline]
    pub fn tt(&self) -> mrb_vtype {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
    }
    #[inline]
    pub fn set_tt(&mut self, val: mrb_vtype) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 8u8, val as u64)
        }
    }
    #[inline]
    pub fn color(&self) -> u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 3u8) as u32) }
    }
    #[inline]
    pub fn set_color(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(8usize, 3u8, val as u64)
        }
    }
    #[inline]
    pub fn flags(&self) -> u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 21u8) as u32) }
    }
    #[inline]
    pub fn set_flags(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(11usize, 21u8, val as u64)
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        tt: mrb_vtype,
        color: u32,
        flags: u32,
    ) -> __BindgenBitfieldUnit<[u8; 4usize], u32> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u32> =
            Default::default();
        __bindgen_bitfield_unit.set(0usize, 8u8, {
            let tt: u32 = unsafe { ::std::mem::transmute(tt) };
            tt as u64
        });
        __bindgen_bitfield_unit.set(8usize, 3u8, {
            let color: u32 = unsafe { ::std::mem::transmute(color) };
            color as u64
        });
        __bindgen_bitfield_unit.set(11usize, 21u8, {
            let flags: u32 = unsafe { ::std::mem::transmute(flags) };
            flags as u64
        });
        __bindgen_bitfield_unit
    }
}
extern "C" {
    pub fn mrb_range_ptr(mrb: *mut mrb_state, range: mrb_value) -> *mut RRange;
}
extern "C" {
    pub fn mrb_range_new(
        mrb: *mut mrb_state,
        start: mrb_value,
        end: mrb_value,
        exclude: mrb_bool,
    ) -> mrb_value;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum mrb_range_beg_len {
    MRB_RANGE_TYPE_MISMATCH = 0,
    MRB_RANGE_OK = 1,
    MRB_RANGE_OUT = 2,
}
extern "C" {
    pub fn mrb_range_beg_len(
        mrb: *mut mrb_state,
        range: mrb_value,
        begp: *mut mrb_int,
        lenp: *mut mrb_int,
        len: mrb_int,
        trunc: mrb_bool,
    ) -> mrb_range_beg_len;
}
extern "C" {
    pub fn mrb_get_values_at(
        mrb: *mut mrb_state,
        obj: mrb_value,
        olen: mrb_int,
        argc: mrb_int,
        argv: *const mrb_value,
        func: ::std::option::Option<
            unsafe extern "C" fn(arg1: *mut mrb_state, arg2: mrb_value, arg3: mrb_int) -> mrb_value,
        >,
    ) -> mrb_value;
}
extern "C" {
    pub fn mrb_gc_mark_range(mrb: *mut mrb_state, r: *mut RRange);
}
extern "C" {
    pub static mut mrb_digitmap: [::std::os::raw::c_char; 0usize];
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct RString {
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u32>,
    pub c: *mut RClass,
    pub gcnext: *mut RBasic,
    pub as_: RString__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union RString__bindgen_ty_1 {
    pub heap: RString__bindgen_ty_1__bindgen_ty_1,
    pub ary: [::std::os::raw::c_char; 24usize],
    _bindgen_union_align: [u64; 3usize],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct RString__bindgen_ty_1__bindgen_ty_1 {
    pub len: mrb_int,
    pub aux: RString__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
    pub ptr: *mut ::std::os::raw::c_char,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union RString__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
    pub capa: mrb_int,
    pub shared: *mut mrb_shared_string,
    pub fshared: *mut RString,
    _bindgen_union_align: u64,
}
impl RString {
    #[inline]
    pub fn tt(&self) -> mrb_vtype {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
    }
    #[inline]
    pub fn set_tt(&mut self, val: mrb_vtype) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 8u8, val as u64)
        }
    }
    #[inline]
    pub fn color(&self) -> u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 3u8) as u32) }
    }
    #[inline]
    pub fn set_color(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(8usize, 3u8, val as u64)
        }
    }
    #[inline]
    pub fn flags(&self) -> u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 21u8) as u32) }
    }
    #[inline]
    pub fn set_flags(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(11usize, 21u8, val as u64)
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        tt: mrb_vtype,
        color: u32,
        flags: u32,
    ) -> __BindgenBitfieldUnit<[u8; 4usize], u32> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u32> =
            Default::default();
        __bindgen_bitfield_unit.set(0usize, 8u8, {
            let tt: u32 = unsafe { ::std::mem::transmute(tt) };
            tt as u64
        });
        __bindgen_bitfield_unit.set(8usize, 3u8, {
            let color: u32 = unsafe { ::std::mem::transmute(color) };
            color as u64
        });
        __bindgen_bitfield_unit.set(11usize, 21u8, {
            let flags: u32 = unsafe { ::std::mem::transmute(flags) };
            flags as u64
        });
        __bindgen_bitfield_unit
    }
}
extern "C" {
    pub fn mrb_str_strlen(arg1: *mut mrb_state, arg2: *mut RString) -> mrb_int;
}
extern "C" {
    pub fn mrb_gc_free_str(arg1: *mut mrb_state, arg2: *mut RString);
}
extern "C" {
    pub fn mrb_str_modify(arg1: *mut mrb_state, arg2: *mut RString);
}
extern "C" {
    pub fn mrb_str_index(
        arg1: *mut mrb_state,
        arg2: mrb_value,
        arg3: *const ::std::os::raw::c_char,
        arg4: mrb_int,
        arg5: mrb_int,
    ) -> mrb_int;
}
extern "C" {
    pub fn mrb_str_concat(arg1: *mut mrb_state, arg2: mrb_value, arg3: mrb_value);
}
extern "C" {
    pub fn mrb_str_plus(arg1: *mut mrb_state, arg2: mrb_value, arg3: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_ptr_to_str(arg1: *mut mrb_state, arg2: *mut ::std::os::raw::c_void) -> mrb_value;
}
extern "C" {
    pub fn mrb_obj_as_string(mrb: *mut mrb_state, obj: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_str_resize(mrb: *mut mrb_state, str: mrb_value, len: mrb_int) -> mrb_value;
}
extern "C" {
    pub fn mrb_str_substr(
        mrb: *mut mrb_state,
        str: mrb_value,
        beg: mrb_int,
        len: mrb_int,
    ) -> mrb_value;
}
extern "C" {
    pub fn mrb_ensure_string_type(mrb: *mut mrb_state, str: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_check_string_type(mrb: *mut mrb_state, str: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_string_type(mrb: *mut mrb_state, str: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_str_new_capa(mrb: *mut mrb_state, capa: usize) -> mrb_value;
}
extern "C" {
    pub fn mrb_str_buf_new(mrb: *mut mrb_state, capa: usize) -> mrb_value;
}
extern "C" {
    pub fn mrb_string_value_cstr(
        mrb: *mut mrb_state,
        ptr: *mut mrb_value,
    ) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn mrb_string_value_ptr(
        mrb: *mut mrb_state,
        str: mrb_value,
    ) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn mrb_string_value_len(mrb: *mut mrb_state, str: mrb_value) -> mrb_int;
}
extern "C" {
    pub fn mrb_str_dup(mrb: *mut mrb_state, str: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_str_intern(mrb: *mut mrb_state, self_: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_str_to_inum(
        mrb: *mut mrb_state,
        str: mrb_value,
        base: mrb_int,
        badcheck: mrb_bool,
    ) -> mrb_value;
}
extern "C" {
    pub fn mrb_cstr_to_inum(
        mrb: *mut mrb_state,
        s: *const ::std::os::raw::c_char,
        base: mrb_int,
        badcheck: mrb_bool,
    ) -> mrb_value;
}
extern "C" {
    pub fn mrb_str_to_dbl(mrb: *mut mrb_state, str: mrb_value, badcheck: mrb_bool) -> f64;
}
extern "C" {
    pub fn mrb_cstr_to_dbl(
        mrb: *mut mrb_state,
        s: *const ::std::os::raw::c_char,
        badcheck: mrb_bool,
    ) -> f64;
}
extern "C" {
    pub fn mrb_str_to_str(mrb: *mut mrb_state, str: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_str_equal(mrb: *mut mrb_state, str1: mrb_value, str2: mrb_value) -> mrb_bool;
}
extern "C" {
    pub fn mrb_str_cat(
        mrb: *mut mrb_state,
        str: mrb_value,
        ptr: *const ::std::os::raw::c_char,
        len: usize,
    ) -> mrb_value;
}
extern "C" {
    pub fn mrb_str_cat_cstr(
        mrb: *mut mrb_state,
        str: mrb_value,
        ptr: *const ::std::os::raw::c_char,
    ) -> mrb_value;
}
extern "C" {
    pub fn mrb_str_cat_str(mrb: *mut mrb_state, str: mrb_value, str2: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_str_append(mrb: *mut mrb_state, str: mrb_value, str2: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_str_cmp(
        mrb: *mut mrb_state,
        str1: mrb_value,
        str2: mrb_value,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mrb_str_to_cstr(mrb: *mut mrb_state, str: mrb_value) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn mrb_str_pool(mrb: *mut mrb_state, str: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_str_hash(mrb: *mut mrb_state, str: mrb_value) -> u32;
}
extern "C" {
    pub fn mrb_str_dump(mrb: *mut mrb_state, str: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_str_inspect(mrb: *mut mrb_state, str: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_str_beg_len(str_len: mrb_int, begp: *mut mrb_int, lenp: *mut mrb_int) -> mrb_bool;
}
extern "C" {
    pub fn mrb_str_byte_subseq(
        mrb: *mut mrb_state,
        str: mrb_value,
        beg: mrb_int,
        len: mrb_int,
    ) -> mrb_value;
}
pub type __jmp_buf = [::std::os::raw::c_long; 8usize];
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __sigset_t {
    pub __val: [::std::os::raw::c_ulong; 16usize],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __jmp_buf_tag {
    pub __jmpbuf: __jmp_buf,
    pub __mask_was_saved: ::std::os::raw::c_int,
    pub __saved_mask: __sigset_t,
}
pub type jmp_buf = [__jmp_buf_tag; 1usize];
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mrb_jmpbuf {
    pub impl_: jmp_buf,
}
extern "C" {
    pub fn mrb_vm_special_get(arg1: *mut mrb_state, arg2: mrb_sym) -> mrb_value;
}
extern "C" {
    pub fn mrb_vm_special_set(arg1: *mut mrb_state, arg2: mrb_sym, arg3: mrb_value);
}
extern "C" {
    pub fn mrb_vm_cv_get(arg1: *mut mrb_state, arg2: mrb_sym) -> mrb_value;
}
extern "C" {
    pub fn mrb_vm_cv_set(arg1: *mut mrb_state, arg2: mrb_sym, arg3: mrb_value);
}
extern "C" {
    pub fn mrb_vm_const_get(arg1: *mut mrb_state, arg2: mrb_sym) -> mrb_value;
}
extern "C" {
    pub fn mrb_vm_const_set(arg1: *mut mrb_state, arg2: mrb_sym, arg3: mrb_value);
}
extern "C" {
    pub fn mrb_const_get(arg1: *mut mrb_state, arg2: mrb_value, arg3: mrb_sym) -> mrb_value;
}
extern "C" {
    pub fn mrb_const_set(arg1: *mut mrb_state, arg2: mrb_value, arg3: mrb_sym, arg4: mrb_value);
}
extern "C" {
    pub fn mrb_const_defined(arg1: *mut mrb_state, arg2: mrb_value, arg3: mrb_sym) -> mrb_bool;
}
extern "C" {
    pub fn mrb_const_remove(arg1: *mut mrb_state, arg2: mrb_value, arg3: mrb_sym);
}
extern "C" {
    pub fn mrb_iv_name_sym_p(mrb: *mut mrb_state, sym: mrb_sym) -> mrb_bool;
}
extern "C" {
    pub fn mrb_iv_name_sym_check(mrb: *mut mrb_state, sym: mrb_sym);
}
extern "C" {
    pub fn mrb_obj_iv_get(mrb: *mut mrb_state, obj: *mut RObject, sym: mrb_sym) -> mrb_value;
}
extern "C" {
    pub fn mrb_obj_iv_set(mrb: *mut mrb_state, obj: *mut RObject, sym: mrb_sym, v: mrb_value);
}
extern "C" {
    pub fn mrb_obj_iv_defined(mrb: *mut mrb_state, obj: *mut RObject, sym: mrb_sym) -> mrb_bool;
}
extern "C" {
    pub fn mrb_iv_get(mrb: *mut mrb_state, obj: mrb_value, sym: mrb_sym) -> mrb_value;
}
extern "C" {
    pub fn mrb_iv_set(mrb: *mut mrb_state, obj: mrb_value, sym: mrb_sym, v: mrb_value);
}
extern "C" {
    pub fn mrb_iv_defined(arg1: *mut mrb_state, arg2: mrb_value, arg3: mrb_sym) -> mrb_bool;
}
extern "C" {
    pub fn mrb_iv_remove(mrb: *mut mrb_state, obj: mrb_value, sym: mrb_sym) -> mrb_value;
}
extern "C" {
    pub fn mrb_iv_copy(mrb: *mut mrb_state, dst: mrb_value, src: mrb_value);
}
extern "C" {
    pub fn mrb_const_defined_at(mrb: *mut mrb_state, mod_: mrb_value, id: mrb_sym) -> mrb_bool;
}
extern "C" {
    pub fn mrb_gv_get(mrb: *mut mrb_state, sym: mrb_sym) -> mrb_value;
}
extern "C" {
    pub fn mrb_gv_set(mrb: *mut mrb_state, sym: mrb_sym, val: mrb_value);
}
extern "C" {
    pub fn mrb_gv_remove(mrb: *mut mrb_state, sym: mrb_sym);
}
extern "C" {
    pub fn mrb_cv_get(mrb: *mut mrb_state, mod_: mrb_value, sym: mrb_sym) -> mrb_value;
}
extern "C" {
    pub fn mrb_mod_cv_set(mrb: *mut mrb_state, c: *mut RClass, sym: mrb_sym, v: mrb_value);
}
extern "C" {
    pub fn mrb_cv_set(mrb: *mut mrb_state, mod_: mrb_value, sym: mrb_sym, v: mrb_value);
}
extern "C" {
    pub fn mrb_cv_defined(mrb: *mut mrb_state, mod_: mrb_value, sym: mrb_sym) -> mrb_bool;
}
extern "C" {
    pub fn mrb_obj_iv_inspect(arg1: *mut mrb_state, arg2: *mut RObject) -> mrb_value;
}
extern "C" {
    pub fn mrb_obj_iv_set_force(mrb: *mut mrb_state, obj: *mut RObject, sym: mrb_sym, v: mrb_value);
}
extern "C" {
    pub fn mrb_mod_constants(mrb: *mut mrb_state, mod_: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_f_global_variables(mrb: *mut mrb_state, self_: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_obj_instance_variables(arg1: *mut mrb_state, arg2: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_mod_class_variables(arg1: *mut mrb_state, arg2: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_mod_cv_get(mrb: *mut mrb_state, c: *mut RClass, sym: mrb_sym) -> mrb_value;
}
extern "C" {
    pub fn mrb_mod_cv_defined(mrb: *mut mrb_state, c: *mut RClass, sym: mrb_sym) -> mrb_bool;
}
extern "C" {
    pub fn mrb_ident_p(s: *const ::std::os::raw::c_char, len: mrb_int) -> mrb_bool;
}
extern "C" {
    pub fn mrb_gc_mark_gv(arg1: *mut mrb_state);
}
extern "C" {
    pub fn mrb_gc_free_gv(arg1: *mut mrb_state);
}
extern "C" {
    pub fn mrb_gc_mark_iv(arg1: *mut mrb_state, arg2: *mut RObject);
}
extern "C" {
    pub fn mrb_gc_mark_iv_size(arg1: *mut mrb_state, arg2: *mut RObject) -> usize;
}
extern "C" {
    pub fn mrb_gc_free_iv(arg1: *mut mrb_state, arg2: *mut RObject);
}
pub type mrb_iv_foreach_func = ::std::option::Option<
    unsafe extern "C" fn(
        arg1: *mut mrb_state,
        arg2: mrb_sym,
        arg3: mrb_value,
        arg4: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int,
>;
extern "C" {
    pub fn mrb_iv_foreach(
        mrb: *mut mrb_state,
        obj: mrb_value,
        func: mrb_iv_foreach_func,
        p: *mut ::std::os::raw::c_void,
    );
}
extern "C" {
    pub fn mrb_sys_value_is_nil(value: mrb_value) -> bool;
}
extern "C" {
    pub fn mrb_sys_value_is_false(value: mrb_value) -> bool;
}
extern "C" {
    pub fn mrb_sys_value_is_true(value: mrb_value) -> bool;
}
extern "C" {
    pub fn mrb_sys_fixnum_to_cint(value: mrb_value) -> mrb_int;
}
extern "C" {
    pub fn mrb_sys_float_to_cdouble(value: mrb_value) -> mrb_float;
}
extern "C" {
    pub fn mrb_sys_cptr_ptr(value: mrb_value) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn mrb_sys_basic_ptr(value: mrb_value) -> *mut RBasic;
}
extern "C" {
    pub fn mrb_sys_obj_ptr(value: mrb_value) -> *mut RObject;
}
extern "C" {
    pub fn mrb_sys_proc_ptr(value: mrb_value) -> *mut RProc;
}
extern "C" {
    pub fn mrb_sys_class_ptr(value: mrb_value) -> *mut RClass;
}
extern "C" {
    pub fn mrb_sys_class_to_rclass(value: mrb_value) -> *mut RClass;
}
extern "C" {
    pub fn mrb_sys_class_of_value(mrb: *mut mrb_state, value: mrb_value) -> *mut RClass;
}
extern "C" {
    pub fn mrb_sys_nil_value() -> mrb_value;
}
extern "C" {
    pub fn mrb_sys_false_value() -> mrb_value;
}
extern "C" {
    pub fn mrb_sys_true_value() -> mrb_value;
}
extern "C" {
    pub fn mrb_sys_fixnum_value(value: mrb_int) -> mrb_value;
}
extern "C" {
    pub fn mrb_sys_float_value(mrb: *mut mrb_state, value: mrb_float) -> mrb_value;
}
extern "C" {
    pub fn mrb_sys_cptr_value(mrb: *mut mrb_state, ptr: *mut ::std::os::raw::c_void) -> mrb_value;
}
extern "C" {
    pub fn mrb_sys_obj_value(p: *mut ::std::os::raw::c_void) -> mrb_value;
}
extern "C" {
    pub fn mrb_sys_class_value(klass: *mut RClass) -> mrb_value;
}
extern "C" {
    pub fn mrb_sys_module_value(module: *mut RClass) -> mrb_value;
}
extern "C" {
    pub fn mrb_sys_data_value(data: *mut RData) -> mrb_value;
}
extern "C" {
    pub fn mrb_sys_proc_value(mrb: *mut mrb_state, proc_: *mut RProc) -> mrb_value;
}
extern "C" {
    pub fn mrb_sys_symbol_name(
        mrb: *mut mrb_state,
        value: mrb_value,
    ) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn mrb_sys_new_symbol(
        mrb: *mut mrb_state,
        string: *const ::std::os::raw::c_char,
        len: usize,
    ) -> mrb_value;
}
extern "C" {
    pub fn mrb_sys_set_instance_tt(class: *mut RClass, type_: mrb_vtype);
}
extern "C" {
    pub fn mrb_sys_data_init(
        value: *mut mrb_value,
        ptr: *mut ::std::os::raw::c_void,
        type_: *const mrb_data_type,
    );
}
extern "C" {
    pub fn mrb_sys_raise(
        mrb: *mut mrb_state,
        eclass: *const ::std::os::raw::c_char,
        msg: *const ::std::os::raw::c_char,
    );
}
extern "C" {
    pub fn mrb_sys_raise_current_exception(mrb: *mut mrb_state);
}
extern "C" {
    pub fn mrb_sys_value_debug_str(mrb: *mut mrb_state, value: mrb_value) -> mrb_value;
}
extern "C" {
    pub fn mrb_sys_ary_len(value: mrb_value) -> mrb_int;
}
extern "C" {
    pub fn mrb_sys_gc_arena_save(mrb: *mut mrb_state) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn mrb_sys_gc_arena_restore(mrb: *mut mrb_state, arena_index: ::std::os::raw::c_int);
}
extern "C" {
    pub fn mrb_sys_gc_disable(mrb: *mut mrb_state) -> bool;
}
extern "C" {
    pub fn mrb_sys_gc_enable(mrb: *mut mrb_state) -> bool;
}
extern "C" {
    pub fn mrb_sys_value_is_dead(_mrb: *mut mrb_state, value: mrb_value) -> bool;
}
extern "C" {
    pub fn mrb_sys_gc_live_objects(mrb: *mut mrb_state) -> ::std::os::raw::c_int;
}
pub type __builtin_va_list = [__va_list_tag; 1usize];
#[repr(C)]
#[derive(Debug, Copy, Clone)]
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,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct iv_tbl {
    pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct symbol_name {
    pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mrb_irep_debug_info {
    pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct htable {
    pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mrb_shared_string {
    pub _address: u8,
}