Skip to main content

rbspy_ruby_structs/
ruby_4_0_10.rs

1/* automatically generated by rust-bindgen 0.73.2 */
2
3#[repr(C)]
4#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
5pub struct __BindgenBitfieldUnit<Storage> {
6    storage: Storage,
7}
8impl<Storage> __BindgenBitfieldUnit<Storage> {
9    #[inline]
10    pub const fn new(storage: Storage) -> Self {
11        Self { storage }
12    }
13}
14impl<Storage> __BindgenBitfieldUnit<Storage>
15where
16    Storage: AsRef<[u8]> + AsMut<[u8]>,
17{
18    #[inline]
19    fn extract_bit(byte: u8, index: usize) -> bool {
20        let bit_index = if cfg!(target_endian = "big") {
21            7 - (index % 8)
22        } else {
23            index % 8
24        };
25        let mask = 1 << bit_index;
26        byte & mask == mask
27    }
28    #[inline]
29    pub fn get_bit(&self, index: usize) -> bool {
30        debug_assert!(index / 8 < self.storage.as_ref().len());
31        let byte_index = index / 8;
32        let byte = self.storage.as_ref()[byte_index];
33        Self::extract_bit(byte, index)
34    }
35    #[inline]
36    pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool {
37        debug_assert!(index / 8 < core::mem::size_of::<Storage>());
38        let byte_index = index / 8;
39        let byte = unsafe {
40            *(core::ptr::addr_of!((*this).storage) as *const u8).offset(byte_index as isize)
41        };
42        Self::extract_bit(byte, index)
43    }
44    #[inline]
45    fn change_bit(byte: u8, index: usize, val: bool) -> u8 {
46        let bit_index = if cfg!(target_endian = "big") {
47            7 - (index % 8)
48        } else {
49            index % 8
50        };
51        let mask = 1 << bit_index;
52        if val {
53            byte | mask
54        } else {
55            byte & !mask
56        }
57    }
58    #[inline]
59    pub fn set_bit(&mut self, index: usize, val: bool) {
60        debug_assert!(index / 8 < self.storage.as_ref().len());
61        let byte_index = index / 8;
62        let byte = &mut self.storage.as_mut()[byte_index];
63        *byte = Self::change_bit(*byte, index, val);
64    }
65    #[inline]
66    pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) {
67        debug_assert!(index / 8 < core::mem::size_of::<Storage>());
68        let byte_index = index / 8;
69        let byte = unsafe {
70            (core::ptr::addr_of_mut!((*this).storage) as *mut u8).offset(byte_index as isize)
71        };
72        unsafe { *byte = Self::change_bit(*byte, index, val) };
73    }
74    #[inline]
75    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
76        debug_assert!(bit_width <= 64);
77        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
78        debug_assert!((bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len());
79        if bit_width == 0 {
80            return 0;
81        }
82        let mut val = 0u64;
83        let storage = self.storage.as_ref();
84        let start_byte = bit_offset / 8;
85        let bit_shift = bit_offset % 8;
86        let bytes_needed = (bit_width as usize + bit_shift + 7) / 8;
87        if cfg!(target_endian = "big") {
88            for i in 0..bytes_needed {
89                val |= (storage[start_byte + i].reverse_bits() as u64) << (i * 8);
90            }
91        } else {
92            for i in 0..bytes_needed {
93                val |= (storage[start_byte + i] as u64) << (i * 8);
94            }
95        }
96        val >>= bit_shift;
97        if bit_width < 64 {
98            val &= (1u64 << bit_width) - 1;
99        }
100        if cfg!(target_endian = "big") {
101            val = val.reverse_bits() >> (64 - bit_width as usize);
102        }
103        val
104    }
105    #[inline]
106    pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 {
107        debug_assert!(bit_width <= 64);
108        debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
109        debug_assert!(
110            (bit_offset + (bit_width as usize) + 7) / 8 <= core::mem::size_of::<Storage>()
111        );
112        if bit_width == 0 {
113            return 0;
114        }
115        let mut val = 0u64;
116        let start_byte = bit_offset / 8;
117        let bit_shift = bit_offset % 8;
118        let bytes_needed = (bit_width as usize + bit_shift + 7) / 8;
119        let storage_ptr = unsafe { core::ptr::addr_of!((*this).storage) as *const u8 };
120        if cfg!(target_endian = "big") {
121            for i in 0..bytes_needed {
122                let byte = unsafe { *storage_ptr.add(start_byte + i) };
123                val |= (byte.reverse_bits() as u64) << (i * 8);
124            }
125        } else {
126            for i in 0..bytes_needed {
127                let byte = unsafe { *storage_ptr.add(start_byte + i) };
128                val |= (byte as u64) << (i * 8);
129            }
130        }
131        val >>= bit_shift;
132        if bit_width < 64 {
133            val &= (1u64 << bit_width) - 1;
134        }
135        if cfg!(target_endian = "big") {
136            val = val.reverse_bits() >> (64 - bit_width as usize);
137        }
138        val
139    }
140    #[inline]
141    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
142        debug_assert!(bit_width <= 64);
143        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
144        debug_assert!((bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len());
145        if bit_width == 0 {
146            return;
147        }
148        let mut val = val;
149        if bit_width < 64 {
150            val &= (1u64 << bit_width) - 1;
151        }
152        if cfg!(target_endian = "big") {
153            val = val.reverse_bits() >> (64 - bit_width as usize);
154        }
155        let storage = self.storage.as_mut();
156        let start_byte = bit_offset / 8;
157        let bit_shift = bit_offset % 8;
158        let bytes_needed = (bit_width as usize + bit_shift + 7) / 8;
159        val <<= bit_shift;
160        let field_mask = if bit_width as usize + bit_shift >= 64 {
161            !0u64 << bit_shift
162        } else {
163            ((1u64 << bit_width) - 1) << bit_shift
164        };
165        for i in 0..bytes_needed {
166            let byte_val = (val >> (i * 8)) as u8;
167            let byte_mask = (field_mask >> (i * 8)) as u8;
168            if cfg!(target_endian = "big") {
169                let byte = storage[start_byte + i].reverse_bits();
170                let new_byte = (byte & !byte_mask) | (byte_val & byte_mask);
171                storage[start_byte + i] = new_byte.reverse_bits();
172            } else {
173                storage[start_byte + i] =
174                    (storage[start_byte + i] & !byte_mask) | (byte_val & byte_mask);
175            }
176        }
177    }
178    #[inline]
179    pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) {
180        debug_assert!(bit_width <= 64);
181        debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
182        debug_assert!(
183            (bit_offset + (bit_width as usize) + 7) / 8 <= core::mem::size_of::<Storage>()
184        );
185        if bit_width == 0 {
186            return;
187        }
188        let mut val = val;
189        if bit_width < 64 {
190            val &= (1u64 << bit_width) - 1;
191        }
192        if cfg!(target_endian = "big") {
193            val = val.reverse_bits() >> (64 - bit_width as usize);
194        }
195        let start_byte = bit_offset / 8;
196        let bit_shift = bit_offset % 8;
197        let bytes_needed = (bit_width as usize + bit_shift + 7) / 8;
198        val <<= bit_shift;
199        let field_mask = if bit_width as usize + bit_shift >= 64 {
200            !0u64 << bit_shift
201        } else {
202            ((1u64 << bit_width) - 1) << bit_shift
203        };
204        let storage_ptr = unsafe { core::ptr::addr_of_mut!((*this).storage) as *mut u8 };
205        for i in 0..bytes_needed {
206            let byte_val = (val >> (i * 8)) as u8;
207            let byte_mask = (field_mask >> (i * 8)) as u8;
208            let byte_ptr = unsafe { storage_ptr.add(start_byte + i) };
209            if cfg!(target_endian = "big") {
210                let byte = unsafe { (*byte_ptr).reverse_bits() };
211                let new_byte = (byte & !byte_mask) | (byte_val & byte_mask);
212                unsafe { *byte_ptr = new_byte.reverse_bits() };
213            } else {
214                unsafe { *byte_ptr = (*byte_ptr & !byte_mask) | (byte_val & byte_mask) };
215            }
216        }
217    }
218}
219#[doc = " Const-generic methods for efficient bitfield access when offset and width"]
220#[doc = " are known at compile time."]
221impl<const N: usize> __BindgenBitfieldUnit<[u8; N]> {
222    #[doc = " Get a field using const generics for compile-time optimization."]
223    #[doc = " Uses native word size operations when the field fits in usize."]
224    #[inline]
225    pub const fn get_const<const BIT_OFFSET: usize, const BIT_WIDTH: u8>(&self) -> u64 {
226        debug_assert!(BIT_WIDTH <= 64);
227        debug_assert!(BIT_OFFSET / 8 < N);
228        debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N);
229        if BIT_WIDTH == 0 {
230            return 0;
231        }
232        let start_byte = BIT_OFFSET / 8;
233        let bit_shift = BIT_OFFSET % 8;
234        let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8;
235        if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize {
236            let mut val = 0usize;
237            if cfg!(target_endian = "big") {
238                let mut i = 0;
239                while i < bytes_needed {
240                    val |= (self.storage[start_byte + i].reverse_bits() as usize) << (i * 8);
241                    i += 1;
242                }
243            } else {
244                let mut i = 0;
245                while i < bytes_needed {
246                    val |= (self.storage[start_byte + i] as usize) << (i * 8);
247                    i += 1;
248                }
249            }
250            val >>= bit_shift;
251            if (BIT_WIDTH as u32) < usize::BITS {
252                val &= (1usize << BIT_WIDTH) - 1;
253            }
254            if cfg!(target_endian = "big") {
255                val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize);
256            }
257            val as u64
258        } else {
259            let mut val = 0u64;
260            if cfg!(target_endian = "big") {
261                let mut i = 0;
262                while i < bytes_needed {
263                    val |= (self.storage[start_byte + i].reverse_bits() as u64) << (i * 8);
264                    i += 1;
265                }
266            } else {
267                let mut i = 0;
268                while i < bytes_needed {
269                    val |= (self.storage[start_byte + i] as u64) << (i * 8);
270                    i += 1;
271                }
272            }
273            val >>= bit_shift;
274            if BIT_WIDTH < 64 {
275                val &= (1u64 << BIT_WIDTH) - 1;
276            }
277            if cfg!(target_endian = "big") {
278                val = val.reverse_bits() >> (64 - BIT_WIDTH as usize);
279            }
280            val
281        }
282    }
283    #[doc = " Set a field using const generics for compile-time optimization."]
284    #[doc = " Uses native word size operations when the field fits in usize."]
285    #[inline]
286    pub fn set_const<const BIT_OFFSET: usize, const BIT_WIDTH: u8>(&mut self, val: u64) {
287        debug_assert!(BIT_WIDTH <= 64);
288        debug_assert!(BIT_OFFSET / 8 < N);
289        debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N);
290        if BIT_WIDTH == 0 {
291            return;
292        }
293        let start_byte = BIT_OFFSET / 8;
294        let bit_shift = BIT_OFFSET % 8;
295        let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8;
296        if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize {
297            let mut val = val as usize;
298            if (BIT_WIDTH as u32) < usize::BITS {
299                val &= (1usize << BIT_WIDTH) - 1;
300            }
301            if cfg!(target_endian = "big") {
302                val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize);
303            }
304            val <<= bit_shift;
305            let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize {
306                !0usize << bit_shift
307            } else {
308                ((1usize << BIT_WIDTH) - 1) << bit_shift
309            };
310            let mut i = 0;
311            while i < bytes_needed {
312                let byte_val = (val >> (i * 8)) as u8;
313                let byte_mask = (field_mask >> (i * 8)) as u8;
314                if cfg!(target_endian = "big") {
315                    let byte = self.storage[start_byte + i].reverse_bits();
316                    let new_byte = (byte & !byte_mask) | (byte_val & byte_mask);
317                    self.storage[start_byte + i] = new_byte.reverse_bits();
318                } else {
319                    self.storage[start_byte + i] =
320                        (self.storage[start_byte + i] & !byte_mask) | (byte_val & byte_mask);
321                }
322                i += 1;
323            }
324        } else {
325            let mut val = val;
326            if BIT_WIDTH < 64 {
327                val &= (1u64 << BIT_WIDTH) - 1;
328            }
329            if cfg!(target_endian = "big") {
330                val = val.reverse_bits() >> (64 - BIT_WIDTH as usize);
331            }
332            val <<= bit_shift;
333            let field_mask = if BIT_WIDTH as usize + bit_shift >= 64 {
334                !0u64 << bit_shift
335            } else {
336                ((1u64 << BIT_WIDTH) - 1) << bit_shift
337            };
338            let mut i = 0;
339            while i < bytes_needed {
340                let byte_val = (val >> (i * 8)) as u8;
341                let byte_mask = (field_mask >> (i * 8)) as u8;
342                if cfg!(target_endian = "big") {
343                    let byte = self.storage[start_byte + i].reverse_bits();
344                    let new_byte = (byte & !byte_mask) | (byte_val & byte_mask);
345                    self.storage[start_byte + i] = new_byte.reverse_bits();
346                } else {
347                    self.storage[start_byte + i] =
348                        (self.storage[start_byte + i] & !byte_mask) | (byte_val & byte_mask);
349                }
350                i += 1;
351            }
352        }
353    }
354    #[doc = " Raw pointer get using const generics for compile-time optimization."]
355    #[doc = " Uses native word size operations when the field fits in usize."]
356    #[inline]
357    pub const unsafe fn raw_get_const<const BIT_OFFSET: usize, const BIT_WIDTH: u8>(
358        this: *const Self,
359    ) -> u64 {
360        debug_assert!(BIT_WIDTH <= 64);
361        debug_assert!(BIT_OFFSET / 8 < N);
362        debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N);
363        if BIT_WIDTH == 0 {
364            return 0;
365        }
366        let start_byte = BIT_OFFSET / 8;
367        let bit_shift = BIT_OFFSET % 8;
368        let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8;
369        let storage_ptr = unsafe { core::ptr::addr_of!((*this).storage) as *const u8 };
370        if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize {
371            let mut val = 0usize;
372            if cfg!(target_endian = "big") {
373                let mut i = 0;
374                while i < bytes_needed {
375                    let byte = unsafe { *storage_ptr.add(start_byte + i) };
376                    val |= (byte.reverse_bits() as usize) << (i * 8);
377                    i += 1;
378                }
379            } else {
380                let mut i = 0;
381                while i < bytes_needed {
382                    let byte = unsafe { *storage_ptr.add(start_byte + i) };
383                    val |= (byte as usize) << (i * 8);
384                    i += 1;
385                }
386            }
387            val >>= bit_shift;
388            if (BIT_WIDTH as u32) < usize::BITS {
389                val &= (1usize << BIT_WIDTH) - 1;
390            }
391            if cfg!(target_endian = "big") {
392                val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize);
393            }
394            val as u64
395        } else {
396            let mut val = 0u64;
397            if cfg!(target_endian = "big") {
398                let mut i = 0;
399                while i < bytes_needed {
400                    let byte = unsafe { *storage_ptr.add(start_byte + i) };
401                    val |= (byte.reverse_bits() as u64) << (i * 8);
402                    i += 1;
403                }
404            } else {
405                let mut i = 0;
406                while i < bytes_needed {
407                    let byte = unsafe { *storage_ptr.add(start_byte + i) };
408                    val |= (byte as u64) << (i * 8);
409                    i += 1;
410                }
411            }
412            val >>= bit_shift;
413            if BIT_WIDTH < 64 {
414                val &= (1u64 << BIT_WIDTH) - 1;
415            }
416            if cfg!(target_endian = "big") {
417                val = val.reverse_bits() >> (64 - BIT_WIDTH as usize);
418            }
419            val
420        }
421    }
422    #[doc = " Raw pointer set using const generics for compile-time optimization."]
423    #[doc = " Uses native word size operations when the field fits in usize."]
424    #[inline]
425    pub unsafe fn raw_set_const<const BIT_OFFSET: usize, const BIT_WIDTH: u8>(
426        this: *mut Self,
427        val: u64,
428    ) {
429        debug_assert!(BIT_WIDTH <= 64);
430        debug_assert!(BIT_OFFSET / 8 < N);
431        debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N);
432        if BIT_WIDTH == 0 {
433            return;
434        }
435        let start_byte = BIT_OFFSET / 8;
436        let bit_shift = BIT_OFFSET % 8;
437        let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8;
438        let storage_ptr = this.cast::<[u8; N]>().cast::<u8>();
439        if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize {
440            let mut val = val as usize;
441            if (BIT_WIDTH as u32) < usize::BITS {
442                val &= (1usize << BIT_WIDTH) - 1;
443            }
444            if cfg!(target_endian = "big") {
445                val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize);
446            }
447            val <<= bit_shift;
448            let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize {
449                !0usize << bit_shift
450            } else {
451                ((1usize << BIT_WIDTH) - 1) << bit_shift
452            };
453            let mut i = 0;
454            while i < bytes_needed {
455                let byte_val = (val >> (i * 8)) as u8;
456                let byte_mask = (field_mask >> (i * 8)) as u8;
457                let byte_ptr = unsafe { storage_ptr.add(start_byte + i) };
458                if cfg!(target_endian = "big") {
459                    let byte = unsafe { (*byte_ptr).reverse_bits() };
460                    let new_byte = (byte & !byte_mask) | (byte_val & byte_mask);
461                    unsafe { *byte_ptr = new_byte.reverse_bits() };
462                } else {
463                    unsafe { *byte_ptr = (*byte_ptr & !byte_mask) | (byte_val & byte_mask) };
464                }
465                i += 1;
466            }
467        } else {
468            let mut val = val;
469            if BIT_WIDTH < 64 {
470                val &= (1u64 << BIT_WIDTH) - 1;
471            }
472            if cfg!(target_endian = "big") {
473                val = val.reverse_bits() >> (64 - BIT_WIDTH as usize);
474            }
475            val <<= bit_shift;
476            let field_mask = if BIT_WIDTH as usize + bit_shift >= 64 {
477                !0u64 << bit_shift
478            } else {
479                ((1u64 << BIT_WIDTH) - 1) << bit_shift
480            };
481            let mut i = 0;
482            while i < bytes_needed {
483                let byte_val = (val >> (i * 8)) as u8;
484                let byte_mask = (field_mask >> (i * 8)) as u8;
485                let byte_ptr = unsafe { storage_ptr.add(start_byte + i) };
486                if cfg!(target_endian = "big") {
487                    let byte = unsafe { (*byte_ptr).reverse_bits() };
488                    let new_byte = (byte & !byte_mask) | (byte_val & byte_mask);
489                    unsafe { *byte_ptr = new_byte.reverse_bits() };
490                } else {
491                    unsafe { *byte_ptr = (*byte_ptr & !byte_mask) | (byte_val & byte_mask) };
492                }
493                i += 1;
494            }
495        }
496    }
497}
498#[repr(C)]
499#[derive(Default)]
500pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
501impl<T> __IncompleteArrayField<T> {
502    #[inline]
503    pub const fn new() -> Self {
504        __IncompleteArrayField(::std::marker::PhantomData, [])
505    }
506    #[inline]
507    pub fn as_ptr(&self) -> *const T {
508        self as *const _ as *const T
509    }
510    #[inline]
511    pub fn as_mut_ptr(&mut self) -> *mut T {
512        self as *mut _ as *mut T
513    }
514    #[inline]
515    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
516        ::std::slice::from_raw_parts(self.as_ptr(), len)
517    }
518    #[inline]
519    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
520        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
521    }
522}
523impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
524    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
525        fmt.write_str("__IncompleteArrayField")
526    }
527}
528#[repr(C)]
529#[derive(Debug, Copy, Clone)]
530pub struct __sigset_t {
531    pub __val: [usize; 16usize],
532}
533#[repr(C)]
534#[derive(Copy, Clone)]
535pub union __atomic_wide_counter {
536    pub __value64: ::std::os::raw::c_ulonglong,
537    pub __value32: __atomic_wide_counter__bindgen_ty_1,
538}
539#[repr(C)]
540#[derive(Debug, Copy, Clone)]
541pub struct __atomic_wide_counter__bindgen_ty_1 {
542    pub __low: ::std::os::raw::c_uint,
543    pub __high: ::std::os::raw::c_uint,
544}
545impl ::std::fmt::Debug for __atomic_wide_counter {
546    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
547        write!(f, "__atomic_wide_counter {{ union }}")
548    }
549}
550#[repr(C)]
551#[derive(Debug, Copy, Clone)]
552pub struct __pthread_internal_list {
553    pub __prev: *mut __pthread_internal_list,
554    pub __next: *mut __pthread_internal_list,
555}
556pub type __pthread_list_t = __pthread_internal_list;
557#[repr(C)]
558#[derive(Debug, Copy, Clone)]
559pub struct __pthread_mutex_s {
560    pub __lock: ::std::os::raw::c_int,
561    pub __count: ::std::os::raw::c_uint,
562    pub __owner: ::std::os::raw::c_int,
563    pub __nusers: ::std::os::raw::c_uint,
564    pub __kind: ::std::os::raw::c_int,
565    pub __spins: ::std::os::raw::c_short,
566    pub __elision: ::std::os::raw::c_short,
567    pub __list: __pthread_list_t,
568}
569#[repr(C)]
570#[derive(Copy, Clone)]
571pub struct __pthread_cond_s {
572    pub __wseq: __atomic_wide_counter,
573    pub __g1_start: __atomic_wide_counter,
574    pub __g_refs: [::std::os::raw::c_uint; 2usize],
575    pub __g_size: [::std::os::raw::c_uint; 2usize],
576    pub __g1_orig_size: ::std::os::raw::c_uint,
577    pub __wrefs: ::std::os::raw::c_uint,
578    pub __g_signals: [::std::os::raw::c_uint; 2usize],
579}
580impl ::std::fmt::Debug for __pthread_cond_s {
581    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
582        write ! (f , "__pthread_cond_s {{ __wseq: {:?}, __g1_start: {:?}, __g_refs: {:?}, __g_size: {:?}, __g1_orig_size: {:?}, __wrefs: {:?}, __g_signals: {:?} }}" , self . __wseq , self . __g1_start , self . __g_refs , self . __g_size , self . __g1_orig_size , self . __wrefs , self . __g_signals)
583    }
584}
585pub type pthread_t = usize;
586#[repr(C)]
587#[derive(Copy, Clone)]
588pub union pthread_mutex_t {
589    pub __data: __pthread_mutex_s,
590    pub __size: [::std::os::raw::c_char; 40usize],
591    pub __align: ::std::os::raw::c_long,
592}
593impl ::std::fmt::Debug for pthread_mutex_t {
594    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
595        write!(f, "pthread_mutex_t {{ union }}")
596    }
597}
598#[repr(C)]
599#[derive(Copy, Clone)]
600pub union pthread_cond_t {
601    pub __data: __pthread_cond_s,
602    pub __size: [::std::os::raw::c_char; 48usize],
603    pub __align: ::std::os::raw::c_longlong,
604}
605impl ::std::fmt::Debug for pthread_cond_t {
606    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
607        write!(f, "pthread_cond_t {{ union }}")
608    }
609}
610pub type __jmp_buf = [::std::os::raw::c_long; 8usize];
611#[repr(C)]
612#[derive(Debug, Copy, Clone)]
613pub struct __jmp_buf_tag {
614    pub __jmpbuf: __jmp_buf,
615    pub __mask_was_saved: ::std::os::raw::c_int,
616    pub __saved_mask: __sigset_t,
617}
618pub type jmp_buf = [__jmp_buf_tag; 1usize];
619pub type sigjmp_buf = [__jmp_buf_tag; 1usize];
620#[repr(C)]
621#[derive(Debug, Copy, Clone)]
622pub struct ccan_list_node {
623    pub next: *mut ccan_list_node,
624    pub prev: *mut ccan_list_node,
625}
626#[repr(C)]
627#[derive(Debug, Copy, Clone)]
628pub struct ccan_list_head {
629    pub n: ccan_list_node,
630}
631pub const ruby_id_types_RUBY_ID_LOCAL: ruby_id_types = 0;
632pub const ruby_id_types_RUBY_ID_STATIC_SYM: ruby_id_types = 1;
633pub const ruby_id_types_RUBY_ID_INSTANCE: ruby_id_types = 2;
634pub const ruby_id_types_RUBY_ID_GLOBAL: ruby_id_types = 6;
635pub const ruby_id_types_RUBY_ID_ATTRSET: ruby_id_types = 8;
636pub const ruby_id_types_RUBY_ID_CONST: ruby_id_types = 10;
637pub const ruby_id_types_RUBY_ID_CLASS: ruby_id_types = 12;
638pub const ruby_id_types_RUBY_ID_INTERNAL: ruby_id_types = 14;
639pub const ruby_id_types_RUBY_ID_SCOPE_SHIFT: ruby_id_types = 4;
640pub const ruby_id_types_RUBY_ID_SCOPE_MASK: ruby_id_types = 14;
641pub type ruby_id_types = ::std::os::raw::c_uint;
642pub const ruby_method_ids_idDot2: ruby_method_ids = 128;
643pub const ruby_method_ids_idDot3: ruby_method_ids = 129;
644pub const ruby_method_ids_idUPlus: ruby_method_ids = 132;
645pub const ruby_method_ids_idUMinus: ruby_method_ids = 133;
646pub const ruby_method_ids_idPow: ruby_method_ids = 134;
647pub const ruby_method_ids_idCmp: ruby_method_ids = 135;
648pub const ruby_method_ids_idPLUS: ruby_method_ids = 43;
649pub const ruby_method_ids_idMINUS: ruby_method_ids = 45;
650pub const ruby_method_ids_idMULT: ruby_method_ids = 42;
651pub const ruby_method_ids_idDIV: ruby_method_ids = 47;
652pub const ruby_method_ids_idMOD: ruby_method_ids = 37;
653pub const ruby_method_ids_idLTLT: ruby_method_ids = 136;
654pub const ruby_method_ids_idGTGT: ruby_method_ids = 137;
655pub const ruby_method_ids_idLT: ruby_method_ids = 60;
656pub const ruby_method_ids_idLE: ruby_method_ids = 138;
657pub const ruby_method_ids_idGT: ruby_method_ids = 62;
658pub const ruby_method_ids_idGE: ruby_method_ids = 139;
659pub const ruby_method_ids_idEq: ruby_method_ids = 140;
660pub const ruby_method_ids_idEqq: ruby_method_ids = 141;
661pub const ruby_method_ids_idNeq: ruby_method_ids = 142;
662pub const ruby_method_ids_idNot: ruby_method_ids = 33;
663pub const ruby_method_ids_idAnd: ruby_method_ids = 38;
664pub const ruby_method_ids_idOr: ruby_method_ids = 124;
665pub const ruby_method_ids_idBackquote: ruby_method_ids = 96;
666pub const ruby_method_ids_idEqTilde: ruby_method_ids = 143;
667pub const ruby_method_ids_idNeqTilde: ruby_method_ids = 144;
668pub const ruby_method_ids_idAREF: ruby_method_ids = 145;
669pub const ruby_method_ids_idASET: ruby_method_ids = 146;
670pub const ruby_method_ids_idCOLON2: ruby_method_ids = 147;
671pub const ruby_method_ids_idANDOP: ruby_method_ids = 148;
672pub const ruby_method_ids_idOROP: ruby_method_ids = 149;
673pub const ruby_method_ids_idANDDOT: ruby_method_ids = 150;
674pub const ruby_method_ids_tPRESERVED_ID_BEGIN: ruby_method_ids = 150;
675pub const ruby_method_ids_idNilP: ruby_method_ids = 151;
676pub const ruby_method_ids_idIncludeP: ruby_method_ids = 152;
677pub const ruby_method_ids_idItImplicit: ruby_method_ids = 153;
678pub const ruby_method_ids_idNULL: ruby_method_ids = 154;
679pub const ruby_method_ids_idEmptyP: ruby_method_ids = 155;
680pub const ruby_method_ids_idEqlP: ruby_method_ids = 156;
681pub const ruby_method_ids_idRespond_to: ruby_method_ids = 157;
682pub const ruby_method_ids_idRespond_to_missing: ruby_method_ids = 158;
683pub const ruby_method_ids_idIFUNC: ruby_method_ids = 159;
684pub const ruby_method_ids_idCFUNC: ruby_method_ids = 160;
685pub const ruby_method_ids_id_core_set_method_alias: ruby_method_ids = 161;
686pub const ruby_method_ids_id_core_set_variable_alias: ruby_method_ids = 162;
687pub const ruby_method_ids_id_core_undef_method: ruby_method_ids = 163;
688pub const ruby_method_ids_id_core_define_method: ruby_method_ids = 164;
689pub const ruby_method_ids_id_core_define_singleton_method: ruby_method_ids = 165;
690pub const ruby_method_ids_id_core_set_postexe: ruby_method_ids = 166;
691pub const ruby_method_ids_id_core_hash_merge_ptr: ruby_method_ids = 167;
692pub const ruby_method_ids_id_core_hash_merge_kwd: ruby_method_ids = 168;
693pub const ruby_method_ids_id_core_raise: ruby_method_ids = 169;
694pub const ruby_method_ids_id_core_sprintf: ruby_method_ids = 170;
695pub const ruby_method_ids_id_debug_created_info: ruby_method_ids = 171;
696pub const ruby_method_ids_tPRESERVED_ID_END: ruby_method_ids = 172;
697pub const ruby_method_ids_tTOKEN_LOCAL_BEGIN: ruby_method_ids = 171;
698pub const ruby_method_ids_tMax: ruby_method_ids = 172;
699pub const ruby_method_ids_tMin: ruby_method_ids = 173;
700pub const ruby_method_ids_tHash: ruby_method_ids = 174;
701pub const ruby_method_ids_tFreeze: ruby_method_ids = 175;
702pub const ruby_method_ids_tInspect: ruby_method_ids = 176;
703pub const ruby_method_ids_tIntern: ruby_method_ids = 177;
704pub const ruby_method_ids_tObject_id: ruby_method_ids = 178;
705pub const ruby_method_ids_t__id__: ruby_method_ids = 179;
706pub const ruby_method_ids_tConst_added: ruby_method_ids = 180;
707pub const ruby_method_ids_tConst_missing: ruby_method_ids = 181;
708pub const ruby_method_ids_tMethodMissing: ruby_method_ids = 182;
709pub const ruby_method_ids_tMethod_added: ruby_method_ids = 183;
710pub const ruby_method_ids_tSingleton_method_added: ruby_method_ids = 184;
711pub const ruby_method_ids_tMethod_removed: ruby_method_ids = 185;
712pub const ruby_method_ids_tSingleton_method_removed: ruby_method_ids = 186;
713pub const ruby_method_ids_tMethod_undefined: ruby_method_ids = 187;
714pub const ruby_method_ids_tSingleton_method_undefined: ruby_method_ids = 188;
715pub const ruby_method_ids_tLength: ruby_method_ids = 189;
716pub const ruby_method_ids_tSize: ruby_method_ids = 190;
717pub const ruby_method_ids_tGets: ruby_method_ids = 191;
718pub const ruby_method_ids_tSucc: ruby_method_ids = 192;
719pub const ruby_method_ids_tEach: ruby_method_ids = 193;
720pub const ruby_method_ids_tProc: ruby_method_ids = 194;
721pub const ruby_method_ids_tLambda: ruby_method_ids = 195;
722pub const ruby_method_ids_tSend: ruby_method_ids = 196;
723pub const ruby_method_ids_t__send__: ruby_method_ids = 197;
724pub const ruby_method_ids_t__recursive_key__: ruby_method_ids = 198;
725pub const ruby_method_ids_tInitialize: ruby_method_ids = 199;
726pub const ruby_method_ids_tInitialize_copy: ruby_method_ids = 200;
727pub const ruby_method_ids_tInitialize_clone: ruby_method_ids = 201;
728pub const ruby_method_ids_tInitialize_dup: ruby_method_ids = 202;
729pub const ruby_method_ids_tTo_int: ruby_method_ids = 203;
730pub const ruby_method_ids_tTo_ary: ruby_method_ids = 204;
731pub const ruby_method_ids_tTo_str: ruby_method_ids = 205;
732pub const ruby_method_ids_tTo_sym: ruby_method_ids = 206;
733pub const ruby_method_ids_tTo_hash: ruby_method_ids = 207;
734pub const ruby_method_ids_tTo_proc: ruby_method_ids = 208;
735pub const ruby_method_ids_tTo_io: ruby_method_ids = 209;
736pub const ruby_method_ids_tTo_a: ruby_method_ids = 210;
737pub const ruby_method_ids_tTo_s: ruby_method_ids = 211;
738pub const ruby_method_ids_tTo_i: ruby_method_ids = 212;
739pub const ruby_method_ids_tTo_f: ruby_method_ids = 213;
740pub const ruby_method_ids_tTo_r: ruby_method_ids = 214;
741pub const ruby_method_ids_tBt: ruby_method_ids = 215;
742pub const ruby_method_ids_tBt_locations: ruby_method_ids = 216;
743pub const ruby_method_ids_tCall: ruby_method_ids = 217;
744pub const ruby_method_ids_tMesg: ruby_method_ids = 218;
745pub const ruby_method_ids_tException: ruby_method_ids = 219;
746pub const ruby_method_ids_tLocals: ruby_method_ids = 220;
747pub const ruby_method_ids_tNOT: ruby_method_ids = 221;
748pub const ruby_method_ids_tAND: ruby_method_ids = 222;
749pub const ruby_method_ids_tOR: ruby_method_ids = 223;
750pub const ruby_method_ids_tDiv: ruby_method_ids = 224;
751pub const ruby_method_ids_tDivmod: ruby_method_ids = 225;
752pub const ruby_method_ids_tFdiv: ruby_method_ids = 226;
753pub const ruby_method_ids_tQuo: ruby_method_ids = 227;
754pub const ruby_method_ids_tName: ruby_method_ids = 228;
755pub const ruby_method_ids_tNil: ruby_method_ids = 229;
756pub const ruby_method_ids_tPath: ruby_method_ids = 230;
757pub const ruby_method_ids_tPack: ruby_method_ids = 231;
758pub const ruby_method_ids_tBuffer: ruby_method_ids = 232;
759pub const ruby_method_ids_tAborted: ruby_method_ids = 233;
760pub const ruby_method_ids_tExited: ruby_method_ids = 234;
761pub const ruby_method_ids_tUScore: ruby_method_ids = 235;
762pub const ruby_method_ids_tNUMPARAM_1: ruby_method_ids = 236;
763pub const ruby_method_ids_tNUMPARAM_2: ruby_method_ids = 237;
764pub const ruby_method_ids_tNUMPARAM_3: ruby_method_ids = 238;
765pub const ruby_method_ids_tNUMPARAM_4: ruby_method_ids = 239;
766pub const ruby_method_ids_tNUMPARAM_5: ruby_method_ids = 240;
767pub const ruby_method_ids_tNUMPARAM_6: ruby_method_ids = 241;
768pub const ruby_method_ids_tNUMPARAM_7: ruby_method_ids = 242;
769pub const ruby_method_ids_tNUMPARAM_8: ruby_method_ids = 243;
770pub const ruby_method_ids_tNUMPARAM_9: ruby_method_ids = 244;
771pub const ruby_method_ids_tIt: ruby_method_ids = 245;
772pub const ruby_method_ids_tDefault: ruby_method_ids = 246;
773pub const ruby_method_ids_tTOKEN_LOCAL_END: ruby_method_ids = 247;
774pub const ruby_method_ids_tTOKEN_INSTANCE_BEGIN: ruby_method_ids = 246;
775pub const ruby_method_ids_tTOKEN_INSTANCE_END: ruby_method_ids = 247;
776pub const ruby_method_ids_tTOKEN_GLOBAL_BEGIN: ruby_method_ids = 246;
777pub const ruby_method_ids_tLASTLINE: ruby_method_ids = 247;
778pub const ruby_method_ids_tBACKREF: ruby_method_ids = 248;
779pub const ruby_method_ids_tERROR_INFO: ruby_method_ids = 249;
780pub const ruby_method_ids_tTOKEN_GLOBAL_END: ruby_method_ids = 250;
781pub const ruby_method_ids_tTOKEN_CONST_BEGIN: ruby_method_ids = 249;
782pub const ruby_method_ids_tRuby: ruby_method_ids = 250;
783pub const ruby_method_ids_tTOKEN_CONST_END: ruby_method_ids = 251;
784pub const ruby_method_ids_tTOKEN_CLASS_BEGIN: ruby_method_ids = 250;
785pub const ruby_method_ids_tTOKEN_CLASS_END: ruby_method_ids = 251;
786pub const ruby_method_ids_tTOKEN_ATTRSET_BEGIN: ruby_method_ids = 250;
787pub const ruby_method_ids_tTOKEN_ATTRSET_END: ruby_method_ids = 251;
788pub const ruby_method_ids_tNEXT_ID: ruby_method_ids = 251;
789pub const ruby_method_ids_idMax: ruby_method_ids = 2753;
790pub const ruby_method_ids_idMin: ruby_method_ids = 2769;
791pub const ruby_method_ids_idHash: ruby_method_ids = 2785;
792pub const ruby_method_ids_idFreeze: ruby_method_ids = 2801;
793pub const ruby_method_ids_idInspect: ruby_method_ids = 2817;
794pub const ruby_method_ids_idIntern: ruby_method_ids = 2833;
795pub const ruby_method_ids_idObject_id: ruby_method_ids = 2849;
796pub const ruby_method_ids_id__id__: ruby_method_ids = 2865;
797pub const ruby_method_ids_idConst_added: ruby_method_ids = 2881;
798pub const ruby_method_ids_idConst_missing: ruby_method_ids = 2897;
799pub const ruby_method_ids_idMethodMissing: ruby_method_ids = 2913;
800pub const ruby_method_ids_idMethod_added: ruby_method_ids = 2929;
801pub const ruby_method_ids_idSingleton_method_added: ruby_method_ids = 2945;
802pub const ruby_method_ids_idMethod_removed: ruby_method_ids = 2961;
803pub const ruby_method_ids_idSingleton_method_removed: ruby_method_ids = 2977;
804pub const ruby_method_ids_idMethod_undefined: ruby_method_ids = 2993;
805pub const ruby_method_ids_idSingleton_method_undefined: ruby_method_ids = 3009;
806pub const ruby_method_ids_idLength: ruby_method_ids = 3025;
807pub const ruby_method_ids_idSize: ruby_method_ids = 3041;
808pub const ruby_method_ids_idGets: ruby_method_ids = 3057;
809pub const ruby_method_ids_idSucc: ruby_method_ids = 3073;
810pub const ruby_method_ids_idEach: ruby_method_ids = 3089;
811pub const ruby_method_ids_idProc: ruby_method_ids = 3105;
812pub const ruby_method_ids_idLambda: ruby_method_ids = 3121;
813pub const ruby_method_ids_idSend: ruby_method_ids = 3137;
814pub const ruby_method_ids_id__send__: ruby_method_ids = 3153;
815pub const ruby_method_ids_id__recursive_key__: ruby_method_ids = 3169;
816pub const ruby_method_ids_idInitialize: ruby_method_ids = 3185;
817pub const ruby_method_ids_idInitialize_copy: ruby_method_ids = 3201;
818pub const ruby_method_ids_idInitialize_clone: ruby_method_ids = 3217;
819pub const ruby_method_ids_idInitialize_dup: ruby_method_ids = 3233;
820pub const ruby_method_ids_idTo_int: ruby_method_ids = 3249;
821pub const ruby_method_ids_idTo_ary: ruby_method_ids = 3265;
822pub const ruby_method_ids_idTo_str: ruby_method_ids = 3281;
823pub const ruby_method_ids_idTo_sym: ruby_method_ids = 3297;
824pub const ruby_method_ids_idTo_hash: ruby_method_ids = 3313;
825pub const ruby_method_ids_idTo_proc: ruby_method_ids = 3329;
826pub const ruby_method_ids_idTo_io: ruby_method_ids = 3345;
827pub const ruby_method_ids_idTo_a: ruby_method_ids = 3361;
828pub const ruby_method_ids_idTo_s: ruby_method_ids = 3377;
829pub const ruby_method_ids_idTo_i: ruby_method_ids = 3393;
830pub const ruby_method_ids_idTo_f: ruby_method_ids = 3409;
831pub const ruby_method_ids_idTo_r: ruby_method_ids = 3425;
832pub const ruby_method_ids_idBt: ruby_method_ids = 3441;
833pub const ruby_method_ids_idBt_locations: ruby_method_ids = 3457;
834pub const ruby_method_ids_idCall: ruby_method_ids = 3473;
835pub const ruby_method_ids_idMesg: ruby_method_ids = 3489;
836pub const ruby_method_ids_idException: ruby_method_ids = 3505;
837pub const ruby_method_ids_idLocals: ruby_method_ids = 3521;
838pub const ruby_method_ids_idNOT: ruby_method_ids = 3537;
839pub const ruby_method_ids_idAND: ruby_method_ids = 3553;
840pub const ruby_method_ids_idOR: ruby_method_ids = 3569;
841pub const ruby_method_ids_idDiv: ruby_method_ids = 3585;
842pub const ruby_method_ids_idDivmod: ruby_method_ids = 3601;
843pub const ruby_method_ids_idFdiv: ruby_method_ids = 3617;
844pub const ruby_method_ids_idQuo: ruby_method_ids = 3633;
845pub const ruby_method_ids_idName: ruby_method_ids = 3649;
846pub const ruby_method_ids_idNil: ruby_method_ids = 3665;
847pub const ruby_method_ids_idPath: ruby_method_ids = 3681;
848pub const ruby_method_ids_idPack: ruby_method_ids = 3697;
849pub const ruby_method_ids_idBuffer: ruby_method_ids = 3713;
850pub const ruby_method_ids_idAborted: ruby_method_ids = 3729;
851pub const ruby_method_ids_idExited: ruby_method_ids = 3745;
852pub const ruby_method_ids_idUScore: ruby_method_ids = 3761;
853pub const ruby_method_ids_idNUMPARAM_1: ruby_method_ids = 3777;
854pub const ruby_method_ids_idNUMPARAM_2: ruby_method_ids = 3793;
855pub const ruby_method_ids_idNUMPARAM_3: ruby_method_ids = 3809;
856pub const ruby_method_ids_idNUMPARAM_4: ruby_method_ids = 3825;
857pub const ruby_method_ids_idNUMPARAM_5: ruby_method_ids = 3841;
858pub const ruby_method_ids_idNUMPARAM_6: ruby_method_ids = 3857;
859pub const ruby_method_ids_idNUMPARAM_7: ruby_method_ids = 3873;
860pub const ruby_method_ids_idNUMPARAM_8: ruby_method_ids = 3889;
861pub const ruby_method_ids_idNUMPARAM_9: ruby_method_ids = 3905;
862pub const ruby_method_ids_idIt: ruby_method_ids = 3921;
863pub const ruby_method_ids_idDefault: ruby_method_ids = 3937;
864pub const ruby_method_ids_idLASTLINE: ruby_method_ids = 3959;
865pub const ruby_method_ids_idBACKREF: ruby_method_ids = 3975;
866pub const ruby_method_ids_idERROR_INFO: ruby_method_ids = 3991;
867pub const ruby_method_ids_idRuby: ruby_method_ids = 4011;
868pub const ruby_method_ids_tLAST_OP_ID: ruby_method_ids = 171;
869pub const ruby_method_ids_idLAST_OP_ID: ruby_method_ids = 10;
870pub type ruby_method_ids = ::std::os::raw::c_uint;
871pub type VALUE = usize;
872pub type ID = usize;
873pub type rb_alloc_func_t = ::std::option::Option<unsafe extern "C" fn(klass: VALUE) -> VALUE>;
874#[repr(C)]
875#[derive(Debug, Copy, Clone)]
876pub struct RBasic {
877    pub flags: VALUE,
878    pub klass: VALUE,
879}
880pub const ruby_fl_ushift_RUBY_FL_USHIFT: ruby_fl_ushift = 12;
881pub type ruby_fl_ushift = ::std::os::raw::c_uint;
882pub const ruby_fl_type_RUBY_FL_WB_PROTECTED: ruby_fl_type = 32;
883pub const ruby_fl_type_RUBY_FL_PROMOTED: ruby_fl_type = 32;
884pub const ruby_fl_type_RUBY_FL_USERPRIV0: ruby_fl_type = 64;
885pub const ruby_fl_type_RUBY_FL_FINALIZE: ruby_fl_type = 128;
886pub const ruby_fl_type_RUBY_FL_TAINT: ruby_fl_type = 0;
887pub const ruby_fl_type_RUBY_FL_EXIVAR: ruby_fl_type = 0;
888pub const ruby_fl_type_RUBY_FL_SHAREABLE: ruby_fl_type = 256;
889pub const ruby_fl_type_RUBY_FL_UNTRUSTED: ruby_fl_type = 0;
890pub const ruby_fl_type_RUBY_FL_UNUSED9: ruby_fl_type = 512;
891pub const ruby_fl_type_RUBY_FL_UNUSED10: ruby_fl_type = 1024;
892pub const ruby_fl_type_RUBY_FL_FREEZE: ruby_fl_type = 2048;
893pub const ruby_fl_type_RUBY_FL_USER0: ruby_fl_type = 4096;
894pub const ruby_fl_type_RUBY_FL_USER1: ruby_fl_type = 8192;
895pub const ruby_fl_type_RUBY_FL_USER2: ruby_fl_type = 16384;
896pub const ruby_fl_type_RUBY_FL_USER3: ruby_fl_type = 32768;
897pub const ruby_fl_type_RUBY_FL_USER4: ruby_fl_type = 65536;
898pub const ruby_fl_type_RUBY_FL_USER5: ruby_fl_type = 131072;
899pub const ruby_fl_type_RUBY_FL_USER6: ruby_fl_type = 262144;
900pub const ruby_fl_type_RUBY_FL_USER7: ruby_fl_type = 524288;
901pub const ruby_fl_type_RUBY_FL_USER8: ruby_fl_type = 1048576;
902pub const ruby_fl_type_RUBY_FL_USER9: ruby_fl_type = 2097152;
903pub const ruby_fl_type_RUBY_FL_USER10: ruby_fl_type = 4194304;
904pub const ruby_fl_type_RUBY_FL_USER11: ruby_fl_type = 8388608;
905pub const ruby_fl_type_RUBY_FL_USER12: ruby_fl_type = 16777216;
906pub const ruby_fl_type_RUBY_FL_USER13: ruby_fl_type = 33554432;
907pub const ruby_fl_type_RUBY_FL_USER14: ruby_fl_type = 67108864;
908pub const ruby_fl_type_RUBY_FL_USER15: ruby_fl_type = 134217728;
909pub const ruby_fl_type_RUBY_FL_USER16: ruby_fl_type = 268435456;
910pub const ruby_fl_type_RUBY_FL_USER17: ruby_fl_type = 536870912;
911pub const ruby_fl_type_RUBY_FL_USER18: ruby_fl_type = 1073741824;
912pub const ruby_fl_type_RUBY_FL_USER19: ruby_fl_type = -2147483648;
913pub const ruby_fl_type_RUBY_ELTS_SHARED: ruby_fl_type = 4096;
914pub const ruby_fl_type_RUBY_FL_SINGLETON: ruby_fl_type = 8192;
915pub type ruby_fl_type = ::std::os::raw::c_int;
916#[repr(C)]
917#[derive(Copy, Clone)]
918pub struct RString {
919    pub basic: RBasic,
920    pub len: ::std::os::raw::c_long,
921    pub as_: RString__bindgen_ty_1,
922}
923#[repr(C)]
924#[derive(Copy, Clone)]
925pub union RString__bindgen_ty_1 {
926    pub heap: RString__bindgen_ty_1__bindgen_ty_1,
927    pub embed: RString__bindgen_ty_1__bindgen_ty_2,
928}
929#[repr(C)]
930#[derive(Copy, Clone)]
931pub struct RString__bindgen_ty_1__bindgen_ty_1 {
932    pub ptr: *mut ::std::os::raw::c_char,
933    pub aux: RString__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
934}
935#[repr(C)]
936#[derive(Copy, Clone)]
937pub union RString__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
938    pub capa: ::std::os::raw::c_long,
939    pub shared: VALUE,
940}
941impl ::std::fmt::Debug for RString__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
942    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
943        write!(
944            f,
945            "RString__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {{ union }}"
946        )
947    }
948}
949impl ::std::fmt::Debug for RString__bindgen_ty_1__bindgen_ty_1 {
950    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
951        write!(
952            f,
953            "RString__bindgen_ty_1__bindgen_ty_1 {{ ptr: {:?}, aux: {:?} }}",
954            self.ptr, self.aux
955        )
956    }
957}
958#[repr(C)]
959#[derive(Debug, Copy, Clone)]
960pub struct RString__bindgen_ty_1__bindgen_ty_2 {
961    pub ary: [::std::os::raw::c_char; 1usize],
962}
963impl ::std::fmt::Debug for RString__bindgen_ty_1 {
964    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
965        write!(f, "RString__bindgen_ty_1 {{ union }}")
966    }
967}
968impl ::std::fmt::Debug for RString {
969    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
970        write!(
971            f,
972            "RString {{ basic: {:?}, len: {:?}, as: {:?} }}",
973            self.basic, self.len, self.as_
974        )
975    }
976}
977pub type st_data_t = usize;
978pub type st_index_t = st_data_t;
979#[repr(C)]
980#[derive(Debug, Copy, Clone)]
981pub struct st_hash_type {
982    pub compare: ::std::option::Option<
983        unsafe extern "C" fn(arg1: st_data_t, arg2: st_data_t) -> ::std::os::raw::c_int,
984    >,
985    pub hash: ::std::option::Option<unsafe extern "C" fn(arg1: st_data_t) -> st_index_t>,
986}
987#[repr(C)]
988#[derive(Debug)]
989pub struct st_table_entry {
990    _unused: [u8; 0],
991}
992#[repr(C)]
993#[derive(Debug, Copy, Clone)]
994pub struct st_table {
995    pub entry_power: ::std::os::raw::c_uchar,
996    pub bin_power: ::std::os::raw::c_uchar,
997    pub size_ind: ::std::os::raw::c_uchar,
998    pub rebuilds_num: ::std::os::raw::c_uint,
999    pub type_: *const st_hash_type,
1000    pub num_entries: st_index_t,
1001    pub bins: *mut st_index_t,
1002    pub entries_start: st_index_t,
1003    pub entries_bound: st_index_t,
1004    pub entries: *mut st_table_entry,
1005}
1006#[repr(C)]
1007#[derive(Copy, Clone)]
1008pub struct RArray {
1009    pub basic: RBasic,
1010    pub as_: RArray__bindgen_ty_1,
1011}
1012#[repr(C)]
1013#[derive(Copy, Clone)]
1014pub union RArray__bindgen_ty_1 {
1015    pub heap: RArray__bindgen_ty_1__bindgen_ty_1,
1016    pub ary: [VALUE; 1usize],
1017}
1018#[repr(C)]
1019#[derive(Copy, Clone)]
1020pub struct RArray__bindgen_ty_1__bindgen_ty_1 {
1021    pub len: ::std::os::raw::c_long,
1022    pub aux: RArray__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
1023    pub ptr: *const VALUE,
1024}
1025#[repr(C)]
1026#[derive(Copy, Clone)]
1027pub union RArray__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
1028    pub capa: ::std::os::raw::c_long,
1029    pub shared_root: VALUE,
1030}
1031impl ::std::fmt::Debug for RArray__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
1032    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1033        write!(
1034            f,
1035            "RArray__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {{ union }}"
1036        )
1037    }
1038}
1039impl ::std::fmt::Debug for RArray__bindgen_ty_1__bindgen_ty_1 {
1040    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1041        write!(
1042            f,
1043            "RArray__bindgen_ty_1__bindgen_ty_1 {{ len: {:?}, aux: {:?}, ptr: {:?} }}",
1044            self.len, self.aux, self.ptr
1045        )
1046    }
1047}
1048impl ::std::fmt::Debug for RArray__bindgen_ty_1 {
1049    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1050        write!(f, "RArray__bindgen_ty_1 {{ union }}")
1051    }
1052}
1053impl ::std::fmt::Debug for RArray {
1054    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1055        write!(
1056            f,
1057            "RArray {{ basic: {:?}, as: {:?} }}",
1058            self.basic, self.as_
1059        )
1060    }
1061}
1062pub type rb_event_flag_t = u32;
1063pub type rb_unblock_function_t =
1064    ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>;
1065#[repr(C)]
1066#[derive(Debug, Copy, Clone)]
1067pub struct rb_box_struct {
1068    pub box_object: VALUE,
1069    pub box_id: ::std::os::raw::c_long,
1070    pub top_self: VALUE,
1071    pub load_path: VALUE,
1072    pub load_path_snapshot: VALUE,
1073    pub load_path_check_cache: VALUE,
1074    pub expanded_load_path: VALUE,
1075    pub loaded_features: VALUE,
1076    pub loaded_features_snapshot: VALUE,
1077    pub loaded_features_realpaths: VALUE,
1078    pub loaded_features_realpath_map: VALUE,
1079    pub loaded_features_index: *mut st_table,
1080    pub loading_table: *mut st_table,
1081    pub ruby_dln_libmap: VALUE,
1082    pub gvar_tbl: VALUE,
1083    pub classext_cow_classes: *mut st_table,
1084    pub is_root: u8,
1085    pub is_user: u8,
1086    pub is_optional: u8,
1087}
1088pub type rb_box_t = rb_box_struct;
1089pub type rb_serial_t = ::std::os::raw::c_ulonglong;
1090#[repr(C)]
1091#[derive(Debug)]
1092pub struct set_table_entry {
1093    _unused: [u8; 0],
1094}
1095#[repr(C)]
1096#[derive(Debug, Copy, Clone)]
1097pub struct set_table {
1098    pub entry_power: ::std::os::raw::c_uchar,
1099    pub bin_power: ::std::os::raw::c_uchar,
1100    pub size_ind: ::std::os::raw::c_uchar,
1101    pub rebuilds_num: ::std::os::raw::c_uint,
1102    pub type_: *const st_hash_type,
1103    pub num_entries: st_index_t,
1104    pub entries_start: st_index_t,
1105    pub entries_bound: st_index_t,
1106    pub entries: *mut set_table_entry,
1107}
1108pub const method_missing_reason_MISSING_NOENTRY: method_missing_reason = 0;
1109pub const method_missing_reason_MISSING_PRIVATE: method_missing_reason = 1;
1110pub const method_missing_reason_MISSING_PROTECTED: method_missing_reason = 2;
1111pub const method_missing_reason_MISSING_FCALL: method_missing_reason = 4;
1112pub const method_missing_reason_MISSING_VCALL: method_missing_reason = 8;
1113pub const method_missing_reason_MISSING_SUPER: method_missing_reason = 16;
1114pub const method_missing_reason_MISSING_MISSING: method_missing_reason = 32;
1115pub const method_missing_reason_MISSING_NONE: method_missing_reason = 64;
1116pub type method_missing_reason = ::std::os::raw::c_uint;
1117#[repr(C)]
1118#[derive(Debug)]
1119pub struct rb_callcache {
1120    _unused: [u8; 0],
1121}
1122#[repr(C)]
1123#[derive(Debug)]
1124pub struct rb_id_table {
1125    _unused: [u8; 0],
1126}
1127pub const imemo_type_imemo_env: imemo_type = 0;
1128pub const imemo_type_imemo_cref: imemo_type = 1;
1129pub const imemo_type_imemo_svar: imemo_type = 2;
1130pub const imemo_type_imemo_throw_data: imemo_type = 3;
1131pub const imemo_type_imemo_ifunc: imemo_type = 4;
1132pub const imemo_type_imemo_memo: imemo_type = 5;
1133pub const imemo_type_imemo_ment: imemo_type = 6;
1134pub const imemo_type_imemo_iseq: imemo_type = 7;
1135pub const imemo_type_imemo_tmpbuf: imemo_type = 8;
1136pub const imemo_type_imemo_cvar_entry: imemo_type = 9;
1137pub const imemo_type_imemo_callinfo: imemo_type = 10;
1138pub const imemo_type_imemo_callcache: imemo_type = 11;
1139pub const imemo_type_imemo_constcache: imemo_type = 12;
1140pub const imemo_type_imemo_fields: imemo_type = 13;
1141pub type imemo_type = ::std::os::raw::c_uint;
1142#[repr(C)]
1143#[derive(Debug, Copy, Clone)]
1144pub struct vm_svar {
1145    pub flags: VALUE,
1146    pub cref_or_me: VALUE,
1147    pub lastline: VALUE,
1148    pub backref: VALUE,
1149    pub others: VALUE,
1150}
1151pub type rb_atomic_t = ::std::os::raw::c_uint;
1152pub const rb_method_visibility_t_METHOD_VISI_UNDEF: rb_method_visibility_t = 0;
1153pub const rb_method_visibility_t_METHOD_VISI_PUBLIC: rb_method_visibility_t = 1;
1154pub const rb_method_visibility_t_METHOD_VISI_PRIVATE: rb_method_visibility_t = 2;
1155pub const rb_method_visibility_t_METHOD_VISI_PROTECTED: rb_method_visibility_t = 3;
1156pub const rb_method_visibility_t_METHOD_VISI_MASK: rb_method_visibility_t = 3;
1157pub type rb_method_visibility_t = ::std::os::raw::c_uint;
1158#[repr(C)]
1159#[derive(Debug, Copy, Clone)]
1160pub struct rb_scope_visi_struct {
1161    pub _bindgen_align: [u32; 0],
1162    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
1163    pub __bindgen_padding_0: [u8; 3usize],
1164}
1165impl rb_scope_visi_struct {
1166    #[inline]
1167    #[allow(unnecessary_transmutes)]
1168    pub fn method_visi(&self) -> rb_method_visibility_t {
1169        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<0usize, 3u8>() as u32) }
1170    }
1171    #[inline]
1172    #[allow(unnecessary_transmutes)]
1173    pub fn set_method_visi(&mut self, val: rb_method_visibility_t) {
1174        unsafe {
1175            let val: u32 = ::std::mem::transmute(val);
1176            self._bitfield_1.set_const::<0usize, 3u8>(val as u64)
1177        }
1178    }
1179    #[inline]
1180    #[allow(unnecessary_transmutes)]
1181    pub unsafe fn method_visi_raw(this: *const Self) -> rb_method_visibility_t {
1182        unsafe {
1183            ::std::mem::transmute(
1184                <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get_const::<0usize, 3u8>(
1185                    ::std::ptr::addr_of!((*this)._bitfield_1),
1186                ) as u32,
1187            )
1188        }
1189    }
1190    #[inline]
1191    #[allow(unnecessary_transmutes)]
1192    pub unsafe fn set_method_visi_raw(this: *mut Self, val: rb_method_visibility_t) {
1193        unsafe {
1194            let val: u32 = ::std::mem::transmute(val);
1195            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set_const::<0usize, 3u8>(
1196                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1197                val as u64,
1198            )
1199        }
1200    }
1201    #[inline]
1202    #[allow(unnecessary_transmutes)]
1203    pub fn module_func(&self) -> ::std::os::raw::c_uint {
1204        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<3usize, 1u8>() as u32) }
1205    }
1206    #[inline]
1207    #[allow(unnecessary_transmutes)]
1208    pub fn set_module_func(&mut self, val: ::std::os::raw::c_uint) {
1209        unsafe {
1210            let val: u32 = ::std::mem::transmute(val);
1211            self._bitfield_1.set_const::<3usize, 1u8>(val as u64)
1212        }
1213    }
1214    #[inline]
1215    #[allow(unnecessary_transmutes)]
1216    pub unsafe fn module_func_raw(this: *const Self) -> ::std::os::raw::c_uint {
1217        unsafe {
1218            ::std::mem::transmute(
1219                <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get_const::<3usize, 1u8>(
1220                    ::std::ptr::addr_of!((*this)._bitfield_1),
1221                ) as u32,
1222            )
1223        }
1224    }
1225    #[inline]
1226    #[allow(unnecessary_transmutes)]
1227    pub unsafe fn set_module_func_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
1228        unsafe {
1229            let val: u32 = ::std::mem::transmute(val);
1230            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set_const::<3usize, 1u8>(
1231                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1232                val as u64,
1233            )
1234        }
1235    }
1236    #[inline]
1237    #[allow(unnecessary_transmutes)]
1238    pub fn new_bitfield_1(
1239        method_visi: rb_method_visibility_t,
1240        module_func: ::std::os::raw::c_uint,
1241    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
1242        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
1243        __bindgen_bitfield_unit.set_const::<0usize, 3u8>({
1244            let method_visi: u32 = unsafe { ::std::mem::transmute(method_visi) };
1245            method_visi as u64
1246        });
1247        __bindgen_bitfield_unit.set_const::<3usize, 1u8>({
1248            let module_func: u32 = unsafe { ::std::mem::transmute(module_func) };
1249            module_func as u64
1250        });
1251        __bindgen_bitfield_unit
1252    }
1253}
1254pub type rb_scope_visibility_t = rb_scope_visi_struct;
1255#[repr(C)]
1256#[derive(Debug, Copy, Clone)]
1257pub struct rb_cref_struct {
1258    pub flags: VALUE,
1259    pub refinements: VALUE,
1260    pub klass_or_self: VALUE,
1261    pub next: *mut rb_cref_struct,
1262    pub scope_visi: rb_scope_visibility_t,
1263}
1264pub type rb_cref_t = rb_cref_struct;
1265#[repr(C)]
1266#[derive(Debug, Copy, Clone)]
1267pub struct rb_method_entry_struct {
1268    pub flags: VALUE,
1269    pub defined_class: VALUE,
1270    pub def: *mut rb_method_definition_struct,
1271    pub called_id: ID,
1272    pub owner: VALUE,
1273}
1274pub const rb_method_type_t_VM_METHOD_TYPE_ISEQ: rb_method_type_t = 0;
1275pub const rb_method_type_t_VM_METHOD_TYPE_CFUNC: rb_method_type_t = 1;
1276pub const rb_method_type_t_VM_METHOD_TYPE_ATTRSET: rb_method_type_t = 2;
1277pub const rb_method_type_t_VM_METHOD_TYPE_IVAR: rb_method_type_t = 3;
1278pub const rb_method_type_t_VM_METHOD_TYPE_BMETHOD: rb_method_type_t = 4;
1279pub const rb_method_type_t_VM_METHOD_TYPE_ZSUPER: rb_method_type_t = 5;
1280pub const rb_method_type_t_VM_METHOD_TYPE_ALIAS: rb_method_type_t = 6;
1281pub const rb_method_type_t_VM_METHOD_TYPE_UNDEF: rb_method_type_t = 7;
1282pub const rb_method_type_t_VM_METHOD_TYPE_NOTIMPLEMENTED: rb_method_type_t = 8;
1283pub const rb_method_type_t_VM_METHOD_TYPE_OPTIMIZED: rb_method_type_t = 9;
1284pub const rb_method_type_t_VM_METHOD_TYPE_MISSING: rb_method_type_t = 10;
1285pub const rb_method_type_t_VM_METHOD_TYPE_REFINED: rb_method_type_t = 11;
1286pub type rb_method_type_t = ::std::os::raw::c_uint;
1287pub type rb_iseq_t = rb_iseq_struct;
1288#[repr(C)]
1289#[derive(Debug, Copy, Clone)]
1290pub struct rb_method_iseq_struct {
1291    pub iseqptr: *const rb_iseq_t,
1292    pub cref: *mut rb_cref_t,
1293}
1294pub type rb_method_iseq_t = rb_method_iseq_struct;
1295pub type rb_cfunc_t = ::std::option::Option<unsafe extern "C" fn() -> VALUE>;
1296#[repr(C)]
1297#[derive(Debug, Copy, Clone)]
1298pub struct rb_method_cfunc_struct {
1299    pub func: rb_cfunc_t,
1300    pub invoker: ::std::option::Option<
1301        unsafe extern "C" fn(
1302            recv: VALUE,
1303            argc: ::std::os::raw::c_int,
1304            argv: *const VALUE,
1305            func: ::std::option::Option<unsafe extern "C" fn() -> VALUE>,
1306        ) -> VALUE,
1307    >,
1308    pub argc: ::std::os::raw::c_int,
1309}
1310pub type rb_method_cfunc_t = rb_method_cfunc_struct;
1311#[repr(C)]
1312#[derive(Debug, Copy, Clone)]
1313pub struct rb_method_attr_struct {
1314    pub id: ID,
1315    pub location: VALUE,
1316}
1317pub type rb_method_attr_t = rb_method_attr_struct;
1318#[repr(C)]
1319#[derive(Debug, Copy, Clone)]
1320pub struct rb_method_alias_struct {
1321    pub original_me: *mut rb_method_entry_struct,
1322}
1323pub type rb_method_alias_t = rb_method_alias_struct;
1324#[repr(C)]
1325#[derive(Debug, Copy, Clone)]
1326pub struct rb_method_refined_struct {
1327    pub orig_me: *mut rb_method_entry_struct,
1328}
1329pub type rb_method_refined_t = rb_method_refined_struct;
1330#[repr(C)]
1331#[derive(Debug, Copy, Clone)]
1332pub struct rb_method_bmethod_struct {
1333    pub proc_: VALUE,
1334    pub defined_ractor_id: rb_serial_t,
1335    pub local_hooks_cnt: ::std::os::raw::c_uint,
1336}
1337pub type rb_method_bmethod_t = rb_method_bmethod_struct;
1338pub const method_optimized_type_OPTIMIZED_METHOD_TYPE_SEND: method_optimized_type = 0;
1339pub const method_optimized_type_OPTIMIZED_METHOD_TYPE_CALL: method_optimized_type = 1;
1340pub const method_optimized_type_OPTIMIZED_METHOD_TYPE_BLOCK_CALL: method_optimized_type = 2;
1341pub const method_optimized_type_OPTIMIZED_METHOD_TYPE_STRUCT_AREF: method_optimized_type = 3;
1342pub const method_optimized_type_OPTIMIZED_METHOD_TYPE_STRUCT_ASET: method_optimized_type = 4;
1343pub const method_optimized_type_OPTIMIZED_METHOD_TYPE__MAX: method_optimized_type = 5;
1344pub type method_optimized_type = ::std::os::raw::c_uint;
1345#[repr(C)]
1346#[derive(Debug, Copy, Clone)]
1347pub struct rb_method_optimized {
1348    pub type_: method_optimized_type,
1349    pub index: ::std::os::raw::c_uint,
1350}
1351pub type rb_method_optimized_t = rb_method_optimized;
1352#[repr(C)]
1353#[derive(Copy, Clone)]
1354pub struct rb_method_definition_struct {
1355    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
1356    pub reference_count: rb_atomic_t,
1357    pub body: rb_method_definition_struct__bindgen_ty_1,
1358    pub original_id: ID,
1359    pub method_serial: usize,
1360    pub box_: *const rb_box_t,
1361}
1362#[repr(C)]
1363#[derive(Copy, Clone)]
1364pub union rb_method_definition_struct__bindgen_ty_1 {
1365    pub iseq: rb_method_iseq_t,
1366    pub cfunc: rb_method_cfunc_t,
1367    pub attr: rb_method_attr_t,
1368    pub alias: rb_method_alias_t,
1369    pub refined: rb_method_refined_t,
1370    pub bmethod: rb_method_bmethod_t,
1371    pub optimized: rb_method_optimized_t,
1372}
1373impl ::std::fmt::Debug for rb_method_definition_struct__bindgen_ty_1 {
1374    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1375        write!(f, "rb_method_definition_struct__bindgen_ty_1 {{ union }}")
1376    }
1377}
1378impl rb_method_definition_struct {
1379    #[inline]
1380    #[allow(unnecessary_transmutes)]
1381    pub fn type_(&self) -> rb_method_type_t {
1382        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<0usize, 4u8>() as u32) }
1383    }
1384    #[inline]
1385    #[allow(unnecessary_transmutes)]
1386    pub fn set_type(&mut self, val: rb_method_type_t) {
1387        unsafe {
1388            let val: u32 = ::std::mem::transmute(val);
1389            self._bitfield_1.set_const::<0usize, 4u8>(val as u64)
1390        }
1391    }
1392    #[inline]
1393    #[allow(unnecessary_transmutes)]
1394    pub unsafe fn type__raw(this: *const Self) -> rb_method_type_t {
1395        unsafe {
1396            ::std::mem::transmute(
1397                <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get_const::<0usize, 4u8>(
1398                    ::std::ptr::addr_of!((*this)._bitfield_1),
1399                ) as u32,
1400            )
1401        }
1402    }
1403    #[inline]
1404    #[allow(unnecessary_transmutes)]
1405    pub unsafe fn set_type_raw(this: *mut Self, val: rb_method_type_t) {
1406        unsafe {
1407            let val: u32 = ::std::mem::transmute(val);
1408            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set_const::<0usize, 4u8>(
1409                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1410                val as u64,
1411            )
1412        }
1413    }
1414    #[inline]
1415    #[allow(unnecessary_transmutes)]
1416    pub fn iseq_overload(&self) -> ::std::os::raw::c_uint {
1417        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<4usize, 1u8>() as u32) }
1418    }
1419    #[inline]
1420    #[allow(unnecessary_transmutes)]
1421    pub fn set_iseq_overload(&mut self, val: ::std::os::raw::c_uint) {
1422        unsafe {
1423            let val: u32 = ::std::mem::transmute(val);
1424            self._bitfield_1.set_const::<4usize, 1u8>(val as u64)
1425        }
1426    }
1427    #[inline]
1428    #[allow(unnecessary_transmutes)]
1429    pub unsafe fn iseq_overload_raw(this: *const Self) -> ::std::os::raw::c_uint {
1430        unsafe {
1431            ::std::mem::transmute(
1432                <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get_const::<4usize, 1u8>(
1433                    ::std::ptr::addr_of!((*this)._bitfield_1),
1434                ) as u32,
1435            )
1436        }
1437    }
1438    #[inline]
1439    #[allow(unnecessary_transmutes)]
1440    pub unsafe fn set_iseq_overload_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
1441        unsafe {
1442            let val: u32 = ::std::mem::transmute(val);
1443            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set_const::<4usize, 1u8>(
1444                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1445                val as u64,
1446            )
1447        }
1448    }
1449    #[inline]
1450    #[allow(unnecessary_transmutes)]
1451    pub fn no_redef_warning(&self) -> ::std::os::raw::c_uint {
1452        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<5usize, 1u8>() as u32) }
1453    }
1454    #[inline]
1455    #[allow(unnecessary_transmutes)]
1456    pub fn set_no_redef_warning(&mut self, val: ::std::os::raw::c_uint) {
1457        unsafe {
1458            let val: u32 = ::std::mem::transmute(val);
1459            self._bitfield_1.set_const::<5usize, 1u8>(val as u64)
1460        }
1461    }
1462    #[inline]
1463    #[allow(unnecessary_transmutes)]
1464    pub unsafe fn no_redef_warning_raw(this: *const Self) -> ::std::os::raw::c_uint {
1465        unsafe {
1466            ::std::mem::transmute(
1467                <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get_const::<5usize, 1u8>(
1468                    ::std::ptr::addr_of!((*this)._bitfield_1),
1469                ) as u32,
1470            )
1471        }
1472    }
1473    #[inline]
1474    #[allow(unnecessary_transmutes)]
1475    pub unsafe fn set_no_redef_warning_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
1476        unsafe {
1477            let val: u32 = ::std::mem::transmute(val);
1478            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set_const::<5usize, 1u8>(
1479                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1480                val as u64,
1481            )
1482        }
1483    }
1484    #[inline]
1485    #[allow(unnecessary_transmutes)]
1486    pub fn aliased(&self) -> ::std::os::raw::c_uint {
1487        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<6usize, 1u8>() as u32) }
1488    }
1489    #[inline]
1490    #[allow(unnecessary_transmutes)]
1491    pub fn set_aliased(&mut self, val: ::std::os::raw::c_uint) {
1492        unsafe {
1493            let val: u32 = ::std::mem::transmute(val);
1494            self._bitfield_1.set_const::<6usize, 1u8>(val as u64)
1495        }
1496    }
1497    #[inline]
1498    #[allow(unnecessary_transmutes)]
1499    pub unsafe fn aliased_raw(this: *const Self) -> ::std::os::raw::c_uint {
1500        unsafe {
1501            ::std::mem::transmute(
1502                <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get_const::<6usize, 1u8>(
1503                    ::std::ptr::addr_of!((*this)._bitfield_1),
1504                ) as u32,
1505            )
1506        }
1507    }
1508    #[inline]
1509    #[allow(unnecessary_transmutes)]
1510    pub unsafe fn set_aliased_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
1511        unsafe {
1512            let val: u32 = ::std::mem::transmute(val);
1513            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set_const::<6usize, 1u8>(
1514                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1515                val as u64,
1516            )
1517        }
1518    }
1519    #[inline]
1520    #[allow(unnecessary_transmutes)]
1521    pub fn new_bitfield_1(
1522        type_: rb_method_type_t,
1523        iseq_overload: ::std::os::raw::c_uint,
1524        no_redef_warning: ::std::os::raw::c_uint,
1525        aliased: ::std::os::raw::c_uint,
1526    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
1527        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
1528        __bindgen_bitfield_unit.set_const::<0usize, 4u8>({
1529            let type_: u32 = unsafe { ::std::mem::transmute(type_) };
1530            type_ as u64
1531        });
1532        __bindgen_bitfield_unit.set_const::<4usize, 1u8>({
1533            let iseq_overload: u32 = unsafe { ::std::mem::transmute(iseq_overload) };
1534            iseq_overload as u64
1535        });
1536        __bindgen_bitfield_unit.set_const::<5usize, 1u8>({
1537            let no_redef_warning: u32 = unsafe { ::std::mem::transmute(no_redef_warning) };
1538            no_redef_warning as u64
1539        });
1540        __bindgen_bitfield_unit.set_const::<6usize, 1u8>({
1541            let aliased: u32 = unsafe { ::std::mem::transmute(aliased) };
1542            aliased as u64
1543        });
1544        __bindgen_bitfield_unit
1545    }
1546}
1547#[repr(C)]
1548#[derive(Debug, Copy, Clone)]
1549pub struct rb_code_position_struct {
1550    pub lineno: ::std::os::raw::c_int,
1551    pub column: ::std::os::raw::c_int,
1552}
1553pub type rb_code_position_t = rb_code_position_struct;
1554#[repr(C)]
1555#[derive(Debug, Copy, Clone)]
1556pub struct rb_code_location_struct {
1557    pub beg_pos: rb_code_position_t,
1558    pub end_pos: rb_code_position_t,
1559}
1560pub type rb_code_location_t = rb_code_location_struct;
1561#[repr(C)]
1562#[derive(Debug, Copy, Clone)]
1563pub struct RNode {
1564    pub flags: VALUE,
1565    pub nd_loc: rb_code_location_t,
1566    pub node_id: ::std::os::raw::c_int,
1567}
1568pub type NODE = RNode;
1569pub type rb_nativethread_id_t = pthread_t;
1570pub type rb_nativethread_lock_t = pthread_mutex_t;
1571pub type rb_nativethread_cond_t = pthread_cond_t;
1572#[repr(C)]
1573#[derive(Debug, Copy, Clone)]
1574pub struct rb_thread_sched_waiting {
1575    pub flags: rb_thread_sched_waiting_thread_sched_waiting_flag,
1576    pub data: rb_thread_sched_waiting__bindgen_ty_1,
1577    pub node: ccan_list_node,
1578}
1579pub const rb_thread_sched_waiting_thread_sched_waiting_flag_thread_sched_waiting_none:
1580    rb_thread_sched_waiting_thread_sched_waiting_flag = 0;
1581pub const rb_thread_sched_waiting_thread_sched_waiting_flag_thread_sched_waiting_timeout:
1582    rb_thread_sched_waiting_thread_sched_waiting_flag = 1;
1583pub const rb_thread_sched_waiting_thread_sched_waiting_flag_thread_sched_waiting_io_read:
1584    rb_thread_sched_waiting_thread_sched_waiting_flag = 2;
1585pub const rb_thread_sched_waiting_thread_sched_waiting_flag_thread_sched_waiting_io_write:
1586    rb_thread_sched_waiting_thread_sched_waiting_flag = 8;
1587pub const rb_thread_sched_waiting_thread_sched_waiting_flag_thread_sched_waiting_io_force:
1588    rb_thread_sched_waiting_thread_sched_waiting_flag = 64;
1589pub type rb_thread_sched_waiting_thread_sched_waiting_flag = ::std::os::raw::c_uint;
1590#[repr(C)]
1591#[derive(Debug, Copy, Clone)]
1592pub struct rb_thread_sched_waiting__bindgen_ty_1 {
1593    pub timeout: u64,
1594    pub event_serial: u32,
1595    pub fd: ::std::os::raw::c_int,
1596    pub result: ::std::os::raw::c_int,
1597}
1598#[repr(C)]
1599#[derive(Debug, Copy, Clone)]
1600pub struct rb_thread_sched_item {
1601    pub node: rb_thread_sched_item__bindgen_ty_1,
1602    pub waiting_reason: rb_thread_sched_waiting,
1603    pub event_serial: u32,
1604    pub finished: u8,
1605    pub malloc_stack: u8,
1606    pub context_stack: *mut ::std::os::raw::c_void,
1607    pub context: *mut coroutine_context,
1608}
1609#[repr(C)]
1610#[derive(Debug, Copy, Clone)]
1611pub struct rb_thread_sched_item__bindgen_ty_1 {
1612    pub ubf: ccan_list_node,
1613    pub readyq: ccan_list_node,
1614    pub is_ready: u8,
1615    pub timeslice_threads: ccan_list_node,
1616    pub running_threads: ccan_list_node,
1617    pub zombie_threads: ccan_list_node,
1618}
1619#[repr(C)]
1620#[derive(Copy, Clone)]
1621pub struct rb_native_thread {
1622    pub serial: rb_atomic_t,
1623    pub vm: *mut rb_vm_struct,
1624    pub thread_id: rb_nativethread_id_t,
1625    pub tid: ::std::os::raw::c_int,
1626    pub running_thread: *mut rb_thread_struct,
1627    pub cond: rb_native_thread__bindgen_ty_1,
1628    pub altstack: *mut ::std::os::raw::c_void,
1629    pub nt_context: *mut coroutine_context,
1630    pub dedicated: ::std::os::raw::c_int,
1631    pub machine_stack_maxsize: usize,
1632}
1633#[repr(C)]
1634#[derive(Copy, Clone)]
1635pub union rb_native_thread__bindgen_ty_1 {
1636    pub intr: rb_nativethread_cond_t,
1637    pub readyq: rb_nativethread_cond_t,
1638}
1639impl ::std::fmt::Debug for rb_native_thread__bindgen_ty_1 {
1640    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1641        write!(f, "rb_native_thread__bindgen_ty_1 {{ union }}")
1642    }
1643}
1644impl ::std::fmt::Debug for rb_native_thread {
1645    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1646        write ! (f , "rb_native_thread {{ serial: {:?}, vm: {:?}, thread_id: {:?}, tid: {:?}, running_thread: {:?}, cond: {:?}, altstack: {:?}, nt_context: {:?}, dedicated: {:?} }}" , self . serial , self . vm , self . thread_id , self . tid , self . running_thread , self . cond , self . altstack , self . nt_context , self . dedicated)
1647    }
1648}
1649#[repr(C)]
1650#[derive(Copy, Clone)]
1651pub struct rb_thread_sched {
1652    pub lock_: rb_nativethread_lock_t,
1653    pub running: *mut rb_thread_struct,
1654    pub runnable_hot_th: *mut rb_thread_struct,
1655    pub runnable_hot_th_waiting: ::std::os::raw::c_int,
1656    pub is_running: u8,
1657    pub is_running_timeslice: u8,
1658    pub enable_mn_threads: u8,
1659    pub readyq: ccan_list_head,
1660    pub readyq_cnt: ::std::os::raw::c_int,
1661    pub grq_node: ccan_list_node,
1662}
1663impl ::std::fmt::Debug for rb_thread_sched {
1664    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1665        write ! (f , "rb_thread_sched {{ lock_: {:?}, running: {:?}, runnable_hot_th: {:?}, runnable_hot_th_waiting: {:?}, is_running: {:?}, is_running_timeslice: {:?}, enable_mn_threads: {:?}, readyq: {:?}, readyq_cnt: {:?}, grq_node: {:?} }}" , self . lock_ , self . running , self . runnable_hot_th , self . runnable_hot_th_waiting , self . is_running , self . is_running_timeslice , self . enable_mn_threads , self . readyq , self . readyq_cnt , self . grq_node)
1666    }
1667}
1668pub type rb_snum_t = ::std::os::raw::c_long;
1669pub const ruby_tag_type_RUBY_TAG_NONE: ruby_tag_type = 0;
1670pub const ruby_tag_type_RUBY_TAG_RETURN: ruby_tag_type = 1;
1671pub const ruby_tag_type_RUBY_TAG_BREAK: ruby_tag_type = 2;
1672pub const ruby_tag_type_RUBY_TAG_NEXT: ruby_tag_type = 3;
1673pub const ruby_tag_type_RUBY_TAG_RETRY: ruby_tag_type = 4;
1674pub const ruby_tag_type_RUBY_TAG_REDO: ruby_tag_type = 5;
1675pub const ruby_tag_type_RUBY_TAG_RAISE: ruby_tag_type = 6;
1676pub const ruby_tag_type_RUBY_TAG_THROW: ruby_tag_type = 7;
1677pub const ruby_tag_type_RUBY_TAG_FATAL: ruby_tag_type = 8;
1678pub const ruby_tag_type_RUBY_TAG_MASK: ruby_tag_type = 15;
1679pub type ruby_tag_type = ::std::os::raw::c_uint;
1680pub type rb_compile_option_t = rb_compile_option_struct;
1681#[repr(C)]
1682#[derive(Debug, Copy, Clone)]
1683pub struct iseq_inline_constant_cache_entry {
1684    pub flags: VALUE,
1685    pub value: VALUE,
1686    pub ic_cref: *const rb_cref_t,
1687}
1688#[repr(C)]
1689#[derive(Debug, Copy, Clone)]
1690pub struct iseq_inline_constant_cache {
1691    pub entry: *mut iseq_inline_constant_cache_entry,
1692    pub segments: *const ID,
1693}
1694#[repr(C)]
1695#[derive(Debug, Copy, Clone)]
1696pub struct iseq_inline_iv_cache_entry {
1697    pub value: u64,
1698    pub iv_set_name: ID,
1699}
1700#[repr(C)]
1701#[derive(Copy, Clone)]
1702pub union iseq_inline_storage_entry {
1703    pub once: iseq_inline_storage_entry__bindgen_ty_1,
1704    pub ic_cache: iseq_inline_constant_cache,
1705    pub iv_cache: iseq_inline_iv_cache_entry,
1706}
1707#[repr(C)]
1708#[derive(Debug, Copy, Clone)]
1709pub struct iseq_inline_storage_entry__bindgen_ty_1 {
1710    pub running_thread: *mut rb_thread_struct,
1711    pub value: VALUE,
1712}
1713impl ::std::fmt::Debug for iseq_inline_storage_entry {
1714    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1715        write!(f, "iseq_inline_storage_entry {{ union }}")
1716    }
1717}
1718#[repr(C)]
1719#[derive(Debug, Copy, Clone)]
1720pub struct rb_calling_info {
1721    pub cd: *mut rb_call_data,
1722    pub cc: *const rb_callcache,
1723    pub block_handler: VALUE,
1724    pub recv: VALUE,
1725    pub argc: ::std::os::raw::c_int,
1726    pub kw_splat: u8,
1727    pub heap_argv: VALUE,
1728}
1729#[repr(C)]
1730#[derive(Debug, Copy, Clone)]
1731pub struct rb_iseq_location_struct {
1732    pub pathobj: VALUE,
1733    pub base_label: VALUE,
1734    pub label: VALUE,
1735    pub first_lineno: ::std::os::raw::c_int,
1736    pub node_id: ::std::os::raw::c_int,
1737    pub code_location: rb_code_location_t,
1738}
1739pub type rb_iseq_location_t = rb_iseq_location_struct;
1740pub type iseq_bits_t = usize;
1741pub const rb_iseq_type_ISEQ_TYPE_TOP: rb_iseq_type = 0;
1742pub const rb_iseq_type_ISEQ_TYPE_METHOD: rb_iseq_type = 1;
1743pub const rb_iseq_type_ISEQ_TYPE_BLOCK: rb_iseq_type = 2;
1744pub const rb_iseq_type_ISEQ_TYPE_CLASS: rb_iseq_type = 3;
1745pub const rb_iseq_type_ISEQ_TYPE_RESCUE: rb_iseq_type = 4;
1746pub const rb_iseq_type_ISEQ_TYPE_ENSURE: rb_iseq_type = 5;
1747pub const rb_iseq_type_ISEQ_TYPE_EVAL: rb_iseq_type = 6;
1748pub const rb_iseq_type_ISEQ_TYPE_MAIN: rb_iseq_type = 7;
1749pub const rb_iseq_type_ISEQ_TYPE_PLAIN: rb_iseq_type = 8;
1750pub type rb_iseq_type = ::std::os::raw::c_uint;
1751pub type rb_jit_func_t = ::std::option::Option<
1752    unsafe extern "C" fn(
1753        arg1: *mut rb_execution_context_struct,
1754        arg2: *mut rb_control_frame_struct,
1755    ) -> VALUE,
1756>;
1757#[repr(C)]
1758#[derive(Copy, Clone)]
1759pub struct rb_iseq_constant_body {
1760    pub type_: rb_iseq_type,
1761    pub iseq_size: ::std::os::raw::c_uint,
1762    pub iseq_encoded: *mut VALUE,
1763    pub param: rb_iseq_constant_body_rb_iseq_parameters,
1764    pub location: rb_iseq_location_t,
1765    pub insns_info: rb_iseq_constant_body_iseq_insn_info,
1766    pub local_table: *const ID,
1767    pub lvar_states: *mut rb_iseq_constant_body_lvar_state,
1768    pub catch_table: *mut iseq_catch_table,
1769    pub parent_iseq: *const rb_iseq_struct,
1770    pub local_iseq: *mut rb_iseq_struct,
1771    pub is_entries: *mut iseq_inline_storage_entry,
1772    pub call_data: *mut rb_call_data,
1773    pub variable: rb_iseq_constant_body__bindgen_ty_1,
1774    pub local_table_size: ::std::os::raw::c_uint,
1775    pub ic_size: ::std::os::raw::c_uint,
1776    pub ise_size: ::std::os::raw::c_uint,
1777    pub ivc_size: ::std::os::raw::c_uint,
1778    pub icvarc_size: ::std::os::raw::c_uint,
1779    pub ci_size: ::std::os::raw::c_uint,
1780    pub stack_max: ::std::os::raw::c_uint,
1781    pub builtin_attrs: ::std::os::raw::c_uint,
1782    pub prism: u8,
1783    pub jit_ep_escape_recorded: rb_atomic_t,
1784    pub mark_bits: rb_iseq_constant_body__bindgen_ty_2,
1785    pub outer_variables: *mut rb_id_table,
1786    pub mandatory_only_iseq: *const rb_iseq_t,
1787    pub jit_entry: rb_jit_func_t,
1788    pub jit_entry_calls: ::std::os::raw::c_ulong,
1789    pub jit_exception: rb_jit_func_t,
1790    pub jit_exception_calls: ::std::os::raw::c_ulong,
1791    pub yjit_payload: *mut ::std::os::raw::c_void,
1792    pub yjit_calls_at_interv: u64,
1793}
1794#[repr(C)]
1795#[derive(Debug, Copy, Clone)]
1796pub struct rb_iseq_constant_body_rb_iseq_parameters {
1797    pub flags: rb_iseq_constant_body_rb_iseq_parameters__bindgen_ty_1,
1798    pub size: ::std::os::raw::c_uint,
1799    pub lead_num: ::std::os::raw::c_int,
1800    pub opt_num: ::std::os::raw::c_int,
1801    pub rest_start: ::std::os::raw::c_int,
1802    pub post_start: ::std::os::raw::c_int,
1803    pub post_num: ::std::os::raw::c_int,
1804    pub block_start: ::std::os::raw::c_int,
1805    pub opt_table: *const VALUE,
1806    pub keyword: *const rb_iseq_constant_body_rb_iseq_parameters_rb_iseq_param_keyword,
1807}
1808#[repr(C)]
1809#[derive(Debug, Copy, Clone)]
1810pub struct rb_iseq_constant_body_rb_iseq_parameters__bindgen_ty_1 {
1811    pub _bindgen_align: [u32; 0],
1812    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
1813    pub __bindgen_padding_0: u16,
1814}
1815impl rb_iseq_constant_body_rb_iseq_parameters__bindgen_ty_1 {
1816    #[inline]
1817    #[allow(unnecessary_transmutes)]
1818    pub fn has_lead(&self) -> ::std::os::raw::c_uint {
1819        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<0usize, 1u8>() as u32) }
1820    }
1821    #[inline]
1822    #[allow(unnecessary_transmutes)]
1823    pub fn set_has_lead(&mut self, val: ::std::os::raw::c_uint) {
1824        unsafe {
1825            let val: u32 = ::std::mem::transmute(val);
1826            self._bitfield_1.set_const::<0usize, 1u8>(val as u64)
1827        }
1828    }
1829    #[inline]
1830    #[allow(unnecessary_transmutes)]
1831    pub unsafe fn has_lead_raw(this: *const Self) -> ::std::os::raw::c_uint {
1832        unsafe {
1833            ::std::mem::transmute(
1834                <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get_const::<0usize, 1u8>(
1835                    ::std::ptr::addr_of!((*this)._bitfield_1),
1836                ) as u32,
1837            )
1838        }
1839    }
1840    #[inline]
1841    #[allow(unnecessary_transmutes)]
1842    pub unsafe fn set_has_lead_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
1843        unsafe {
1844            let val: u32 = ::std::mem::transmute(val);
1845            <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set_const::<0usize, 1u8>(
1846                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1847                val as u64,
1848            )
1849        }
1850    }
1851    #[inline]
1852    #[allow(unnecessary_transmutes)]
1853    pub fn has_opt(&self) -> ::std::os::raw::c_uint {
1854        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<1usize, 1u8>() as u32) }
1855    }
1856    #[inline]
1857    #[allow(unnecessary_transmutes)]
1858    pub fn set_has_opt(&mut self, val: ::std::os::raw::c_uint) {
1859        unsafe {
1860            let val: u32 = ::std::mem::transmute(val);
1861            self._bitfield_1.set_const::<1usize, 1u8>(val as u64)
1862        }
1863    }
1864    #[inline]
1865    #[allow(unnecessary_transmutes)]
1866    pub unsafe fn has_opt_raw(this: *const Self) -> ::std::os::raw::c_uint {
1867        unsafe {
1868            ::std::mem::transmute(
1869                <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get_const::<1usize, 1u8>(
1870                    ::std::ptr::addr_of!((*this)._bitfield_1),
1871                ) as u32,
1872            )
1873        }
1874    }
1875    #[inline]
1876    #[allow(unnecessary_transmutes)]
1877    pub unsafe fn set_has_opt_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
1878        unsafe {
1879            let val: u32 = ::std::mem::transmute(val);
1880            <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set_const::<1usize, 1u8>(
1881                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1882                val as u64,
1883            )
1884        }
1885    }
1886    #[inline]
1887    #[allow(unnecessary_transmutes)]
1888    pub fn has_rest(&self) -> ::std::os::raw::c_uint {
1889        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<2usize, 1u8>() as u32) }
1890    }
1891    #[inline]
1892    #[allow(unnecessary_transmutes)]
1893    pub fn set_has_rest(&mut self, val: ::std::os::raw::c_uint) {
1894        unsafe {
1895            let val: u32 = ::std::mem::transmute(val);
1896            self._bitfield_1.set_const::<2usize, 1u8>(val as u64)
1897        }
1898    }
1899    #[inline]
1900    #[allow(unnecessary_transmutes)]
1901    pub unsafe fn has_rest_raw(this: *const Self) -> ::std::os::raw::c_uint {
1902        unsafe {
1903            ::std::mem::transmute(
1904                <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get_const::<2usize, 1u8>(
1905                    ::std::ptr::addr_of!((*this)._bitfield_1),
1906                ) as u32,
1907            )
1908        }
1909    }
1910    #[inline]
1911    #[allow(unnecessary_transmutes)]
1912    pub unsafe fn set_has_rest_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
1913        unsafe {
1914            let val: u32 = ::std::mem::transmute(val);
1915            <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set_const::<2usize, 1u8>(
1916                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1917                val as u64,
1918            )
1919        }
1920    }
1921    #[inline]
1922    #[allow(unnecessary_transmutes)]
1923    pub fn has_post(&self) -> ::std::os::raw::c_uint {
1924        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<3usize, 1u8>() as u32) }
1925    }
1926    #[inline]
1927    #[allow(unnecessary_transmutes)]
1928    pub fn set_has_post(&mut self, val: ::std::os::raw::c_uint) {
1929        unsafe {
1930            let val: u32 = ::std::mem::transmute(val);
1931            self._bitfield_1.set_const::<3usize, 1u8>(val as u64)
1932        }
1933    }
1934    #[inline]
1935    #[allow(unnecessary_transmutes)]
1936    pub unsafe fn has_post_raw(this: *const Self) -> ::std::os::raw::c_uint {
1937        unsafe {
1938            ::std::mem::transmute(
1939                <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get_const::<3usize, 1u8>(
1940                    ::std::ptr::addr_of!((*this)._bitfield_1),
1941                ) as u32,
1942            )
1943        }
1944    }
1945    #[inline]
1946    #[allow(unnecessary_transmutes)]
1947    pub unsafe fn set_has_post_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
1948        unsafe {
1949            let val: u32 = ::std::mem::transmute(val);
1950            <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set_const::<3usize, 1u8>(
1951                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1952                val as u64,
1953            )
1954        }
1955    }
1956    #[inline]
1957    #[allow(unnecessary_transmutes)]
1958    pub fn has_kw(&self) -> ::std::os::raw::c_uint {
1959        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<4usize, 1u8>() as u32) }
1960    }
1961    #[inline]
1962    #[allow(unnecessary_transmutes)]
1963    pub fn set_has_kw(&mut self, val: ::std::os::raw::c_uint) {
1964        unsafe {
1965            let val: u32 = ::std::mem::transmute(val);
1966            self._bitfield_1.set_const::<4usize, 1u8>(val as u64)
1967        }
1968    }
1969    #[inline]
1970    #[allow(unnecessary_transmutes)]
1971    pub unsafe fn has_kw_raw(this: *const Self) -> ::std::os::raw::c_uint {
1972        unsafe {
1973            ::std::mem::transmute(
1974                <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get_const::<4usize, 1u8>(
1975                    ::std::ptr::addr_of!((*this)._bitfield_1),
1976                ) as u32,
1977            )
1978        }
1979    }
1980    #[inline]
1981    #[allow(unnecessary_transmutes)]
1982    pub unsafe fn set_has_kw_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
1983        unsafe {
1984            let val: u32 = ::std::mem::transmute(val);
1985            <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set_const::<4usize, 1u8>(
1986                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1987                val as u64,
1988            )
1989        }
1990    }
1991    #[inline]
1992    #[allow(unnecessary_transmutes)]
1993    pub fn has_kwrest(&self) -> ::std::os::raw::c_uint {
1994        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<5usize, 1u8>() as u32) }
1995    }
1996    #[inline]
1997    #[allow(unnecessary_transmutes)]
1998    pub fn set_has_kwrest(&mut self, val: ::std::os::raw::c_uint) {
1999        unsafe {
2000            let val: u32 = ::std::mem::transmute(val);
2001            self._bitfield_1.set_const::<5usize, 1u8>(val as u64)
2002        }
2003    }
2004    #[inline]
2005    #[allow(unnecessary_transmutes)]
2006    pub unsafe fn has_kwrest_raw(this: *const Self) -> ::std::os::raw::c_uint {
2007        unsafe {
2008            ::std::mem::transmute(
2009                <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get_const::<5usize, 1u8>(
2010                    ::std::ptr::addr_of!((*this)._bitfield_1),
2011                ) as u32,
2012            )
2013        }
2014    }
2015    #[inline]
2016    #[allow(unnecessary_transmutes)]
2017    pub unsafe fn set_has_kwrest_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
2018        unsafe {
2019            let val: u32 = ::std::mem::transmute(val);
2020            <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set_const::<5usize, 1u8>(
2021                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2022                val as u64,
2023            )
2024        }
2025    }
2026    #[inline]
2027    #[allow(unnecessary_transmutes)]
2028    pub fn has_block(&self) -> ::std::os::raw::c_uint {
2029        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<6usize, 1u8>() as u32) }
2030    }
2031    #[inline]
2032    #[allow(unnecessary_transmutes)]
2033    pub fn set_has_block(&mut self, val: ::std::os::raw::c_uint) {
2034        unsafe {
2035            let val: u32 = ::std::mem::transmute(val);
2036            self._bitfield_1.set_const::<6usize, 1u8>(val as u64)
2037        }
2038    }
2039    #[inline]
2040    #[allow(unnecessary_transmutes)]
2041    pub unsafe fn has_block_raw(this: *const Self) -> ::std::os::raw::c_uint {
2042        unsafe {
2043            ::std::mem::transmute(
2044                <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get_const::<6usize, 1u8>(
2045                    ::std::ptr::addr_of!((*this)._bitfield_1),
2046                ) as u32,
2047            )
2048        }
2049    }
2050    #[inline]
2051    #[allow(unnecessary_transmutes)]
2052    pub unsafe fn set_has_block_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
2053        unsafe {
2054            let val: u32 = ::std::mem::transmute(val);
2055            <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set_const::<6usize, 1u8>(
2056                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2057                val as u64,
2058            )
2059        }
2060    }
2061    #[inline]
2062    #[allow(unnecessary_transmutes)]
2063    pub fn ambiguous_param0(&self) -> ::std::os::raw::c_uint {
2064        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<7usize, 1u8>() as u32) }
2065    }
2066    #[inline]
2067    #[allow(unnecessary_transmutes)]
2068    pub fn set_ambiguous_param0(&mut self, val: ::std::os::raw::c_uint) {
2069        unsafe {
2070            let val: u32 = ::std::mem::transmute(val);
2071            self._bitfield_1.set_const::<7usize, 1u8>(val as u64)
2072        }
2073    }
2074    #[inline]
2075    #[allow(unnecessary_transmutes)]
2076    pub unsafe fn ambiguous_param0_raw(this: *const Self) -> ::std::os::raw::c_uint {
2077        unsafe {
2078            ::std::mem::transmute(
2079                <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get_const::<7usize, 1u8>(
2080                    ::std::ptr::addr_of!((*this)._bitfield_1),
2081                ) as u32,
2082            )
2083        }
2084    }
2085    #[inline]
2086    #[allow(unnecessary_transmutes)]
2087    pub unsafe fn set_ambiguous_param0_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
2088        unsafe {
2089            let val: u32 = ::std::mem::transmute(val);
2090            <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set_const::<7usize, 1u8>(
2091                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2092                val as u64,
2093            )
2094        }
2095    }
2096    #[inline]
2097    #[allow(unnecessary_transmutes)]
2098    pub fn accepts_no_kwarg(&self) -> ::std::os::raw::c_uint {
2099        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<8usize, 1u8>() as u32) }
2100    }
2101    #[inline]
2102    #[allow(unnecessary_transmutes)]
2103    pub fn set_accepts_no_kwarg(&mut self, val: ::std::os::raw::c_uint) {
2104        unsafe {
2105            let val: u32 = ::std::mem::transmute(val);
2106            self._bitfield_1.set_const::<8usize, 1u8>(val as u64)
2107        }
2108    }
2109    #[inline]
2110    #[allow(unnecessary_transmutes)]
2111    pub unsafe fn accepts_no_kwarg_raw(this: *const Self) -> ::std::os::raw::c_uint {
2112        unsafe {
2113            ::std::mem::transmute(
2114                <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get_const::<8usize, 1u8>(
2115                    ::std::ptr::addr_of!((*this)._bitfield_1),
2116                ) as u32,
2117            )
2118        }
2119    }
2120    #[inline]
2121    #[allow(unnecessary_transmutes)]
2122    pub unsafe fn set_accepts_no_kwarg_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
2123        unsafe {
2124            let val: u32 = ::std::mem::transmute(val);
2125            <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set_const::<8usize, 1u8>(
2126                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2127                val as u64,
2128            )
2129        }
2130    }
2131    #[inline]
2132    #[allow(unnecessary_transmutes)]
2133    pub fn ruby2_keywords(&self) -> ::std::os::raw::c_uint {
2134        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<9usize, 1u8>() as u32) }
2135    }
2136    #[inline]
2137    #[allow(unnecessary_transmutes)]
2138    pub fn set_ruby2_keywords(&mut self, val: ::std::os::raw::c_uint) {
2139        unsafe {
2140            let val: u32 = ::std::mem::transmute(val);
2141            self._bitfield_1.set_const::<9usize, 1u8>(val as u64)
2142        }
2143    }
2144    #[inline]
2145    #[allow(unnecessary_transmutes)]
2146    pub unsafe fn ruby2_keywords_raw(this: *const Self) -> ::std::os::raw::c_uint {
2147        unsafe {
2148            ::std::mem::transmute(
2149                <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get_const::<9usize, 1u8>(
2150                    ::std::ptr::addr_of!((*this)._bitfield_1),
2151                ) as u32,
2152            )
2153        }
2154    }
2155    #[inline]
2156    #[allow(unnecessary_transmutes)]
2157    pub unsafe fn set_ruby2_keywords_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
2158        unsafe {
2159            let val: u32 = ::std::mem::transmute(val);
2160            <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set_const::<9usize, 1u8>(
2161                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2162                val as u64,
2163            )
2164        }
2165    }
2166    #[inline]
2167    #[allow(unnecessary_transmutes)]
2168    pub fn anon_rest(&self) -> ::std::os::raw::c_uint {
2169        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<10usize, 1u8>() as u32) }
2170    }
2171    #[inline]
2172    #[allow(unnecessary_transmutes)]
2173    pub fn set_anon_rest(&mut self, val: ::std::os::raw::c_uint) {
2174        unsafe {
2175            let val: u32 = ::std::mem::transmute(val);
2176            self._bitfield_1.set_const::<10usize, 1u8>(val as u64)
2177        }
2178    }
2179    #[inline]
2180    #[allow(unnecessary_transmutes)]
2181    pub unsafe fn anon_rest_raw(this: *const Self) -> ::std::os::raw::c_uint {
2182        unsafe {
2183            ::std::mem::transmute(
2184                <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get_const::<10usize, 1u8>(
2185                    ::std::ptr::addr_of!((*this)._bitfield_1),
2186                ) as u32,
2187            )
2188        }
2189    }
2190    #[inline]
2191    #[allow(unnecessary_transmutes)]
2192    pub unsafe fn set_anon_rest_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
2193        unsafe {
2194            let val: u32 = ::std::mem::transmute(val);
2195            <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set_const::<10usize, 1u8>(
2196                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2197                val as u64,
2198            )
2199        }
2200    }
2201    #[inline]
2202    #[allow(unnecessary_transmutes)]
2203    pub fn anon_kwrest(&self) -> ::std::os::raw::c_uint {
2204        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<11usize, 1u8>() as u32) }
2205    }
2206    #[inline]
2207    #[allow(unnecessary_transmutes)]
2208    pub fn set_anon_kwrest(&mut self, val: ::std::os::raw::c_uint) {
2209        unsafe {
2210            let val: u32 = ::std::mem::transmute(val);
2211            self._bitfield_1.set_const::<11usize, 1u8>(val as u64)
2212        }
2213    }
2214    #[inline]
2215    #[allow(unnecessary_transmutes)]
2216    pub unsafe fn anon_kwrest_raw(this: *const Self) -> ::std::os::raw::c_uint {
2217        unsafe {
2218            ::std::mem::transmute(
2219                <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get_const::<11usize, 1u8>(
2220                    ::std::ptr::addr_of!((*this)._bitfield_1),
2221                ) as u32,
2222            )
2223        }
2224    }
2225    #[inline]
2226    #[allow(unnecessary_transmutes)]
2227    pub unsafe fn set_anon_kwrest_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
2228        unsafe {
2229            let val: u32 = ::std::mem::transmute(val);
2230            <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set_const::<11usize, 1u8>(
2231                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2232                val as u64,
2233            )
2234        }
2235    }
2236    #[inline]
2237    #[allow(unnecessary_transmutes)]
2238    pub fn use_block(&self) -> ::std::os::raw::c_uint {
2239        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<12usize, 1u8>() as u32) }
2240    }
2241    #[inline]
2242    #[allow(unnecessary_transmutes)]
2243    pub fn set_use_block(&mut self, val: ::std::os::raw::c_uint) {
2244        unsafe {
2245            let val: u32 = ::std::mem::transmute(val);
2246            self._bitfield_1.set_const::<12usize, 1u8>(val as u64)
2247        }
2248    }
2249    #[inline]
2250    #[allow(unnecessary_transmutes)]
2251    pub unsafe fn use_block_raw(this: *const Self) -> ::std::os::raw::c_uint {
2252        unsafe {
2253            ::std::mem::transmute(
2254                <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get_const::<12usize, 1u8>(
2255                    ::std::ptr::addr_of!((*this)._bitfield_1),
2256                ) as u32,
2257            )
2258        }
2259    }
2260    #[inline]
2261    #[allow(unnecessary_transmutes)]
2262    pub unsafe fn set_use_block_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
2263        unsafe {
2264            let val: u32 = ::std::mem::transmute(val);
2265            <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set_const::<12usize, 1u8>(
2266                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2267                val as u64,
2268            )
2269        }
2270    }
2271    #[inline]
2272    #[allow(unnecessary_transmutes)]
2273    pub fn forwardable(&self) -> ::std::os::raw::c_uint {
2274        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<13usize, 1u8>() as u32) }
2275    }
2276    #[inline]
2277    #[allow(unnecessary_transmutes)]
2278    pub fn set_forwardable(&mut self, val: ::std::os::raw::c_uint) {
2279        unsafe {
2280            let val: u32 = ::std::mem::transmute(val);
2281            self._bitfield_1.set_const::<13usize, 1u8>(val as u64)
2282        }
2283    }
2284    #[inline]
2285    #[allow(unnecessary_transmutes)]
2286    pub unsafe fn forwardable_raw(this: *const Self) -> ::std::os::raw::c_uint {
2287        unsafe {
2288            ::std::mem::transmute(
2289                <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get_const::<13usize, 1u8>(
2290                    ::std::ptr::addr_of!((*this)._bitfield_1),
2291                ) as u32,
2292            )
2293        }
2294    }
2295    #[inline]
2296    #[allow(unnecessary_transmutes)]
2297    pub unsafe fn set_forwardable_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
2298        unsafe {
2299            let val: u32 = ::std::mem::transmute(val);
2300            <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set_const::<13usize, 1u8>(
2301                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2302                val as u64,
2303            )
2304        }
2305    }
2306    #[inline]
2307    #[allow(unnecessary_transmutes)]
2308    pub fn new_bitfield_1(
2309        has_lead: ::std::os::raw::c_uint,
2310        has_opt: ::std::os::raw::c_uint,
2311        has_rest: ::std::os::raw::c_uint,
2312        has_post: ::std::os::raw::c_uint,
2313        has_kw: ::std::os::raw::c_uint,
2314        has_kwrest: ::std::os::raw::c_uint,
2315        has_block: ::std::os::raw::c_uint,
2316        ambiguous_param0: ::std::os::raw::c_uint,
2317        accepts_no_kwarg: ::std::os::raw::c_uint,
2318        ruby2_keywords: ::std::os::raw::c_uint,
2319        anon_rest: ::std::os::raw::c_uint,
2320        anon_kwrest: ::std::os::raw::c_uint,
2321        use_block: ::std::os::raw::c_uint,
2322        forwardable: ::std::os::raw::c_uint,
2323    ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
2324        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
2325        __bindgen_bitfield_unit.set_const::<0usize, 1u8>({
2326            let has_lead: u32 = unsafe { ::std::mem::transmute(has_lead) };
2327            has_lead as u64
2328        });
2329        __bindgen_bitfield_unit.set_const::<1usize, 1u8>({
2330            let has_opt: u32 = unsafe { ::std::mem::transmute(has_opt) };
2331            has_opt as u64
2332        });
2333        __bindgen_bitfield_unit.set_const::<2usize, 1u8>({
2334            let has_rest: u32 = unsafe { ::std::mem::transmute(has_rest) };
2335            has_rest as u64
2336        });
2337        __bindgen_bitfield_unit.set_const::<3usize, 1u8>({
2338            let has_post: u32 = unsafe { ::std::mem::transmute(has_post) };
2339            has_post as u64
2340        });
2341        __bindgen_bitfield_unit.set_const::<4usize, 1u8>({
2342            let has_kw: u32 = unsafe { ::std::mem::transmute(has_kw) };
2343            has_kw as u64
2344        });
2345        __bindgen_bitfield_unit.set_const::<5usize, 1u8>({
2346            let has_kwrest: u32 = unsafe { ::std::mem::transmute(has_kwrest) };
2347            has_kwrest as u64
2348        });
2349        __bindgen_bitfield_unit.set_const::<6usize, 1u8>({
2350            let has_block: u32 = unsafe { ::std::mem::transmute(has_block) };
2351            has_block as u64
2352        });
2353        __bindgen_bitfield_unit.set_const::<7usize, 1u8>({
2354            let ambiguous_param0: u32 = unsafe { ::std::mem::transmute(ambiguous_param0) };
2355            ambiguous_param0 as u64
2356        });
2357        __bindgen_bitfield_unit.set_const::<8usize, 1u8>({
2358            let accepts_no_kwarg: u32 = unsafe { ::std::mem::transmute(accepts_no_kwarg) };
2359            accepts_no_kwarg as u64
2360        });
2361        __bindgen_bitfield_unit.set_const::<9usize, 1u8>({
2362            let ruby2_keywords: u32 = unsafe { ::std::mem::transmute(ruby2_keywords) };
2363            ruby2_keywords as u64
2364        });
2365        __bindgen_bitfield_unit.set_const::<10usize, 1u8>({
2366            let anon_rest: u32 = unsafe { ::std::mem::transmute(anon_rest) };
2367            anon_rest as u64
2368        });
2369        __bindgen_bitfield_unit.set_const::<11usize, 1u8>({
2370            let anon_kwrest: u32 = unsafe { ::std::mem::transmute(anon_kwrest) };
2371            anon_kwrest as u64
2372        });
2373        __bindgen_bitfield_unit.set_const::<12usize, 1u8>({
2374            let use_block: u32 = unsafe { ::std::mem::transmute(use_block) };
2375            use_block as u64
2376        });
2377        __bindgen_bitfield_unit.set_const::<13usize, 1u8>({
2378            let forwardable: u32 = unsafe { ::std::mem::transmute(forwardable) };
2379            forwardable as u64
2380        });
2381        __bindgen_bitfield_unit
2382    }
2383}
2384#[repr(C)]
2385#[derive(Debug, Copy, Clone)]
2386pub struct rb_iseq_constant_body_rb_iseq_parameters_rb_iseq_param_keyword {
2387    pub num: ::std::os::raw::c_int,
2388    pub required_num: ::std::os::raw::c_int,
2389    pub bits_start: ::std::os::raw::c_int,
2390    pub rest_start: ::std::os::raw::c_int,
2391    pub table: *const ID,
2392    pub default_values: *mut VALUE,
2393}
2394#[repr(C)]
2395#[derive(Debug, Copy, Clone)]
2396pub struct rb_iseq_constant_body_iseq_insn_info {
2397    pub body: *const iseq_insn_info_entry,
2398    pub positions: *mut ::std::os::raw::c_uint,
2399    pub size: ::std::os::raw::c_uint,
2400    pub succ_index_table: *mut succ_index_table,
2401}
2402pub const rb_iseq_constant_body_lvar_state_lvar_uninitialized: rb_iseq_constant_body_lvar_state = 0;
2403pub const rb_iseq_constant_body_lvar_state_lvar_initialized: rb_iseq_constant_body_lvar_state = 1;
2404pub const rb_iseq_constant_body_lvar_state_lvar_reassigned: rb_iseq_constant_body_lvar_state = 2;
2405pub type rb_iseq_constant_body_lvar_state = ::std::os::raw::c_uint;
2406#[repr(C)]
2407#[derive(Debug, Copy, Clone)]
2408pub struct rb_iseq_constant_body__bindgen_ty_1 {
2409    pub flip_count: rb_snum_t,
2410    pub script_lines: VALUE,
2411    pub coverage: VALUE,
2412    pub pc2branchindex: VALUE,
2413    pub original_iseq: *mut VALUE,
2414}
2415#[repr(C)]
2416#[derive(Copy, Clone)]
2417pub union rb_iseq_constant_body__bindgen_ty_2 {
2418    pub list: *mut iseq_bits_t,
2419    pub single: iseq_bits_t,
2420}
2421impl ::std::fmt::Debug for rb_iseq_constant_body__bindgen_ty_2 {
2422    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2423        write!(f, "rb_iseq_constant_body__bindgen_ty_2 {{ union }}")
2424    }
2425}
2426impl ::std::fmt::Debug for rb_iseq_constant_body {
2427    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2428        write ! (f , "rb_iseq_constant_body {{ type: {:?}, iseq_size: {:?}, iseq_encoded: {:?}, param: {:?}, location: {:?}, insns_info: {:?}, local_table: {:?}, lvar_states: {:?}, catch_table: {:?}, parent_iseq: {:?}, local_iseq: {:?}, is_entries: {:?}, call_data: {:?}, variable: {:?}, local_table_size: {:?}, ic_size: {:?}, ise_size: {:?}, ivc_size: {:?}, icvarc_size: {:?}, ci_size: {:?}, stack_max: {:?}, builtin_attrs: {:?}, prism: {:?}, jit_ep_escape_recorded: {:?}, mark_bits: {:?}, outer_variables: {:?}, mandatory_only_iseq: {:?}, jit_entry: {:?}, jit_entry_calls: {:?}, jit_exception: {:?}, jit_exception_calls: {:?}, yjit_payload: {:?} }}" , self . type_ , self . iseq_size , self . iseq_encoded , self . param , self . location , self . insns_info , self . local_table , self . lvar_states , self . catch_table , self . parent_iseq , self . local_iseq , self . is_entries , self . call_data , self . variable , self . local_table_size , self . ic_size , self . ise_size , self . ivc_size , self . icvarc_size , self . ci_size , self . stack_max , self . builtin_attrs , self . prism , self . jit_ep_escape_recorded , self . mark_bits , self . outer_variables , self . mandatory_only_iseq , self . jit_entry , self . jit_entry_calls , self . jit_exception , self . jit_exception_calls , self . yjit_payload)
2429    }
2430}
2431#[repr(C)]
2432#[derive(Copy, Clone)]
2433pub struct rb_iseq_struct {
2434    pub flags: VALUE,
2435    pub wrapper: VALUE,
2436    pub body: *mut rb_iseq_constant_body,
2437    pub aux: rb_iseq_struct__bindgen_ty_1,
2438}
2439#[repr(C)]
2440#[derive(Copy, Clone)]
2441pub union rb_iseq_struct__bindgen_ty_1 {
2442    pub compile_data: *mut iseq_compile_data,
2443    pub loader: rb_iseq_struct__bindgen_ty_1__bindgen_ty_1,
2444    pub exec: rb_iseq_struct__bindgen_ty_1__bindgen_ty_2,
2445}
2446#[repr(C)]
2447#[derive(Debug, Copy, Clone)]
2448pub struct rb_iseq_struct__bindgen_ty_1__bindgen_ty_1 {
2449    pub obj: VALUE,
2450    pub index: ::std::os::raw::c_int,
2451}
2452#[repr(C)]
2453#[derive(Debug, Copy, Clone)]
2454pub struct rb_iseq_struct__bindgen_ty_1__bindgen_ty_2 {
2455    pub local_hooks_cnt: ::std::os::raw::c_uint,
2456    pub global_trace_events: rb_event_flag_t,
2457}
2458impl ::std::fmt::Debug for rb_iseq_struct__bindgen_ty_1 {
2459    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2460        write!(f, "rb_iseq_struct__bindgen_ty_1 {{ union }}")
2461    }
2462}
2463impl ::std::fmt::Debug for rb_iseq_struct {
2464    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2465        write!(
2466            f,
2467            "rb_iseq_struct {{ flags: {:?}, wrapper: {:?}, body: {:?}, aux: {:?} }}",
2468            self.flags, self.wrapper, self.body, self.aux
2469        )
2470    }
2471}
2472pub type rb_vm_at_exit_func = ::std::option::Option<unsafe extern "C" fn(arg1: *mut rb_vm_struct)>;
2473#[repr(C)]
2474#[derive(Debug, Copy, Clone)]
2475pub struct rb_at_exit_list {
2476    pub func: rb_vm_at_exit_func,
2477    pub next: *mut rb_at_exit_list,
2478}
2479pub const rb_hook_list_type_hook_list_type_ractor_local: rb_hook_list_type = 0;
2480pub const rb_hook_list_type_hook_list_type_targeted_iseq: rb_hook_list_type = 1;
2481pub const rb_hook_list_type_hook_list_type_targeted_def: rb_hook_list_type = 2;
2482pub const rb_hook_list_type_hook_list_type_global: rb_hook_list_type = 3;
2483pub type rb_hook_list_type = ::std::os::raw::c_uint;
2484#[repr(C)]
2485#[derive(Debug, Copy, Clone)]
2486pub struct rb_hook_list_struct {
2487    pub hooks: *mut rb_event_hook_struct,
2488    pub events: rb_event_flag_t,
2489    pub running: ::std::os::raw::c_uint,
2490    pub type_: rb_hook_list_type,
2491    pub need_clean: u8,
2492}
2493pub type rb_hook_list_t = rb_hook_list_struct;
2494#[repr(C)]
2495#[derive(Debug)]
2496pub struct rb_builtin_function {
2497    _unused: [u8; 0],
2498}
2499#[repr(C)]
2500#[derive(Debug, Copy, Clone)]
2501pub struct global_object_list {
2502    pub varptr: *mut VALUE,
2503    pub next: *mut global_object_list,
2504}
2505#[repr(C)]
2506#[derive(Copy, Clone)]
2507pub struct rb_vm_struct {
2508    pub self_: VALUE,
2509    pub ractor: rb_vm_struct__bindgen_ty_1,
2510    pub main_altstack: *mut ::std::os::raw::c_void,
2511    pub fork_gen: rb_serial_t,
2512    pub ubf_async_safe: ::std::os::raw::c_int,
2513    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
2514    pub mark_object_ary: VALUE,
2515    pub global_object_list: *mut global_object_list,
2516    pub special_exceptions: [VALUE; 5usize],
2517    pub master_box: *mut rb_box_t,
2518    pub root_box: *mut rb_box_t,
2519    pub main_box: *mut rb_box_t,
2520    pub static_ext_inits: *mut st_table,
2521    pub trap_list: rb_vm_struct__bindgen_ty_2,
2522    pub global_hooks: rb_hook_list_t,
2523    pub postponed_job_queue: *mut rb_postponed_job_queue,
2524    pub src_encoding_index: ::std::os::raw::c_int,
2525    pub workqueue: ccan_list_head,
2526    pub workqueue_lock: rb_nativethread_lock_t,
2527    pub orig_progname: VALUE,
2528    pub progname: VALUE,
2529    pub coverages: VALUE,
2530    pub me2counter: VALUE,
2531    pub coverage_mode: ::std::os::raw::c_int,
2532    pub gc: rb_vm_struct__bindgen_ty_3,
2533    pub at_exit: *mut rb_at_exit_list,
2534    pub builtin_function_table: *const rb_builtin_function,
2535    pub ci_table: *mut st_table,
2536    pub negative_cme_table: *mut rb_id_table,
2537    pub overloaded_cme_table: *mut st_table,
2538    pub unused_block_warning_table: *mut set_table,
2539    pub cc_refinement_table: *mut set_table,
2540    pub constant_cache: *mut rb_id_table,
2541    pub inserting_constant_cache_id: ID,
2542    pub global_cc_cache_table: [*const rb_callcache; 1023usize],
2543    pub global_cc_cache_table_used: u8,
2544    pub default_params: rb_vm_struct__bindgen_ty_4,
2545}
2546#[repr(C)]
2547#[derive(Copy, Clone)]
2548pub struct rb_vm_struct__bindgen_ty_1 {
2549    pub set: ccan_list_head,
2550    pub cnt: ::std::os::raw::c_uint,
2551    pub blocking_cnt: ::std::os::raw::c_uint,
2552    pub main_ractor: *mut rb_ractor_struct,
2553    pub main_thread: *mut rb_thread_struct,
2554    pub sync: rb_vm_struct__bindgen_ty_1__bindgen_ty_1,
2555    pub sched: rb_vm_struct__bindgen_ty_1__bindgen_ty_2,
2556}
2557#[repr(C)]
2558#[derive(Copy, Clone)]
2559pub struct rb_vm_struct__bindgen_ty_1__bindgen_ty_1 {
2560    pub lock: rb_nativethread_lock_t,
2561    pub lock_owner: *mut rb_ractor_struct,
2562    pub lock_rec: ::std::os::raw::c_uint,
2563    pub terminate_cond: rb_nativethread_cond_t,
2564    pub terminate_waiting: u8,
2565}
2566impl ::std::fmt::Debug for rb_vm_struct__bindgen_ty_1__bindgen_ty_1 {
2567    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2568        write ! (f , "rb_vm_struct__bindgen_ty_1__bindgen_ty_1 {{ lock: {:?}, lock_owner: {:?}, lock_rec: {:?}, terminate_cond: {:?}, terminate_waiting: {:?} }}" , self . lock , self . lock_owner , self . lock_rec , self . terminate_cond , self . terminate_waiting)
2569    }
2570}
2571#[repr(C)]
2572#[derive(Copy, Clone)]
2573pub struct rb_vm_struct__bindgen_ty_1__bindgen_ty_2 {
2574    pub lock: rb_nativethread_lock_t,
2575    pub lock_owner: *mut rb_ractor_struct,
2576    pub locked: u8,
2577    pub cond: rb_nativethread_cond_t,
2578    pub snt_cnt: ::std::os::raw::c_uint,
2579    pub dnt_cnt: ::std::os::raw::c_uint,
2580    pub running_cnt: ::std::os::raw::c_uint,
2581    pub max_cpu: ::std::os::raw::c_uint,
2582    pub grq: ccan_list_head,
2583    pub grq_cnt: ::std::os::raw::c_uint,
2584    pub running_threads: ccan_list_head,
2585    pub timeslice_threads: ccan_list_head,
2586    pub zombie_threads: ccan_list_head,
2587    pub timeslice_wait_inf: u8,
2588    pub barrier_complete_cond: rb_nativethread_cond_t,
2589    pub barrier_release_cond: rb_nativethread_cond_t,
2590    pub barrier_waiting: u8,
2591    pub barrier_waiting_cnt: ::std::os::raw::c_uint,
2592    pub barrier_serial: ::std::os::raw::c_uint,
2593    pub barrier_ractor: *mut rb_ractor_struct,
2594    pub barrier_lock_rec: ::std::os::raw::c_uint,
2595}
2596impl ::std::fmt::Debug for rb_vm_struct__bindgen_ty_1__bindgen_ty_2 {
2597    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2598        write ! (f , "rb_vm_struct__bindgen_ty_1__bindgen_ty_2 {{ lock: {:?}, lock_owner: {:?}, locked: {:?}, cond: {:?}, snt_cnt: {:?}, dnt_cnt: {:?}, running_cnt: {:?}, max_cpu: {:?}, grq: {:?}, grq_cnt: {:?}, running_threads: {:?}, timeslice_threads: {:?}, zombie_threads: {:?}, timeslice_wait_inf: {:?}, barrier_complete_cond: {:?}, barrier_release_cond: {:?}, barrier_waiting: {:?}, barrier_waiting_cnt: {:?}, barrier_serial: {:?}, barrier_ractor: {:?}, barrier_lock_rec: {:?} }}" , self . lock , self . lock_owner , self . locked , self . cond , self . snt_cnt , self . dnt_cnt , self . running_cnt , self . max_cpu , self . grq , self . grq_cnt , self . running_threads , self . timeslice_threads , self . zombie_threads , self . timeslice_wait_inf , self . barrier_complete_cond , self . barrier_release_cond , self . barrier_waiting , self . barrier_waiting_cnt , self . barrier_serial , self . barrier_ractor , self . barrier_lock_rec)
2599    }
2600}
2601impl ::std::fmt::Debug for rb_vm_struct__bindgen_ty_1 {
2602    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2603        write ! (f , "rb_vm_struct__bindgen_ty_1 {{ set: {:?}, cnt: {:?}, blocking_cnt: {:?}, main_ractor: {:?}, main_thread: {:?}, sync: {:?}, sched: {:?} }}" , self . set , self . cnt , self . blocking_cnt , self . main_ractor , self . main_thread , self . sync , self . sched)
2604    }
2605}
2606#[repr(C)]
2607#[derive(Debug, Copy, Clone)]
2608pub struct rb_vm_struct__bindgen_ty_2 {
2609    pub cmd: [VALUE; 65usize],
2610}
2611#[repr(C)]
2612#[derive(Debug, Copy, Clone)]
2613pub struct rb_vm_struct__bindgen_ty_3 {
2614    pub objspace: *mut rb_objspace,
2615    pub mark_func_data: *mut rb_vm_struct__bindgen_ty_3_gc_mark_func_data_struct,
2616}
2617#[repr(C)]
2618#[derive(Debug, Copy, Clone)]
2619pub struct rb_vm_struct__bindgen_ty_3_gc_mark_func_data_struct {
2620    pub data: *mut ::std::os::raw::c_void,
2621    pub mark_func:
2622        ::std::option::Option<unsafe extern "C" fn(v: VALUE, data: *mut ::std::os::raw::c_void)>,
2623}
2624#[repr(C)]
2625#[derive(Debug, Copy, Clone)]
2626pub struct rb_vm_struct__bindgen_ty_4 {
2627    pub thread_vm_stack_size: usize,
2628    pub thread_machine_stack_size: usize,
2629    pub fiber_vm_stack_size: usize,
2630    pub fiber_machine_stack_size: usize,
2631}
2632impl ::std::fmt::Debug for rb_vm_struct {
2633    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2634        write ! (f , "rb_vm_struct {{ self: {:?}, ractor: {:?}, main_altstack: {:?}, fork_gen: {:?}, ubf_async_safe: {:?}, running : {:?}, thread_abort_on_exception : {:?}, thread_report_on_exception : {:?}, thread_ignore_deadlock : {:?}, mark_object_ary: {:?}, global_object_list: {:?}, special_exceptions: {:?}, master_box: {:?}, root_box: {:?}, main_box: {:?}, static_ext_inits: {:?}, trap_list: {:?}, global_hooks: {:?}, postponed_job_queue: {:?}, src_encoding_index: {:?}, workqueue: {:?}, workqueue_lock: {:?}, orig_progname: {:?}, progname: {:?}, coverages: {:?}, me2counter: {:?}, coverage_mode: {:?}, gc: {:?}, at_exit: {:?}, builtin_function_table: {:?}, ci_table: {:?}, negative_cme_table: {:?}, overloaded_cme_table: {:?}, unused_block_warning_table: {:?}, cc_refinement_table: {:?}, constant_cache: {:?}, inserting_constant_cache_id: {:?}, global_cc_cache_table: {:?}, global_cc_cache_table_used: {:?}, default_params: {:?} }}" , self . self_ , self . ractor , self . main_altstack , self . fork_gen , self . ubf_async_safe , self . running () , self . thread_abort_on_exception () , self . thread_report_on_exception () , self . thread_ignore_deadlock () , self . mark_object_ary , self . global_object_list , self . special_exceptions , self . master_box , self . root_box , self . main_box , self . static_ext_inits , self . trap_list , self . global_hooks , self . postponed_job_queue , self . src_encoding_index , self . workqueue , self . workqueue_lock , self . orig_progname , self . progname , self . coverages , self . me2counter , self . coverage_mode , self . gc , self . at_exit , self . builtin_function_table , self . ci_table , self . negative_cme_table , self . overloaded_cme_table , self . unused_block_warning_table , self . cc_refinement_table , self . constant_cache , self . inserting_constant_cache_id , self . global_cc_cache_table , self . global_cc_cache_table_used , self . default_params)
2635    }
2636}
2637impl rb_vm_struct {
2638    #[inline]
2639    #[allow(unnecessary_transmutes)]
2640    pub fn running(&self) -> ::std::os::raw::c_uint {
2641        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<0usize, 1u8>() as u32) }
2642    }
2643    #[inline]
2644    #[allow(unnecessary_transmutes)]
2645    pub fn set_running(&mut self, val: ::std::os::raw::c_uint) {
2646        unsafe {
2647            let val: u32 = ::std::mem::transmute(val);
2648            self._bitfield_1.set_const::<0usize, 1u8>(val as u64)
2649        }
2650    }
2651    #[inline]
2652    #[allow(unnecessary_transmutes)]
2653    pub unsafe fn running_raw(this: *const Self) -> ::std::os::raw::c_uint {
2654        unsafe {
2655            ::std::mem::transmute(
2656                <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get_const::<0usize, 1u8>(
2657                    ::std::ptr::addr_of!((*this)._bitfield_1),
2658                ) as u32,
2659            )
2660        }
2661    }
2662    #[inline]
2663    #[allow(unnecessary_transmutes)]
2664    pub unsafe fn set_running_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
2665        unsafe {
2666            let val: u32 = ::std::mem::transmute(val);
2667            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set_const::<0usize, 1u8>(
2668                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2669                val as u64,
2670            )
2671        }
2672    }
2673    #[inline]
2674    #[allow(unnecessary_transmutes)]
2675    pub fn thread_abort_on_exception(&self) -> ::std::os::raw::c_uint {
2676        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<1usize, 1u8>() as u32) }
2677    }
2678    #[inline]
2679    #[allow(unnecessary_transmutes)]
2680    pub fn set_thread_abort_on_exception(&mut self, val: ::std::os::raw::c_uint) {
2681        unsafe {
2682            let val: u32 = ::std::mem::transmute(val);
2683            self._bitfield_1.set_const::<1usize, 1u8>(val as u64)
2684        }
2685    }
2686    #[inline]
2687    #[allow(unnecessary_transmutes)]
2688    pub unsafe fn thread_abort_on_exception_raw(this: *const Self) -> ::std::os::raw::c_uint {
2689        unsafe {
2690            ::std::mem::transmute(
2691                <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get_const::<1usize, 1u8>(
2692                    ::std::ptr::addr_of!((*this)._bitfield_1),
2693                ) as u32,
2694            )
2695        }
2696    }
2697    #[inline]
2698    #[allow(unnecessary_transmutes)]
2699    pub unsafe fn set_thread_abort_on_exception_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
2700        unsafe {
2701            let val: u32 = ::std::mem::transmute(val);
2702            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set_const::<1usize, 1u8>(
2703                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2704                val as u64,
2705            )
2706        }
2707    }
2708    #[inline]
2709    #[allow(unnecessary_transmutes)]
2710    pub fn thread_report_on_exception(&self) -> ::std::os::raw::c_uint {
2711        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<2usize, 1u8>() as u32) }
2712    }
2713    #[inline]
2714    #[allow(unnecessary_transmutes)]
2715    pub fn set_thread_report_on_exception(&mut self, val: ::std::os::raw::c_uint) {
2716        unsafe {
2717            let val: u32 = ::std::mem::transmute(val);
2718            self._bitfield_1.set_const::<2usize, 1u8>(val as u64)
2719        }
2720    }
2721    #[inline]
2722    #[allow(unnecessary_transmutes)]
2723    pub unsafe fn thread_report_on_exception_raw(this: *const Self) -> ::std::os::raw::c_uint {
2724        unsafe {
2725            ::std::mem::transmute(
2726                <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get_const::<2usize, 1u8>(
2727                    ::std::ptr::addr_of!((*this)._bitfield_1),
2728                ) as u32,
2729            )
2730        }
2731    }
2732    #[inline]
2733    #[allow(unnecessary_transmutes)]
2734    pub unsafe fn set_thread_report_on_exception_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
2735        unsafe {
2736            let val: u32 = ::std::mem::transmute(val);
2737            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set_const::<2usize, 1u8>(
2738                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2739                val as u64,
2740            )
2741        }
2742    }
2743    #[inline]
2744    #[allow(unnecessary_transmutes)]
2745    pub fn thread_ignore_deadlock(&self) -> ::std::os::raw::c_uint {
2746        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<3usize, 1u8>() as u32) }
2747    }
2748    #[inline]
2749    #[allow(unnecessary_transmutes)]
2750    pub fn set_thread_ignore_deadlock(&mut self, val: ::std::os::raw::c_uint) {
2751        unsafe {
2752            let val: u32 = ::std::mem::transmute(val);
2753            self._bitfield_1.set_const::<3usize, 1u8>(val as u64)
2754        }
2755    }
2756    #[inline]
2757    #[allow(unnecessary_transmutes)]
2758    pub unsafe fn thread_ignore_deadlock_raw(this: *const Self) -> ::std::os::raw::c_uint {
2759        unsafe {
2760            ::std::mem::transmute(
2761                <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get_const::<3usize, 1u8>(
2762                    ::std::ptr::addr_of!((*this)._bitfield_1),
2763                ) as u32,
2764            )
2765        }
2766    }
2767    #[inline]
2768    #[allow(unnecessary_transmutes)]
2769    pub unsafe fn set_thread_ignore_deadlock_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
2770        unsafe {
2771            let val: u32 = ::std::mem::transmute(val);
2772            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set_const::<3usize, 1u8>(
2773                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2774                val as u64,
2775            )
2776        }
2777    }
2778    #[inline]
2779    #[allow(unnecessary_transmutes)]
2780    pub fn new_bitfield_1(
2781        running: ::std::os::raw::c_uint,
2782        thread_abort_on_exception: ::std::os::raw::c_uint,
2783        thread_report_on_exception: ::std::os::raw::c_uint,
2784        thread_ignore_deadlock: ::std::os::raw::c_uint,
2785    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
2786        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
2787        __bindgen_bitfield_unit.set_const::<0usize, 1u8>({
2788            let running: u32 = unsafe { ::std::mem::transmute(running) };
2789            running as u64
2790        });
2791        __bindgen_bitfield_unit.set_const::<1usize, 1u8>({
2792            let thread_abort_on_exception: u32 =
2793                unsafe { ::std::mem::transmute(thread_abort_on_exception) };
2794            thread_abort_on_exception as u64
2795        });
2796        __bindgen_bitfield_unit.set_const::<2usize, 1u8>({
2797            let thread_report_on_exception: u32 =
2798                unsafe { ::std::mem::transmute(thread_report_on_exception) };
2799            thread_report_on_exception as u64
2800        });
2801        __bindgen_bitfield_unit.set_const::<3usize, 1u8>({
2802            let thread_ignore_deadlock: u32 =
2803                unsafe { ::std::mem::transmute(thread_ignore_deadlock) };
2804            thread_ignore_deadlock as u64
2805        });
2806        __bindgen_bitfield_unit
2807    }
2808}
2809pub type rb_vm_t = rb_vm_struct;
2810#[repr(C)]
2811#[derive(Debug, Copy, Clone)]
2812pub struct rb_control_frame_struct {
2813    pub pc: *const VALUE,
2814    pub sp: *mut VALUE,
2815    pub iseq: *const rb_iseq_t,
2816    pub self_: VALUE,
2817    pub ep: *const VALUE,
2818    pub block_code: *const ::std::os::raw::c_void,
2819    pub jit_return: *mut ::std::os::raw::c_void,
2820}
2821pub type rb_control_frame_t = rb_control_frame_struct;
2822pub const rb_thread_status_THREAD_RUNNABLE: rb_thread_status = 0;
2823pub const rb_thread_status_THREAD_STOPPED: rb_thread_status = 1;
2824pub const rb_thread_status_THREAD_STOPPED_FOREVER: rb_thread_status = 2;
2825pub const rb_thread_status_THREAD_KILLED: rb_thread_status = 3;
2826pub type rb_thread_status = ::std::os::raw::c_uint;
2827pub type rb_jmpbuf_t = sigjmp_buf;
2828pub type rb_vm_tag_jmpbuf_t = rb_jmpbuf_t;
2829#[repr(C)]
2830#[derive(Debug, Copy, Clone)]
2831pub struct rb_vm_tag {
2832    pub tag: VALUE,
2833    pub retval: VALUE,
2834    pub buf: rb_vm_tag_jmpbuf_t,
2835    pub prev: *mut rb_vm_tag,
2836    pub state: ruby_tag_type,
2837    pub lock_rec: ::std::os::raw::c_uint,
2838}
2839#[repr(C)]
2840#[derive(Debug, Copy, Clone)]
2841pub struct rb_unblock_callback {
2842    pub func: rb_unblock_function_t,
2843    pub arg: *mut ::std::os::raw::c_void,
2844}
2845#[repr(C)]
2846#[derive(Debug)]
2847pub struct rb_mutex_struct {
2848    _unused: [u8; 0],
2849}
2850#[repr(C)]
2851#[derive(Debug)]
2852pub struct rb_fiber_struct {
2853    _unused: [u8; 0],
2854}
2855pub type rb_fiber_t = rb_fiber_struct;
2856#[repr(C)]
2857#[derive(Debug, Copy, Clone)]
2858pub struct rb_waiting_list {
2859    pub next: *mut rb_waiting_list,
2860    pub thread: *mut rb_thread_struct,
2861    pub fiber: *mut rb_fiber_struct,
2862}
2863#[repr(C)]
2864#[derive(Debug, Copy, Clone)]
2865pub struct rb_execution_context_struct {
2866    pub vm_stack: *mut VALUE,
2867    pub vm_stack_size: usize,
2868    pub cfp: *mut rb_control_frame_t,
2869    pub tag: *mut rb_vm_tag,
2870    pub interrupt_flag: rb_atomic_t,
2871    pub interrupt_mask: rb_atomic_t,
2872    pub fiber_ptr: *mut rb_fiber_t,
2873    pub thread_ptr: *mut rb_thread_struct,
2874    pub serial: rb_serial_t,
2875    pub ractor_id: rb_serial_t,
2876    pub local_storage: *mut rb_id_table,
2877    pub local_storage_recursive_hash: VALUE,
2878    pub local_storage_recursive_hash_for_trace: VALUE,
2879    pub storage: VALUE,
2880    pub root_lep: *const VALUE,
2881    pub root_svar: VALUE,
2882    pub trace_arg: *mut rb_trace_arg_struct,
2883    pub errinfo: VALUE,
2884    pub passed_block_handler: VALUE,
2885    pub raised_flag: u8,
2886    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
2887    pub private_const_reference: VALUE,
2888    pub gen_fields_cache: rb_execution_context_struct__bindgen_ty_1,
2889    pub machine: rb_execution_context_struct__bindgen_ty_2,
2890}
2891#[repr(C)]
2892#[derive(Debug, Copy, Clone)]
2893pub struct rb_execution_context_struct__bindgen_ty_1 {
2894    pub obj: VALUE,
2895    pub fields_obj: VALUE,
2896}
2897#[repr(C)]
2898#[derive(Debug, Copy, Clone)]
2899pub struct rb_execution_context_struct__bindgen_ty_2 {
2900    pub stack_start: *mut VALUE,
2901    pub stack_end: *mut VALUE,
2902    pub stack_maxsize: usize,
2903    pub regs: jmp_buf,
2904}
2905impl rb_execution_context_struct {
2906    #[inline]
2907    #[allow(unnecessary_transmutes)]
2908    pub fn method_missing_reason(&self) -> method_missing_reason {
2909        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<0usize, 8u8>() as u32) }
2910    }
2911    #[inline]
2912    #[allow(unnecessary_transmutes)]
2913    pub fn set_method_missing_reason(&mut self, val: method_missing_reason) {
2914        unsafe {
2915            let val: u32 = ::std::mem::transmute(val);
2916            self._bitfield_1.set_const::<0usize, 8u8>(val as u64)
2917        }
2918    }
2919    #[inline]
2920    #[allow(unnecessary_transmutes)]
2921    pub unsafe fn method_missing_reason_raw(this: *const Self) -> method_missing_reason {
2922        unsafe {
2923            ::std::mem::transmute(
2924                <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get_const::<0usize, 8u8>(
2925                    ::std::ptr::addr_of!((*this)._bitfield_1),
2926                ) as u32,
2927            )
2928        }
2929    }
2930    #[inline]
2931    #[allow(unnecessary_transmutes)]
2932    pub unsafe fn set_method_missing_reason_raw(this: *mut Self, val: method_missing_reason) {
2933        unsafe {
2934            let val: u32 = ::std::mem::transmute(val);
2935            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set_const::<0usize, 8u8>(
2936                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2937                val as u64,
2938            )
2939        }
2940    }
2941    #[inline]
2942    #[allow(unnecessary_transmutes)]
2943    pub fn new_bitfield_1(
2944        method_missing_reason: method_missing_reason,
2945    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
2946        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
2947        __bindgen_bitfield_unit.set_const::<0usize, 8u8>({
2948            let method_missing_reason: u32 =
2949                unsafe { ::std::mem::transmute(method_missing_reason) };
2950            method_missing_reason as u64
2951        });
2952        __bindgen_bitfield_unit
2953    }
2954}
2955pub type rb_execution_context_t = rb_execution_context_struct;
2956#[repr(C)]
2957#[derive(Debug, Copy, Clone)]
2958pub struct rb_ext_config {
2959    pub ractor_safe: u8,
2960}
2961pub type rb_ractor_t = rb_ractor_struct;
2962#[repr(C)]
2963#[derive(Copy, Clone)]
2964pub struct rb_thread_struct {
2965    pub lt_node: ccan_list_node,
2966    pub self_: VALUE,
2967    pub ractor: *mut rb_ractor_t,
2968    pub vm: *mut rb_vm_t,
2969    pub nt: *mut rb_native_thread,
2970    pub ec: *mut rb_execution_context_t,
2971    pub sched: rb_thread_sched_item,
2972    pub mn_schedulable: u8,
2973    pub serial: rb_atomic_t,
2974    pub last_status: VALUE,
2975    pub calling: *mut rb_calling_info,
2976    pub top_self: VALUE,
2977    pub top_wrapper: VALUE,
2978    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
2979    pub priority: i8,
2980    pub running_time_us: u32,
2981    pub blocking_region_buffer: *mut ::std::os::raw::c_void,
2982    pub thgroup: VALUE,
2983    pub value: VALUE,
2984    pub pending_interrupt_queue: VALUE,
2985    pub pending_interrupt_mask_stack: VALUE,
2986    pub interrupt_lock: rb_nativethread_lock_t,
2987    pub unblock: rb_unblock_callback,
2988    pub locking_mutex: VALUE,
2989    pub keeping_mutexes: *mut rb_mutex_struct,
2990    pub interrupt_exec_tasks: ccan_list_head,
2991    pub join_list: *mut rb_waiting_list,
2992    pub invoke_arg: rb_thread_struct__bindgen_ty_1,
2993    pub invoke_type: rb_thread_struct_thread_invoke_type,
2994    pub root_fiber: *mut rb_fiber_t,
2995    pub scheduler: VALUE,
2996    pub blocking: ::std::os::raw::c_uint,
2997    pub name: VALUE,
2998    pub specific_storage: *mut *mut ::std::os::raw::c_void,
2999    pub ext_config: rb_ext_config,
3000}
3001#[repr(C)]
3002#[derive(Copy, Clone)]
3003pub union rb_thread_struct__bindgen_ty_1 {
3004    pub proc_: rb_thread_struct__bindgen_ty_1__bindgen_ty_1,
3005    pub func: rb_thread_struct__bindgen_ty_1__bindgen_ty_2,
3006}
3007#[repr(C)]
3008#[derive(Debug, Copy, Clone)]
3009pub struct rb_thread_struct__bindgen_ty_1__bindgen_ty_1 {
3010    pub proc_: VALUE,
3011    pub args: VALUE,
3012    pub kw_splat: ::std::os::raw::c_int,
3013}
3014#[repr(C)]
3015#[derive(Debug, Copy, Clone)]
3016pub struct rb_thread_struct__bindgen_ty_1__bindgen_ty_2 {
3017    pub func:
3018        ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> VALUE>,
3019    pub arg: *mut ::std::os::raw::c_void,
3020}
3021impl ::std::fmt::Debug for rb_thread_struct__bindgen_ty_1 {
3022    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3023        write!(f, "rb_thread_struct__bindgen_ty_1 {{ union }}")
3024    }
3025}
3026pub const rb_thread_struct_thread_invoke_type_thread_invoke_type_none:
3027    rb_thread_struct_thread_invoke_type = 0;
3028pub const rb_thread_struct_thread_invoke_type_thread_invoke_type_proc:
3029    rb_thread_struct_thread_invoke_type = 1;
3030pub const rb_thread_struct_thread_invoke_type_thread_invoke_type_ractor_proc:
3031    rb_thread_struct_thread_invoke_type = 2;
3032pub const rb_thread_struct_thread_invoke_type_thread_invoke_type_func:
3033    rb_thread_struct_thread_invoke_type = 3;
3034pub type rb_thread_struct_thread_invoke_type = ::std::os::raw::c_uint;
3035impl ::std::fmt::Debug for rb_thread_struct {
3036    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3037        write ! (f , "rb_thread_struct {{ lt_node: {:?}, self: {:?}, ractor: {:?}, vm: {:?}, nt: {:?}, ec: {:?}, sched: {:?}, mn_schedulable: {:?}, serial: {:?}, last_status: {:?}, calling: {:?}, top_self: {:?}, top_wrapper: {:?}, status : {:?}, has_dedicated_nt : {:?}, to_kill : {:?}, abort_on_exception : {:?}, report_on_exception : {:?}, pending_interrupt_queue_checked : {:?}, blocking_region_buffer: {:?}, thgroup: {:?}, value: {:?}, pending_interrupt_queue: {:?}, pending_interrupt_mask_stack: {:?}, interrupt_lock: {:?}, unblock: {:?}, locking_mutex: {:?}, keeping_mutexes: {:?}, interrupt_exec_tasks: {:?}, join_list: {:?}, invoke_arg: {:?}, invoke_type: {:?}, root_fiber: {:?}, scheduler: {:?}, blocking: {:?}, name: {:?}, specific_storage: {:?}, ext_config: {:?} }}" , self . lt_node , self . self_ , self . ractor , self . vm , self . nt , self . ec , self . sched , self . mn_schedulable , self . serial , self . last_status , self . calling , self . top_self , self . top_wrapper , self . status () , self . has_dedicated_nt () , self . to_kill () , self . abort_on_exception () , self . report_on_exception () , self . pending_interrupt_queue_checked () , self . blocking_region_buffer , self . thgroup , self . value , self . pending_interrupt_queue , self . pending_interrupt_mask_stack , self . interrupt_lock , self . unblock , self . locking_mutex , self . keeping_mutexes , self . interrupt_exec_tasks , self . join_list , self . invoke_arg , self . invoke_type , self . root_fiber , self . scheduler , self . blocking , self . name , self . specific_storage , self . ext_config)
3038    }
3039}
3040impl rb_thread_struct {
3041    #[inline]
3042    #[allow(unnecessary_transmutes)]
3043    pub fn status(&self) -> rb_thread_status {
3044        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<0usize, 2u8>() as u32) }
3045    }
3046    #[inline]
3047    #[allow(unnecessary_transmutes)]
3048    pub fn set_status(&mut self, val: rb_thread_status) {
3049        unsafe {
3050            let val: u32 = ::std::mem::transmute(val);
3051            self._bitfield_1.set_const::<0usize, 2u8>(val as u64)
3052        }
3053    }
3054    #[inline]
3055    #[allow(unnecessary_transmutes)]
3056    pub unsafe fn status_raw(this: *const Self) -> rb_thread_status {
3057        unsafe {
3058            ::std::mem::transmute(
3059                <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get_const::<0usize, 2u8>(
3060                    ::std::ptr::addr_of!((*this)._bitfield_1),
3061                ) as u32,
3062            )
3063        }
3064    }
3065    #[inline]
3066    #[allow(unnecessary_transmutes)]
3067    pub unsafe fn set_status_raw(this: *mut Self, val: rb_thread_status) {
3068        unsafe {
3069            let val: u32 = ::std::mem::transmute(val);
3070            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set_const::<0usize, 2u8>(
3071                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3072                val as u64,
3073            )
3074        }
3075    }
3076    #[inline]
3077    #[allow(unnecessary_transmutes)]
3078    pub fn has_dedicated_nt(&self) -> ::std::os::raw::c_uint {
3079        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<2usize, 1u8>() as u32) }
3080    }
3081    #[inline]
3082    #[allow(unnecessary_transmutes)]
3083    pub fn set_has_dedicated_nt(&mut self, val: ::std::os::raw::c_uint) {
3084        unsafe {
3085            let val: u32 = ::std::mem::transmute(val);
3086            self._bitfield_1.set_const::<2usize, 1u8>(val as u64)
3087        }
3088    }
3089    #[inline]
3090    #[allow(unnecessary_transmutes)]
3091    pub unsafe fn has_dedicated_nt_raw(this: *const Self) -> ::std::os::raw::c_uint {
3092        unsafe {
3093            ::std::mem::transmute(
3094                <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get_const::<2usize, 1u8>(
3095                    ::std::ptr::addr_of!((*this)._bitfield_1),
3096                ) as u32,
3097            )
3098        }
3099    }
3100    #[inline]
3101    #[allow(unnecessary_transmutes)]
3102    pub unsafe fn set_has_dedicated_nt_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
3103        unsafe {
3104            let val: u32 = ::std::mem::transmute(val);
3105            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set_const::<2usize, 1u8>(
3106                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3107                val as u64,
3108            )
3109        }
3110    }
3111    #[inline]
3112    #[allow(unnecessary_transmutes)]
3113    pub fn to_kill(&self) -> ::std::os::raw::c_uint {
3114        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<3usize, 1u8>() as u32) }
3115    }
3116    #[inline]
3117    #[allow(unnecessary_transmutes)]
3118    pub fn set_to_kill(&mut self, val: ::std::os::raw::c_uint) {
3119        unsafe {
3120            let val: u32 = ::std::mem::transmute(val);
3121            self._bitfield_1.set_const::<3usize, 1u8>(val as u64)
3122        }
3123    }
3124    #[inline]
3125    #[allow(unnecessary_transmutes)]
3126    pub unsafe fn to_kill_raw(this: *const Self) -> ::std::os::raw::c_uint {
3127        unsafe {
3128            ::std::mem::transmute(
3129                <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get_const::<3usize, 1u8>(
3130                    ::std::ptr::addr_of!((*this)._bitfield_1),
3131                ) as u32,
3132            )
3133        }
3134    }
3135    #[inline]
3136    #[allow(unnecessary_transmutes)]
3137    pub unsafe fn set_to_kill_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
3138        unsafe {
3139            let val: u32 = ::std::mem::transmute(val);
3140            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set_const::<3usize, 1u8>(
3141                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3142                val as u64,
3143            )
3144        }
3145    }
3146    #[inline]
3147    #[allow(unnecessary_transmutes)]
3148    pub fn abort_on_exception(&self) -> ::std::os::raw::c_uint {
3149        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<4usize, 1u8>() as u32) }
3150    }
3151    #[inline]
3152    #[allow(unnecessary_transmutes)]
3153    pub fn set_abort_on_exception(&mut self, val: ::std::os::raw::c_uint) {
3154        unsafe {
3155            let val: u32 = ::std::mem::transmute(val);
3156            self._bitfield_1.set_const::<4usize, 1u8>(val as u64)
3157        }
3158    }
3159    #[inline]
3160    #[allow(unnecessary_transmutes)]
3161    pub unsafe fn abort_on_exception_raw(this: *const Self) -> ::std::os::raw::c_uint {
3162        unsafe {
3163            ::std::mem::transmute(
3164                <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get_const::<4usize, 1u8>(
3165                    ::std::ptr::addr_of!((*this)._bitfield_1),
3166                ) as u32,
3167            )
3168        }
3169    }
3170    #[inline]
3171    #[allow(unnecessary_transmutes)]
3172    pub unsafe fn set_abort_on_exception_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
3173        unsafe {
3174            let val: u32 = ::std::mem::transmute(val);
3175            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set_const::<4usize, 1u8>(
3176                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3177                val as u64,
3178            )
3179        }
3180    }
3181    #[inline]
3182    #[allow(unnecessary_transmutes)]
3183    pub fn report_on_exception(&self) -> ::std::os::raw::c_uint {
3184        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<5usize, 1u8>() as u32) }
3185    }
3186    #[inline]
3187    #[allow(unnecessary_transmutes)]
3188    pub fn set_report_on_exception(&mut self, val: ::std::os::raw::c_uint) {
3189        unsafe {
3190            let val: u32 = ::std::mem::transmute(val);
3191            self._bitfield_1.set_const::<5usize, 1u8>(val as u64)
3192        }
3193    }
3194    #[inline]
3195    #[allow(unnecessary_transmutes)]
3196    pub unsafe fn report_on_exception_raw(this: *const Self) -> ::std::os::raw::c_uint {
3197        unsafe {
3198            ::std::mem::transmute(
3199                <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get_const::<5usize, 1u8>(
3200                    ::std::ptr::addr_of!((*this)._bitfield_1),
3201                ) as u32,
3202            )
3203        }
3204    }
3205    #[inline]
3206    #[allow(unnecessary_transmutes)]
3207    pub unsafe fn set_report_on_exception_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
3208        unsafe {
3209            let val: u32 = ::std::mem::transmute(val);
3210            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set_const::<5usize, 1u8>(
3211                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3212                val as u64,
3213            )
3214        }
3215    }
3216    #[inline]
3217    #[allow(unnecessary_transmutes)]
3218    pub fn pending_interrupt_queue_checked(&self) -> ::std::os::raw::c_uint {
3219        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<6usize, 1u8>() as u32) }
3220    }
3221    #[inline]
3222    #[allow(unnecessary_transmutes)]
3223    pub fn set_pending_interrupt_queue_checked(&mut self, val: ::std::os::raw::c_uint) {
3224        unsafe {
3225            let val: u32 = ::std::mem::transmute(val);
3226            self._bitfield_1.set_const::<6usize, 1u8>(val as u64)
3227        }
3228    }
3229    #[inline]
3230    #[allow(unnecessary_transmutes)]
3231    pub unsafe fn pending_interrupt_queue_checked_raw(this: *const Self) -> ::std::os::raw::c_uint {
3232        unsafe {
3233            ::std::mem::transmute(
3234                <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get_const::<6usize, 1u8>(
3235                    ::std::ptr::addr_of!((*this)._bitfield_1),
3236                ) as u32,
3237            )
3238        }
3239    }
3240    #[inline]
3241    #[allow(unnecessary_transmutes)]
3242    pub unsafe fn set_pending_interrupt_queue_checked_raw(
3243        this: *mut Self,
3244        val: ::std::os::raw::c_uint,
3245    ) {
3246        unsafe {
3247            let val: u32 = ::std::mem::transmute(val);
3248            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set_const::<6usize, 1u8>(
3249                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3250                val as u64,
3251            )
3252        }
3253    }
3254    #[inline]
3255    #[allow(unnecessary_transmutes)]
3256    pub fn new_bitfield_1(
3257        status: rb_thread_status,
3258        has_dedicated_nt: ::std::os::raw::c_uint,
3259        to_kill: ::std::os::raw::c_uint,
3260        abort_on_exception: ::std::os::raw::c_uint,
3261        report_on_exception: ::std::os::raw::c_uint,
3262        pending_interrupt_queue_checked: ::std::os::raw::c_uint,
3263    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
3264        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
3265        __bindgen_bitfield_unit.set_const::<0usize, 2u8>({
3266            let status: u32 = unsafe { ::std::mem::transmute(status) };
3267            status as u64
3268        });
3269        __bindgen_bitfield_unit.set_const::<2usize, 1u8>({
3270            let has_dedicated_nt: u32 = unsafe { ::std::mem::transmute(has_dedicated_nt) };
3271            has_dedicated_nt as u64
3272        });
3273        __bindgen_bitfield_unit.set_const::<3usize, 1u8>({
3274            let to_kill: u32 = unsafe { ::std::mem::transmute(to_kill) };
3275            to_kill as u64
3276        });
3277        __bindgen_bitfield_unit.set_const::<4usize, 1u8>({
3278            let abort_on_exception: u32 = unsafe { ::std::mem::transmute(abort_on_exception) };
3279            abort_on_exception as u64
3280        });
3281        __bindgen_bitfield_unit.set_const::<5usize, 1u8>({
3282            let report_on_exception: u32 = unsafe { ::std::mem::transmute(report_on_exception) };
3283            report_on_exception as u64
3284        });
3285        __bindgen_bitfield_unit.set_const::<6usize, 1u8>({
3286            let pending_interrupt_queue_checked: u32 =
3287                unsafe { ::std::mem::transmute(pending_interrupt_queue_checked) };
3288            pending_interrupt_queue_checked as u64
3289        });
3290        __bindgen_bitfield_unit
3291    }
3292}
3293pub type rb_thread_t = rb_thread_struct;
3294#[repr(C)]
3295#[derive(Debug, Copy, Clone)]
3296pub struct rb_trace_arg_struct {
3297    pub event: rb_event_flag_t,
3298    pub ec: *mut rb_execution_context_t,
3299    pub cfp: *const rb_control_frame_t,
3300    pub self_: VALUE,
3301    pub id: ID,
3302    pub called_id: ID,
3303    pub klass: VALUE,
3304    pub data: VALUE,
3305    pub klass_solved: ::std::os::raw::c_int,
3306    pub lineno: ::std::os::raw::c_int,
3307    pub path: VALUE,
3308}
3309#[repr(C)]
3310#[derive(Debug, Copy, Clone)]
3311pub struct rb_ractor_pub {
3312    pub self_: VALUE,
3313    pub id: u32,
3314    pub hooks: rb_hook_list_t,
3315    pub targeted_hooks: *mut st_table,
3316    pub targeted_hooks_cnt: ::std::os::raw::c_uint,
3317}
3318#[repr(C)]
3319#[derive(Debug)]
3320pub struct rb_objspace {
3321    _unused: [u8; 0],
3322}
3323#[repr(C)]
3324#[derive(Copy, Clone)]
3325pub struct rb_ractor_sync {
3326    pub lock: rb_nativethread_lock_t,
3327    pub recv_queue: *mut ractor_queue,
3328    pub waiters: ccan_list_head,
3329    pub default_port_value: VALUE,
3330    pub ports: *mut st_table,
3331    pub next_port_id: usize,
3332    pub monitors: ccan_list_head,
3333    pub successor: *mut rb_ractor_t,
3334    pub legacy: VALUE,
3335    pub legacy_exc: u8,
3336}
3337impl ::std::fmt::Debug for rb_ractor_sync {
3338    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3339        write ! (f , "rb_ractor_sync {{ lock: {:?}, recv_queue: {:?}, waiters: {:?}, default_port_value: {:?}, ports: {:?}, monitors: {:?}, successor: {:?}, legacy: {:?}, legacy_exc: {:?} }}" , self . lock , self . recv_queue , self . waiters , self . default_port_value , self . ports , self . monitors , self . successor , self . legacy , self . legacy_exc)
3340    }
3341}
3342pub const ractor_status_ractor_created: ractor_status = 0;
3343pub const ractor_status_ractor_running: ractor_status = 1;
3344pub const ractor_status_ractor_blocking: ractor_status = 2;
3345pub const ractor_status_ractor_terminated: ractor_status = 3;
3346pub type ractor_status = ::std::os::raw::c_uint;
3347#[repr(C)]
3348#[derive(Copy, Clone)]
3349pub struct rb_ractor_struct {
3350    pub pub_: rb_ractor_pub,
3351    pub sync: rb_ractor_sync,
3352    pub threads: rb_ractor_struct__bindgen_ty_1,
3353    pub thgroup_default: VALUE,
3354    pub name: VALUE,
3355    pub loc: VALUE,
3356    pub status_: ractor_status,
3357    pub vmlr_node: ccan_list_node,
3358    pub next_ec_serial: rb_serial_t,
3359    pub local_storage: *mut st_table,
3360    pub idkey_local_storage: *mut rb_id_table,
3361    pub local_storage_store_lock: VALUE,
3362    pub r_stdin: VALUE,
3363    pub r_stdout: VALUE,
3364    pub r_stderr: VALUE,
3365    pub verbose: VALUE,
3366    pub debug: VALUE,
3367    pub malloc_gc_disabled: u8,
3368    pub newobj_cache: *mut ::std::os::raw::c_void,
3369}
3370#[repr(C)]
3371#[derive(Copy, Clone)]
3372pub struct rb_ractor_struct__bindgen_ty_1 {
3373    pub set: ccan_list_head,
3374    pub cnt: ::std::os::raw::c_uint,
3375    pub blocking_cnt: ::std::os::raw::c_uint,
3376    pub sleeper: ::std::os::raw::c_uint,
3377    pub sched: rb_thread_sched,
3378    pub running_ec: *mut rb_execution_context_t,
3379    pub main: *mut rb_thread_t,
3380}
3381impl ::std::fmt::Debug for rb_ractor_struct__bindgen_ty_1 {
3382    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3383        write ! (f , "rb_ractor_struct__bindgen_ty_1 {{ set: {:?}, cnt: {:?}, blocking_cnt: {:?}, sleeper: {:?}, sched: {:?}, running_ec: {:?}, main: {:?} }}" , self . set , self . cnt , self . blocking_cnt , self . sleeper , self . sched , self . running_ec , self . main)
3384    }
3385}
3386impl ::std::fmt::Debug for rb_ractor_struct {
3387    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3388        write ! (f , "rb_ractor_struct {{ pub: {:?}, sync: {:?}, threads: {:?}, thgroup_default: {:?}, name: {:?}, loc: {:?}, status_: {:?}, vmlr_node: {:?}, next_ec_serial: {:?}, local_storage: {:?}, idkey_local_storage: {:?}, local_storage_store_lock: {:?}, r_stdin: {:?}, r_stdout: {:?}, r_stderr: {:?}, verbose: {:?}, debug: {:?}, malloc_gc_disabled: {:?}, newobj_cache: {:?} }}" , self . pub_ , self . sync , self . threads , self . thgroup_default , self . name , self . loc , self . status_ , self . vmlr_node , self . next_ec_serial , self . local_storage , self . idkey_local_storage , self . local_storage_store_lock , self . r_stdin , self . r_stdout , self . r_stderr , self . verbose , self . debug , self . malloc_gc_disabled , self . newobj_cache)
3389    }
3390}
3391pub type attr_index_t = u16;
3392#[repr(C)]
3393#[derive(Debug, Copy, Clone)]
3394pub struct rb_subclass_entry {
3395    pub klass: VALUE,
3396    pub next: *mut rb_subclass_entry,
3397    pub prev: *mut rb_subclass_entry,
3398}
3399#[repr(C)]
3400#[derive(Copy, Clone)]
3401pub struct rb_classext_struct {
3402    pub box_: *const rb_box_t,
3403    pub super_: VALUE,
3404    pub fields_obj: VALUE,
3405    pub m_tbl: *mut rb_id_table,
3406    pub const_tbl: *mut rb_id_table,
3407    pub callable_m_tbl: *mut rb_id_table,
3408    pub cc_tbl: VALUE,
3409    pub cvc_tbl: VALUE,
3410    pub superclasses: *mut VALUE,
3411    pub subclasses: *mut rb_subclass_entry,
3412    pub subclass_entry: *mut rb_subclass_entry,
3413    pub module_subclass_entry: *mut rb_subclass_entry,
3414    pub origin_: VALUE,
3415    pub refined_class: VALUE,
3416    pub as_: rb_classext_struct__bindgen_ty_1,
3417    pub max_iv_count: attr_index_t,
3418    pub superclass_depth: u16,
3419    pub variation_count: ::std::os::raw::c_uchar,
3420    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
3421    pub classpath: VALUE,
3422}
3423#[repr(C)]
3424#[derive(Copy, Clone)]
3425pub union rb_classext_struct__bindgen_ty_1 {
3426    pub class: rb_classext_struct__bindgen_ty_1__bindgen_ty_1,
3427    pub singleton_class: rb_classext_struct__bindgen_ty_1__bindgen_ty_2,
3428    pub iclass: rb_classext_struct__bindgen_ty_1__bindgen_ty_3,
3429}
3430#[repr(C)]
3431#[derive(Debug, Copy, Clone)]
3432pub struct rb_classext_struct__bindgen_ty_1__bindgen_ty_1 {
3433    pub allocator: rb_alloc_func_t,
3434}
3435#[repr(C)]
3436#[derive(Debug, Copy, Clone)]
3437pub struct rb_classext_struct__bindgen_ty_1__bindgen_ty_2 {
3438    pub attached_object: VALUE,
3439}
3440#[repr(C)]
3441#[derive(Debug, Copy, Clone)]
3442pub struct rb_classext_struct__bindgen_ty_1__bindgen_ty_3 {
3443    pub includer: VALUE,
3444}
3445impl ::std::fmt::Debug for rb_classext_struct__bindgen_ty_1 {
3446    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3447        write!(f, "rb_classext_struct__bindgen_ty_1 {{ union }}")
3448    }
3449}
3450impl ::std::fmt::Debug for rb_classext_struct {
3451    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3452        write ! (f , "rb_classext_struct {{ box: {:?}, super: {:?}, fields_obj: {:?}, m_tbl: {:?}, const_tbl: {:?}, callable_m_tbl: {:?}, cc_tbl: {:?}, cvc_tbl: {:?}, superclasses: {:?}, subclasses: {:?}, subclass_entry: {:?}, module_subclass_entry: {:?}, origin_: {:?}, refined_class: {:?}, as: {:?}, variation_count: {:?}, permanent_classpath : {:?}, cloned : {:?}, shared_const_tbl : {:?}, iclass_is_origin : {:?}, iclass_origin_shared_mtbl : {:?}, superclasses_with_self : {:?}, classpath: {:?} }}" , self . box_ , self . super_ , self . fields_obj , self . m_tbl , self . const_tbl , self . callable_m_tbl , self . cc_tbl , self . cvc_tbl , self . superclasses , self . subclasses , self . subclass_entry , self . module_subclass_entry , self . origin_ , self . refined_class , self . as_ , self . variation_count , self . permanent_classpath () , self . cloned () , self . shared_const_tbl () , self . iclass_is_origin () , self . iclass_origin_shared_mtbl () , self . superclasses_with_self () , self . classpath)
3453    }
3454}
3455impl rb_classext_struct {
3456    #[inline]
3457    #[allow(unnecessary_transmutes)]
3458    pub fn permanent_classpath(&self) -> bool {
3459        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<0usize, 1u8>() as u8) }
3460    }
3461    #[inline]
3462    #[allow(unnecessary_transmutes)]
3463    pub fn set_permanent_classpath(&mut self, val: bool) {
3464        unsafe {
3465            let val: u8 = ::std::mem::transmute(val);
3466            self._bitfield_1.set_const::<0usize, 1u8>(val as u64)
3467        }
3468    }
3469    #[inline]
3470    #[allow(unnecessary_transmutes)]
3471    pub unsafe fn permanent_classpath_raw(this: *const Self) -> bool {
3472        unsafe {
3473            ::std::mem::transmute(
3474                <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get_const::<0usize, 1u8>(
3475                    ::std::ptr::addr_of!((*this)._bitfield_1),
3476                ) as u8,
3477            )
3478        }
3479    }
3480    #[inline]
3481    #[allow(unnecessary_transmutes)]
3482    pub unsafe fn set_permanent_classpath_raw(this: *mut Self, val: bool) {
3483        unsafe {
3484            let val: u8 = ::std::mem::transmute(val);
3485            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set_const::<0usize, 1u8>(
3486                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3487                val as u64,
3488            )
3489        }
3490    }
3491    #[inline]
3492    #[allow(unnecessary_transmutes)]
3493    pub fn cloned(&self) -> bool {
3494        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<1usize, 1u8>() as u8) }
3495    }
3496    #[inline]
3497    #[allow(unnecessary_transmutes)]
3498    pub fn set_cloned(&mut self, val: bool) {
3499        unsafe {
3500            let val: u8 = ::std::mem::transmute(val);
3501            self._bitfield_1.set_const::<1usize, 1u8>(val as u64)
3502        }
3503    }
3504    #[inline]
3505    #[allow(unnecessary_transmutes)]
3506    pub unsafe fn cloned_raw(this: *const Self) -> bool {
3507        unsafe {
3508            ::std::mem::transmute(
3509                <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get_const::<1usize, 1u8>(
3510                    ::std::ptr::addr_of!((*this)._bitfield_1),
3511                ) as u8,
3512            )
3513        }
3514    }
3515    #[inline]
3516    #[allow(unnecessary_transmutes)]
3517    pub unsafe fn set_cloned_raw(this: *mut Self, val: bool) {
3518        unsafe {
3519            let val: u8 = ::std::mem::transmute(val);
3520            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set_const::<1usize, 1u8>(
3521                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3522                val as u64,
3523            )
3524        }
3525    }
3526    #[inline]
3527    #[allow(unnecessary_transmutes)]
3528    pub fn shared_const_tbl(&self) -> bool {
3529        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<2usize, 1u8>() as u8) }
3530    }
3531    #[inline]
3532    #[allow(unnecessary_transmutes)]
3533    pub fn set_shared_const_tbl(&mut self, val: bool) {
3534        unsafe {
3535            let val: u8 = ::std::mem::transmute(val);
3536            self._bitfield_1.set_const::<2usize, 1u8>(val as u64)
3537        }
3538    }
3539    #[inline]
3540    #[allow(unnecessary_transmutes)]
3541    pub unsafe fn shared_const_tbl_raw(this: *const Self) -> bool {
3542        unsafe {
3543            ::std::mem::transmute(
3544                <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get_const::<2usize, 1u8>(
3545                    ::std::ptr::addr_of!((*this)._bitfield_1),
3546                ) as u8,
3547            )
3548        }
3549    }
3550    #[inline]
3551    #[allow(unnecessary_transmutes)]
3552    pub unsafe fn set_shared_const_tbl_raw(this: *mut Self, val: bool) {
3553        unsafe {
3554            let val: u8 = ::std::mem::transmute(val);
3555            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set_const::<2usize, 1u8>(
3556                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3557                val as u64,
3558            )
3559        }
3560    }
3561    #[inline]
3562    #[allow(unnecessary_transmutes)]
3563    pub fn iclass_is_origin(&self) -> bool {
3564        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<3usize, 1u8>() as u8) }
3565    }
3566    #[inline]
3567    #[allow(unnecessary_transmutes)]
3568    pub fn set_iclass_is_origin(&mut self, val: bool) {
3569        unsafe {
3570            let val: u8 = ::std::mem::transmute(val);
3571            self._bitfield_1.set_const::<3usize, 1u8>(val as u64)
3572        }
3573    }
3574    #[inline]
3575    #[allow(unnecessary_transmutes)]
3576    pub unsafe fn iclass_is_origin_raw(this: *const Self) -> bool {
3577        unsafe {
3578            ::std::mem::transmute(
3579                <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get_const::<3usize, 1u8>(
3580                    ::std::ptr::addr_of!((*this)._bitfield_1),
3581                ) as u8,
3582            )
3583        }
3584    }
3585    #[inline]
3586    #[allow(unnecessary_transmutes)]
3587    pub unsafe fn set_iclass_is_origin_raw(this: *mut Self, val: bool) {
3588        unsafe {
3589            let val: u8 = ::std::mem::transmute(val);
3590            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set_const::<3usize, 1u8>(
3591                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3592                val as u64,
3593            )
3594        }
3595    }
3596    #[inline]
3597    #[allow(unnecessary_transmutes)]
3598    pub fn iclass_origin_shared_mtbl(&self) -> bool {
3599        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<4usize, 1u8>() as u8) }
3600    }
3601    #[inline]
3602    #[allow(unnecessary_transmutes)]
3603    pub fn set_iclass_origin_shared_mtbl(&mut self, val: bool) {
3604        unsafe {
3605            let val: u8 = ::std::mem::transmute(val);
3606            self._bitfield_1.set_const::<4usize, 1u8>(val as u64)
3607        }
3608    }
3609    #[inline]
3610    #[allow(unnecessary_transmutes)]
3611    pub unsafe fn iclass_origin_shared_mtbl_raw(this: *const Self) -> bool {
3612        unsafe {
3613            ::std::mem::transmute(
3614                <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get_const::<4usize, 1u8>(
3615                    ::std::ptr::addr_of!((*this)._bitfield_1),
3616                ) as u8,
3617            )
3618        }
3619    }
3620    #[inline]
3621    #[allow(unnecessary_transmutes)]
3622    pub unsafe fn set_iclass_origin_shared_mtbl_raw(this: *mut Self, val: bool) {
3623        unsafe {
3624            let val: u8 = ::std::mem::transmute(val);
3625            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set_const::<4usize, 1u8>(
3626                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3627                val as u64,
3628            )
3629        }
3630    }
3631    #[inline]
3632    #[allow(unnecessary_transmutes)]
3633    pub fn superclasses_with_self(&self) -> bool {
3634        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<5usize, 1u8>() as u8) }
3635    }
3636    #[inline]
3637    #[allow(unnecessary_transmutes)]
3638    pub fn set_superclasses_with_self(&mut self, val: bool) {
3639        unsafe {
3640            let val: u8 = ::std::mem::transmute(val);
3641            self._bitfield_1.set_const::<5usize, 1u8>(val as u64)
3642        }
3643    }
3644    #[inline]
3645    #[allow(unnecessary_transmutes)]
3646    pub unsafe fn superclasses_with_self_raw(this: *const Self) -> bool {
3647        unsafe {
3648            ::std::mem::transmute(
3649                <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get_const::<5usize, 1u8>(
3650                    ::std::ptr::addr_of!((*this)._bitfield_1),
3651                ) as u8,
3652            )
3653        }
3654    }
3655    #[inline]
3656    #[allow(unnecessary_transmutes)]
3657    pub unsafe fn set_superclasses_with_self_raw(this: *mut Self, val: bool) {
3658        unsafe {
3659            let val: u8 = ::std::mem::transmute(val);
3660            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set_const::<5usize, 1u8>(
3661                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3662                val as u64,
3663            )
3664        }
3665    }
3666    #[inline]
3667    #[allow(unnecessary_transmutes)]
3668    pub fn new_bitfield_1(
3669        permanent_classpath: bool,
3670        cloned: bool,
3671        shared_const_tbl: bool,
3672        iclass_is_origin: bool,
3673        iclass_origin_shared_mtbl: bool,
3674        superclasses_with_self: bool,
3675    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
3676        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
3677        __bindgen_bitfield_unit.set_const::<0usize, 1u8>({
3678            let permanent_classpath: u8 = unsafe { ::std::mem::transmute(permanent_classpath) };
3679            permanent_classpath as u64
3680        });
3681        __bindgen_bitfield_unit.set_const::<1usize, 1u8>({
3682            let cloned: u8 = unsafe { ::std::mem::transmute(cloned) };
3683            cloned as u64
3684        });
3685        __bindgen_bitfield_unit.set_const::<2usize, 1u8>({
3686            let shared_const_tbl: u8 = unsafe { ::std::mem::transmute(shared_const_tbl) };
3687            shared_const_tbl as u64
3688        });
3689        __bindgen_bitfield_unit.set_const::<3usize, 1u8>({
3690            let iclass_is_origin: u8 = unsafe { ::std::mem::transmute(iclass_is_origin) };
3691            iclass_is_origin as u64
3692        });
3693        __bindgen_bitfield_unit.set_const::<4usize, 1u8>({
3694            let iclass_origin_shared_mtbl: u8 =
3695                unsafe { ::std::mem::transmute(iclass_origin_shared_mtbl) };
3696            iclass_origin_shared_mtbl as u64
3697        });
3698        __bindgen_bitfield_unit.set_const::<5usize, 1u8>({
3699            let superclasses_with_self: u8 =
3700                unsafe { ::std::mem::transmute(superclasses_with_self) };
3701            superclasses_with_self as u64
3702        });
3703        __bindgen_bitfield_unit
3704    }
3705}
3706pub type rb_classext_t = rb_classext_struct;
3707#[repr(C)]
3708#[derive(Debug, Copy, Clone)]
3709pub struct RClass {
3710    pub basic: RBasic,
3711    pub object_id: VALUE,
3712}
3713#[repr(C)]
3714#[derive(Copy, Clone)]
3715pub struct RClass_and_rb_classext_t {
3716    pub rclass: RClass,
3717    pub classext: rb_classext_t,
3718}
3719impl ::std::fmt::Debug for RClass_and_rb_classext_t {
3720    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3721        write!(
3722            f,
3723            "RClass_and_rb_classext_t {{ rclass: {:?}, classext: {:?} }}",
3724            self.rclass, self.classext
3725        )
3726    }
3727}
3728#[repr(C)]
3729#[derive(Copy, Clone)]
3730pub struct iseq_compile_data {
3731    pub err_info: VALUE,
3732    pub catch_table_ary: VALUE,
3733    pub iseq_size: ::std::os::raw::c_uint,
3734    pub iseq_encoded: *mut VALUE,
3735    pub is_single_mark_bit: u8,
3736    pub mark_bits: iseq_compile_data__bindgen_ty_1,
3737    pub start_label: *mut iseq_label_data,
3738    pub end_label: *mut iseq_label_data,
3739    pub redo_label: *mut iseq_label_data,
3740    pub current_block: *const rb_iseq_t,
3741    pub ensure_node_stack: *mut iseq_compile_data_ensure_node_stack,
3742    pub node: iseq_compile_data__bindgen_ty_2,
3743    pub insn: iseq_compile_data__bindgen_ty_3,
3744    pub in_rescue: u8,
3745    pub in_masgn: u8,
3746    pub loopval_popped: ::std::os::raw::c_int,
3747    pub last_line: ::std::os::raw::c_int,
3748    pub label_no: ::std::os::raw::c_int,
3749    pub node_level: ::std::os::raw::c_int,
3750    pub isolated_depth: ::std::os::raw::c_int,
3751    pub ci_index: ::std::os::raw::c_uint,
3752    pub ic_index: ::std::os::raw::c_uint,
3753    pub option: *const rb_compile_option_t,
3754    pub ivar_cache_table: *mut rb_id_table,
3755    pub builtin_function_table: *const rb_builtin_function,
3756    pub root_node: *const NODE,
3757    pub catch_except_p: u8,
3758}
3759#[repr(C)]
3760#[derive(Copy, Clone)]
3761pub union iseq_compile_data__bindgen_ty_1 {
3762    pub list: *mut iseq_bits_t,
3763    pub single: iseq_bits_t,
3764}
3765impl ::std::fmt::Debug for iseq_compile_data__bindgen_ty_1 {
3766    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3767        write!(f, "iseq_compile_data__bindgen_ty_1 {{ union }}")
3768    }
3769}
3770#[repr(C)]
3771#[derive(Debug, Copy, Clone)]
3772pub struct iseq_compile_data__bindgen_ty_2 {
3773    pub storage_head: *mut iseq_compile_data_storage,
3774    pub storage_current: *mut iseq_compile_data_storage,
3775}
3776#[repr(C)]
3777#[derive(Debug, Copy, Clone)]
3778pub struct iseq_compile_data__bindgen_ty_3 {
3779    pub storage_head: *mut iseq_compile_data_storage,
3780    pub storage_current: *mut iseq_compile_data_storage,
3781}
3782impl ::std::fmt::Debug for iseq_compile_data {
3783    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3784        write ! (f , "iseq_compile_data {{ err_info: {:?}, catch_table_ary: {:?}, iseq_size: {:?}, iseq_encoded: {:?}, is_single_mark_bit: {:?}, mark_bits: {:?}, start_label: {:?}, end_label: {:?}, redo_label: {:?}, current_block: {:?}, ensure_node_stack: {:?}, node: {:?}, insn: {:?}, in_rescue: {:?}, in_masgn: {:?}, loopval_popped: {:?}, last_line: {:?}, label_no: {:?}, node_level: {:?}, isolated_depth: {:?}, ci_index: {:?}, ic_index: {:?}, option: {:?}, ivar_cache_table: {:?}, builtin_function_table: {:?}, root_node: {:?}, catch_except_p: {:?} }}" , self . err_info , self . catch_table_ary , self . iseq_size , self . iseq_encoded , self . is_single_mark_bit , self . mark_bits , self . start_label , self . end_label , self . redo_label , self . current_block , self . ensure_node_stack , self . node , self . insn , self . in_rescue , self . in_masgn , self . loopval_popped , self . last_line , self . label_no , self . node_level , self . isolated_depth , self . ci_index , self . ic_index , self . option , self . ivar_cache_table , self . builtin_function_table , self . root_node , self . catch_except_p)
3785    }
3786}
3787#[repr(C)]
3788#[derive(Debug, Copy, Clone)]
3789pub struct rb_compile_option_struct {
3790    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
3791    pub debug_level: ::std::os::raw::c_int,
3792}
3793impl rb_compile_option_struct {
3794    #[inline]
3795    #[allow(unnecessary_transmutes)]
3796    pub fn inline_const_cache(&self) -> ::std::os::raw::c_uint {
3797        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<0usize, 1u8>() as u32) }
3798    }
3799    #[inline]
3800    #[allow(unnecessary_transmutes)]
3801    pub fn set_inline_const_cache(&mut self, val: ::std::os::raw::c_uint) {
3802        unsafe {
3803            let val: u32 = ::std::mem::transmute(val);
3804            self._bitfield_1.set_const::<0usize, 1u8>(val as u64)
3805        }
3806    }
3807    #[inline]
3808    #[allow(unnecessary_transmutes)]
3809    pub unsafe fn inline_const_cache_raw(this: *const Self) -> ::std::os::raw::c_uint {
3810        unsafe {
3811            ::std::mem::transmute(
3812                <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get_const::<0usize, 1u8>(
3813                    ::std::ptr::addr_of!((*this)._bitfield_1),
3814                ) as u32,
3815            )
3816        }
3817    }
3818    #[inline]
3819    #[allow(unnecessary_transmutes)]
3820    pub unsafe fn set_inline_const_cache_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
3821        unsafe {
3822            let val: u32 = ::std::mem::transmute(val);
3823            <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set_const::<0usize, 1u8>(
3824                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3825                val as u64,
3826            )
3827        }
3828    }
3829    #[inline]
3830    #[allow(unnecessary_transmutes)]
3831    pub fn peephole_optimization(&self) -> ::std::os::raw::c_uint {
3832        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<1usize, 1u8>() as u32) }
3833    }
3834    #[inline]
3835    #[allow(unnecessary_transmutes)]
3836    pub fn set_peephole_optimization(&mut self, val: ::std::os::raw::c_uint) {
3837        unsafe {
3838            let val: u32 = ::std::mem::transmute(val);
3839            self._bitfield_1.set_const::<1usize, 1u8>(val as u64)
3840        }
3841    }
3842    #[inline]
3843    #[allow(unnecessary_transmutes)]
3844    pub unsafe fn peephole_optimization_raw(this: *const Self) -> ::std::os::raw::c_uint {
3845        unsafe {
3846            ::std::mem::transmute(
3847                <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get_const::<1usize, 1u8>(
3848                    ::std::ptr::addr_of!((*this)._bitfield_1),
3849                ) as u32,
3850            )
3851        }
3852    }
3853    #[inline]
3854    #[allow(unnecessary_transmutes)]
3855    pub unsafe fn set_peephole_optimization_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
3856        unsafe {
3857            let val: u32 = ::std::mem::transmute(val);
3858            <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set_const::<1usize, 1u8>(
3859                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3860                val as u64,
3861            )
3862        }
3863    }
3864    #[inline]
3865    #[allow(unnecessary_transmutes)]
3866    pub fn tailcall_optimization(&self) -> ::std::os::raw::c_uint {
3867        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<2usize, 1u8>() as u32) }
3868    }
3869    #[inline]
3870    #[allow(unnecessary_transmutes)]
3871    pub fn set_tailcall_optimization(&mut self, val: ::std::os::raw::c_uint) {
3872        unsafe {
3873            let val: u32 = ::std::mem::transmute(val);
3874            self._bitfield_1.set_const::<2usize, 1u8>(val as u64)
3875        }
3876    }
3877    #[inline]
3878    #[allow(unnecessary_transmutes)]
3879    pub unsafe fn tailcall_optimization_raw(this: *const Self) -> ::std::os::raw::c_uint {
3880        unsafe {
3881            ::std::mem::transmute(
3882                <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get_const::<2usize, 1u8>(
3883                    ::std::ptr::addr_of!((*this)._bitfield_1),
3884                ) as u32,
3885            )
3886        }
3887    }
3888    #[inline]
3889    #[allow(unnecessary_transmutes)]
3890    pub unsafe fn set_tailcall_optimization_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
3891        unsafe {
3892            let val: u32 = ::std::mem::transmute(val);
3893            <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set_const::<2usize, 1u8>(
3894                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3895                val as u64,
3896            )
3897        }
3898    }
3899    #[inline]
3900    #[allow(unnecessary_transmutes)]
3901    pub fn specialized_instruction(&self) -> ::std::os::raw::c_uint {
3902        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<3usize, 1u8>() as u32) }
3903    }
3904    #[inline]
3905    #[allow(unnecessary_transmutes)]
3906    pub fn set_specialized_instruction(&mut self, val: ::std::os::raw::c_uint) {
3907        unsafe {
3908            let val: u32 = ::std::mem::transmute(val);
3909            self._bitfield_1.set_const::<3usize, 1u8>(val as u64)
3910        }
3911    }
3912    #[inline]
3913    #[allow(unnecessary_transmutes)]
3914    pub unsafe fn specialized_instruction_raw(this: *const Self) -> ::std::os::raw::c_uint {
3915        unsafe {
3916            ::std::mem::transmute(
3917                <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get_const::<3usize, 1u8>(
3918                    ::std::ptr::addr_of!((*this)._bitfield_1),
3919                ) as u32,
3920            )
3921        }
3922    }
3923    #[inline]
3924    #[allow(unnecessary_transmutes)]
3925    pub unsafe fn set_specialized_instruction_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
3926        unsafe {
3927            let val: u32 = ::std::mem::transmute(val);
3928            <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set_const::<3usize, 1u8>(
3929                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3930                val as u64,
3931            )
3932        }
3933    }
3934    #[inline]
3935    #[allow(unnecessary_transmutes)]
3936    pub fn operands_unification(&self) -> ::std::os::raw::c_uint {
3937        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<4usize, 1u8>() as u32) }
3938    }
3939    #[inline]
3940    #[allow(unnecessary_transmutes)]
3941    pub fn set_operands_unification(&mut self, val: ::std::os::raw::c_uint) {
3942        unsafe {
3943            let val: u32 = ::std::mem::transmute(val);
3944            self._bitfield_1.set_const::<4usize, 1u8>(val as u64)
3945        }
3946    }
3947    #[inline]
3948    #[allow(unnecessary_transmutes)]
3949    pub unsafe fn operands_unification_raw(this: *const Self) -> ::std::os::raw::c_uint {
3950        unsafe {
3951            ::std::mem::transmute(
3952                <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get_const::<4usize, 1u8>(
3953                    ::std::ptr::addr_of!((*this)._bitfield_1),
3954                ) as u32,
3955            )
3956        }
3957    }
3958    #[inline]
3959    #[allow(unnecessary_transmutes)]
3960    pub unsafe fn set_operands_unification_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
3961        unsafe {
3962            let val: u32 = ::std::mem::transmute(val);
3963            <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set_const::<4usize, 1u8>(
3964                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3965                val as u64,
3966            )
3967        }
3968    }
3969    #[inline]
3970    #[allow(unnecessary_transmutes)]
3971    pub fn instructions_unification(&self) -> ::std::os::raw::c_uint {
3972        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<5usize, 1u8>() as u32) }
3973    }
3974    #[inline]
3975    #[allow(unnecessary_transmutes)]
3976    pub fn set_instructions_unification(&mut self, val: ::std::os::raw::c_uint) {
3977        unsafe {
3978            let val: u32 = ::std::mem::transmute(val);
3979            self._bitfield_1.set_const::<5usize, 1u8>(val as u64)
3980        }
3981    }
3982    #[inline]
3983    #[allow(unnecessary_transmutes)]
3984    pub unsafe fn instructions_unification_raw(this: *const Self) -> ::std::os::raw::c_uint {
3985        unsafe {
3986            ::std::mem::transmute(
3987                <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get_const::<5usize, 1u8>(
3988                    ::std::ptr::addr_of!((*this)._bitfield_1),
3989                ) as u32,
3990            )
3991        }
3992    }
3993    #[inline]
3994    #[allow(unnecessary_transmutes)]
3995    pub unsafe fn set_instructions_unification_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
3996        unsafe {
3997            let val: u32 = ::std::mem::transmute(val);
3998            <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set_const::<5usize, 1u8>(
3999                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4000                val as u64,
4001            )
4002        }
4003    }
4004    #[inline]
4005    #[allow(unnecessary_transmutes)]
4006    pub fn frozen_string_literal(&self) -> ::std::os::raw::c_int {
4007        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<6usize, 2u8>() as u32) }
4008    }
4009    #[inline]
4010    #[allow(unnecessary_transmutes)]
4011    pub fn set_frozen_string_literal(&mut self, val: ::std::os::raw::c_int) {
4012        unsafe {
4013            let val: u32 = ::std::mem::transmute(val);
4014            self._bitfield_1.set_const::<6usize, 2u8>(val as u64)
4015        }
4016    }
4017    #[inline]
4018    #[allow(unnecessary_transmutes)]
4019    pub unsafe fn frozen_string_literal_raw(this: *const Self) -> ::std::os::raw::c_int {
4020        unsafe {
4021            ::std::mem::transmute(
4022                <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get_const::<6usize, 2u8>(
4023                    ::std::ptr::addr_of!((*this)._bitfield_1),
4024                ) as u32,
4025            )
4026        }
4027    }
4028    #[inline]
4029    #[allow(unnecessary_transmutes)]
4030    pub unsafe fn set_frozen_string_literal_raw(this: *mut Self, val: ::std::os::raw::c_int) {
4031        unsafe {
4032            let val: u32 = ::std::mem::transmute(val);
4033            <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set_const::<6usize, 2u8>(
4034                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4035                val as u64,
4036            )
4037        }
4038    }
4039    #[inline]
4040    #[allow(unnecessary_transmutes)]
4041    pub fn debug_frozen_string_literal(&self) -> ::std::os::raw::c_uint {
4042        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<8usize, 1u8>() as u32) }
4043    }
4044    #[inline]
4045    #[allow(unnecessary_transmutes)]
4046    pub fn set_debug_frozen_string_literal(&mut self, val: ::std::os::raw::c_uint) {
4047        unsafe {
4048            let val: u32 = ::std::mem::transmute(val);
4049            self._bitfield_1.set_const::<8usize, 1u8>(val as u64)
4050        }
4051    }
4052    #[inline]
4053    #[allow(unnecessary_transmutes)]
4054    pub unsafe fn debug_frozen_string_literal_raw(this: *const Self) -> ::std::os::raw::c_uint {
4055        unsafe {
4056            ::std::mem::transmute(
4057                <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get_const::<8usize, 1u8>(
4058                    ::std::ptr::addr_of!((*this)._bitfield_1),
4059                ) as u32,
4060            )
4061        }
4062    }
4063    #[inline]
4064    #[allow(unnecessary_transmutes)]
4065    pub unsafe fn set_debug_frozen_string_literal_raw(
4066        this: *mut Self,
4067        val: ::std::os::raw::c_uint,
4068    ) {
4069        unsafe {
4070            let val: u32 = ::std::mem::transmute(val);
4071            <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set_const::<8usize, 1u8>(
4072                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4073                val as u64,
4074            )
4075        }
4076    }
4077    #[inline]
4078    #[allow(unnecessary_transmutes)]
4079    pub fn coverage_enabled(&self) -> ::std::os::raw::c_uint {
4080        unsafe { ::std::mem::transmute(self._bitfield_1.get_const::<9usize, 1u8>() as u32) }
4081    }
4082    #[inline]
4083    #[allow(unnecessary_transmutes)]
4084    pub fn set_coverage_enabled(&mut self, val: ::std::os::raw::c_uint) {
4085        unsafe {
4086            let val: u32 = ::std::mem::transmute(val);
4087            self._bitfield_1.set_const::<9usize, 1u8>(val as u64)
4088        }
4089    }
4090    #[inline]
4091    #[allow(unnecessary_transmutes)]
4092    pub unsafe fn coverage_enabled_raw(this: *const Self) -> ::std::os::raw::c_uint {
4093        unsafe {
4094            ::std::mem::transmute(
4095                <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get_const::<9usize, 1u8>(
4096                    ::std::ptr::addr_of!((*this)._bitfield_1),
4097                ) as u32,
4098            )
4099        }
4100    }
4101    #[inline]
4102    #[allow(unnecessary_transmutes)]
4103    pub unsafe fn set_coverage_enabled_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
4104        unsafe {
4105            let val: u32 = ::std::mem::transmute(val);
4106            <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set_const::<9usize, 1u8>(
4107                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4108                val as u64,
4109            )
4110        }
4111    }
4112    #[inline]
4113    #[allow(unnecessary_transmutes)]
4114    pub fn new_bitfield_1(
4115        inline_const_cache: ::std::os::raw::c_uint,
4116        peephole_optimization: ::std::os::raw::c_uint,
4117        tailcall_optimization: ::std::os::raw::c_uint,
4118        specialized_instruction: ::std::os::raw::c_uint,
4119        operands_unification: ::std::os::raw::c_uint,
4120        instructions_unification: ::std::os::raw::c_uint,
4121        frozen_string_literal: ::std::os::raw::c_int,
4122        debug_frozen_string_literal: ::std::os::raw::c_uint,
4123        coverage_enabled: ::std::os::raw::c_uint,
4124    ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
4125        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
4126        __bindgen_bitfield_unit.set_const::<0usize, 1u8>({
4127            let inline_const_cache: u32 = unsafe { ::std::mem::transmute(inline_const_cache) };
4128            inline_const_cache as u64
4129        });
4130        __bindgen_bitfield_unit.set_const::<1usize, 1u8>({
4131            let peephole_optimization: u32 =
4132                unsafe { ::std::mem::transmute(peephole_optimization) };
4133            peephole_optimization as u64
4134        });
4135        __bindgen_bitfield_unit.set_const::<2usize, 1u8>({
4136            let tailcall_optimization: u32 =
4137                unsafe { ::std::mem::transmute(tailcall_optimization) };
4138            tailcall_optimization as u64
4139        });
4140        __bindgen_bitfield_unit.set_const::<3usize, 1u8>({
4141            let specialized_instruction: u32 =
4142                unsafe { ::std::mem::transmute(specialized_instruction) };
4143            specialized_instruction as u64
4144        });
4145        __bindgen_bitfield_unit.set_const::<4usize, 1u8>({
4146            let operands_unification: u32 = unsafe { ::std::mem::transmute(operands_unification) };
4147            operands_unification as u64
4148        });
4149        __bindgen_bitfield_unit.set_const::<5usize, 1u8>({
4150            let instructions_unification: u32 =
4151                unsafe { ::std::mem::transmute(instructions_unification) };
4152            instructions_unification as u64
4153        });
4154        __bindgen_bitfield_unit.set_const::<6usize, 2u8>({
4155            let frozen_string_literal: u32 =
4156                unsafe { ::std::mem::transmute(frozen_string_literal) };
4157            frozen_string_literal as u64
4158        });
4159        __bindgen_bitfield_unit.set_const::<8usize, 1u8>({
4160            let debug_frozen_string_literal: u32 =
4161                unsafe { ::std::mem::transmute(debug_frozen_string_literal) };
4162            debug_frozen_string_literal as u64
4163        });
4164        __bindgen_bitfield_unit.set_const::<9usize, 1u8>({
4165            let coverage_enabled: u32 = unsafe { ::std::mem::transmute(coverage_enabled) };
4166            coverage_enabled as u64
4167        });
4168        __bindgen_bitfield_unit
4169    }
4170}
4171#[repr(C)]
4172#[derive(Debug, Copy, Clone)]
4173pub struct iseq_insn_info_entry {
4174    pub line_no: ::std::os::raw::c_int,
4175    pub node_id: ::std::os::raw::c_int,
4176    pub events: rb_event_flag_t,
4177}
4178pub const rb_catch_type_CATCH_TYPE_RESCUE: rb_catch_type = 3;
4179pub const rb_catch_type_CATCH_TYPE_ENSURE: rb_catch_type = 5;
4180pub const rb_catch_type_CATCH_TYPE_RETRY: rb_catch_type = 7;
4181pub const rb_catch_type_CATCH_TYPE_BREAK: rb_catch_type = 9;
4182pub const rb_catch_type_CATCH_TYPE_REDO: rb_catch_type = 11;
4183pub const rb_catch_type_CATCH_TYPE_NEXT: rb_catch_type = 13;
4184pub type rb_catch_type = ::std::os::raw::c_uint;
4185#[repr(C)]
4186#[derive(Debug, Copy, Clone)]
4187pub struct iseq_catch_table_entry {
4188    pub type_: rb_catch_type,
4189    pub iseq: *mut rb_iseq_t,
4190    pub start: ::std::os::raw::c_uint,
4191    pub end: ::std::os::raw::c_uint,
4192    pub cont: ::std::os::raw::c_uint,
4193    pub sp: ::std::os::raw::c_uint,
4194}
4195#[repr(C, packed)]
4196pub struct iseq_catch_table {
4197    pub size: ::std::os::raw::c_uint,
4198    pub entries: __IncompleteArrayField<iseq_catch_table_entry>,
4199}
4200#[repr(C)]
4201#[derive(Debug)]
4202pub struct iseq_compile_data_storage {
4203    pub next: *mut iseq_compile_data_storage,
4204    pub pos: ::std::os::raw::c_uint,
4205    pub size: ::std::os::raw::c_uint,
4206    pub buff: __IncompleteArrayField<::std::os::raw::c_char>,
4207}
4208#[repr(C)]
4209#[derive(Debug, Copy, Clone)]
4210pub struct coroutine_context {
4211    pub _address: u8,
4212}
4213#[repr(C)]
4214#[derive(Debug, Copy, Clone)]
4215pub struct rb_call_data {
4216    pub _address: u8,
4217}
4218#[repr(C)]
4219#[derive(Debug, Copy, Clone)]
4220pub struct succ_index_table {
4221    pub _address: u8,
4222}
4223#[repr(C)]
4224#[derive(Debug, Copy, Clone)]
4225pub struct rb_event_hook_struct {
4226    pub _address: u8,
4227}
4228#[repr(C)]
4229#[derive(Debug, Copy, Clone)]
4230pub struct rb_postponed_job_queue {
4231    pub _address: u8,
4232}
4233#[repr(C)]
4234#[derive(Debug, Copy, Clone)]
4235pub struct ractor_queue {
4236    pub _address: u8,
4237}
4238#[repr(C)]
4239#[derive(Debug, Copy, Clone)]
4240pub struct iseq_label_data {
4241    pub _address: u8,
4242}
4243#[repr(C)]
4244#[derive(Debug, Copy, Clone)]
4245pub struct iseq_compile_data_ensure_node_stack {
4246    pub _address: u8,
4247}