rbspy_ruby_structs/

ruby_2_2_2.rs

/* automatically generated by rust-bindgen 0.73.2 */

#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct __BindgenBitfieldUnit<Storage> {
    storage: Storage,
}
impl<Storage> __BindgenBitfieldUnit<Storage> {
    #[inline]
    pub const fn new(storage: Storage) -> Self {
        Self { storage }
    }
}
impl<Storage> __BindgenBitfieldUnit<Storage>
where
    Storage: AsRef<[u8]> + AsMut<[u8]>,
{
    #[inline]
    fn extract_bit(byte: u8, index: usize) -> bool {
        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 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];
        Self::extract_bit(byte, index)
    }
    #[inline]
    pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool {
        debug_assert!(index / 8 < core::mem::size_of::<Storage>());
        let byte_index = index / 8;
        let byte = unsafe {
            *(core::ptr::addr_of!((*this).storage) as *const u8).offset(byte_index as isize)
        };
        Self::extract_bit(byte, index)
    }
    #[inline]
    fn change_bit(byte: u8, index: usize, val: bool) -> u8 {
        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 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];
        *byte = Self::change_bit(*byte, index, val);
    }
    #[inline]
    pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) {
        debug_assert!(index / 8 < core::mem::size_of::<Storage>());
        let byte_index = index / 8;
        let byte = unsafe {
            (core::ptr::addr_of_mut!((*this).storage) as *mut u8).offset(byte_index as isize)
        };
        unsafe { *byte = Self::change_bit(*byte, index, val) };
    }
    #[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) + 7) / 8 <= self.storage.as_ref().len());
        if bit_width == 0 {
            return 0;
        }
        let mut val = 0u64;
        let storage = self.storage.as_ref();
        let start_byte = bit_offset / 8;
        let bit_shift = bit_offset % 8;
        let bytes_needed = (bit_width as usize + bit_shift + 7) / 8;
        if cfg!(target_endian = "big") {
            for i in 0..bytes_needed {
                val |= (storage[start_byte + i].reverse_bits() as u64) << (i * 8);
            }
        } else {
            for i in 0..bytes_needed {
                val |= (storage[start_byte + i] as u64) << (i * 8);
            }
        }
        val >>= bit_shift;
        if bit_width < 64 {
            val &= (1u64 << bit_width) - 1;
        }
        if cfg!(target_endian = "big") {
            val = val.reverse_bits() >> (64 - bit_width as usize);
        }
        val
    }
    #[inline]
    pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 {
        debug_assert!(bit_width <= 64);
        debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
        debug_assert!(
            (bit_offset + (bit_width as usize) + 7) / 8 <= core::mem::size_of::<Storage>()
        );
        if bit_width == 0 {
            return 0;
        }
        let mut val = 0u64;
        let start_byte = bit_offset / 8;
        let bit_shift = bit_offset % 8;
        let bytes_needed = (bit_width as usize + bit_shift + 7) / 8;
        let storage_ptr = unsafe { core::ptr::addr_of!((*this).storage) as *const u8 };
        if cfg!(target_endian = "big") {
            for i in 0..bytes_needed {
                let byte = unsafe { *storage_ptr.add(start_byte + i) };
                val |= (byte.reverse_bits() as u64) << (i * 8);
            }
        } else {
            for i in 0..bytes_needed {
                let byte = unsafe { *storage_ptr.add(start_byte + i) };
                val |= (byte as u64) << (i * 8);
            }
        }
        val >>= bit_shift;
        if bit_width < 64 {
            val &= (1u64 << bit_width) - 1;
        }
        if cfg!(target_endian = "big") {
            val = val.reverse_bits() >> (64 - bit_width as usize);
        }
        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) + 7) / 8 <= self.storage.as_ref().len());
        if bit_width == 0 {
            return;
        }
        let mut val = val;
        if bit_width < 64 {
            val &= (1u64 << bit_width) - 1;
        }
        if cfg!(target_endian = "big") {
            val = val.reverse_bits() >> (64 - bit_width as usize);
        }
        let storage = self.storage.as_mut();
        let start_byte = bit_offset / 8;
        let bit_shift = bit_offset % 8;
        let bytes_needed = (bit_width as usize + bit_shift + 7) / 8;
        val <<= bit_shift;
        let field_mask = if bit_width as usize + bit_shift >= 64 {
            !0u64 << bit_shift
        } else {
            ((1u64 << bit_width) - 1) << bit_shift
        };
        for i in 0..bytes_needed {
            let byte_val = (val >> (i * 8)) as u8;
            let byte_mask = (field_mask >> (i * 8)) as u8;
            if cfg!(target_endian = "big") {
                let byte = storage[start_byte + i].reverse_bits();
                let new_byte = (byte & !byte_mask) | (byte_val & byte_mask);
                storage[start_byte + i] = new_byte.reverse_bits();
            } else {
                storage[start_byte + i] =
                    (storage[start_byte + i] & !byte_mask) | (byte_val & byte_mask);
            }
        }
    }
    #[inline]
    pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) {
        debug_assert!(bit_width <= 64);
        debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
        debug_assert!(
            (bit_offset + (bit_width as usize) + 7) / 8 <= core::mem::size_of::<Storage>()
        );
        if bit_width == 0 {
            return;
        }
        let mut val = val;
        if bit_width < 64 {
            val &= (1u64 << bit_width) - 1;
        }
        if cfg!(target_endian = "big") {
            val = val.reverse_bits() >> (64 - bit_width as usize);
        }
        let start_byte = bit_offset / 8;
        let bit_shift = bit_offset % 8;
        let bytes_needed = (bit_width as usize + bit_shift + 7) / 8;
        val <<= bit_shift;
        let field_mask = if bit_width as usize + bit_shift >= 64 {
            !0u64 << bit_shift
        } else {
            ((1u64 << bit_width) - 1) << bit_shift
        };
        let storage_ptr = unsafe { core::ptr::addr_of_mut!((*this).storage) as *mut u8 };
        for i in 0..bytes_needed {
            let byte_val = (val >> (i * 8)) as u8;
            let byte_mask = (field_mask >> (i * 8)) as u8;
            let byte_ptr = unsafe { storage_ptr.add(start_byte + i) };
            if cfg!(target_endian = "big") {
                let byte = unsafe { (*byte_ptr).reverse_bits() };
                let new_byte = (byte & !byte_mask) | (byte_val & byte_mask);
                unsafe { *byte_ptr = new_byte.reverse_bits() };
            } else {
                unsafe { *byte_ptr = (*byte_ptr & !byte_mask) | (byte_val & byte_mask) };
            }
        }
    }
}
#[doc = " Const-generic methods for efficient bitfield access when offset and width"]
#[doc = " are known at compile time."]
impl<const N: usize> __BindgenBitfieldUnit<[u8; N]> {
    #[doc = " Get a field using const generics for compile-time optimization."]
    #[doc = " Uses native word size operations when the field fits in usize."]
    #[inline]
    pub const fn get_const<const BIT_OFFSET: usize, const BIT_WIDTH: u8>(&self) -> u64 {
        debug_assert!(BIT_WIDTH <= 64);
        debug_assert!(BIT_OFFSET / 8 < N);
        debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N);
        if BIT_WIDTH == 0 {
            return 0;
        }
        let start_byte = BIT_OFFSET / 8;
        let bit_shift = BIT_OFFSET % 8;
        let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8;
        if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize {
            let mut val = 0usize;
            if cfg!(target_endian = "big") {
                let mut i = 0;
                while i < bytes_needed {
                    val |= (self.storage[start_byte + i].reverse_bits() as usize) << (i * 8);
                    i += 1;
                }
            } else {
                let mut i = 0;
                while i < bytes_needed {
                    val |= (self.storage[start_byte + i] as usize) << (i * 8);
                    i += 1;
                }
            }
            val >>= bit_shift;
            if (BIT_WIDTH as u32) < usize::BITS {
                val &= (1usize << BIT_WIDTH) - 1;
            }
            if cfg!(target_endian = "big") {
                val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize);
            }
            val as u64
        } else {
            let mut val = 0u64;
            if cfg!(target_endian = "big") {
                let mut i = 0;
                while i < bytes_needed {
                    val |= (self.storage[start_byte + i].reverse_bits() as u64) << (i * 8);
                    i += 1;
                }
            } else {
                let mut i = 0;
                while i < bytes_needed {
                    val |= (self.storage[start_byte + i] as u64) << (i * 8);
                    i += 1;
                }
            }
            val >>= bit_shift;
            if BIT_WIDTH < 64 {
                val &= (1u64 << BIT_WIDTH) - 1;
            }
            if cfg!(target_endian = "big") {
                val = val.reverse_bits() >> (64 - BIT_WIDTH as usize);
            }
            val
        }
    }
    #[doc = " Set a field using const generics for compile-time optimization."]
    #[doc = " Uses native word size operations when the field fits in usize."]
    #[inline]
    pub fn set_const<const BIT_OFFSET: usize, const BIT_WIDTH: u8>(&mut self, val: u64) {
        debug_assert!(BIT_WIDTH <= 64);
        debug_assert!(BIT_OFFSET / 8 < N);
        debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N);
        if BIT_WIDTH == 0 {
            return;
        }
        let start_byte = BIT_OFFSET / 8;
        let bit_shift = BIT_OFFSET % 8;
        let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8;
        if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize {
            let mut val = val as usize;
            if (BIT_WIDTH as u32) < usize::BITS {
                val &= (1usize << BIT_WIDTH) - 1;
            }
            if cfg!(target_endian = "big") {
                val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize);
            }
            val <<= bit_shift;
            let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize {
                !0usize << bit_shift
            } else {
                ((1usize << BIT_WIDTH) - 1) << bit_shift
            };
            let mut i = 0;
            while i < bytes_needed {
                let byte_val = (val >> (i * 8)) as u8;
                let byte_mask = (field_mask >> (i * 8)) as u8;
                if cfg!(target_endian = "big") {
                    let byte = self.storage[start_byte + i].reverse_bits();
                    let new_byte = (byte & !byte_mask) | (byte_val & byte_mask);
                    self.storage[start_byte + i] = new_byte.reverse_bits();
                } else {
                    self.storage[start_byte + i] =
                        (self.storage[start_byte + i] & !byte_mask) | (byte_val & byte_mask);
                }
                i += 1;
            }
        } else {
            let mut val = val;
            if BIT_WIDTH < 64 {
                val &= (1u64 << BIT_WIDTH) - 1;
            }
            if cfg!(target_endian = "big") {
                val = val.reverse_bits() >> (64 - BIT_WIDTH as usize);
            }
            val <<= bit_shift;
            let field_mask = if BIT_WIDTH as usize + bit_shift >= 64 {
                !0u64 << bit_shift
            } else {
                ((1u64 << BIT_WIDTH) - 1) << bit_shift
            };
            let mut i = 0;
            while i < bytes_needed {
                let byte_val = (val >> (i * 8)) as u8;
                let byte_mask = (field_mask >> (i * 8)) as u8;
                if cfg!(target_endian = "big") {
                    let byte = self.storage[start_byte + i].reverse_bits();
                    let new_byte = (byte & !byte_mask) | (byte_val & byte_mask);
                    self.storage[start_byte + i] = new_byte.reverse_bits();
                } else {
                    self.storage[start_byte + i] =
                        (self.storage[start_byte + i] & !byte_mask) | (byte_val & byte_mask);
                }
                i += 1;
            }
        }
    }
    #[doc = " Raw pointer get using const generics for compile-time optimization."]
    #[doc = " Uses native word size operations when the field fits in usize."]
    #[inline]
    pub const unsafe fn raw_get_const<const BIT_OFFSET: usize, const BIT_WIDTH: u8>(
        this: *const Self,
    ) -> u64 {
        debug_assert!(BIT_WIDTH <= 64);
        debug_assert!(BIT_OFFSET / 8 < N);
        debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N);
        if BIT_WIDTH == 0 {
            return 0;
        }
        let start_byte = BIT_OFFSET / 8;
        let bit_shift = BIT_OFFSET % 8;
        let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8;
        let storage_ptr = unsafe { core::ptr::addr_of!((*this).storage) as *const u8 };
        if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize {
            let mut val = 0usize;
            if cfg!(target_endian = "big") {
                let mut i = 0;
                while i < bytes_needed {
                    let byte = unsafe { *storage_ptr.add(start_byte + i) };
                    val |= (byte.reverse_bits() as usize) << (i * 8);
                    i += 1;
                }
            } else {
                let mut i = 0;
                while i < bytes_needed {
                    let byte = unsafe { *storage_ptr.add(start_byte + i) };
                    val |= (byte as usize) << (i * 8);
                    i += 1;
                }
            }
            val >>= bit_shift;
            if (BIT_WIDTH as u32) < usize::BITS {
                val &= (1usize << BIT_WIDTH) - 1;
            }
            if cfg!(target_endian = "big") {
                val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize);
            }
            val as u64
        } else {
            let mut val = 0u64;
            if cfg!(target_endian = "big") {
                let mut i = 0;
                while i < bytes_needed {
                    let byte = unsafe { *storage_ptr.add(start_byte + i) };
                    val |= (byte.reverse_bits() as u64) << (i * 8);
                    i += 1;
                }
            } else {
                let mut i = 0;
                while i < bytes_needed {
                    let byte = unsafe { *storage_ptr.add(start_byte + i) };
                    val |= (byte as u64) << (i * 8);
                    i += 1;
                }
            }
            val >>= bit_shift;
            if BIT_WIDTH < 64 {
                val &= (1u64 << BIT_WIDTH) - 1;
            }
            if cfg!(target_endian = "big") {
                val = val.reverse_bits() >> (64 - BIT_WIDTH as usize);
            }
            val
        }
    }
    #[doc = " Raw pointer set using const generics for compile-time optimization."]
    #[doc = " Uses native word size operations when the field fits in usize."]
    #[inline]
    pub unsafe fn raw_set_const<const BIT_OFFSET: usize, const BIT_WIDTH: u8>(
        this: *mut Self,
        val: u64,
    ) {
        debug_assert!(BIT_WIDTH <= 64);
        debug_assert!(BIT_OFFSET / 8 < N);
        debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N);
        if BIT_WIDTH == 0 {
            return;
        }
        let start_byte = BIT_OFFSET / 8;
        let bit_shift = BIT_OFFSET % 8;
        let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8;
        let storage_ptr = this.cast::<[u8; N]>().cast::<u8>();
        if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize {
            let mut val = val as usize;
            if (BIT_WIDTH as u32) < usize::BITS {
                val &= (1usize << BIT_WIDTH) - 1;
            }
            if cfg!(target_endian = "big") {
                val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize);
            }
            val <<= bit_shift;
            let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize {
                !0usize << bit_shift
            } else {
                ((1usize << BIT_WIDTH) - 1) << bit_shift
            };
            let mut i = 0;
            while i < bytes_needed {
                let byte_val = (val >> (i * 8)) as u8;
                let byte_mask = (field_mask >> (i * 8)) as u8;
                let byte_ptr = unsafe { storage_ptr.add(start_byte + i) };
                if cfg!(target_endian = "big") {
                    let byte = unsafe { (*byte_ptr).reverse_bits() };
                    let new_byte = (byte & !byte_mask) | (byte_val & byte_mask);
                    unsafe { *byte_ptr = new_byte.reverse_bits() };
                } else {
                    unsafe { *byte_ptr = (*byte_ptr & !byte_mask) | (byte_val & byte_mask) };
                }
                i += 1;
            }
        } else {
            let mut val = val;
            if BIT_WIDTH < 64 {
                val &= (1u64 << BIT_WIDTH) - 1;
            }
            if cfg!(target_endian = "big") {
                val = val.reverse_bits() >> (64 - BIT_WIDTH as usize);
            }
            val <<= bit_shift;
            let field_mask = if BIT_WIDTH as usize + bit_shift >= 64 {
                !0u64 << bit_shift
            } else {
                ((1u64 << BIT_WIDTH) - 1) << bit_shift
            };
            let mut i = 0;
            while i < bytes_needed {
                let byte_val = (val >> (i * 8)) as u8;
                let byte_mask = (field_mask >> (i * 8)) as u8;
                let byte_ptr = unsafe { storage_ptr.add(start_byte + i) };
                if cfg!(target_endian = "big") {
                    let byte = unsafe { (*byte_ptr).reverse_bits() };
                    let new_byte = (byte & !byte_mask) | (byte_val & byte_mask);
                    unsafe { *byte_ptr = new_byte.reverse_bits() };
                } else {
                    unsafe { *byte_ptr = (*byte_ptr & !byte_mask) | (byte_val & byte_mask) };
                }
                i += 1;
            }
        }
    }
}
pub type __clockid_t = ::std::os::raw::c_int;
pub type clockid_t = __clockid_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __sigset_t {
    pub __val: [usize; 16usize],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_internal_list {
    pub __prev: *mut __pthread_internal_list,
    pub __next: *mut __pthread_internal_list,
}
pub type __pthread_list_t = __pthread_internal_list;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_mutex_s {
    pub __lock: ::std::os::raw::c_int,
    pub __count: ::std::os::raw::c_uint,
    pub __owner: ::std::os::raw::c_int,
    pub __nusers: ::std::os::raw::c_uint,
    pub __kind: ::std::os::raw::c_int,
    pub __spins: ::std::os::raw::c_short,
    pub __elision: ::std::os::raw::c_short,
    pub __list: __pthread_list_t,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct __pthread_cond_s {
    pub __bindgen_anon_1: __pthread_cond_s__bindgen_ty_1,
    pub __bindgen_anon_2: __pthread_cond_s__bindgen_ty_2,
    pub __g_refs: [::std::os::raw::c_uint; 2usize],
    pub __g_size: [::std::os::raw::c_uint; 2usize],
    pub __g1_orig_size: ::std::os::raw::c_uint,
    pub __wrefs: ::std::os::raw::c_uint,
    pub __g_signals: [::std::os::raw::c_uint; 2usize],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __pthread_cond_s__bindgen_ty_1 {
    pub __wseq: ::std::os::raw::c_ulonglong,
    pub __wseq32: __pthread_cond_s__bindgen_ty_1__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_cond_s__bindgen_ty_1__bindgen_ty_1 {
    pub __low: ::std::os::raw::c_uint,
    pub __high: ::std::os::raw::c_uint,
}
impl ::std::fmt::Debug for __pthread_cond_s__bindgen_ty_1 {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        write!(f, "__pthread_cond_s__bindgen_ty_1 {{ union }}")
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __pthread_cond_s__bindgen_ty_2 {
    pub __g1_start: ::std::os::raw::c_ulonglong,
    pub __g1_start32: __pthread_cond_s__bindgen_ty_2__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_cond_s__bindgen_ty_2__bindgen_ty_1 {
    pub __low: ::std::os::raw::c_uint,
    pub __high: ::std::os::raw::c_uint,
}
impl ::std::fmt::Debug for __pthread_cond_s__bindgen_ty_2 {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        write!(f, "__pthread_cond_s__bindgen_ty_2 {{ union }}")
    }
}
impl ::std::fmt::Debug for __pthread_cond_s {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        write ! (f , "__pthread_cond_s {{ __bindgen_anon_1: {:?}, __bindgen_anon_2: {:?}, __g_refs: {:?}, __g_size: {:?}, __g1_orig_size: {:?}, __wrefs: {:?}, __g_signals: {:?} }}" , self . __bindgen_anon_1 , self . __bindgen_anon_2 , self . __g_refs , self . __g_size , self . __g1_orig_size , self . __wrefs , self . __g_signals)
    }
}
pub type pthread_t = usize;
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_mutex_t {
    pub __data: __pthread_mutex_s,
    pub __size: [::std::os::raw::c_char; 40usize],
    pub __align: ::std::os::raw::c_long,
}
impl ::std::fmt::Debug for pthread_mutex_t {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        write!(f, "pthread_mutex_t {{ union }}")
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_cond_t {
    pub __data: __pthread_cond_s,
    pub __size: [::std::os::raw::c_char; 48usize],
    pub __align: ::std::os::raw::c_longlong,
}
impl ::std::fmt::Debug for pthread_cond_t {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        write!(f, "pthread_cond_t {{ union }}")
    }
}
pub type VALUE = usize;
pub type ID = usize;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RBasic {
    pub flags: VALUE,
    pub klass: VALUE,
}
pub type rb_classext_t = rb_classext_struct;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct RString {
    pub basic: 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],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct RString__bindgen_ty_1__bindgen_ty_1 {
    pub len: ::std::os::raw::c_long,
    pub ptr: *mut ::std::os::raw::c_char,
    pub aux: RString__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union RString__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
    pub capa: ::std::os::raw::c_long,
    pub shared: VALUE,
}
impl ::std::fmt::Debug for RString__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        write!(
            f,
            "RString__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {{ union }}"
        )
    }
}
impl ::std::fmt::Debug for RString__bindgen_ty_1__bindgen_ty_1 {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        write!(
            f,
            "RString__bindgen_ty_1__bindgen_ty_1 {{ len: {:?}, ptr: {:?}, aux: {:?} }}",
            self.len, self.ptr, self.aux
        )
    }
}
impl ::std::fmt::Debug for RString__bindgen_ty_1 {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        write!(f, "RString__bindgen_ty_1 {{ union }}")
    }
}
impl ::std::fmt::Debug for RString {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        write!(
            f,
            "RString {{ basic: {:?}, as: {:?} }}",
            self.basic, self.as_
        )
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct RArray {
    pub basic: 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,
    pub ary: [VALUE; 3usize],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct RArray__bindgen_ty_1__bindgen_ty_1 {
    pub len: ::std::os::raw::c_long,
    pub aux: RArray__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
    pub ptr: *const VALUE,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union RArray__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
    pub capa: ::std::os::raw::c_long,
    pub shared: VALUE,
}
impl ::std::fmt::Debug for RArray__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        write!(
            f,
            "RArray__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {{ union }}"
        )
    }
}
impl ::std::fmt::Debug for RArray__bindgen_ty_1__bindgen_ty_1 {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        write!(
            f,
            "RArray__bindgen_ty_1__bindgen_ty_1 {{ len: {:?}, aux: {:?}, ptr: {:?} }}",
            self.len, self.aux, self.ptr
        )
    }
}
impl ::std::fmt::Debug for RArray__bindgen_ty_1 {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        write!(f, "RArray__bindgen_ty_1 {{ union }}")
    }
}
impl ::std::fmt::Debug for RArray {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        write!(
            f,
            "RArray {{ basic: {:?}, as: {:?} }}",
            self.basic, self.as_
        )
    }
}
#[repr(C)]
#[derive(Debug)]
pub struct rb_global_variable {
    _unused: [u8; 0],
}
pub type st_data_t = usize;
pub type st_index_t = st_data_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct st_hash_type {
    pub compare: ::std::option::Option<unsafe extern "C" fn() -> ::std::os::raw::c_int>,
    pub hash: ::std::option::Option<unsafe extern "C" fn() -> st_index_t>,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct st_table {
    pub type_: *const st_hash_type,
    pub num_bins: st_index_t,
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
    pub as_: st_table__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union st_table__bindgen_ty_1 {
    pub big: st_table__bindgen_ty_1__bindgen_ty_1,
    pub packed: st_table__bindgen_ty_1__bindgen_ty_2,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct st_table__bindgen_ty_1__bindgen_ty_1 {
    pub bins: *mut *mut st_table_entry,
    pub head: *mut st_table_entry,
    pub tail: *mut st_table_entry,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct st_table__bindgen_ty_1__bindgen_ty_2 {
    pub entries: *mut st_packed_entry,
    pub real_entries: st_index_t,
}
impl ::std::fmt::Debug for st_table__bindgen_ty_1 {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        write!(f, "st_table__bindgen_ty_1 {{ union }}")
    }
}
impl ::std::fmt::Debug for st_table {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        write ! (f , "st_table {{ type: {:?}, num_bins: {:?}, entries_packed : {:?}, num_entries : {:?}, as: {:?} }}" , self . type_ , self . num_bins , self . entries_packed () , self . num_entries () , self . as_)
    }
}
impl st_table {
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn entries_packed(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<0usize, 1u8>() as u32) }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn set_entries_packed(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set_const::<0usize, 1u8>(val as u64)
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub unsafe fn entries_packed_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get_const::<0usize, 1u8>(
                    ::std::ptr::addr_of!((*this)._bitfield_1),
                ) as u32,
            )
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub unsafe fn set_entries_packed_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set_const::<0usize, 1u8>(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                val as u64,
            )
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn num_entries(&self) -> st_index_t {
        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<1usize, 63u8>() as u64) }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn set_num_entries(&mut self, val: st_index_t) {
        unsafe {
            let val: usize = ::std::mem::transmute(val);
            self._bitfield_1.set_const::<1usize, 63u8>(val as u64)
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub unsafe fn num_entries_raw(this: *const Self) -> st_index_t {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get_const::<1usize, 63u8>(
                    ::std::ptr::addr_of!((*this)._bitfield_1),
                ) as u64,
            )
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub unsafe fn set_num_entries_raw(this: *mut Self, val: st_index_t) {
        unsafe {
            let val: usize = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set_const::<1usize, 63u8>(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                val as u64,
            )
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn new_bitfield_1(
        entries_packed: ::std::os::raw::c_uint,
        num_entries: st_index_t,
    ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
        __bindgen_bitfield_unit.set_const::<0usize, 1u8>({
            let entries_packed: u32 = unsafe { ::std::mem::transmute(entries_packed) };
            entries_packed as u64
        });
        __bindgen_bitfield_unit.set_const::<1usize, 63u8>({
            let num_entries: usize = unsafe { ::std::mem::transmute(num_entries) };
            num_entries as u64
        });
        __bindgen_bitfield_unit
    }
}
pub type rb_alloc_func_t = ::std::option::Option<unsafe extern "C" fn(arg1: VALUE) -> VALUE>;
pub type rb_unblock_function_t =
    ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>;
pub type rb_event_flag_t = u32;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct RNode {
    pub flags: VALUE,
    pub nd_reserved: VALUE,
    pub u1: RNode__bindgen_ty_1,
    pub u2: RNode__bindgen_ty_2,
    pub u3: RNode__bindgen_ty_3,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union RNode__bindgen_ty_1 {
    pub node: *mut RNode,
    pub id: ID,
    pub value: VALUE,
    pub cfunc: ::std::option::Option<unsafe extern "C" fn() -> VALUE>,
    pub tbl: *mut ID,
}
impl ::std::fmt::Debug for RNode__bindgen_ty_1 {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        write!(f, "RNode__bindgen_ty_1 {{ union }}")
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union RNode__bindgen_ty_2 {
    pub node: *mut RNode,
    pub id: ID,
    pub argc: ::std::os::raw::c_long,
    pub value: VALUE,
}
impl ::std::fmt::Debug for RNode__bindgen_ty_2 {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        write!(f, "RNode__bindgen_ty_2 {{ union }}")
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union RNode__bindgen_ty_3 {
    pub node: *mut RNode,
    pub id: ID,
    pub state: ::std::os::raw::c_long,
    pub entry: *mut rb_global_entry,
    pub args: *mut rb_args_info,
    pub cnt: ::std::os::raw::c_long,
    pub value: VALUE,
}
impl ::std::fmt::Debug for RNode__bindgen_ty_3 {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        write!(f, "RNode__bindgen_ty_3 {{ union }}")
    }
}
impl ::std::fmt::Debug for RNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        write!(
            f,
            "RNode {{ flags: {:?}, nd_reserved: {:?}, u1: {:?}, u2: {:?}, u3: {:?} }}",
            self.flags, self.nd_reserved, self.u1, self.u2, self.u3
        )
    }
}
pub type NODE = RNode;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rb_global_entry {
    pub var: *mut rb_global_variable,
    pub id: ID,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rb_args_info {
    pub pre_init: *mut NODE,
    pub post_init: *mut NODE,
    pub pre_args_num: ::std::os::raw::c_int,
    pub post_args_num: ::std::os::raw::c_int,
    pub first_post_arg: ID,
    pub rest_arg: ID,
    pub block_arg: ID,
    pub kw_args: *mut NODE,
    pub kw_rest_arg: *mut NODE,
    pub opt_args: *mut NODE,
}
pub const ruby_id_types_RUBY_ID_STATIC_SYM: ruby_id_types = 1;
pub const ruby_id_types_RUBY_ID_LOCAL: ruby_id_types = 0;
pub const ruby_id_types_RUBY_ID_INSTANCE: ruby_id_types = 2;
pub const ruby_id_types_RUBY_ID_GLOBAL: ruby_id_types = 6;
pub const ruby_id_types_RUBY_ID_ATTRSET: ruby_id_types = 8;
pub const ruby_id_types_RUBY_ID_CONST: ruby_id_types = 10;
pub const ruby_id_types_RUBY_ID_CLASS: ruby_id_types = 12;
pub const ruby_id_types_RUBY_ID_JUNK: ruby_id_types = 14;
pub const ruby_id_types_RUBY_ID_INTERNAL: ruby_id_types = 14;
pub const ruby_id_types_RUBY_ID_SCOPE_SHIFT: ruby_id_types = 4;
pub const ruby_id_types_RUBY_ID_SCOPE_MASK: ruby_id_types = 14;
pub type ruby_id_types = ::std::os::raw::c_uint;
pub const ruby_method_ids_idDot2: ruby_method_ids = 128;
pub const ruby_method_ids_idDot3: ruby_method_ids = 129;
pub const ruby_method_ids_idUPlus: ruby_method_ids = 130;
pub const ruby_method_ids_idUMinus: ruby_method_ids = 131;
pub const ruby_method_ids_idPow: ruby_method_ids = 132;
pub const ruby_method_ids_idCmp: ruby_method_ids = 134;
pub const ruby_method_ids_idPLUS: ruby_method_ids = 43;
pub const ruby_method_ids_idMINUS: ruby_method_ids = 45;
pub const ruby_method_ids_idMULT: ruby_method_ids = 42;
pub const ruby_method_ids_idDIV: ruby_method_ids = 47;
pub const ruby_method_ids_idMOD: ruby_method_ids = 37;
pub const ruby_method_ids_idLT: ruby_method_ids = 60;
pub const ruby_method_ids_idLTLT: ruby_method_ids = 135;
pub const ruby_method_ids_idLE: ruby_method_ids = 137;
pub const ruby_method_ids_idGT: ruby_method_ids = 62;
pub const ruby_method_ids_idGTGT: ruby_method_ids = 136;
pub const ruby_method_ids_idGE: ruby_method_ids = 138;
pub const ruby_method_ids_idEq: ruby_method_ids = 139;
pub const ruby_method_ids_idEqq: ruby_method_ids = 140;
pub const ruby_method_ids_idNeq: ruby_method_ids = 141;
pub const ruby_method_ids_idNot: ruby_method_ids = 33;
pub const ruby_method_ids_idBackquote: ruby_method_ids = 96;
pub const ruby_method_ids_idEqTilde: ruby_method_ids = 142;
pub const ruby_method_ids_idNeqTilde: ruby_method_ids = 143;
pub const ruby_method_ids_idAREF: ruby_method_ids = 144;
pub const ruby_method_ids_idASET: ruby_method_ids = 145;
pub const ruby_method_ids_idCOLON2: ruby_method_ids = 146;
pub const ruby_method_ids_idANDOP: ruby_method_ids = 148;
pub const ruby_method_ids_idOROP: ruby_method_ids = 149;
pub const ruby_method_ids_tPRESERVED_ID_BEGIN: ruby_method_ids = 149;
pub const ruby_method_ids_idNULL: ruby_method_ids = 150;
pub const ruby_method_ids_idEmptyP: ruby_method_ids = 151;
pub const ruby_method_ids_idEqlP: ruby_method_ids = 152;
pub const ruby_method_ids_idRespond_to: ruby_method_ids = 153;
pub const ruby_method_ids_idRespond_to_missing: ruby_method_ids = 154;
pub const ruby_method_ids_idIFUNC: ruby_method_ids = 155;
pub const ruby_method_ids_idCFUNC: ruby_method_ids = 156;
pub const ruby_method_ids_id_core_set_method_alias: ruby_method_ids = 157;
pub const ruby_method_ids_id_core_set_variable_alias: ruby_method_ids = 158;
pub const ruby_method_ids_id_core_undef_method: ruby_method_ids = 159;
pub const ruby_method_ids_id_core_define_method: ruby_method_ids = 160;
pub const ruby_method_ids_id_core_define_singleton_method: ruby_method_ids = 161;
pub const ruby_method_ids_id_core_set_postexe: ruby_method_ids = 162;
pub const ruby_method_ids_id_core_hash_from_ary: ruby_method_ids = 163;
pub const ruby_method_ids_id_core_hash_merge_ary: ruby_method_ids = 164;
pub const ruby_method_ids_id_core_hash_merge_ptr: ruby_method_ids = 165;
pub const ruby_method_ids_id_core_hash_merge_kwd: ruby_method_ids = 166;
pub const ruby_method_ids_tPRESERVED_ID_END: ruby_method_ids = 167;
pub const ruby_method_ids_tFreeze: ruby_method_ids = 168;
pub const ruby_method_ids_tInspect: ruby_method_ids = 169;
pub const ruby_method_ids_tIntern: ruby_method_ids = 170;
pub const ruby_method_ids_tObject_id: ruby_method_ids = 171;
pub const ruby_method_ids_tConst_missing: ruby_method_ids = 172;
pub const ruby_method_ids_tMethodMissing: ruby_method_ids = 173;
pub const ruby_method_ids_tMethod_added: ruby_method_ids = 174;
pub const ruby_method_ids_tSingleton_method_added: ruby_method_ids = 175;
pub const ruby_method_ids_tMethod_removed: ruby_method_ids = 176;
pub const ruby_method_ids_tSingleton_method_removed: ruby_method_ids = 177;
pub const ruby_method_ids_tMethod_undefined: ruby_method_ids = 178;
pub const ruby_method_ids_tSingleton_method_undefined: ruby_method_ids = 179;
pub const ruby_method_ids_tLength: ruby_method_ids = 180;
pub const ruby_method_ids_tSize: ruby_method_ids = 181;
pub const ruby_method_ids_tGets: ruby_method_ids = 182;
pub const ruby_method_ids_tSucc: ruby_method_ids = 183;
pub const ruby_method_ids_tEach: ruby_method_ids = 184;
pub const ruby_method_ids_tProc: ruby_method_ids = 185;
pub const ruby_method_ids_tLambda: ruby_method_ids = 186;
pub const ruby_method_ids_tSend: ruby_method_ids = 187;
pub const ruby_method_ids_t__send__: ruby_method_ids = 188;
pub const ruby_method_ids_t__attached__: ruby_method_ids = 189;
pub const ruby_method_ids_tInitialize: ruby_method_ids = 190;
pub const ruby_method_ids_tInitialize_copy: ruby_method_ids = 191;
pub const ruby_method_ids_tInitialize_clone: ruby_method_ids = 192;
pub const ruby_method_ids_tInitialize_dup: ruby_method_ids = 193;
pub const ruby_method_ids_tTo_int: ruby_method_ids = 194;
pub const ruby_method_ids_tTo_ary: ruby_method_ids = 195;
pub const ruby_method_ids_tTo_str: ruby_method_ids = 196;
pub const ruby_method_ids_tTo_sym: ruby_method_ids = 197;
pub const ruby_method_ids_tTo_hash: ruby_method_ids = 198;
pub const ruby_method_ids_tTo_proc: ruby_method_ids = 199;
pub const ruby_method_ids_tTo_io: ruby_method_ids = 200;
pub const ruby_method_ids_tTo_a: ruby_method_ids = 201;
pub const ruby_method_ids_tTo_s: ruby_method_ids = 202;
pub const ruby_method_ids_tTo_i: ruby_method_ids = 203;
pub const ruby_method_ids_tBt: ruby_method_ids = 204;
pub const ruby_method_ids_tBt_locations: ruby_method_ids = 205;
pub const ruby_method_ids_tCall: ruby_method_ids = 206;
pub const ruby_method_ids_tMesg: ruby_method_ids = 207;
pub const ruby_method_ids_tException: ruby_method_ids = 208;
pub const ruby_method_ids_tUScore: ruby_method_ids = 209;
pub const ruby_method_ids_tNEXT_ID: ruby_method_ids = 210;
pub const ruby_method_ids_idFreeze: ruby_method_ids = 2689;
pub const ruby_method_ids_idInspect: ruby_method_ids = 2705;
pub const ruby_method_ids_idIntern: ruby_method_ids = 2721;
pub const ruby_method_ids_idObject_id: ruby_method_ids = 2737;
pub const ruby_method_ids_idConst_missing: ruby_method_ids = 2753;
pub const ruby_method_ids_idMethodMissing: ruby_method_ids = 2769;
pub const ruby_method_ids_idMethod_added: ruby_method_ids = 2785;
pub const ruby_method_ids_idSingleton_method_added: ruby_method_ids = 2801;
pub const ruby_method_ids_idMethod_removed: ruby_method_ids = 2817;
pub const ruby_method_ids_idSingleton_method_removed: ruby_method_ids = 2833;
pub const ruby_method_ids_idMethod_undefined: ruby_method_ids = 2849;
pub const ruby_method_ids_idSingleton_method_undefined: ruby_method_ids = 2865;
pub const ruby_method_ids_idLength: ruby_method_ids = 2881;
pub const ruby_method_ids_idSize: ruby_method_ids = 2897;
pub const ruby_method_ids_idGets: ruby_method_ids = 2913;
pub const ruby_method_ids_idSucc: ruby_method_ids = 2929;
pub const ruby_method_ids_idEach: ruby_method_ids = 2945;
pub const ruby_method_ids_idProc: ruby_method_ids = 2961;
pub const ruby_method_ids_idLambda: ruby_method_ids = 2977;
pub const ruby_method_ids_idSend: ruby_method_ids = 2993;
pub const ruby_method_ids_id__send__: ruby_method_ids = 3009;
pub const ruby_method_ids_id__attached__: ruby_method_ids = 3025;
pub const ruby_method_ids_idInitialize: ruby_method_ids = 3041;
pub const ruby_method_ids_idInitialize_copy: ruby_method_ids = 3057;
pub const ruby_method_ids_idInitialize_clone: ruby_method_ids = 3073;
pub const ruby_method_ids_idInitialize_dup: ruby_method_ids = 3089;
pub const ruby_method_ids_idTo_int: ruby_method_ids = 3105;
pub const ruby_method_ids_idTo_ary: ruby_method_ids = 3121;
pub const ruby_method_ids_idTo_str: ruby_method_ids = 3137;
pub const ruby_method_ids_idTo_sym: ruby_method_ids = 3153;
pub const ruby_method_ids_idTo_hash: ruby_method_ids = 3169;
pub const ruby_method_ids_idTo_proc: ruby_method_ids = 3185;
pub const ruby_method_ids_idTo_io: ruby_method_ids = 3201;
pub const ruby_method_ids_idTo_a: ruby_method_ids = 3217;
pub const ruby_method_ids_idTo_s: ruby_method_ids = 3233;
pub const ruby_method_ids_idTo_i: ruby_method_ids = 3249;
pub const ruby_method_ids_idBt: ruby_method_ids = 3265;
pub const ruby_method_ids_idBt_locations: ruby_method_ids = 3281;
pub const ruby_method_ids_idCall: ruby_method_ids = 3297;
pub const ruby_method_ids_idMesg: ruby_method_ids = 3313;
pub const ruby_method_ids_idException: ruby_method_ids = 3329;
pub const ruby_method_ids_idUScore: ruby_method_ids = 3345;
pub const ruby_method_ids_tLAST_OP_ID: ruby_method_ids = 166;
pub const ruby_method_ids_idLAST_OP_ID: ruby_method_ids = 10;
pub type ruby_method_ids = ::std::os::raw::c_uint;
pub type rb_subclass_entry_t = rb_subclass_entry;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rb_subclass_entry {
    pub klass: VALUE,
    pub next: *mut rb_subclass_entry_t,
}
pub type rb_serial_t = ::std::os::raw::c_ulonglong;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rb_classext_struct {
    pub iv_index_tbl: *mut st_table,
    pub iv_tbl: *mut st_table,
    pub const_tbl: *mut st_table,
    pub subclasses: *mut rb_subclass_entry_t,
    pub parent_subclasses: *mut *mut rb_subclass_entry_t,
    pub module_subclasses: *mut *mut rb_subclass_entry_t,
    pub class_serial: rb_serial_t,
    pub origin: VALUE,
    pub refined_class: VALUE,
    pub allocator: rb_alloc_func_t,
}
pub const rb_method_flag_t_NOEX_PUBLIC: rb_method_flag_t = 0;
pub const rb_method_flag_t_NOEX_NOSUPER: rb_method_flag_t = 1;
pub const rb_method_flag_t_NOEX_PRIVATE: rb_method_flag_t = 2;
pub const rb_method_flag_t_NOEX_PROTECTED: rb_method_flag_t = 4;
pub const rb_method_flag_t_NOEX_MASK: rb_method_flag_t = 6;
pub const rb_method_flag_t_NOEX_BASIC: rb_method_flag_t = 8;
pub const rb_method_flag_t_NOEX_UNDEF: rb_method_flag_t = 1;
pub const rb_method_flag_t_NOEX_MODFUNC: rb_method_flag_t = 18;
pub const rb_method_flag_t_NOEX_SUPER: rb_method_flag_t = 32;
pub const rb_method_flag_t_NOEX_VCALL: rb_method_flag_t = 64;
pub const rb_method_flag_t_NOEX_RESPONDS: rb_method_flag_t = 128;
pub const rb_method_flag_t_NOEX_BIT_WIDTH: rb_method_flag_t = 8;
pub const rb_method_flag_t_NOEX_SAFE_SHIFT_OFFSET: rb_method_flag_t = 8;
pub type rb_method_flag_t = ::std::os::raw::c_uint;
pub const rb_method_type_t_VM_METHOD_TYPE_ISEQ: rb_method_type_t = 0;
pub const rb_method_type_t_VM_METHOD_TYPE_CFUNC: rb_method_type_t = 1;
pub const rb_method_type_t_VM_METHOD_TYPE_ATTRSET: rb_method_type_t = 2;
pub const rb_method_type_t_VM_METHOD_TYPE_IVAR: rb_method_type_t = 3;
pub const rb_method_type_t_VM_METHOD_TYPE_BMETHOD: rb_method_type_t = 4;
pub const rb_method_type_t_VM_METHOD_TYPE_ZSUPER: rb_method_type_t = 5;
pub const rb_method_type_t_VM_METHOD_TYPE_UNDEF: rb_method_type_t = 6;
pub const rb_method_type_t_VM_METHOD_TYPE_NOTIMPLEMENTED: rb_method_type_t = 7;
pub const rb_method_type_t_VM_METHOD_TYPE_OPTIMIZED: rb_method_type_t = 8;
pub const rb_method_type_t_VM_METHOD_TYPE_MISSING: rb_method_type_t = 9;
pub const rb_method_type_t_VM_METHOD_TYPE_REFINED: rb_method_type_t = 10;
pub type rb_method_type_t = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rb_method_cfunc_struct {
    pub func: ::std::option::Option<unsafe extern "C" fn() -> VALUE>,
    pub invoker: ::std::option::Option<
        unsafe extern "C" fn(
            func: ::std::option::Option<unsafe extern "C" fn() -> VALUE>,
            recv: VALUE,
            argc: ::std::os::raw::c_int,
            argv: *const VALUE,
        ) -> VALUE,
    >,
    pub argc: ::std::os::raw::c_int,
}
pub type rb_method_cfunc_t = rb_method_cfunc_struct;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rb_method_attr_struct {
    pub id: ID,
    pub location: VALUE,
}
pub type rb_method_attr_t = rb_method_attr_struct;
pub type rb_iseq_t = rb_iseq_struct;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct rb_method_definition_struct {
    pub type_: rb_method_type_t,
    pub alias_count: ::std::os::raw::c_int,
    pub original_id: ID,
    pub body: rb_method_definition_struct__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union rb_method_definition_struct__bindgen_ty_1 {
    pub iseq: *mut rb_iseq_t,
    pub cfunc: rb_method_cfunc_t,
    pub attr: rb_method_attr_t,
    pub proc_: VALUE,
    pub optimize_type: rb_method_definition_struct__bindgen_ty_1_method_optimized_type,
    pub orig_me: *mut rb_method_entry_struct,
}
pub const rb_method_definition_struct__bindgen_ty_1_method_optimized_type_OPTIMIZED_METHOD_TYPE_SEND : rb_method_definition_struct__bindgen_ty_1_method_optimized_type = 0 ;
pub const rb_method_definition_struct__bindgen_ty_1_method_optimized_type_OPTIMIZED_METHOD_TYPE_CALL : rb_method_definition_struct__bindgen_ty_1_method_optimized_type = 1 ;
pub const rb_method_definition_struct__bindgen_ty_1_method_optimized_type_OPTIMIZED_METHOD_TYPE__MAX : rb_method_definition_struct__bindgen_ty_1_method_optimized_type = 2 ;
pub type rb_method_definition_struct__bindgen_ty_1_method_optimized_type = ::std::os::raw::c_uint;
impl ::std::fmt::Debug for rb_method_definition_struct__bindgen_ty_1 {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        write!(f, "rb_method_definition_struct__bindgen_ty_1 {{ union }}")
    }
}
pub type rb_method_definition_t = rb_method_definition_struct;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rb_method_entry_struct {
    pub flag: rb_method_flag_t,
    pub mark: ::std::os::raw::c_char,
    pub def: *mut rb_method_definition_t,
    pub called_id: ID,
    pub klass: VALUE,
}
pub type rb_method_entry_t = rb_method_entry_struct;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct unlinked_method_entry_list_entry {
    pub next: *mut unlinked_method_entry_list_entry,
    pub me: *mut rb_method_entry_t,
}
pub type rb_atomic_t = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct list_node {
    pub next: *mut list_node,
    pub prev: *mut list_node,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct list_head {
    pub n: list_node,
}
pub type __jmp_buf = [::std::os::raw::c_long; 8usize];
pub type rb_nativethread_id_t = pthread_t;
pub type rb_nativethread_lock_t = pthread_mutex_t;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct rb_thread_cond_struct {
    pub cond: pthread_cond_t,
    pub clockid: clockid_t,
}
impl ::std::fmt::Debug for rb_thread_cond_struct {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        write!(
            f,
            "rb_thread_cond_struct {{ cond: {:?}, clockid: {:?} }}",
            self.cond, self.clockid
        )
    }
}
pub type rb_nativethread_cond_t = rb_thread_cond_struct;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct native_thread_data_struct {
    pub signal_thread_list: *mut ::std::os::raw::c_void,
    pub sleep_cond: rb_nativethread_cond_t,
}
impl ::std::fmt::Debug for native_thread_data_struct {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        write!(
            f,
            "native_thread_data_struct {{ signal_thread_list: {:?}, sleep_cond: {:?} }}",
            self.signal_thread_list, self.sleep_cond
        )
    }
}
pub type native_thread_data_t = native_thread_data_struct;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct rb_global_vm_lock_struct {
    pub acquired: ::std::os::raw::c_ulong,
    pub lock: rb_nativethread_lock_t,
    pub waiting: ::std::os::raw::c_ulong,
    pub cond: rb_nativethread_cond_t,
    pub switch_cond: rb_nativethread_cond_t,
    pub switch_wait_cond: rb_nativethread_cond_t,
    pub need_yield: ::std::os::raw::c_int,
    pub wait_yield: ::std::os::raw::c_int,
}
impl ::std::fmt::Debug for rb_global_vm_lock_struct {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        write ! (f , "rb_global_vm_lock_struct {{ acquired: {:?}, lock: {:?}, waiting: {:?}, cond: {:?}, switch_cond: {:?}, switch_wait_cond: {:?}, need_yield: {:?}, wait_yield: {:?} }}" , self . acquired , self . lock , self . waiting , self . cond , self . switch_cond , self . switch_wait_cond , self . need_yield , self . wait_yield)
    }
}
pub type rb_global_vm_lock_t = rb_global_vm_lock_struct;
#[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];
pub type rb_num_t = usize;
#[repr(C)]
#[derive(Debug)]
pub struct iseq_compile_data_ensure_node_stack {
    _unused: [u8; 0],
}
pub type rb_compile_option_t = rb_compile_option_struct;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct iseq_inline_cache_entry {
    pub ic_serial: rb_serial_t,
    pub ic_value: iseq_inline_cache_entry__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union iseq_inline_cache_entry__bindgen_ty_1 {
    pub index: usize,
    pub value: VALUE,
}
impl ::std::fmt::Debug for iseq_inline_cache_entry__bindgen_ty_1 {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        write!(f, "iseq_inline_cache_entry__bindgen_ty_1 {{ union }}")
    }
}
impl ::std::fmt::Debug for iseq_inline_cache_entry {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        write!(
            f,
            "iseq_inline_cache_entry {{ ic_serial: {:?}, ic_value: {:?} }}",
            self.ic_serial, self.ic_value
        )
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union iseq_inline_storage_entry {
    pub once: iseq_inline_storage_entry__bindgen_ty_1,
    pub cache: iseq_inline_cache_entry,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct iseq_inline_storage_entry__bindgen_ty_1 {
    pub running_thread: *mut rb_thread_struct,
    pub value: VALUE,
}
impl ::std::fmt::Debug for iseq_inline_storage_entry {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        write!(f, "iseq_inline_storage_entry {{ union }}")
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rb_call_info_kw_arg_struct {
    pub keyword_len: ::std::os::raw::c_int,
    pub keywords: [VALUE; 1usize],
}
pub type rb_call_info_kw_arg_t = rb_call_info_kw_arg_struct;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct rb_call_info_struct {
    pub mid: ID,
    pub flag: ::std::os::raw::c_uint,
    pub orig_argc: ::std::os::raw::c_int,
    pub blockiseq: *mut rb_iseq_t,
    pub kw_arg: *mut rb_call_info_kw_arg_t,
    pub method_state: rb_serial_t,
    pub class_serial: rb_serial_t,
    pub klass: VALUE,
    pub me: *const rb_method_entry_t,
    pub defined_class: VALUE,
    pub blockptr: *mut rb_block_struct,
    pub recv: VALUE,
    pub argc: ::std::os::raw::c_int,
    pub aux: rb_call_info_struct__bindgen_ty_1,
    pub call: ::std::option::Option<
        unsafe extern "C" fn(
            th: *mut rb_thread_struct,
            cfp: *mut rb_control_frame_struct,
            ci: *mut rb_call_info_struct,
        ) -> VALUE,
    >,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union rb_call_info_struct__bindgen_ty_1 {
    pub opt_pc: ::std::os::raw::c_int,
    pub index: ::std::os::raw::c_int,
    pub missing_reason: ::std::os::raw::c_int,
    pub inc_sp: ::std::os::raw::c_int,
}
impl ::std::fmt::Debug for rb_call_info_struct__bindgen_ty_1 {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        write!(f, "rb_call_info_struct__bindgen_ty_1 {{ union }}")
    }
}
impl ::std::fmt::Debug for rb_call_info_struct {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        write ! (f , "rb_call_info_struct {{ mid: {:?}, flag: {:?}, orig_argc: {:?}, blockiseq: {:?}, kw_arg: {:?}, method_state: {:?}, class_serial: {:?}, klass: {:?}, me: {:?}, defined_class: {:?}, blockptr: {:?}, recv: {:?}, argc: {:?}, aux: {:?}, call: {:?} }}" , self . mid , self . flag , self . orig_argc , self . blockiseq , self . kw_arg , self . method_state , self . class_serial , self . klass , self . me , self . defined_class , self . blockptr , self . recv , self . argc , self . aux , self . call)
    }
}
pub type rb_call_info_t = rb_call_info_struct;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rb_iseq_location_struct {
    pub path: VALUE,
    pub absolute_path: VALUE,
    pub base_label: VALUE,
    pub label: VALUE,
    pub first_lineno: VALUE,
}
pub type rb_iseq_location_t = rb_iseq_location_struct;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rb_iseq_struct {
    pub type_: rb_iseq_struct_iseq_type,
    pub stack_max: ::std::os::raw::c_int,
    pub location: rb_iseq_location_t,
    pub iseq_encoded: *mut VALUE,
    pub iseq_size: ::std::os::raw::c_uint,
    pub line_info_size: ::std::os::raw::c_uint,
    pub mark_ary: VALUE,
    pub coverage: VALUE,
    pub line_info_table: *mut iseq_line_info_entry,
    pub local_table: *mut ID,
    pub local_table_size: ::std::os::raw::c_int,
    pub local_size: ::std::os::raw::c_int,
    pub is_entries: *mut iseq_inline_storage_entry,
    pub is_size: ::std::os::raw::c_int,
    pub callinfo_size: ::std::os::raw::c_int,
    pub callinfo_entries: *mut rb_call_info_t,
    pub param: rb_iseq_struct__bindgen_ty_1,
    pub catch_table: *mut iseq_catch_table,
    pub parent_iseq: *mut rb_iseq_struct,
    pub local_iseq: *mut rb_iseq_struct,
    pub self_: VALUE,
    pub orig: VALUE,
    pub cref_stack: *mut NODE,
    pub klass: VALUE,
    pub defined_method_id: ID,
    pub flip_cnt: rb_num_t,
    pub compile_data: *mut iseq_compile_data,
    pub iseq: *mut VALUE,
}
pub const rb_iseq_struct_iseq_type_ISEQ_TYPE_TOP: rb_iseq_struct_iseq_type = 0;
pub const rb_iseq_struct_iseq_type_ISEQ_TYPE_METHOD: rb_iseq_struct_iseq_type = 1;
pub const rb_iseq_struct_iseq_type_ISEQ_TYPE_BLOCK: rb_iseq_struct_iseq_type = 2;
pub const rb_iseq_struct_iseq_type_ISEQ_TYPE_CLASS: rb_iseq_struct_iseq_type = 3;
pub const rb_iseq_struct_iseq_type_ISEQ_TYPE_RESCUE: rb_iseq_struct_iseq_type = 4;
pub const rb_iseq_struct_iseq_type_ISEQ_TYPE_ENSURE: rb_iseq_struct_iseq_type = 5;
pub const rb_iseq_struct_iseq_type_ISEQ_TYPE_EVAL: rb_iseq_struct_iseq_type = 6;
pub const rb_iseq_struct_iseq_type_ISEQ_TYPE_MAIN: rb_iseq_struct_iseq_type = 7;
pub const rb_iseq_struct_iseq_type_ISEQ_TYPE_DEFINED_GUARD: rb_iseq_struct_iseq_type = 8;
pub type rb_iseq_struct_iseq_type = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rb_iseq_struct__bindgen_ty_1 {
    pub flags: rb_iseq_struct__bindgen_ty_1__bindgen_ty_1,
    pub size: ::std::os::raw::c_int,
    pub lead_num: ::std::os::raw::c_int,
    pub opt_num: ::std::os::raw::c_int,
    pub rest_start: ::std::os::raw::c_int,
    pub post_start: ::std::os::raw::c_int,
    pub post_num: ::std::os::raw::c_int,
    pub block_start: ::std::os::raw::c_int,
    pub opt_table: *mut VALUE,
    pub keyword: *mut rb_iseq_struct__bindgen_ty_1_rb_iseq_param_keyword,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rb_iseq_struct__bindgen_ty_1__bindgen_ty_1 {
    pub _bindgen_align: [u32; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
    pub __bindgen_padding_0: [u8; 3usize],
}
impl rb_iseq_struct__bindgen_ty_1__bindgen_ty_1 {
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn has_lead(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<0usize, 1u8>() as u32) }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn set_has_lead(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set_const::<0usize, 1u8>(val as u64)
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub unsafe fn has_lead_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get_const::<0usize, 1u8>(
                    ::std::ptr::addr_of!((*this)._bitfield_1),
                ) as u32,
            )
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub unsafe fn set_has_lead_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set_const::<0usize, 1u8>(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                val as u64,
            )
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn has_opt(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<1usize, 1u8>() as u32) }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn set_has_opt(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set_const::<1usize, 1u8>(val as u64)
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub unsafe fn has_opt_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get_const::<1usize, 1u8>(
                    ::std::ptr::addr_of!((*this)._bitfield_1),
                ) as u32,
            )
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub unsafe fn set_has_opt_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set_const::<1usize, 1u8>(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                val as u64,
            )
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn has_rest(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<2usize, 1u8>() as u32) }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn set_has_rest(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set_const::<2usize, 1u8>(val as u64)
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub unsafe fn has_rest_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get_const::<2usize, 1u8>(
                    ::std::ptr::addr_of!((*this)._bitfield_1),
                ) as u32,
            )
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub unsafe fn set_has_rest_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set_const::<2usize, 1u8>(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                val as u64,
            )
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn has_post(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<3usize, 1u8>() as u32) }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn set_has_post(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set_const::<3usize, 1u8>(val as u64)
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub unsafe fn has_post_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get_const::<3usize, 1u8>(
                    ::std::ptr::addr_of!((*this)._bitfield_1),
                ) as u32,
            )
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub unsafe fn set_has_post_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set_const::<3usize, 1u8>(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                val as u64,
            )
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn has_kw(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<4usize, 1u8>() as u32) }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn set_has_kw(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set_const::<4usize, 1u8>(val as u64)
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub unsafe fn has_kw_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get_const::<4usize, 1u8>(
                    ::std::ptr::addr_of!((*this)._bitfield_1),
                ) as u32,
            )
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub unsafe fn set_has_kw_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set_const::<4usize, 1u8>(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                val as u64,
            )
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn has_kwrest(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<5usize, 1u8>() as u32) }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn set_has_kwrest(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set_const::<5usize, 1u8>(val as u64)
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub unsafe fn has_kwrest_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get_const::<5usize, 1u8>(
                    ::std::ptr::addr_of!((*this)._bitfield_1),
                ) as u32,
            )
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub unsafe fn set_has_kwrest_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set_const::<5usize, 1u8>(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                val as u64,
            )
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn has_block(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<6usize, 1u8>() as u32) }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn set_has_block(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set_const::<6usize, 1u8>(val as u64)
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub unsafe fn has_block_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get_const::<6usize, 1u8>(
                    ::std::ptr::addr_of!((*this)._bitfield_1),
                ) as u32,
            )
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub unsafe fn set_has_block_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set_const::<6usize, 1u8>(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                val as u64,
            )
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn ambiguous_param0(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<7usize, 1u8>() as u32) }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn set_ambiguous_param0(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set_const::<7usize, 1u8>(val as u64)
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub unsafe fn ambiguous_param0_raw(this: *const Self) -> ::std::os::raw::c_uint {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get_const::<7usize, 1u8>(
                    ::std::ptr::addr_of!((*this)._bitfield_1),
                ) as u32,
            )
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub unsafe fn set_ambiguous_param0_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set_const::<7usize, 1u8>(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                val as u64,
            )
        }
    }
    #[inline]
    #[allow(unnecessary_transmutes)]
    pub fn new_bitfield_1(
        has_lead: ::std::os::raw::c_uint,
        has_opt: ::std::os::raw::c_uint,
        has_rest: ::std::os::raw::c_uint,
        has_post: ::std::os::raw::c_uint,
        has_kw: ::std::os::raw::c_uint,
        has_kwrest: ::std::os::raw::c_uint,
        has_block: ::std::os::raw::c_uint,
        ambiguous_param0: ::std::os::raw::c_uint,
    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
        __bindgen_bitfield_unit.set_const::<0usize, 1u8>({
            let has_lead: u32 = unsafe { ::std::mem::transmute(has_lead) };
            has_lead as u64
        });
        __bindgen_bitfield_unit.set_const::<1usize, 1u8>({
            let has_opt: u32 = unsafe { ::std::mem::transmute(has_opt) };
            has_opt as u64
        });
        __bindgen_bitfield_unit.set_const::<2usize, 1u8>({
            let has_rest: u32 = unsafe { ::std::mem::transmute(has_rest) };
            has_rest as u64
        });
        __bindgen_bitfield_unit.set_const::<3usize, 1u8>({
            let has_post: u32 = unsafe { ::std::mem::transmute(has_post) };
            has_post as u64
        });
        __bindgen_bitfield_unit.set_const::<4usize, 1u8>({
            let has_kw: u32 = unsafe { ::std::mem::transmute(has_kw) };
            has_kw as u64
        });
        __bindgen_bitfield_unit.set_const::<5usize, 1u8>({
            let has_kwrest: u32 = unsafe { ::std::mem::transmute(has_kwrest) };
            has_kwrest as u64
        });
        __bindgen_bitfield_unit.set_const::<6usize, 1u8>({
            let has_block: u32 = unsafe { ::std::mem::transmute(has_block) };
            has_block as u64
        });
        __bindgen_bitfield_unit.set_const::<7usize, 1u8>({
            let ambiguous_param0: u32 = unsafe { ::std::mem::transmute(ambiguous_param0) };
            ambiguous_param0 as u64
        });
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rb_iseq_struct__bindgen_ty_1_rb_iseq_param_keyword {
    pub num: ::std::os::raw::c_int,
    pub required_num: ::std::os::raw::c_int,
    pub bits_start: ::std::os::raw::c_int,
    pub rest_start: ::std::os::raw::c_int,
    pub table: *mut ID,
    pub default_values: *mut VALUE,
}
#[repr(C)]
#[derive(Debug)]
pub struct rb_objspace {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rb_hook_list_struct {
    pub hooks: *mut rb_event_hook_struct,
    pub events: rb_event_flag_t,
    pub need_clean: ::std::os::raw::c_int,
}
pub type rb_hook_list_t = rb_hook_list_struct;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct rb_vm_struct {
    pub self_: VALUE,
    pub gvl: rb_global_vm_lock_t,
    pub thread_destruct_lock: rb_nativethread_lock_t,
    pub main_thread: *mut rb_thread_struct,
    pub running_thread: *mut rb_thread_struct,
    pub living_threads: list_head,
    pub living_thread_num: usize,
    pub thgroup_default: VALUE,
    pub running: ::std::os::raw::c_int,
    pub thread_abort_on_exception: ::std::os::raw::c_int,
    pub trace_running: ::std::os::raw::c_int,
    pub sleeper: ::std::os::raw::c_int,
    pub mark_object_ary: VALUE,
    pub special_exceptions: [VALUE; 4usize],
    pub top_self: VALUE,
    pub load_path: VALUE,
    pub load_path_snapshot: VALUE,
    pub load_path_check_cache: VALUE,
    pub expanded_load_path: VALUE,
    pub loaded_features: VALUE,
    pub loaded_features_snapshot: VALUE,
    pub loaded_features_index: *mut st_table,
    pub loading_table: *mut st_table,
    pub trap_list: [rb_vm_struct__bindgen_ty_1; 65usize],
    pub event_hooks: rb_hook_list_t,
    pub ensure_rollback_table: *mut st_table,
    pub postponed_job_buffer: *mut rb_postponed_job_struct,
    pub postponed_job_index: ::std::os::raw::c_int,
    pub src_encoding_index: ::std::os::raw::c_int,
    pub verbose: VALUE,
    pub debug: VALUE,
    pub orig_progname: VALUE,
    pub progname: VALUE,
    pub coverages: VALUE,
    pub unlinked_method_entry_list: *mut unlinked_method_entry_list_entry,
    pub defined_module_hash: VALUE,
    pub objspace: *mut rb_objspace,
    pub at_exit: RArray,
    pub defined_strings: *mut VALUE,
    pub frozen_strings: *mut st_table,
    pub default_params: rb_vm_struct__bindgen_ty_2,
    pub redefined_flag: [::std::os::raw::c_short; 22usize],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rb_vm_struct__bindgen_ty_1 {
    pub cmd: VALUE,
    pub safe: ::std::os::raw::c_int,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rb_vm_struct__bindgen_ty_2 {
    pub thread_vm_stack_size: usize,
    pub thread_machine_stack_size: usize,
    pub fiber_vm_stack_size: usize,
    pub fiber_machine_stack_size: usize,
}
impl ::std::fmt::Debug for rb_vm_struct {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        write ! (f , "rb_vm_struct {{ self: {:?}, gvl: {:?}, thread_destruct_lock: {:?}, main_thread: {:?}, running_thread: {:?}, living_threads: {:?}, thgroup_default: {:?}, running: {:?}, thread_abort_on_exception: {:?}, trace_running: {:?}, sleeper: {:?}, mark_object_ary: {:?}, special_exceptions: {:?}, top_self: {:?}, load_path: {:?}, load_path_snapshot: {:?}, load_path_check_cache: {:?}, expanded_load_path: {:?}, loaded_features: {:?}, loaded_features_snapshot: {:?}, loaded_features_index: {:?}, loading_table: {:?}, trap_list: {:?}, event_hooks: {:?}, ensure_rollback_table: {:?}, postponed_job_buffer: {:?}, postponed_job_index: {:?}, src_encoding_index: {:?}, verbose: {:?}, debug: {:?}, orig_progname: {:?}, progname: {:?}, coverages: {:?}, unlinked_method_entry_list: {:?}, defined_module_hash: {:?}, objspace: {:?}, at_exit: {:?}, defined_strings: {:?}, frozen_strings: {:?}, default_params: {:?}, redefined_flag: {:?} }}" , self . self_ , self . gvl , self . thread_destruct_lock , self . main_thread , self . running_thread , self . living_threads , self . thgroup_default , self . running , self . thread_abort_on_exception , self . trace_running , self . sleeper , self . mark_object_ary , self . special_exceptions , self . top_self , self . load_path , self . load_path_snapshot , self . load_path_check_cache , self . expanded_load_path , self . loaded_features , self . loaded_features_snapshot , self . loaded_features_index , self . loading_table , self . trap_list , self . event_hooks , self . ensure_rollback_table , self . postponed_job_buffer , self . postponed_job_index , self . src_encoding_index , self . verbose , self . debug , self . orig_progname , self . progname , self . coverages , self . unlinked_method_entry_list , self . defined_module_hash , self . objspace , self . at_exit , self . defined_strings , self . frozen_strings , self . default_params , self . redefined_flag)
    }
}
pub type rb_vm_t = rb_vm_struct;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rb_control_frame_struct {
    pub pc: *mut VALUE,
    pub sp: *mut VALUE,
    pub iseq: *mut rb_iseq_t,
    pub flag: VALUE,
    pub self_: VALUE,
    pub klass: VALUE,
    pub ep: *mut VALUE,
    pub block_iseq: *mut rb_iseq_t,
    pub proc_: VALUE,
    pub me: *const rb_method_entry_t,
}
pub type rb_control_frame_t = rb_control_frame_struct;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rb_block_struct {
    pub self_: VALUE,
    pub klass: VALUE,
    pub ep: *mut VALUE,
    pub iseq: *mut rb_iseq_t,
    pub proc_: VALUE,
}
pub type rb_block_t = rb_block_struct;
pub const rb_thread_status_THREAD_RUNNABLE: rb_thread_status = 0;
pub const rb_thread_status_THREAD_STOPPED: rb_thread_status = 1;
pub const rb_thread_status_THREAD_STOPPED_FOREVER: rb_thread_status = 2;
pub const rb_thread_status_THREAD_KILLED: rb_thread_status = 3;
pub type rb_thread_status = ::std::os::raw::c_uint;
pub type rb_jmpbuf_t = jmp_buf;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rb_vm_tag {
    pub tag: VALUE,
    pub retval: VALUE,
    pub buf: rb_jmpbuf_t,
    pub prev: *mut rb_vm_tag,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rb_vm_protect_tag {
    pub prev: *mut rb_vm_protect_tag,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rb_unblock_callback {
    pub func: rb_unblock_function_t,
    pub arg: *mut ::std::os::raw::c_void,
}
#[repr(C)]
#[derive(Debug)]
pub struct rb_mutex_struct {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rb_thread_list_struct {
    pub next: *mut rb_thread_list_struct,
    pub th: *mut rb_thread_struct,
}
pub type rb_thread_list_t = rb_thread_list_struct;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rb_ensure_entry {
    pub marker: VALUE,
    pub e_proc: ::std::option::Option<unsafe extern "C" fn() -> VALUE>,
    pub data2: VALUE,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rb_ensure_list {
    pub next: *mut rb_ensure_list,
    pub entry: rb_ensure_entry,
}
pub type rb_ensure_list_t = rb_ensure_list;
#[repr(C)]
#[derive(Debug)]
pub struct rb_fiber_struct {
    _unused: [u8; 0],
}
pub type rb_fiber_t = rb_fiber_struct;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct rb_thread_struct {
    pub vmlt_node: list_node,
    pub self_: VALUE,
    pub vm: *mut rb_vm_t,
    pub stack: *mut VALUE,
    pub stack_size: usize,
    pub cfp: *mut rb_control_frame_t,
    pub safe_level: ::std::os::raw::c_int,
    pub raised_flag: ::std::os::raw::c_int,
    pub last_status: VALUE,
    pub state: ::std::os::raw::c_int,
    pub waiting_fd: ::std::os::raw::c_int,
    pub passed_block: *const rb_block_t,
    pub passed_bmethod_me: *const rb_method_entry_t,
    pub passed_ci: *mut rb_call_info_t,
    pub top_self: VALUE,
    pub top_wrapper: VALUE,
    pub base_block: *mut rb_block_t,
    pub root_lep: *mut VALUE,
    pub root_svar: VALUE,
    pub thread_id: rb_nativethread_id_t,
    pub status: rb_thread_status,
    pub to_kill: ::std::os::raw::c_int,
    pub priority: ::std::os::raw::c_int,
    pub mark_stack_len: ::std::os::raw::c_int,
    pub native_thread_data: native_thread_data_t,
    pub blocking_region_buffer: *mut ::std::os::raw::c_void,
    pub thgroup: VALUE,
    pub value: VALUE,
    pub errinfo: VALUE,
    pub pending_interrupt_queue: VALUE,
    pub pending_interrupt_mask_stack: VALUE,
    pub pending_interrupt_queue_checked: ::std::os::raw::c_int,
    pub interrupt_flag: rb_atomic_t,
    pub interrupt_mask: ::std::os::raw::c_ulong,
    pub interrupt_lock: rb_nativethread_lock_t,
    pub interrupt_cond: rb_nativethread_cond_t,
    pub unblock: rb_unblock_callback,
    pub locking_mutex: VALUE,
    pub keeping_mutexes: *mut rb_mutex_struct,
    pub tag: *mut rb_vm_tag,
    pub protect_tag: *mut rb_vm_protect_tag,
    pub parse_in_eval: ::std::os::raw::c_int,
    pub mild_compile_error: ::std::os::raw::c_int,
    pub local_storage: *mut st_table,
    pub local_storage_recursive_hash: VALUE,
    pub local_storage_recursive_hash_for_trace: VALUE,
    pub join_list: *mut rb_thread_list_t,
    pub first_proc: VALUE,
    pub first_args: VALUE,
    pub first_func: ::std::option::Option<unsafe extern "C" fn() -> VALUE>,
    pub machine: rb_thread_struct__bindgen_ty_1,
    pub stat_insn_usage: VALUE,
    pub event_hooks: rb_hook_list_t,
    pub trace_arg: *mut rb_trace_arg_struct,
    pub fiber: *mut rb_fiber_t,
    pub root_fiber: *mut rb_fiber_t,
    pub root_jmpbuf: rb_jmpbuf_t,
    pub ensure_list: *mut rb_ensure_list_t,
    pub method_missing_reason: ::std::os::raw::c_int,
    pub abort_on_exception: ::std::os::raw::c_int,
    pub altstack: *mut ::std::os::raw::c_void,
    pub running_time_us: ::std::os::raw::c_ulong,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rb_thread_struct__bindgen_ty_1 {
    pub stack_start: *mut VALUE,
    pub stack_end: *mut VALUE,
    pub stack_maxsize: usize,
    pub regs: jmp_buf,
}
impl ::std::fmt::Debug for rb_thread_struct {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        write ! (f , "rb_thread_struct {{ vmlt_node: {:?}, self: {:?}, vm: {:?}, stack: {:?}, cfp: {:?}, safe_level: {:?}, raised_flag: {:?}, last_status: {:?}, state: {:?}, waiting_fd: {:?}, passed_block: {:?}, passed_bmethod_me: {:?}, passed_ci: {:?}, top_self: {:?}, top_wrapper: {:?}, base_block: {:?}, root_lep: {:?}, root_svar: {:?}, thread_id: {:?}, status: {:?}, to_kill: {:?}, priority: {:?}, mark_stack_len: {:?}, native_thread_data: {:?}, blocking_region_buffer: {:?}, thgroup: {:?}, value: {:?}, errinfo: {:?}, pending_interrupt_queue: {:?}, pending_interrupt_mask_stack: {:?}, pending_interrupt_queue_checked: {:?}, interrupt_flag: {:?}, interrupt_mask: {:?}, interrupt_lock: {:?}, interrupt_cond: {:?}, unblock: {:?}, locking_mutex: {:?}, keeping_mutexes: {:?}, tag: {:?}, protect_tag: {:?}, parse_in_eval: {:?}, mild_compile_error: {:?}, local_storage: {:?}, local_storage_recursive_hash: {:?}, local_storage_recursive_hash_for_trace: {:?}, join_list: {:?}, first_proc: {:?}, first_args: {:?}, first_func: {:?}, machine: {:?}, stat_insn_usage: {:?}, event_hooks: {:?}, trace_arg: {:?}, fiber: {:?}, root_fiber: {:?}, root_jmpbuf: {:?}, ensure_list: {:?}, method_missing_reason: {:?}, abort_on_exception: {:?}, altstack: {:?}, running_time_us: {:?} }}" , self . vmlt_node , self . self_ , self . vm , self . stack , self . cfp , self . safe_level , self . raised_flag , self . last_status , self . state , self . waiting_fd , self . passed_block , self . passed_bmethod_me , self . passed_ci , self . top_self , self . top_wrapper , self . base_block , self . root_lep , self . root_svar , self . thread_id , self . status , self . to_kill , self . priority , self . mark_stack_len , self . native_thread_data , self . blocking_region_buffer , self . thgroup , self . value , self . errinfo , self . pending_interrupt_queue , self . pending_interrupt_mask_stack , self . pending_interrupt_queue_checked , self . interrupt_flag , self . interrupt_mask , self . interrupt_lock , self . interrupt_cond , self . unblock , self . locking_mutex , self . keeping_mutexes , self . tag , self . protect_tag , self . parse_in_eval , self . mild_compile_error , self . local_storage , self . local_storage_recursive_hash , self . local_storage_recursive_hash_for_trace , self . join_list , self . first_proc , self . first_args , self . first_func , self . machine , self . stat_insn_usage , self . event_hooks , self . trace_arg , self . fiber , self . root_fiber , self . root_jmpbuf , self . ensure_list , self . method_missing_reason , self . abort_on_exception , self . altstack , self . running_time_us)
    }
}
pub type rb_thread_t = rb_thread_struct;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rb_trace_arg_struct {
    pub event: rb_event_flag_t,
    pub th: *mut rb_thread_t,
    pub cfp: *mut rb_control_frame_t,
    pub self_: VALUE,
    pub id: ID,
    pub klass: VALUE,
    pub data: VALUE,
    pub klass_solved: ::std::os::raw::c_int,
    pub lineno: ::std::os::raw::c_int,
    pub path: VALUE,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rb_compile_option_struct {
    pub inline_const_cache: ::std::os::raw::c_int,
    pub peephole_optimization: ::std::os::raw::c_int,
    pub tailcall_optimization: ::std::os::raw::c_int,
    pub specialized_instruction: ::std::os::raw::c_int,
    pub operands_unification: ::std::os::raw::c_int,
    pub instructions_unification: ::std::os::raw::c_int,
    pub stack_caching: ::std::os::raw::c_int,
    pub trace_instruction: ::std::os::raw::c_int,
    pub debug_level: ::std::os::raw::c_int,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct iseq_line_info_entry {
    pub position: ::std::os::raw::c_uint,
    pub line_no: ::std::os::raw::c_uint,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct iseq_catch_table_entry {
    pub type_: iseq_catch_table_entry_catch_type,
    pub iseq: VALUE,
    pub start: ::std::os::raw::c_uint,
    pub end: ::std::os::raw::c_uint,
    pub cont: ::std::os::raw::c_uint,
    pub sp: ::std::os::raw::c_uint,
}
pub const iseq_catch_table_entry_catch_type_CATCH_TYPE_RESCUE: iseq_catch_table_entry_catch_type =
    3;
pub const iseq_catch_table_entry_catch_type_CATCH_TYPE_ENSURE: iseq_catch_table_entry_catch_type =
    5;
pub const iseq_catch_table_entry_catch_type_CATCH_TYPE_RETRY: iseq_catch_table_entry_catch_type = 7;
pub const iseq_catch_table_entry_catch_type_CATCH_TYPE_BREAK: iseq_catch_table_entry_catch_type = 9;
pub const iseq_catch_table_entry_catch_type_CATCH_TYPE_REDO: iseq_catch_table_entry_catch_type = 11;
pub const iseq_catch_table_entry_catch_type_CATCH_TYPE_NEXT: iseq_catch_table_entry_catch_type = 13;
pub type iseq_catch_table_entry_catch_type = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct iseq_catch_table {
    pub size: ::std::os::raw::c_int,
    pub entries: [iseq_catch_table_entry; 1usize],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct iseq_compile_data_storage {
    pub next: *mut iseq_compile_data_storage,
    pub pos: ::std::os::raw::c_uint,
    pub size: ::std::os::raw::c_uint,
    pub buff: [::std::os::raw::c_char; 1usize],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct iseq_compile_data {
    pub err_info: VALUE,
    pub mark_ary: VALUE,
    pub catch_table_ary: VALUE,
    pub start_label: *mut iseq_label_data,
    pub end_label: *mut iseq_label_data,
    pub redo_label: *mut iseq_label_data,
    pub current_block: VALUE,
    pub ensure_node: VALUE,
    pub for_iseq: VALUE,
    pub ensure_node_stack: *mut iseq_compile_data_ensure_node_stack,
    pub loopval_popped: ::std::os::raw::c_int,
    pub cached_const: ::std::os::raw::c_int,
    pub storage_head: *mut iseq_compile_data_storage,
    pub storage_current: *mut iseq_compile_data_storage,
    pub last_line: ::std::os::raw::c_int,
    pub last_coverable_line: ::std::os::raw::c_int,
    pub label_no: ::std::os::raw::c_int,
    pub node_level: ::std::os::raw::c_int,
    pub option: *const rb_compile_option_t,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct st_table_entry {
    pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct st_packed_entry {
    pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rb_event_hook_struct {
    pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rb_postponed_job_struct {
    pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct iseq_label_data {
    pub _address: u8,
}