/* -*- C -*- */

/* This is  an auto-generated file  and is a  part of the  programming language
 * Ruby.   The person  who  created  a program  to  generate  this file  (``I''
 * hereafter) would like  to refrain from defining licensing  of this generated
 * source code.
 *
 * This file consists of many small  parts of codes copyrighted by each author,
 * not  only  the  ``I''  person.   Those  original  authors  agree  with  some
 * open-source license.  I  believe that the license we agree  is the condition
 * mentioned in  the file COPYING.  It  states "4.  You may  modify and include
 * the part of the software into any  other software ...".  But the problem is,
 * the license never makes it clear if  such modified parts still remain in the
 * same  license, or  not.   The fact  that  we agree  with  the source  code's
 * licensing terms does not automatically  define that of generated ones.  This
 * is the reason why this file is  under an unclear situation.  All what I know
 * is that above provision guarantees this file to exist.
 *
 * Please let me hesitate to declare  something about this nuanced contract.  I
 * am not in the position to take  over other authors' license to merge into my
 * one.  Changing them to (say) GPLv3 is not doable by myself.  Perhaps someday
 * it might turn  out to be okay to  say this file is under a  license.  I wish
 * the situation would become more clear in the future. */

/*******************************************************************/
/*******************************************************************/
/*******************************************************************/
/**
  This file contains instruction information for yarv instruction sequence..

  ----
  This file is auto generated by insns2vm.rb
  DO NOT TOUCH!

  If you want to fix something, you must edit "tool/ruby_vm/views/insns_info.inc.erb"
  or tool/insns2vm.rb
 */

enum ruby_insn_type_chars {
    TS_VARIABLE = '.',
    TS_CALLDATA = 'C',
    TS_CDHASH = 'H',
    TS_IC = 'K',
    TS_IVC = 'A',
    TS_ID = 'I',
    TS_ISE = 'T',
    TS_ISEQ = 'S',
    TS_OFFSET = 'O',
    TS_VALUE = 'V',
    TS_LINDEX = 'L',
    TS_FUNCPTR = 'F',
    TS_NUM = 'N',
    TS_BUILTIN = 'R',
};

CONSTFUNC(MAYBE_UNUSED(static const char *insn_name(VALUE insn)));

RUBY_SYMBOL_EXPORT_BEGIN /* for debuggers */
extern const int rb_vm_max_insn_name_size;
extern const char rb_vm_insn_name_base[];
extern const unsigned short rb_vm_insn_name_offset[VM_INSTRUCTION_SIZE];
RUBY_SYMBOL_EXPORT_END

#ifdef RUBY_VM_INSNS_INFO
const int rb_vm_max_insn_name_size = 38;

const char rb_vm_insn_name_base[] =
    "nop" "\0"
    "getlocal" "\0"
    "setlocal" "\0"
    "getblockparam" "\0"
    "setblockparam" "\0"
    "getblockparamproxy" "\0"
    "getspecial" "\0"
    "setspecial" "\0"
    "getinstancevariable" "\0"
    "setinstancevariable" "\0"
    "getclassvariable" "\0"
    "setclassvariable" "\0"
    "getconstant" "\0"
    "setconstant" "\0"
    "getglobal" "\0"
    "setglobal" "\0"
    "putnil" "\0"
    "putself" "\0"
    "putobject" "\0"
    "putspecialobject" "\0"
    "putstring" "\0"
    "concatstrings" "\0"
    "anytostring" "\0"
    "toregexp" "\0"
    "intern" "\0"
    "newarray" "\0"
    "newarraykwsplat" "\0"
    "duparray" "\0"
    "duphash" "\0"
    "expandarray" "\0"
    "concatarray" "\0"
    "splatarray" "\0"
    "newhash" "\0"
    "newrange" "\0"
    "pop" "\0"
    "dup" "\0"
    "dupn" "\0"
    "swap" "\0"
    "topn" "\0"
    "setn" "\0"
    "adjuststack" "\0"
    "defined" "\0"
    "checkmatch" "\0"
    "checkkeyword" "\0"
    "checktype" "\0"
    "defineclass" "\0"
    "definemethod" "\0"
    "definesmethod" "\0"
    "send" "\0"
    "opt_send_without_block" "\0"
    "objtostring" "\0"
    "opt_str_freeze" "\0"
    "opt_nil_p" "\0"
    "opt_str_uminus" "\0"
    "opt_newarray_max" "\0"
    "opt_newarray_min" "\0"
    "invokesuper" "\0"
    "invokeblock" "\0"
    "leave" "\0"
    "throw" "\0"
    "jump" "\0"
    "branchif" "\0"
    "branchunless" "\0"
    "branchnil" "\0"
    "opt_getinlinecache" "\0"
    "opt_setinlinecache" "\0"
    "once" "\0"
    "opt_case_dispatch" "\0"
    "opt_plus" "\0"
    "opt_minus" "\0"
    "opt_mult" "\0"
    "opt_div" "\0"
    "opt_mod" "\0"
    "opt_eq" "\0"
    "opt_neq" "\0"
    "opt_lt" "\0"
    "opt_le" "\0"
    "opt_gt" "\0"
    "opt_ge" "\0"
    "opt_ltlt" "\0"
    "opt_and" "\0"
    "opt_or" "\0"
    "opt_aref" "\0"
    "opt_aset" "\0"
    "opt_aset_with" "\0"
    "opt_aref_with" "\0"
    "opt_length" "\0"
    "opt_size" "\0"
    "opt_empty_p" "\0"
    "opt_succ" "\0"
    "opt_not" "\0"
    "opt_regexpmatch2" "\0"
    "invokebuiltin" "\0"
    "opt_invokebuiltin_delegate" "\0"
    "opt_invokebuiltin_delegate_leave" "\0"
    "getlocal_WC_0" "\0"
    "getlocal_WC_1" "\0"
    "setlocal_WC_0" "\0"
    "setlocal_WC_1" "\0"
    "putobject_INT2FIX_0_" "\0"
    "putobject_INT2FIX_1_" "\0"
    "trace_nop" "\0"
    "trace_getlocal" "\0"
    "trace_setlocal" "\0"
    "trace_getblockparam" "\0"
    "trace_setblockparam" "\0"
    "trace_getblockparamproxy" "\0"
    "trace_getspecial" "\0"
    "trace_setspecial" "\0"
    "trace_getinstancevariable" "\0"
    "trace_setinstancevariable" "\0"
    "trace_getclassvariable" "\0"
    "trace_setclassvariable" "\0"
    "trace_getconstant" "\0"
    "trace_setconstant" "\0"
    "trace_getglobal" "\0"
    "trace_setglobal" "\0"
    "trace_putnil" "\0"
    "trace_putself" "\0"
    "trace_putobject" "\0"
    "trace_putspecialobject" "\0"
    "trace_putstring" "\0"
    "trace_concatstrings" "\0"
    "trace_anytostring" "\0"
    "trace_toregexp" "\0"
    "trace_intern" "\0"
    "trace_newarray" "\0"
    "trace_newarraykwsplat" "\0"
    "trace_duparray" "\0"
    "trace_duphash" "\0"
    "trace_expandarray" "\0"
    "trace_concatarray" "\0"
    "trace_splatarray" "\0"
    "trace_newhash" "\0"
    "trace_newrange" "\0"
    "trace_pop" "\0"
    "trace_dup" "\0"
    "trace_dupn" "\0"
    "trace_swap" "\0"
    "trace_topn" "\0"
    "trace_setn" "\0"
    "trace_adjuststack" "\0"
    "trace_defined" "\0"
    "trace_checkmatch" "\0"
    "trace_checkkeyword" "\0"
    "trace_checktype" "\0"
    "trace_defineclass" "\0"
    "trace_definemethod" "\0"
    "trace_definesmethod" "\0"
    "trace_send" "\0"
    "trace_opt_send_without_block" "\0"
    "trace_objtostring" "\0"
    "trace_opt_str_freeze" "\0"
    "trace_opt_nil_p" "\0"
    "trace_opt_str_uminus" "\0"
    "trace_opt_newarray_max" "\0"
    "trace_opt_newarray_min" "\0"
    "trace_invokesuper" "\0"
    "trace_invokeblock" "\0"
    "trace_leave" "\0"
    "trace_throw" "\0"
    "trace_jump" "\0"
    "trace_branchif" "\0"
    "trace_branchunless" "\0"
    "trace_branchnil" "\0"
    "trace_opt_getinlinecache" "\0"
    "trace_opt_setinlinecache" "\0"
    "trace_once" "\0"
    "trace_opt_case_dispatch" "\0"
    "trace_opt_plus" "\0"
    "trace_opt_minus" "\0"
    "trace_opt_mult" "\0"
    "trace_opt_div" "\0"
    "trace_opt_mod" "\0"
    "trace_opt_eq" "\0"
    "trace_opt_neq" "\0"
    "trace_opt_lt" "\0"
    "trace_opt_le" "\0"
    "trace_opt_gt" "\0"
    "trace_opt_ge" "\0"
    "trace_opt_ltlt" "\0"
    "trace_opt_and" "\0"
    "trace_opt_or" "\0"
    "trace_opt_aref" "\0"
    "trace_opt_aset" "\0"
    "trace_opt_aset_with" "\0"
    "trace_opt_aref_with" "\0"
    "trace_opt_length" "\0"
    "trace_opt_size" "\0"
    "trace_opt_empty_p" "\0"
    "trace_opt_succ" "\0"
    "trace_opt_not" "\0"
    "trace_opt_regexpmatch2" "\0"
    "trace_invokebuiltin" "\0"
    "trace_opt_invokebuiltin_delegate" "\0"
    "trace_opt_invokebuiltin_delegate_leave" "\0"
    "trace_getlocal_WC_0" "\0"
    "trace_getlocal_WC_1" "\0"
    "trace_setlocal_WC_0" "\0"
    "trace_setlocal_WC_1" "\0"
    "trace_putobject_INT2FIX_0_" "\0"
    "trace_putobject_INT2FIX_1_" "\0"
    ;

const unsigned short rb_vm_insn_name_offset[] = {
       0,    4,   13,   22,   36,   50,   69,   80,   91,  111,  131,  148,
     165,  177,  189,  199,  209,  216,  224,  234,  251,  261,  275,  287,
     296,  303,  312,  328,  337,  345,  357,  369,  380,  388,  397,  401,
     405,  410,  415,  420,  425,  437,  445,  456,  469,  479,  491,  504,
     518,  523,  546,  558,  573,  583,  598,  615,  632,  644,  656,  662,
     668,  673,  682,  695,  705,  724,  743,  748,  766,  775,  785,  794,
     802,  810,  817,  825,  832,  839,  846,  853,  862,  870,  877,  886,
     895,  909,  923,  934,  943,  955,  964,  972,  989, 1003, 1030, 1063,
    1077, 1091, 1105, 1119, 1140, 1161, 1171, 1186, 1201, 1221, 1241, 1266,
    1283, 1300, 1326, 1352, 1375, 1398, 1416, 1434, 1450, 1466, 1479, 1493,
    1509, 1532, 1548, 1568, 1586, 1601, 1614, 1629, 1651, 1666, 1680, 1698,
    1716, 1733, 1747, 1762, 1772, 1782, 1793, 1804, 1815, 1826, 1844, 1858,
    1875, 1894, 1910, 1928, 1947, 1967, 1978, 2007, 2025, 2046, 2062, 2083,
    2106, 2129, 2147, 2165, 2177, 2189, 2200, 2215, 2234, 2250, 2275, 2300,
    2311, 2335, 2350, 2366, 2381, 2395, 2409, 2422, 2436, 2449, 2462, 2475,
    2488, 2503, 2517, 2530, 2545, 2560, 2580, 2600, 2617, 2632, 2650, 2665,
    2679, 2702, 2722, 2755, 2794, 2814, 2834, 2854, 2874, 2901,
};

ASSERT_VM_INSTRUCTION_SIZE(rb_vm_insn_name_offset);
#endif

const char *
insn_name(VALUE i)
{
    return &rb_vm_insn_name_base[rb_vm_insn_name_offset[i]];
}

CONSTFUNC(MAYBE_UNUSED(static int insn_len(VALUE insn)));

RUBY_SYMBOL_EXPORT_BEGIN /* for debuggers */
extern const uint8_t rb_vm_insn_len_info[VM_INSTRUCTION_SIZE];
RUBY_SYMBOL_EXPORT_END

#ifdef RUBY_VM_INSNS_INFO
const uint8_t rb_vm_insn_len_info[] = {
    1, 3, 3, 3, 3, 3, 3, 2, 3, 3, 3, 3, 2, 2, 2, 2, 1, 1, 2, 2, 2, 2, 1,
    3, 1, 2, 2, 2, 2, 3, 1, 2, 2, 2, 1, 1, 2, 1, 2, 2, 2, 4, 2, 3, 2, 4,
    3, 3, 3, 2, 2, 3, 2, 3, 2, 2, 3, 2, 1, 2, 2, 2, 2, 2, 3, 2, 3, 3, 2,
    2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 2, 2, 2, 2, 2, 2,
    2, 3, 3, 2, 2, 2, 2, 1, 1, 1, 3, 3, 3, 3, 3, 3, 2, 3, 3, 3, 3, 2, 2,
    2, 2, 1, 1, 2, 2, 2, 2, 1, 3, 1, 2, 2, 2, 2, 3, 1, 2, 2, 2, 1, 1, 2,
    1, 2, 2, 2, 4, 2, 3, 2, 4, 3, 3, 3, 2, 2, 3, 2, 3, 2, 2, 3, 2, 1, 2,
    2, 2, 2, 2, 3, 2, 3, 3, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2,
    2, 3, 3, 2, 2, 2, 2, 2, 2, 2, 3, 3, 2, 2, 2, 2, 1, 1,
};

ASSERT_VM_INSTRUCTION_SIZE(rb_vm_insn_len_info);
#endif

int
insn_len(VALUE i)
{
    return rb_vm_insn_len_info[i];
}

CONSTFUNC(MAYBE_UNUSED(static const char *insn_op_types(VALUE insn)));
CONSTFUNC(MAYBE_UNUSED(static int insn_op_type(VALUE insn, long pos)));

RUBY_SYMBOL_EXPORT_BEGIN /* for debuggers */
extern const char rb_vm_insn_op_base[];
extern const unsigned short rb_vm_insn_op_offset[VM_INSTRUCTION_SIZE];
RUBY_SYMBOL_EXPORT_END

#ifdef RUBY_VM_INSNS_INFO
const char rb_vm_insn_op_base[] =
    ""     "\0" "LN"   "\0" "LN"   "\0" "LN"   "\0" "LN"   "\0"
    "LN"   "\0" "NN"   "\0" "N"    "\0" "IA"   "\0" "IA"   "\0"
    "IA"   "\0" "IA"   "\0" "I"    "\0" "I"    "\0" "I"    "\0"
    "I"    "\0" ""     "\0" ""     "\0" "V"    "\0" "N"    "\0"
    "V"    "\0" "N"    "\0" ""     "\0" "NN"   "\0" ""     "\0"
    "N"    "\0" "N"    "\0" "V"    "\0" "V"    "\0" "NN"   "\0"
    ""     "\0" "V"    "\0" "N"    "\0" "N"    "\0" ""     "\0"
    ""     "\0" "N"    "\0" ""     "\0" "N"    "\0" "N"    "\0"
    "N"    "\0" "NVV"  "\0" "N"    "\0" "LL"   "\0" "N"    "\0"
    "ISN"  "\0" "IS"   "\0" "IS"   "\0" "CS"   "\0" "C"    "\0"
    "C"    "\0" "VC"   "\0" "C"    "\0" "VC"   "\0" "N"    "\0"
    "N"    "\0" "CS"   "\0" "C"    "\0" ""     "\0" "N"    "\0"
    "O"    "\0" "O"    "\0" "O"    "\0" "O"    "\0" "OK"   "\0"
    "K"    "\0" "ST"   "\0" "HO"   "\0" "C"    "\0" "C"    "\0"
    "C"    "\0" "C"    "\0" "C"    "\0" "C"    "\0" "CC"   "\0"
    "C"    "\0" "C"    "\0" "C"    "\0" "C"    "\0" "C"    "\0"
    "C"    "\0" "C"    "\0" "C"    "\0" "C"    "\0" "VC"   "\0"
    "VC"   "\0" "C"    "\0" "C"    "\0" "C"    "\0" "C"    "\0"
    "C"    "\0" "C"    "\0" "R"    "\0" "RN"   "\0" "RN"   "\0"
    "L"    "\0" "L"    "\0" "L"    "\0" "L"    "\0" ""     "\0"
    ""     "\0" ""     "\0" "LN"   "\0" "LN"   "\0" "LN"   "\0"
    "LN"   "\0" "LN"   "\0" "NN"   "\0" "N"    "\0" "IA"   "\0"
    "IA"   "\0" "IA"   "\0" "IA"   "\0" "I"    "\0" "I"    "\0"
    "I"    "\0" "I"    "\0" ""     "\0" ""     "\0" "V"    "\0"
    "N"    "\0" "V"    "\0" "N"    "\0" ""     "\0" "NN"   "\0"
    ""     "\0" "N"    "\0" "N"    "\0" "V"    "\0" "V"    "\0"
    "NN"   "\0" ""     "\0" "V"    "\0" "N"    "\0" "N"    "\0"
    ""     "\0" ""     "\0" "N"    "\0" ""     "\0" "N"    "\0"
    "N"    "\0" "N"    "\0" "NVV"  "\0" "N"    "\0" "LL"   "\0"
    "N"    "\0" "ISN"  "\0" "IS"   "\0" "IS"   "\0" "CS"   "\0"
    "C"    "\0" "C"    "\0" "VC"   "\0" "C"    "\0" "VC"   "\0"
    "N"    "\0" "N"    "\0" "CS"   "\0" "C"    "\0" ""     "\0"
    "N"    "\0" "O"    "\0" "O"    "\0" "O"    "\0" "O"    "\0"
    "OK"   "\0" "K"    "\0" "ST"   "\0" "HO"   "\0" "C"    "\0"
    "C"    "\0" "C"    "\0" "C"    "\0" "C"    "\0" "C"    "\0"
    "CC"   "\0" "C"    "\0" "C"    "\0" "C"    "\0" "C"    "\0"
    "C"    "\0" "C"    "\0" "C"    "\0" "C"    "\0" "C"    "\0"
    "VC"   "\0" "VC"   "\0" "C"    "\0" "C"    "\0" "C"    "\0"
    "C"    "\0" "C"    "\0" "C"    "\0" "R"    "\0" "RN"   "\0"
    "RN"   "\0" "L"    "\0" "L"    "\0" "L"    "\0" "L"    "\0"
    ""     "\0" ""     "\0"
    ;

const unsigned short rb_vm_insn_op_offset[] = {
      0,   1,   4,   7,  10,  13,  16,  19,  21,  24,  27,  30,
     33,  35,  37,  39,  41,  42,  43,  45,  47,  49,  51,  52,
     55,  56,  58,  60,  62,  64,  67,  68,  70,  72,  74,  75,
     76,  78,  79,  81,  83,  85,  89,  91,  94,  96, 100, 103,
    106, 109, 111, 113, 116, 118, 121, 123, 125, 128, 130, 131,
    133, 135, 137, 139, 141, 144, 146, 149, 152, 154, 156, 158,
    160, 162, 164, 167, 169, 171, 173, 175, 177, 179, 181, 183,
    185, 188, 191, 193, 195, 197, 199, 201, 203, 205, 208, 211,
    213, 215, 217, 219, 220, 221, 222, 225, 228, 231, 234, 237,
    240, 242, 245, 248, 251, 254, 256, 258, 260, 262, 263, 264,
    266, 268, 270, 272, 273, 276, 277, 279, 281, 283, 285, 288,
    289, 291, 293, 295, 296, 297, 299, 300, 302, 304, 306, 310,
    312, 315, 317, 321, 324, 327, 330, 332, 334, 337, 339, 342,
    344, 346, 349, 351, 352, 354, 356, 358, 360, 362, 365, 367,
    370, 373, 375, 377, 379, 381, 383, 385, 388, 390, 392, 394,
    396, 398, 400, 402, 404, 406, 409, 412, 414, 416, 418, 420,
    422, 424, 426, 429, 432, 434, 436, 438, 440, 441,
};

ASSERT_VM_INSTRUCTION_SIZE(rb_vm_insn_op_offset);
#endif

const char *
insn_op_types(VALUE i)
{
    return &rb_vm_insn_op_base[rb_vm_insn_op_offset[i]];
}

int
insn_op_type(VALUE i, long j)
{
    if (j >= insn_len(i)) {
        return 0;
    }
    else {
        return insn_op_types(i)[j];
    }
}

#line 10 "tool/ruby_vm/views/_leaf_helpers.erb"

#include "iseq.h"

// This is used to tell MJIT that this insn would be leaf if CHECK_INTS didn't exist.
// It should be used only when RUBY_VM_CHECK_INTS is directly written in insns.def.
static bool leafness_of_check_ints = false;

static bool
leafness_of_defined(rb_num_t op_type)
{
    /* see also: vm_insnhelper.c:vm_defined() */
    switch (op_type) {
      case DEFINED_IVAR:
      case DEFINED_GVAR:
      case DEFINED_CVAR:
      case DEFINED_YIELD:
      case DEFINED_REF:
      case DEFINED_ZSUPER:
        return false;
      case DEFINED_CONST:
      case DEFINED_CONST_FROM:
        /* has rb_autoload_load(); */
        return false;
      case DEFINED_FUNC:
      case DEFINED_METHOD:
        /* calls #respond_to_missing? */
        return false;
      default:
        rb_bug("unknown operand %ld: blame @shyouhei.", op_type);
    }
}

static bool
leafness_of_checkmatch(rb_num_t flag)
{
    /* see also: vm_insnhelper.c:check_match() */
    if (flag == VM_CHECKMATCH_TYPE_WHEN) {
        return true;
    }
    else {
        /* has rb_funcallv() */
        return false;
    }
}
#line 468 "insns_info.inc"

#line 10 "tool/ruby_vm/views/_sp_inc_helpers.erb"

static rb_snum_t
sp_inc_of_sendish(const struct rb_callinfo *ci)
{
    /* Send-ish instructions will:
     *
     * 1. Pop block argument, if any.
     * 2. Pop ordinal arguments.
     * 3. Pop receiver.
     * 4. Push return value.
     */
    const int argb = (vm_ci_flag(ci) & VM_CALL_ARGS_BLOCKARG) ? 1 : 0;
    const int argc = vm_ci_argc(ci);
    const int recv = 1;
    const int retn = 1;

    /*         1.     2.     3.     4. */
    return 0 - argb - argc - recv + retn;
}

static rb_snum_t
sp_inc_of_invokeblock(const struct rb_callinfo *ci)
{
    /* sp_inc of invokeblock is almost identical to that of sendish
     * instructions, except that it does not pop receiver. */
    return sp_inc_of_sendish(ci) + 1;
}
#line 498 "insns_info.inc"

#ifndef RUBY_VM_EXEC_H
/* can't #include "vm_exec.h" here... */
typedef long OFFSET;
typedef unsigned long lindex_t;
typedef VALUE GENTRY;
typedef rb_iseq_t *ISEQ;
#endif

PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_nop(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_nop(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_nop(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_nop(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_nop(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_nop(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_nop(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_nop(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_nop(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_getlocal(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_getlocal(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_getlocal(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getlocal(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_getlocal(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_getlocal(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_getlocal(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_getlocal(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_getlocal(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_setlocal(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_setlocal(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_setlocal(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setlocal(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_setlocal(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_setlocal(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_setlocal(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_setlocal(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_setlocal(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_getblockparam(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_getblockparam(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_getblockparam(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getblockparam(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_getblockparam(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_getblockparam(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_getblockparam(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_getblockparam(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_getblockparam(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_setblockparam(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_setblockparam(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_setblockparam(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setblockparam(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_setblockparam(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_setblockparam(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_setblockparam(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_setblockparam(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_setblockparam(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_getblockparamproxy(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_getblockparamproxy(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_getblockparamproxy(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getblockparamproxy(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_getblockparamproxy(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_getblockparamproxy(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_getblockparamproxy(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_getblockparamproxy(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_getblockparamproxy(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_getspecial(rb_num_t key, rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_getspecial(rb_num_t key, rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_getspecial(rb_num_t key, rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getspecial(rb_num_t key, rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_getspecial(rb_num_t key, rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_getspecial(rb_num_t key, rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_getspecial(rb_num_t key, rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_getspecial(rb_num_t key, rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_getspecial(rb_num_t key, rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_setspecial(rb_num_t key)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_setspecial(rb_num_t key)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_setspecial(rb_num_t key)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setspecial(rb_num_t key)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_setspecial(rb_num_t key)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_setspecial(rb_num_t key)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_setspecial(rb_num_t key)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_setspecial(rb_num_t key)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_setspecial(rb_num_t key)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_getinstancevariable(ID id, IVC ic)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_getinstancevariable(ID id, IVC ic)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_getinstancevariable(ID id, IVC ic)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getinstancevariable(ID id, IVC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_getinstancevariable(ID id, IVC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_getinstancevariable(ID id, IVC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_getinstancevariable(ID id, IVC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_getinstancevariable(ID id, IVC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_getinstancevariable(ID id, IVC ic)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_setinstancevariable(ID id, IVC ic)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_setinstancevariable(ID id, IVC ic)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_setinstancevariable(ID id, IVC ic)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setinstancevariable(ID id, IVC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_setinstancevariable(ID id, IVC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_setinstancevariable(ID id, IVC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_setinstancevariable(ID id, IVC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_setinstancevariable(ID id, IVC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_setinstancevariable(ID id, IVC ic)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_getclassvariable(ID id, IVC ic)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_getclassvariable(ID id, IVC ic)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_getclassvariable(ID id, IVC ic)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getclassvariable(ID id, IVC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_getclassvariable(ID id, IVC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_getclassvariable(ID id, IVC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_getclassvariable(ID id, IVC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_getclassvariable(ID id, IVC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_getclassvariable(ID id, IVC ic)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_setclassvariable(ID id, IVC ic)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_setclassvariable(ID id, IVC ic)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_setclassvariable(ID id, IVC ic)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setclassvariable(ID id, IVC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_setclassvariable(ID id, IVC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_setclassvariable(ID id, IVC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_setclassvariable(ID id, IVC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_setclassvariable(ID id, IVC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_setclassvariable(ID id, IVC ic)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_getconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_getconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_getconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_getconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_getconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_getconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_getconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_getconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_setconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_setconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_setconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_setconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_setconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_setconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_setconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_setconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_getglobal(ID gid)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_getglobal(ID gid)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_getglobal(ID gid)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getglobal(ID gid)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_getglobal(ID gid)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_getglobal(ID gid)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_getglobal(ID gid)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_getglobal(ID gid)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_getglobal(ID gid)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_setglobal(ID gid)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_setglobal(ID gid)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_setglobal(ID gid)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setglobal(ID gid)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_setglobal(ID gid)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_setglobal(ID gid)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_setglobal(ID gid)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_setglobal(ID gid)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_setglobal(ID gid)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_putnil(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_putnil(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_putnil(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_putnil(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_putnil(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_putnil(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_putnil(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_putnil(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_putnil(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_putself(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_putself(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_putself(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_putself(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_putself(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_putself(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_putself(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_putself(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_putself(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_putobject(VALUE val)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_putobject(VALUE val)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_putobject(VALUE val)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_putobject(VALUE val)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_putobject(VALUE val)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_putobject(VALUE val)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_putobject(VALUE val)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_putobject(VALUE val)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_putobject(VALUE val)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_putspecialobject(rb_num_t value_type)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_putspecialobject(rb_num_t value_type)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_putspecialobject(rb_num_t value_type)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_putspecialobject(rb_num_t value_type)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_putspecialobject(rb_num_t value_type)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_putspecialobject(rb_num_t value_type)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_putspecialobject(rb_num_t value_type)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_putspecialobject(rb_num_t value_type)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_putspecialobject(rb_num_t value_type)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_putstring(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_putstring(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_putstring(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_putstring(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_putstring(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_putstring(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_putstring(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_putstring(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_putstring(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_concatstrings(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_concatstrings(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_concatstrings(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_concatstrings(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_concatstrings(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_concatstrings(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_concatstrings(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_concatstrings(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_concatstrings(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_anytostring(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_anytostring(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_anytostring(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_anytostring(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_anytostring(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_anytostring(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_anytostring(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_anytostring(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_anytostring(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_toregexp(rb_num_t opt, rb_num_t cnt)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_toregexp(rb_num_t opt, rb_num_t cnt)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_toregexp(rb_num_t opt, rb_num_t cnt)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_toregexp(rb_num_t opt, rb_num_t cnt)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_toregexp(rb_num_t opt, rb_num_t cnt)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_toregexp(rb_num_t opt, rb_num_t cnt)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_toregexp(rb_num_t opt, rb_num_t cnt)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_toregexp(rb_num_t opt, rb_num_t cnt)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_toregexp(rb_num_t opt, rb_num_t cnt)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_intern(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_intern(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_intern(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_intern(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_intern(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_intern(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_intern(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_intern(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_intern(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_newarray(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_newarray(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_newarray(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_newarray(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_newarray(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_newarray(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_newarray(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_newarray(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_newarray(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_newarraykwsplat(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_newarraykwsplat(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_newarraykwsplat(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_newarraykwsplat(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_newarraykwsplat(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_newarraykwsplat(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_newarraykwsplat(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_newarraykwsplat(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_newarraykwsplat(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_duparray(VALUE ary)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_duparray(VALUE ary)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_duparray(VALUE ary)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_duparray(VALUE ary)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_duparray(VALUE ary)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_duparray(VALUE ary)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_duparray(VALUE ary)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_duparray(VALUE ary)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_duparray(VALUE ary)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_duphash(VALUE hash)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_duphash(VALUE hash)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_duphash(VALUE hash)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_duphash(VALUE hash)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_duphash(VALUE hash)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_duphash(VALUE hash)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_duphash(VALUE hash)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_duphash(VALUE hash)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_duphash(VALUE hash)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_expandarray(rb_num_t num, rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_expandarray(rb_num_t num, rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_expandarray(rb_num_t num, rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_expandarray(rb_num_t num, rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_expandarray(rb_num_t num, rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_expandarray(rb_num_t num, rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_expandarray(rb_num_t num, rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_expandarray(rb_num_t num, rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_expandarray(rb_num_t num, rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_concatarray(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_concatarray(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_concatarray(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_concatarray(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_concatarray(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_concatarray(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_concatarray(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_concatarray(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_concatarray(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_splatarray(VALUE flag)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_splatarray(VALUE flag)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_splatarray(VALUE flag)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_splatarray(VALUE flag)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_splatarray(VALUE flag)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_splatarray(VALUE flag)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_splatarray(VALUE flag)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_splatarray(VALUE flag)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_splatarray(VALUE flag)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_newhash(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_newhash(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_newhash(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_newhash(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_newhash(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_newhash(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_newhash(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_newhash(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_newhash(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_newrange(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_newrange(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_newrange(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_newrange(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_newrange(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_newrange(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_newrange(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_newrange(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_newrange(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_pop(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_pop(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_pop(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_pop(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_pop(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_pop(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_pop(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_pop(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_pop(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_dup(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_dup(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_dup(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_dup(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_dup(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_dup(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_dup(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_dup(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_dup(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_dupn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_dupn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_dupn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_dupn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_dupn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_dupn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_dupn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_dupn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_dupn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_swap(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_swap(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_swap(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_swap(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_swap(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_swap(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_swap(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_swap(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_swap(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_topn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_topn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_topn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_topn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_topn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_topn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_topn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_topn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_topn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_setn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_setn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_setn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_setn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_setn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_setn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_setn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_setn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_adjuststack(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_adjuststack(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_adjuststack(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_adjuststack(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_adjuststack(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_adjuststack(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_adjuststack(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_adjuststack(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_adjuststack(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_defined(rb_num_t op_type, VALUE obj, VALUE pushval)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_defined(rb_num_t op_type, VALUE obj, VALUE pushval)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_defined(rb_num_t op_type, VALUE obj, VALUE pushval)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_defined(rb_num_t op_type, VALUE obj, VALUE pushval)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_defined(rb_num_t op_type, VALUE obj, VALUE pushval)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_defined(rb_num_t op_type, VALUE obj, VALUE pushval)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_defined(rb_num_t op_type, VALUE obj, VALUE pushval)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_defined(rb_num_t op_type, VALUE obj, VALUE pushval)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_defined(rb_num_t op_type, VALUE obj, VALUE pushval)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_checkmatch(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_checkmatch(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_checkmatch(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_checkmatch(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_checkmatch(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_checkmatch(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_checkmatch(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_checkmatch(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_checkmatch(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_checkkeyword(lindex_t kw_bits_index, lindex_t keyword_index)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_checkkeyword(lindex_t kw_bits_index, lindex_t keyword_index)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_checkkeyword(lindex_t kw_bits_index, lindex_t keyword_index)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_checkkeyword(lindex_t kw_bits_index, lindex_t keyword_index)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_checkkeyword(lindex_t kw_bits_index, lindex_t keyword_index)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_checkkeyword(lindex_t kw_bits_index, lindex_t keyword_index)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_checkkeyword(lindex_t kw_bits_index, lindex_t keyword_index)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_checkkeyword(lindex_t kw_bits_index, lindex_t keyword_index)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_checkkeyword(lindex_t kw_bits_index, lindex_t keyword_index)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_checktype(rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_checktype(rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_checktype(rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_checktype(rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_checktype(rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_checktype(rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_checktype(rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_checktype(rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_checktype(rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_defineclass(ID id, ISEQ class_iseq, rb_num_t flags)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_defineclass(ID id, ISEQ class_iseq, rb_num_t flags)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_defineclass(ID id, ISEQ class_iseq, rb_num_t flags)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_defineclass(ID id, ISEQ class_iseq, rb_num_t flags)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_defineclass(ID id, ISEQ class_iseq, rb_num_t flags)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_defineclass(ID id, ISEQ class_iseq, rb_num_t flags)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_defineclass(ID id, ISEQ class_iseq, rb_num_t flags)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_defineclass(ID id, ISEQ class_iseq, rb_num_t flags)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_defineclass(ID id, ISEQ class_iseq, rb_num_t flags)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_definemethod(ID id, ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_definemethod(ID id, ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_definemethod(ID id, ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_definemethod(ID id, ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_definemethod(ID id, ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_definemethod(ID id, ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_definemethod(ID id, ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_definemethod(ID id, ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_definemethod(ID id, ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_definesmethod(ID id, ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_definesmethod(ID id, ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_definesmethod(ID id, ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_definesmethod(ID id, ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_definesmethod(ID id, ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_definesmethod(ID id, ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_definesmethod(ID id, ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_definesmethod(ID id, ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_definesmethod(ID id, ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_send(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_comptime_sp_inc_send(CALL_INFO ci, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_send(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_send(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_send(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_send(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_send(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_send(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_send(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_send(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_send_without_block(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_comptime_sp_inc_opt_send_without_block(CALL_INFO ci)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_send_without_block(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_send_without_block(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_send_without_block(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_send_without_block(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_send_without_block(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_send_without_block(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_send_without_block(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_send_without_block(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_objtostring(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_objtostring(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_objtostring(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_objtostring(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_objtostring(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_objtostring(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_objtostring(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_objtostring(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_objtostring(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_str_freeze(VALUE str, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_str_freeze(VALUE str, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_str_freeze(VALUE str, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_str_freeze(VALUE str, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_str_freeze(VALUE str, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_str_freeze(VALUE str, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_str_freeze(VALUE str, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_str_freeze(VALUE str, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_str_freeze(VALUE str, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_nil_p(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_nil_p(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_nil_p(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_nil_p(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_nil_p(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_nil_p(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_nil_p(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_nil_p(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_nil_p(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_str_uminus(VALUE str, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_str_uminus(VALUE str, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_str_uminus(VALUE str, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_str_uminus(VALUE str, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_str_uminus(VALUE str, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_str_uminus(VALUE str, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_str_uminus(VALUE str, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_str_uminus(VALUE str, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_str_uminus(VALUE str, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_newarray_max(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_newarray_max(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_newarray_max(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_newarray_max(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_newarray_max(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_newarray_max(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_newarray_max(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_newarray_max(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_newarray_max(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_newarray_min(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_newarray_min(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_newarray_min(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_newarray_min(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_newarray_min(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_newarray_min(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_newarray_min(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_newarray_min(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_newarray_min(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_invokesuper(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_comptime_sp_inc_invokesuper(CALL_INFO ci, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_invokesuper(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_invokesuper(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_invokesuper(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_invokesuper(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_invokesuper(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_invokesuper(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_invokesuper(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_invokesuper(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_invokeblock(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_comptime_sp_inc_invokeblock(CALL_INFO ci)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_invokeblock(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_invokeblock(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_invokeblock(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_invokeblock(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_invokeblock(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_invokeblock(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_invokeblock(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_invokeblock(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_leave(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_leave(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_leave(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_leave(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_leave(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_leave(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_leave(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_leave(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_leave(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_throw(rb_num_t throw_state)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_throw(rb_num_t throw_state)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_throw(rb_num_t throw_state)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_throw(rb_num_t throw_state)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_throw(rb_num_t throw_state)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_throw(rb_num_t throw_state)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_throw(rb_num_t throw_state)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_throw(rb_num_t throw_state)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_throw(rb_num_t throw_state)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_jump(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_jump(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_jump(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_jump(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_jump(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_jump(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_jump(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_jump(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_jump(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_branchif(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_branchif(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_branchif(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_branchif(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_branchif(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_branchif(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_branchif(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_branchif(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_branchif(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_branchunless(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_branchunless(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_branchunless(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_branchunless(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_branchunless(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_branchunless(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_branchunless(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_branchunless(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_branchunless(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_branchnil(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_branchnil(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_branchnil(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_branchnil(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_branchnil(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_branchnil(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_branchnil(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_branchnil(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_branchnil(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_getinlinecache(OFFSET dst, IC ic)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_getinlinecache(OFFSET dst, IC ic)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_getinlinecache(OFFSET dst, IC ic)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_getinlinecache(OFFSET dst, IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_getinlinecache(OFFSET dst, IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_getinlinecache(OFFSET dst, IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_getinlinecache(OFFSET dst, IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_getinlinecache(OFFSET dst, IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_getinlinecache(OFFSET dst, IC ic)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_setinlinecache(IC ic)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_setinlinecache(IC ic)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_setinlinecache(IC ic)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_setinlinecache(IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_setinlinecache(IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_setinlinecache(IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_setinlinecache(IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_setinlinecache(IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_setinlinecache(IC ic)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_once(ISEQ iseq, ISE ise)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_once(ISEQ iseq, ISE ise)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_once(ISEQ iseq, ISE ise)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_once(ISEQ iseq, ISE ise)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_once(ISEQ iseq, ISE ise)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_once(ISEQ iseq, ISE ise)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_once(ISEQ iseq, ISE ise)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_once(ISEQ iseq, ISE ise)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_once(ISEQ iseq, ISE ise)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_case_dispatch(CDHASH hash, OFFSET else_offset)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_case_dispatch(CDHASH hash, OFFSET else_offset)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_case_dispatch(CDHASH hash, OFFSET else_offset)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_case_dispatch(CDHASH hash, OFFSET else_offset)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_case_dispatch(CDHASH hash, OFFSET else_offset)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_case_dispatch(CDHASH hash, OFFSET else_offset)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_case_dispatch(CDHASH hash, OFFSET else_offset)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_case_dispatch(CDHASH hash, OFFSET else_offset)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_case_dispatch(CDHASH hash, OFFSET else_offset)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_plus(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_plus(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_plus(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_plus(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_plus(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_plus(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_plus(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_plus(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_plus(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_minus(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_minus(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_minus(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_minus(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_minus(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_minus(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_minus(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_minus(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_minus(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_mult(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_mult(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_mult(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_mult(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_mult(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_mult(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_mult(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_mult(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_mult(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_div(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_div(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_div(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_div(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_div(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_div(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_div(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_div(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_div(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_mod(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_mod(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_mod(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_mod(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_mod(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_mod(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_mod(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_mod(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_mod(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_eq(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_eq(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_eq(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_eq(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_eq(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_eq(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_eq(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_eq(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_eq(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_neq(CALL_DATA cd_eq, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_neq(CALL_DATA cd_eq, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_neq(CALL_DATA cd_eq, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_neq(CALL_DATA cd_eq, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_neq(CALL_DATA cd_eq, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_neq(CALL_DATA cd_eq, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_neq(CALL_DATA cd_eq, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_neq(CALL_DATA cd_eq, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_neq(CALL_DATA cd_eq, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_lt(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_lt(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_lt(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_lt(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_lt(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_lt(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_lt(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_lt(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_lt(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_le(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_le(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_le(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_le(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_le(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_le(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_le(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_le(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_le(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_gt(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_gt(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_gt(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_gt(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_gt(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_gt(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_gt(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_gt(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_gt(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_ge(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_ge(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_ge(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_ge(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_ge(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_ge(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_ge(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_ge(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_ge(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_ltlt(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_ltlt(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_ltlt(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_ltlt(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_ltlt(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_ltlt(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_ltlt(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_ltlt(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_ltlt(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_and(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_and(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_and(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_and(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_and(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_and(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_and(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_and(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_and(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_or(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_or(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_or(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_or(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_or(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_or(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_or(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_or(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_or(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_aref(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_aref(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_aref(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_aref(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_aref(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_aref(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_aref(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_aref(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_aref(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_aset(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_aset(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_aset(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_aset(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_aset(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_aset(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_aset(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_aset(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_aset(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_aset_with(VALUE key, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_aset_with(VALUE key, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_aset_with(VALUE key, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_aset_with(VALUE key, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_aset_with(VALUE key, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_aset_with(VALUE key, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_aset_with(VALUE key, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_aset_with(VALUE key, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_aset_with(VALUE key, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_aref_with(VALUE key, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_aref_with(VALUE key, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_aref_with(VALUE key, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_aref_with(VALUE key, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_aref_with(VALUE key, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_aref_with(VALUE key, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_aref_with(VALUE key, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_aref_with(VALUE key, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_aref_with(VALUE key, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_length(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_length(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_length(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_length(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_length(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_length(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_length(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_length(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_length(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_size(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_size(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_size(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_size(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_size(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_size(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_size(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_size(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_size(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_empty_p(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_empty_p(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_empty_p(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_empty_p(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_empty_p(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_empty_p(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_empty_p(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_empty_p(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_empty_p(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_succ(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_succ(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_succ(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_succ(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_succ(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_succ(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_succ(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_succ(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_succ(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_not(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_not(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_not(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_not(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_not(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_not(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_not(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_not(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_not(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_regexpmatch2(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_regexpmatch2(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_regexpmatch2(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_regexpmatch2(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_regexpmatch2(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_regexpmatch2(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_regexpmatch2(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_regexpmatch2(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_regexpmatch2(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_invokebuiltin(RB_BUILTIN bf)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_invokebuiltin(RB_BUILTIN bf)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_invokebuiltin(RB_BUILTIN bf)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_invokebuiltin(RB_BUILTIN bf)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_invokebuiltin(RB_BUILTIN bf)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_invokebuiltin(RB_BUILTIN bf)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_invokebuiltin(RB_BUILTIN bf)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_invokebuiltin(RB_BUILTIN bf)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_invokebuiltin(RB_BUILTIN bf)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_invokebuiltin_delegate(RB_BUILTIN bf, rb_num_t index)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_invokebuiltin_delegate(RB_BUILTIN bf, rb_num_t index)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_invokebuiltin_delegate(RB_BUILTIN bf, rb_num_t index)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_invokebuiltin_delegate(RB_BUILTIN bf, rb_num_t index)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_invokebuiltin_delegate(RB_BUILTIN bf, rb_num_t index)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_invokebuiltin_delegate(RB_BUILTIN bf, rb_num_t index)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_invokebuiltin_delegate(RB_BUILTIN bf, rb_num_t index)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_invokebuiltin_delegate(RB_BUILTIN bf, rb_num_t index)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_invokebuiltin_delegate(RB_BUILTIN bf, rb_num_t index)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_invokebuiltin_delegate_leave(RB_BUILTIN bf, rb_num_t index)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_invokebuiltin_delegate_leave(RB_BUILTIN bf, rb_num_t index)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_invokebuiltin_delegate_leave(RB_BUILTIN bf, rb_num_t index)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_invokebuiltin_delegate_leave(RB_BUILTIN bf, rb_num_t index)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_invokebuiltin_delegate_leave(RB_BUILTIN bf, rb_num_t index)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_invokebuiltin_delegate_leave(RB_BUILTIN bf, rb_num_t index)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_invokebuiltin_delegate_leave(RB_BUILTIN bf, rb_num_t index)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_invokebuiltin_delegate_leave(RB_BUILTIN bf, rb_num_t index)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_invokebuiltin_delegate_leave(RB_BUILTIN bf, rb_num_t index)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_getlocal_WC_0(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_getlocal_WC_0(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_getlocal_WC_0(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getlocal_WC_0(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_getlocal_WC_0(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_getlocal_WC_0(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_getlocal_WC_0(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_getlocal_WC_0(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_getlocal_WC_0(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_getlocal_WC_1(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_getlocal_WC_1(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_getlocal_WC_1(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getlocal_WC_1(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_getlocal_WC_1(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_getlocal_WC_1(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_getlocal_WC_1(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_getlocal_WC_1(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_getlocal_WC_1(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_setlocal_WC_0(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_setlocal_WC_0(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_setlocal_WC_0(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setlocal_WC_0(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_setlocal_WC_0(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_setlocal_WC_0(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_setlocal_WC_0(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_setlocal_WC_0(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_setlocal_WC_0(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_setlocal_WC_1(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_setlocal_WC_1(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_setlocal_WC_1(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setlocal_WC_1(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_setlocal_WC_1(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_setlocal_WC_1(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_setlocal_WC_1(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_setlocal_WC_1(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_setlocal_WC_1(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_putobject_INT2FIX_0_(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_putobject_INT2FIX_0_(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_putobject_INT2FIX_0_(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_putobject_INT2FIX_0_(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_putobject_INT2FIX_0_(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_putobject_INT2FIX_0_(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_putobject_INT2FIX_0_(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_putobject_INT2FIX_0_(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_putobject_INT2FIX_0_(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_putobject_INT2FIX_1_(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_putobject_INT2FIX_1_(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_putobject_INT2FIX_1_(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_putobject_INT2FIX_1_(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_putobject_INT2FIX_1_(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_putobject_INT2FIX_1_(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_putobject_INT2FIX_1_(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_putobject_INT2FIX_1_(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_putobject_INT2FIX_1_(void)));

/* attr enum ruby_vminsn_type bin @ nop()()() */
enum ruby_vminsn_type
attr_bin_nop(void)
{
    return BIN(nop);
}

/* attr bool handles_sp @ nop()()() */
bool
attr_handles_sp_nop(void)
{
    return false;
}

/* attr bool leaf @ nop()()() */
bool
attr_leaf_nop(void)
{
    return true;
}

/* attr const char* name @ nop()()() */
const char*
attr_name_nop(void)
{
    return insn_name(BIN(nop));
}

/* attr rb_num_t open @ nop()()() */
rb_num_t
attr_open_nop(void)
{
    return 0;
}

/* attr rb_num_t popn @ nop()()() */
rb_num_t
attr_popn_nop(void)
{
    return 0;
}

/* attr rb_num_t retn @ nop()()() */
rb_num_t
attr_retn_nop(void)
{
    return 0;
}

/* attr rb_snum_t sp_inc @ nop()()() */
rb_snum_t
attr_sp_inc_nop(void)
{
    return 0;
}

/* attr rb_num_t width @ nop()()() */
rb_num_t
attr_width_nop(void)
{
    return 1;
}

/* attr enum ruby_vminsn_type bin @ getlocal(idx, level)()(val) */
enum ruby_vminsn_type
attr_bin_getlocal(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return BIN(getlocal);
}

/* attr bool handles_sp @ getlocal(idx, level)()(val) */
bool
attr_handles_sp_getlocal(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return false;
}

/* attr bool leaf @ getlocal(idx, level)()(val) */
bool
attr_leaf_getlocal(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return true;
}

/* attr const char* name @ getlocal(idx, level)()(val) */
const char*
attr_name_getlocal(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return insn_name(BIN(getlocal));
}

/* attr rb_num_t open @ getlocal(idx, level)()(val) */
rb_num_t
attr_open_getlocal(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return 2;
}

/* attr rb_num_t popn @ getlocal(idx, level)()(val) */
rb_num_t
attr_popn_getlocal(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return 0;
}

/* attr rb_num_t retn @ getlocal(idx, level)()(val) */
rb_num_t
attr_retn_getlocal(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ getlocal(idx, level)()(val) */
rb_snum_t
attr_sp_inc_getlocal(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return 1;
}

/* attr rb_num_t width @ getlocal(idx, level)()(val) */
rb_num_t
attr_width_getlocal(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ setlocal(idx, level)(val)() */
enum ruby_vminsn_type
attr_bin_setlocal(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return BIN(setlocal);
}

/* attr bool handles_sp @ setlocal(idx, level)(val)() */
bool
attr_handles_sp_setlocal(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return false;
}

/* attr bool leaf @ setlocal(idx, level)(val)() */
bool
attr_leaf_setlocal(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return true;
}

/* attr const char* name @ setlocal(idx, level)(val)() */
const char*
attr_name_setlocal(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return insn_name(BIN(setlocal));
}

/* attr rb_num_t open @ setlocal(idx, level)(val)() */
rb_num_t
attr_open_setlocal(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return 2;
}

/* attr rb_num_t popn @ setlocal(idx, level)(val)() */
rb_num_t
attr_popn_setlocal(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return 1;
}

/* attr rb_num_t retn @ setlocal(idx, level)(val)() */
rb_num_t
attr_retn_setlocal(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return 0;
}

/* attr rb_snum_t sp_inc @ setlocal(idx, level)(val)() */
rb_snum_t
attr_sp_inc_setlocal(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return -1;
}

/* attr rb_num_t width @ setlocal(idx, level)(val)() */
rb_num_t
attr_width_setlocal(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ getblockparam(idx, level)()(val) */
enum ruby_vminsn_type
attr_bin_getblockparam(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return BIN(getblockparam);
}

/* attr bool handles_sp @ getblockparam(idx, level)()(val) */
bool
attr_handles_sp_getblockparam(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return false;
}

/* attr bool leaf @ getblockparam(idx, level)()(val) */
bool
attr_leaf_getblockparam(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return true;
}

/* attr const char* name @ getblockparam(idx, level)()(val) */
const char*
attr_name_getblockparam(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return insn_name(BIN(getblockparam));
}

/* attr rb_num_t open @ getblockparam(idx, level)()(val) */
rb_num_t
attr_open_getblockparam(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return 2;
}

/* attr rb_num_t popn @ getblockparam(idx, level)()(val) */
rb_num_t
attr_popn_getblockparam(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return 0;
}

/* attr rb_num_t retn @ getblockparam(idx, level)()(val) */
rb_num_t
attr_retn_getblockparam(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ getblockparam(idx, level)()(val) */
rb_snum_t
attr_sp_inc_getblockparam(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return 1;
}

/* attr rb_num_t width @ getblockparam(idx, level)()(val) */
rb_num_t
attr_width_getblockparam(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ setblockparam(idx, level)(val)() */
enum ruby_vminsn_type
attr_bin_setblockparam(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return BIN(setblockparam);
}

/* attr bool handles_sp @ setblockparam(idx, level)(val)() */
bool
attr_handles_sp_setblockparam(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return false;
}

/* attr bool leaf @ setblockparam(idx, level)(val)() */
bool
attr_leaf_setblockparam(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return true;
}

/* attr const char* name @ setblockparam(idx, level)(val)() */
const char*
attr_name_setblockparam(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return insn_name(BIN(setblockparam));
}

/* attr rb_num_t open @ setblockparam(idx, level)(val)() */
rb_num_t
attr_open_setblockparam(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return 2;
}

/* attr rb_num_t popn @ setblockparam(idx, level)(val)() */
rb_num_t
attr_popn_setblockparam(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return 1;
}

/* attr rb_num_t retn @ setblockparam(idx, level)(val)() */
rb_num_t
attr_retn_setblockparam(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return 0;
}

/* attr rb_snum_t sp_inc @ setblockparam(idx, level)(val)() */
rb_snum_t
attr_sp_inc_setblockparam(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return -1;
}

/* attr rb_num_t width @ setblockparam(idx, level)(val)() */
rb_num_t
attr_width_setblockparam(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ getblockparamproxy(idx, level)()(val) */
enum ruby_vminsn_type
attr_bin_getblockparamproxy(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return BIN(getblockparamproxy);
}

/* attr bool handles_sp @ getblockparamproxy(idx, level)()(val) */
bool
attr_handles_sp_getblockparamproxy(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return false;
}

/* attr bool leaf @ getblockparamproxy(idx, level)()(val) */
bool
attr_leaf_getblockparamproxy(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return true;
}

/* attr const char* name @ getblockparamproxy(idx, level)()(val) */
const char*
attr_name_getblockparamproxy(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return insn_name(BIN(getblockparamproxy));
}

/* attr rb_num_t open @ getblockparamproxy(idx, level)()(val) */
rb_num_t
attr_open_getblockparamproxy(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return 2;
}

/* attr rb_num_t popn @ getblockparamproxy(idx, level)()(val) */
rb_num_t
attr_popn_getblockparamproxy(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return 0;
}

/* attr rb_num_t retn @ getblockparamproxy(idx, level)()(val) */
rb_num_t
attr_retn_getblockparamproxy(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ getblockparamproxy(idx, level)()(val) */
rb_snum_t
attr_sp_inc_getblockparamproxy(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return 1;
}

/* attr rb_num_t width @ getblockparamproxy(idx, level)()(val) */
rb_num_t
attr_width_getblockparamproxy(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ getspecial(key, type)()(val) */
enum ruby_vminsn_type
attr_bin_getspecial(
    MAYBE_UNUSED(rb_num_t key),
    MAYBE_UNUSED(rb_num_t type)
)
{
    return BIN(getspecial);
}

/* attr bool handles_sp @ getspecial(key, type)()(val) */
bool
attr_handles_sp_getspecial(
    MAYBE_UNUSED(rb_num_t key),
    MAYBE_UNUSED(rb_num_t type)
)
{
    return false;
}

/* attr bool leaf @ getspecial(key, type)()(val) */
bool
attr_leaf_getspecial(
    MAYBE_UNUSED(rb_num_t key),
    MAYBE_UNUSED(rb_num_t type)
)
{
    return
#line 192 "insns.def"
(type == 0) ? true : false;
#line 1965 "insns_info.inc"
}

/* attr const char* name @ getspecial(key, type)()(val) */
const char*
attr_name_getspecial(
    MAYBE_UNUSED(rb_num_t key),
    MAYBE_UNUSED(rb_num_t type)
)
{
    return insn_name(BIN(getspecial));
}

/* attr rb_num_t open @ getspecial(key, type)()(val) */
rb_num_t
attr_open_getspecial(
    MAYBE_UNUSED(rb_num_t key),
    MAYBE_UNUSED(rb_num_t type)
)
{
    return 2;
}

/* attr rb_num_t popn @ getspecial(key, type)()(val) */
rb_num_t
attr_popn_getspecial(
    MAYBE_UNUSED(rb_num_t key),
    MAYBE_UNUSED(rb_num_t type)
)
{
    return 0;
}

/* attr rb_num_t retn @ getspecial(key, type)()(val) */
rb_num_t
attr_retn_getspecial(
    MAYBE_UNUSED(rb_num_t key),
    MAYBE_UNUSED(rb_num_t type)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ getspecial(key, type)()(val) */
rb_snum_t
attr_sp_inc_getspecial(
    MAYBE_UNUSED(rb_num_t key),
    MAYBE_UNUSED(rb_num_t type)
)
{
    return 1;
}

/* attr rb_num_t width @ getspecial(key, type)()(val) */
rb_num_t
attr_width_getspecial(
    MAYBE_UNUSED(rb_num_t key),
    MAYBE_UNUSED(rb_num_t type)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ setspecial(key)(obj)() */
enum ruby_vminsn_type
attr_bin_setspecial(MAYBE_UNUSED(rb_num_t key))
{
    return BIN(setspecial);
}

/* attr bool handles_sp @ setspecial(key)(obj)() */
bool
attr_handles_sp_setspecial(MAYBE_UNUSED(rb_num_t key))
{
    return false;
}

/* attr bool leaf @ setspecial(key)(obj)() */
bool
attr_leaf_setspecial(MAYBE_UNUSED(rb_num_t key))
{
    return true;
}

/* attr const char* name @ setspecial(key)(obj)() */
const char*
attr_name_setspecial(MAYBE_UNUSED(rb_num_t key))
{
    return insn_name(BIN(setspecial));
}

/* attr rb_num_t open @ setspecial(key)(obj)() */
rb_num_t
attr_open_setspecial(MAYBE_UNUSED(rb_num_t key))
{
    return 1;
}

/* attr rb_num_t popn @ setspecial(key)(obj)() */
rb_num_t
attr_popn_setspecial(MAYBE_UNUSED(rb_num_t key))
{
    return 1;
}

/* attr rb_num_t retn @ setspecial(key)(obj)() */
rb_num_t
attr_retn_setspecial(MAYBE_UNUSED(rb_num_t key))
{
    return 0;
}

/* attr rb_snum_t sp_inc @ setspecial(key)(obj)() */
rb_snum_t
attr_sp_inc_setspecial(MAYBE_UNUSED(rb_num_t key))
{
    return -1;
}

/* attr rb_num_t width @ setspecial(key)(obj)() */
rb_num_t
attr_width_setspecial(MAYBE_UNUSED(rb_num_t key))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ getinstancevariable(id, ic)()(val) */
enum ruby_vminsn_type
attr_bin_getinstancevariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic)
)
{
    return BIN(getinstancevariable);
}

/* attr bool handles_sp @ getinstancevariable(id, ic)()(val) */
bool
attr_handles_sp_getinstancevariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic)
)
{
    return false;
}

/* attr bool leaf @ getinstancevariable(id, ic)()(val) */
bool
attr_leaf_getinstancevariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic)
)
{
    return
#line 214 "insns.def"
false;
#line 2121 "insns_info.inc"
}

/* attr const char* name @ getinstancevariable(id, ic)()(val) */
const char*
attr_name_getinstancevariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic)
)
{
    return insn_name(BIN(getinstancevariable));
}

/* attr rb_num_t open @ getinstancevariable(id, ic)()(val) */
rb_num_t
attr_open_getinstancevariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic)
)
{
    return 2;
}

/* attr rb_num_t popn @ getinstancevariable(id, ic)()(val) */
rb_num_t
attr_popn_getinstancevariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic)
)
{
    return 0;
}

/* attr rb_num_t retn @ getinstancevariable(id, ic)()(val) */
rb_num_t
attr_retn_getinstancevariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ getinstancevariable(id, ic)()(val) */
rb_snum_t
attr_sp_inc_getinstancevariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic)
)
{
    return 1;
}

/* attr rb_num_t width @ getinstancevariable(id, ic)()(val) */
rb_num_t
attr_width_getinstancevariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ setinstancevariable(id, ic)(val)() */
enum ruby_vminsn_type
attr_bin_setinstancevariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic)
)
{
    return BIN(setinstancevariable);
}

/* attr bool handles_sp @ setinstancevariable(id, ic)(val)() */
bool
attr_handles_sp_setinstancevariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic)
)
{
    return false;
}

/* attr bool leaf @ setinstancevariable(id, ic)(val)() */
bool
attr_leaf_setinstancevariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic)
)
{
    return
#line 225 "insns.def"
false;
#line 2214 "insns_info.inc"
}

/* attr const char* name @ setinstancevariable(id, ic)(val)() */
const char*
attr_name_setinstancevariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic)
)
{
    return insn_name(BIN(setinstancevariable));
}

/* attr rb_num_t open @ setinstancevariable(id, ic)(val)() */
rb_num_t
attr_open_setinstancevariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic)
)
{
    return 2;
}

/* attr rb_num_t popn @ setinstancevariable(id, ic)(val)() */
rb_num_t
attr_popn_setinstancevariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic)
)
{
    return 1;
}

/* attr rb_num_t retn @ setinstancevariable(id, ic)(val)() */
rb_num_t
attr_retn_setinstancevariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic)
)
{
    return 0;
}

/* attr rb_snum_t sp_inc @ setinstancevariable(id, ic)(val)() */
rb_snum_t
attr_sp_inc_setinstancevariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic)
)
{
    return -1;
}

/* attr rb_num_t width @ setinstancevariable(id, ic)(val)() */
rb_num_t
attr_width_setinstancevariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ getclassvariable(id, ic)()(val) */
enum ruby_vminsn_type
attr_bin_getclassvariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic)
)
{
    return BIN(getclassvariable);
}

/* attr bool handles_sp @ getclassvariable(id, ic)()(val) */
bool
attr_handles_sp_getclassvariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic)
)
{
    return false;
}

/* attr bool leaf @ getclassvariable(id, ic)()(val) */
bool
attr_leaf_getclassvariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic)
)
{
    return
#line 237 "insns.def"
false;
#line 2307 "insns_info.inc"
}

/* attr const char* name @ getclassvariable(id, ic)()(val) */
const char*
attr_name_getclassvariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic)
)
{
    return insn_name(BIN(getclassvariable));
}

/* attr rb_num_t open @ getclassvariable(id, ic)()(val) */
rb_num_t
attr_open_getclassvariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic)
)
{
    return 2;
}

/* attr rb_num_t popn @ getclassvariable(id, ic)()(val) */
rb_num_t
attr_popn_getclassvariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic)
)
{
    return 0;
}

/* attr rb_num_t retn @ getclassvariable(id, ic)()(val) */
rb_num_t
attr_retn_getclassvariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ getclassvariable(id, ic)()(val) */
rb_snum_t
attr_sp_inc_getclassvariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic)
)
{
    return 1;
}

/* attr rb_num_t width @ getclassvariable(id, ic)()(val) */
rb_num_t
attr_width_getclassvariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ setclassvariable(id, ic)(val)() */
enum ruby_vminsn_type
attr_bin_setclassvariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic)
)
{
    return BIN(setclassvariable);
}

/* attr bool handles_sp @ setclassvariable(id, ic)(val)() */
bool
attr_handles_sp_setclassvariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic)
)
{
    return false;
}

/* attr bool leaf @ setclassvariable(id, ic)(val)() */
bool
attr_leaf_setclassvariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic)
)
{
    return
#line 250 "insns.def"
false;
#line 2400 "insns_info.inc"
}

/* attr const char* name @ setclassvariable(id, ic)(val)() */
const char*
attr_name_setclassvariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic)
)
{
    return insn_name(BIN(setclassvariable));
}

/* attr rb_num_t open @ setclassvariable(id, ic)(val)() */
rb_num_t
attr_open_setclassvariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic)
)
{
    return 2;
}

/* attr rb_num_t popn @ setclassvariable(id, ic)(val)() */
rb_num_t
attr_popn_setclassvariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic)
)
{
    return 1;
}

/* attr rb_num_t retn @ setclassvariable(id, ic)(val)() */
rb_num_t
attr_retn_setclassvariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic)
)
{
    return 0;
}

/* attr rb_snum_t sp_inc @ setclassvariable(id, ic)(val)() */
rb_snum_t
attr_sp_inc_setclassvariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic)
)
{
    return -1;
}

/* attr rb_num_t width @ setclassvariable(id, ic)(val)() */
rb_num_t
attr_width_setclassvariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ getconstant(id)(klass, allow_nil)(val) */
enum ruby_vminsn_type
attr_bin_getconstant(MAYBE_UNUSED(ID id))
{
    return BIN(getconstant);
}

/* attr bool handles_sp @ getconstant(id)(klass, allow_nil)(val) */
bool
attr_handles_sp_getconstant(MAYBE_UNUSED(ID id))
{
    return false;
}

/* attr bool leaf @ getconstant(id)(klass, allow_nil)(val) */
bool
attr_leaf_getconstant(MAYBE_UNUSED(ID id))
{
    return
#line 266 "insns.def"
false;
#line 2484 "insns_info.inc"
}

/* attr const char* name @ getconstant(id)(klass, allow_nil)(val) */
const char*
attr_name_getconstant(MAYBE_UNUSED(ID id))
{
    return insn_name(BIN(getconstant));
}

/* attr rb_num_t open @ getconstant(id)(klass, allow_nil)(val) */
rb_num_t
attr_open_getconstant(MAYBE_UNUSED(ID id))
{
    return 1;
}

/* attr rb_num_t popn @ getconstant(id)(klass, allow_nil)(val) */
rb_num_t
attr_popn_getconstant(MAYBE_UNUSED(ID id))
{
    return 2;
}

/* attr rb_num_t retn @ getconstant(id)(klass, allow_nil)(val) */
rb_num_t
attr_retn_getconstant(MAYBE_UNUSED(ID id))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ getconstant(id)(klass, allow_nil)(val) */
rb_snum_t
attr_sp_inc_getconstant(MAYBE_UNUSED(ID id))
{
    return -1;
}

/* attr rb_num_t width @ getconstant(id)(klass, allow_nil)(val) */
rb_num_t
attr_width_getconstant(MAYBE_UNUSED(ID id))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ setconstant(id)(val, cbase)() */
enum ruby_vminsn_type
attr_bin_setconstant(MAYBE_UNUSED(ID id))
{
    return BIN(setconstant);
}

/* attr bool handles_sp @ setconstant(id)(val, cbase)() */
bool
attr_handles_sp_setconstant(MAYBE_UNUSED(ID id))
{
    return false;
}

/* attr bool leaf @ setconstant(id)(val, cbase)() */
bool
attr_leaf_setconstant(MAYBE_UNUSED(ID id))
{
    return
#line 282 "insns.def"
false;
#line 2550 "insns_info.inc"
}

/* attr const char* name @ setconstant(id)(val, cbase)() */
const char*
attr_name_setconstant(MAYBE_UNUSED(ID id))
{
    return insn_name(BIN(setconstant));
}

/* attr rb_num_t open @ setconstant(id)(val, cbase)() */
rb_num_t
attr_open_setconstant(MAYBE_UNUSED(ID id))
{
    return 1;
}

/* attr rb_num_t popn @ setconstant(id)(val, cbase)() */
rb_num_t
attr_popn_setconstant(MAYBE_UNUSED(ID id))
{
    return 2;
}

/* attr rb_num_t retn @ setconstant(id)(val, cbase)() */
rb_num_t
attr_retn_setconstant(MAYBE_UNUSED(ID id))
{
    return 0;
}

/* attr rb_snum_t sp_inc @ setconstant(id)(val, cbase)() */
rb_snum_t
attr_sp_inc_setconstant(MAYBE_UNUSED(ID id))
{
    return -2;
}

/* attr rb_num_t width @ setconstant(id)(val, cbase)() */
rb_num_t
attr_width_setconstant(MAYBE_UNUSED(ID id))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ getglobal(gid)()(val) */
enum ruby_vminsn_type
attr_bin_getglobal(MAYBE_UNUSED(ID gid))
{
    return BIN(getglobal);
}

/* attr bool handles_sp @ getglobal(gid)()(val) */
bool
attr_handles_sp_getglobal(MAYBE_UNUSED(ID gid))
{
    return false;
}

/* attr bool leaf @ getglobal(gid)()(val) */
bool
attr_leaf_getglobal(MAYBE_UNUSED(ID gid))
{
    return
#line 295 "insns.def"
false;
#line 2616 "insns_info.inc"
}

/* attr const char* name @ getglobal(gid)()(val) */
const char*
attr_name_getglobal(MAYBE_UNUSED(ID gid))
{
    return insn_name(BIN(getglobal));
}

/* attr rb_num_t open @ getglobal(gid)()(val) */
rb_num_t
attr_open_getglobal(MAYBE_UNUSED(ID gid))
{
    return 1;
}

/* attr rb_num_t popn @ getglobal(gid)()(val) */
rb_num_t
attr_popn_getglobal(MAYBE_UNUSED(ID gid))
{
    return 0;
}

/* attr rb_num_t retn @ getglobal(gid)()(val) */
rb_num_t
attr_retn_getglobal(MAYBE_UNUSED(ID gid))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ getglobal(gid)()(val) */
rb_snum_t
attr_sp_inc_getglobal(MAYBE_UNUSED(ID gid))
{
    return 1;
}

/* attr rb_num_t width @ getglobal(gid)()(val) */
rb_num_t
attr_width_getglobal(MAYBE_UNUSED(ID gid))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ setglobal(gid)(val)() */
enum ruby_vminsn_type
attr_bin_setglobal(MAYBE_UNUSED(ID gid))
{
    return BIN(setglobal);
}

/* attr bool handles_sp @ setglobal(gid)(val)() */
bool
attr_handles_sp_setglobal(MAYBE_UNUSED(ID gid))
{
    return false;
}

/* attr bool leaf @ setglobal(gid)(val)() */
bool
attr_leaf_setglobal(MAYBE_UNUSED(ID gid))
{
    return
#line 306 "insns.def"
false;
#line 2682 "insns_info.inc"
}

/* attr const char* name @ setglobal(gid)(val)() */
const char*
attr_name_setglobal(MAYBE_UNUSED(ID gid))
{
    return insn_name(BIN(setglobal));
}

/* attr rb_num_t open @ setglobal(gid)(val)() */
rb_num_t
attr_open_setglobal(MAYBE_UNUSED(ID gid))
{
    return 1;
}

/* attr rb_num_t popn @ setglobal(gid)(val)() */
rb_num_t
attr_popn_setglobal(MAYBE_UNUSED(ID gid))
{
    return 1;
}

/* attr rb_num_t retn @ setglobal(gid)(val)() */
rb_num_t
attr_retn_setglobal(MAYBE_UNUSED(ID gid))
{
    return 0;
}

/* attr rb_snum_t sp_inc @ setglobal(gid)(val)() */
rb_snum_t
attr_sp_inc_setglobal(MAYBE_UNUSED(ID gid))
{
    return -1;
}

/* attr rb_num_t width @ setglobal(gid)(val)() */
rb_num_t
attr_width_setglobal(MAYBE_UNUSED(ID gid))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ putnil()()(val) */
enum ruby_vminsn_type
attr_bin_putnil(void)
{
    return BIN(putnil);
}

/* attr bool handles_sp @ putnil()()(val) */
bool
attr_handles_sp_putnil(void)
{
    return false;
}

/* attr bool leaf @ putnil()()(val) */
bool
attr_leaf_putnil(void)
{
    return true;
}

/* attr const char* name @ putnil()()(val) */
const char*
attr_name_putnil(void)
{
    return insn_name(BIN(putnil));
}

/* attr rb_num_t open @ putnil()()(val) */
rb_num_t
attr_open_putnil(void)
{
    return 0;
}

/* attr rb_num_t popn @ putnil()()(val) */
rb_num_t
attr_popn_putnil(void)
{
    return 0;
}

/* attr rb_num_t retn @ putnil()()(val) */
rb_num_t
attr_retn_putnil(void)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ putnil()()(val) */
rb_snum_t
attr_sp_inc_putnil(void)
{
    return 1;
}

/* attr rb_num_t width @ putnil()()(val) */
rb_num_t
attr_width_putnil(void)
{
    return 1;
}

/* attr enum ruby_vminsn_type bin @ putself()()(val) */
enum ruby_vminsn_type
attr_bin_putself(void)
{
    return BIN(putself);
}

/* attr bool handles_sp @ putself()()(val) */
bool
attr_handles_sp_putself(void)
{
    return false;
}

/* attr bool leaf @ putself()()(val) */
bool
attr_leaf_putself(void)
{
    return true;
}

/* attr const char* name @ putself()()(val) */
const char*
attr_name_putself(void)
{
    return insn_name(BIN(putself));
}

/* attr rb_num_t open @ putself()()(val) */
rb_num_t
attr_open_putself(void)
{
    return 0;
}

/* attr rb_num_t popn @ putself()()(val) */
rb_num_t
attr_popn_putself(void)
{
    return 0;
}

/* attr rb_num_t retn @ putself()()(val) */
rb_num_t
attr_retn_putself(void)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ putself()()(val) */
rb_snum_t
attr_sp_inc_putself(void)
{
    return 1;
}

/* attr rb_num_t width @ putself()()(val) */
rb_num_t
attr_width_putself(void)
{
    return 1;
}

/* attr enum ruby_vminsn_type bin @ putobject(val)()(val) */
enum ruby_vminsn_type
attr_bin_putobject(MAYBE_UNUSED(VALUE val))
{
    return BIN(putobject);
}

/* attr bool handles_sp @ putobject(val)()(val) */
bool
attr_handles_sp_putobject(MAYBE_UNUSED(VALUE val))
{
    return false;
}

/* attr bool leaf @ putobject(val)()(val) */
bool
attr_leaf_putobject(MAYBE_UNUSED(VALUE val))
{
    return true;
}

/* attr const char* name @ putobject(val)()(val) */
const char*
attr_name_putobject(MAYBE_UNUSED(VALUE val))
{
    return insn_name(BIN(putobject));
}

/* attr rb_num_t open @ putobject(val)()(val) */
rb_num_t
attr_open_putobject(MAYBE_UNUSED(VALUE val))
{
    return 1;
}

/* attr rb_num_t popn @ putobject(val)()(val) */
rb_num_t
attr_popn_putobject(MAYBE_UNUSED(VALUE val))
{
    return 0;
}

/* attr rb_num_t retn @ putobject(val)()(val) */
rb_num_t
attr_retn_putobject(MAYBE_UNUSED(VALUE val))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ putobject(val)()(val) */
rb_snum_t
attr_sp_inc_putobject(MAYBE_UNUSED(VALUE val))
{
    return 1;
}

/* attr rb_num_t width @ putobject(val)()(val) */
rb_num_t
attr_width_putobject(MAYBE_UNUSED(VALUE val))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ putspecialobject(value_type)()(val) */
enum ruby_vminsn_type
attr_bin_putspecialobject(MAYBE_UNUSED(rb_num_t value_type))
{
    return BIN(putspecialobject);
}

/* attr bool handles_sp @ putspecialobject(value_type)()(val) */
bool
attr_handles_sp_putspecialobject(MAYBE_UNUSED(rb_num_t value_type))
{
    return false;
}

/* attr bool leaf @ putspecialobject(value_type)()(val) */
bool
attr_leaf_putspecialobject(MAYBE_UNUSED(rb_num_t value_type))
{
    return
#line 353 "insns.def"
(value_type == VM_SPECIAL_OBJECT_VMCORE);
#line 2937 "insns_info.inc"
}

/* attr const char* name @ putspecialobject(value_type)()(val) */
const char*
attr_name_putspecialobject(MAYBE_UNUSED(rb_num_t value_type))
{
    return insn_name(BIN(putspecialobject));
}

/* attr rb_num_t open @ putspecialobject(value_type)()(val) */
rb_num_t
attr_open_putspecialobject(MAYBE_UNUSED(rb_num_t value_type))
{
    return 1;
}

/* attr rb_num_t popn @ putspecialobject(value_type)()(val) */
rb_num_t
attr_popn_putspecialobject(MAYBE_UNUSED(rb_num_t value_type))
{
    return 0;
}

/* attr rb_num_t retn @ putspecialobject(value_type)()(val) */
rb_num_t
attr_retn_putspecialobject(MAYBE_UNUSED(rb_num_t value_type))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ putspecialobject(value_type)()(val) */
rb_snum_t
attr_sp_inc_putspecialobject(MAYBE_UNUSED(rb_num_t value_type))
{
    return 1;
}

/* attr rb_num_t width @ putspecialobject(value_type)()(val) */
rb_num_t
attr_width_putspecialobject(MAYBE_UNUSED(rb_num_t value_type))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ putstring(str)()(val) */
enum ruby_vminsn_type
attr_bin_putstring(MAYBE_UNUSED(VALUE str))
{
    return BIN(putstring);
}

/* attr bool handles_sp @ putstring(str)()(val) */
bool
attr_handles_sp_putstring(MAYBE_UNUSED(VALUE str))
{
    return false;
}

/* attr bool leaf @ putstring(str)()(val) */
bool
attr_leaf_putstring(MAYBE_UNUSED(VALUE str))
{
    return true;
}

/* attr const char* name @ putstring(str)()(val) */
const char*
attr_name_putstring(MAYBE_UNUSED(VALUE str))
{
    return insn_name(BIN(putstring));
}

/* attr rb_num_t open @ putstring(str)()(val) */
rb_num_t
attr_open_putstring(MAYBE_UNUSED(VALUE str))
{
    return 1;
}

/* attr rb_num_t popn @ putstring(str)()(val) */
rb_num_t
attr_popn_putstring(MAYBE_UNUSED(VALUE str))
{
    return 0;
}

/* attr rb_num_t retn @ putstring(str)()(val) */
rb_num_t
attr_retn_putstring(MAYBE_UNUSED(VALUE str))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ putstring(str)()(val) */
rb_snum_t
attr_sp_inc_putstring(MAYBE_UNUSED(VALUE str))
{
    return 1;
}

/* attr rb_num_t width @ putstring(str)()(val) */
rb_num_t
attr_width_putstring(MAYBE_UNUSED(VALUE str))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ concatstrings(num)(...)(val) */
enum ruby_vminsn_type
attr_bin_concatstrings(MAYBE_UNUSED(rb_num_t num))
{
    return BIN(concatstrings);
}

/* attr bool handles_sp @ concatstrings(num)(...)(val) */
bool
attr_handles_sp_concatstrings(MAYBE_UNUSED(rb_num_t num))
{
    return false;
}

/* attr bool leaf @ concatstrings(num)(...)(val) */
bool
attr_leaf_concatstrings(MAYBE_UNUSED(rb_num_t num))
{
    return
#line 379 "insns.def"
false;
#line 3066 "insns_info.inc"
}

/* attr const char* name @ concatstrings(num)(...)(val) */
const char*
attr_name_concatstrings(MAYBE_UNUSED(rb_num_t num))
{
    return insn_name(BIN(concatstrings));
}

/* attr rb_num_t open @ concatstrings(num)(...)(val) */
rb_num_t
attr_open_concatstrings(MAYBE_UNUSED(rb_num_t num))
{
    return 1;
}

/* attr rb_num_t popn @ concatstrings(num)(...)(val) */
rb_num_t
attr_popn_concatstrings(MAYBE_UNUSED(rb_num_t num))
{
    return 0;
}

/* attr rb_num_t retn @ concatstrings(num)(...)(val) */
rb_num_t
attr_retn_concatstrings(MAYBE_UNUSED(rb_num_t num))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ concatstrings(num)(...)(val) */
rb_snum_t
attr_sp_inc_concatstrings(MAYBE_UNUSED(rb_num_t num))
{
    return
#line 380 "insns.def"
1 - (rb_snum_t)num;
#line 3104 "insns_info.inc"
}

/* attr rb_num_t width @ concatstrings(num)(...)(val) */
rb_num_t
attr_width_concatstrings(MAYBE_UNUSED(rb_num_t num))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ anytostring()(val, str)(val) */
enum ruby_vminsn_type
attr_bin_anytostring(void)
{
    return BIN(anytostring);
}

/* attr bool handles_sp @ anytostring()(val, str)(val) */
bool
attr_handles_sp_anytostring(void)
{
    return false;
}

/* attr bool leaf @ anytostring()(val, str)(val) */
bool
attr_leaf_anytostring(void)
{
    return true;
}

/* attr const char* name @ anytostring()(val, str)(val) */
const char*
attr_name_anytostring(void)
{
    return insn_name(BIN(anytostring));
}

/* attr rb_num_t open @ anytostring()(val, str)(val) */
rb_num_t
attr_open_anytostring(void)
{
    return 0;
}

/* attr rb_num_t popn @ anytostring()(val, str)(val) */
rb_num_t
attr_popn_anytostring(void)
{
    return 2;
}

/* attr rb_num_t retn @ anytostring()(val, str)(val) */
rb_num_t
attr_retn_anytostring(void)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ anytostring()(val, str)(val) */
rb_snum_t
attr_sp_inc_anytostring(void)
{
    return -1;
}

/* attr rb_num_t width @ anytostring()(val, str)(val) */
rb_num_t
attr_width_anytostring(void)
{
    return 1;
}

/* attr enum ruby_vminsn_type bin @ toregexp(opt, cnt)(...)(val) */
enum ruby_vminsn_type
attr_bin_toregexp(
    MAYBE_UNUSED(rb_num_t opt),
    MAYBE_UNUSED(rb_num_t cnt)
)
{
    return BIN(toregexp);
}

/* attr bool handles_sp @ toregexp(opt, cnt)(...)(val) */
bool
attr_handles_sp_toregexp(
    MAYBE_UNUSED(rb_num_t opt),
    MAYBE_UNUSED(rb_num_t cnt)
)
{
    return false;
}

/* attr bool leaf @ toregexp(opt, cnt)(...)(val) */
bool
attr_leaf_toregexp(
    MAYBE_UNUSED(rb_num_t opt),
    MAYBE_UNUSED(rb_num_t cnt)
)
{
    return
#line 406 "insns.def"
false;
#line 3207 "insns_info.inc"
}

/* attr const char* name @ toregexp(opt, cnt)(...)(val) */
const char*
attr_name_toregexp(
    MAYBE_UNUSED(rb_num_t opt),
    MAYBE_UNUSED(rb_num_t cnt)
)
{
    return insn_name(BIN(toregexp));
}

/* attr rb_num_t open @ toregexp(opt, cnt)(...)(val) */
rb_num_t
attr_open_toregexp(
    MAYBE_UNUSED(rb_num_t opt),
    MAYBE_UNUSED(rb_num_t cnt)
)
{
    return 2;
}

/* attr rb_num_t popn @ toregexp(opt, cnt)(...)(val) */
rb_num_t
attr_popn_toregexp(
    MAYBE_UNUSED(rb_num_t opt),
    MAYBE_UNUSED(rb_num_t cnt)
)
{
    return 0;
}

/* attr rb_num_t retn @ toregexp(opt, cnt)(...)(val) */
rb_num_t
attr_retn_toregexp(
    MAYBE_UNUSED(rb_num_t opt),
    MAYBE_UNUSED(rb_num_t cnt)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ toregexp(opt, cnt)(...)(val) */
rb_snum_t
attr_sp_inc_toregexp(
    MAYBE_UNUSED(rb_num_t opt),
    MAYBE_UNUSED(rb_num_t cnt)
)
{
    return
#line 407 "insns.def"
1 - (rb_snum_t)cnt;
#line 3260 "insns_info.inc"
}

/* attr rb_num_t width @ toregexp(opt, cnt)(...)(val) */
rb_num_t
attr_width_toregexp(
    MAYBE_UNUSED(rb_num_t opt),
    MAYBE_UNUSED(rb_num_t cnt)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ intern()(str)(sym) */
enum ruby_vminsn_type
attr_bin_intern(void)
{
    return BIN(intern);
}

/* attr bool handles_sp @ intern()(str)(sym) */
bool
attr_handles_sp_intern(void)
{
    return false;
}

/* attr bool leaf @ intern()(str)(sym) */
bool
attr_leaf_intern(void)
{
    return true;
}

/* attr const char* name @ intern()(str)(sym) */
const char*
attr_name_intern(void)
{
    return insn_name(BIN(intern));
}

/* attr rb_num_t open @ intern()(str)(sym) */
rb_num_t
attr_open_intern(void)
{
    return 0;
}

/* attr rb_num_t popn @ intern()(str)(sym) */
rb_num_t
attr_popn_intern(void)
{
    return 1;
}

/* attr rb_num_t retn @ intern()(str)(sym) */
rb_num_t
attr_retn_intern(void)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ intern()(str)(sym) */
rb_snum_t
attr_sp_inc_intern(void)
{
    return 0;
}

/* attr rb_num_t width @ intern()(str)(sym) */
rb_num_t
attr_width_intern(void)
{
    return 1;
}

/* attr enum ruby_vminsn_type bin @ newarray(num)(...)(val) */
enum ruby_vminsn_type
attr_bin_newarray(MAYBE_UNUSED(rb_num_t num))
{
    return BIN(newarray);
}

/* attr bool handles_sp @ newarray(num)(...)(val) */
bool
attr_handles_sp_newarray(MAYBE_UNUSED(rb_num_t num))
{
    return false;
}

/* attr bool leaf @ newarray(num)(...)(val) */
bool
attr_leaf_newarray(MAYBE_UNUSED(rb_num_t num))
{
    return true;
}

/* attr const char* name @ newarray(num)(...)(val) */
const char*
attr_name_newarray(MAYBE_UNUSED(rb_num_t num))
{
    return insn_name(BIN(newarray));
}

/* attr rb_num_t open @ newarray(num)(...)(val) */
rb_num_t
attr_open_newarray(MAYBE_UNUSED(rb_num_t num))
{
    return 1;
}

/* attr rb_num_t popn @ newarray(num)(...)(val) */
rb_num_t
attr_popn_newarray(MAYBE_UNUSED(rb_num_t num))
{
    return 0;
}

/* attr rb_num_t retn @ newarray(num)(...)(val) */
rb_num_t
attr_retn_newarray(MAYBE_UNUSED(rb_num_t num))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ newarray(num)(...)(val) */
rb_snum_t
attr_sp_inc_newarray(MAYBE_UNUSED(rb_num_t num))
{
    return
#line 430 "insns.def"
1 - (rb_snum_t)num;
#line 3392 "insns_info.inc"
}

/* attr rb_num_t width @ newarray(num)(...)(val) */
rb_num_t
attr_width_newarray(MAYBE_UNUSED(rb_num_t num))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ newarraykwsplat(num)(...)(val) */
enum ruby_vminsn_type
attr_bin_newarraykwsplat(MAYBE_UNUSED(rb_num_t num))
{
    return BIN(newarraykwsplat);
}

/* attr bool handles_sp @ newarraykwsplat(num)(...)(val) */
bool
attr_handles_sp_newarraykwsplat(MAYBE_UNUSED(rb_num_t num))
{
    return false;
}

/* attr bool leaf @ newarraykwsplat(num)(...)(val) */
bool
attr_leaf_newarraykwsplat(MAYBE_UNUSED(rb_num_t num))
{
    return true;
}

/* attr const char* name @ newarraykwsplat(num)(...)(val) */
const char*
attr_name_newarraykwsplat(MAYBE_UNUSED(rb_num_t num))
{
    return insn_name(BIN(newarraykwsplat));
}

/* attr rb_num_t open @ newarraykwsplat(num)(...)(val) */
rb_num_t
attr_open_newarraykwsplat(MAYBE_UNUSED(rb_num_t num))
{
    return 1;
}

/* attr rb_num_t popn @ newarraykwsplat(num)(...)(val) */
rb_num_t
attr_popn_newarraykwsplat(MAYBE_UNUSED(rb_num_t num))
{
    return 0;
}

/* attr rb_num_t retn @ newarraykwsplat(num)(...)(val) */
rb_num_t
attr_retn_newarraykwsplat(MAYBE_UNUSED(rb_num_t num))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ newarraykwsplat(num)(...)(val) */
rb_snum_t
attr_sp_inc_newarraykwsplat(MAYBE_UNUSED(rb_num_t num))
{
    return
#line 445 "insns.def"
1 - (rb_snum_t)num;
#line 3458 "insns_info.inc"
}

/* attr rb_num_t width @ newarraykwsplat(num)(...)(val) */
rb_num_t
attr_width_newarraykwsplat(MAYBE_UNUSED(rb_num_t num))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ duparray(ary)()(val) */
enum ruby_vminsn_type
attr_bin_duparray(MAYBE_UNUSED(VALUE ary))
{
    return BIN(duparray);
}

/* attr bool handles_sp @ duparray(ary)()(val) */
bool
attr_handles_sp_duparray(MAYBE_UNUSED(VALUE ary))
{
    return false;
}

/* attr bool leaf @ duparray(ary)()(val) */
bool
attr_leaf_duparray(MAYBE_UNUSED(VALUE ary))
{
    return true;
}

/* attr const char* name @ duparray(ary)()(val) */
const char*
attr_name_duparray(MAYBE_UNUSED(VALUE ary))
{
    return insn_name(BIN(duparray));
}

/* attr rb_num_t open @ duparray(ary)()(val) */
rb_num_t
attr_open_duparray(MAYBE_UNUSED(VALUE ary))
{
    return 1;
}

/* attr rb_num_t popn @ duparray(ary)()(val) */
rb_num_t
attr_popn_duparray(MAYBE_UNUSED(VALUE ary))
{
    return 0;
}

/* attr rb_num_t retn @ duparray(ary)()(val) */
rb_num_t
attr_retn_duparray(MAYBE_UNUSED(VALUE ary))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ duparray(ary)()(val) */
rb_snum_t
attr_sp_inc_duparray(MAYBE_UNUSED(VALUE ary))
{
    return 1;
}

/* attr rb_num_t width @ duparray(ary)()(val) */
rb_num_t
attr_width_duparray(MAYBE_UNUSED(VALUE ary))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ duphash(hash)()(val) */
enum ruby_vminsn_type
attr_bin_duphash(MAYBE_UNUSED(VALUE hash))
{
    return BIN(duphash);
}

/* attr bool handles_sp @ duphash(hash)()(val) */
bool
attr_handles_sp_duphash(MAYBE_UNUSED(VALUE hash))
{
    return false;
}

/* attr bool leaf @ duphash(hash)()(val) */
bool
attr_leaf_duphash(MAYBE_UNUSED(VALUE hash))
{
    return true;
}

/* attr const char* name @ duphash(hash)()(val) */
const char*
attr_name_duphash(MAYBE_UNUSED(VALUE hash))
{
    return insn_name(BIN(duphash));
}

/* attr rb_num_t open @ duphash(hash)()(val) */
rb_num_t
attr_open_duphash(MAYBE_UNUSED(VALUE hash))
{
    return 1;
}

/* attr rb_num_t popn @ duphash(hash)()(val) */
rb_num_t
attr_popn_duphash(MAYBE_UNUSED(VALUE hash))
{
    return 0;
}

/* attr rb_num_t retn @ duphash(hash)()(val) */
rb_num_t
attr_retn_duphash(MAYBE_UNUSED(VALUE hash))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ duphash(hash)()(val) */
rb_snum_t
attr_sp_inc_duphash(MAYBE_UNUSED(VALUE hash))
{
    return 1;
}

/* attr rb_num_t width @ duphash(hash)()(val) */
rb_num_t
attr_width_duphash(MAYBE_UNUSED(VALUE hash))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ expandarray(num, flag)(..., ary)(...) */
enum ruby_vminsn_type
attr_bin_expandarray(
    MAYBE_UNUSED(rb_num_t num),
    MAYBE_UNUSED(rb_num_t flag)
)
{
    return BIN(expandarray);
}

/* attr bool handles_sp @ expandarray(num, flag)(..., ary)(...) */
bool
attr_handles_sp_expandarray(
    MAYBE_UNUSED(rb_num_t num),
    MAYBE_UNUSED(rb_num_t flag)
)
{
    return false;
}

/* attr bool leaf @ expandarray(num, flag)(..., ary)(...) */
bool
attr_leaf_expandarray(
    MAYBE_UNUSED(rb_num_t num),
    MAYBE_UNUSED(rb_num_t flag)
)
{
    return
#line 491 "insns.def"
false;
#line 3624 "insns_info.inc"
}

/* attr const char* name @ expandarray(num, flag)(..., ary)(...) */
const char*
attr_name_expandarray(
    MAYBE_UNUSED(rb_num_t num),
    MAYBE_UNUSED(rb_num_t flag)
)
{
    return insn_name(BIN(expandarray));
}

/* attr rb_num_t open @ expandarray(num, flag)(..., ary)(...) */
rb_num_t
attr_open_expandarray(
    MAYBE_UNUSED(rb_num_t num),
    MAYBE_UNUSED(rb_num_t flag)
)
{
    return 2;
}

/* attr rb_num_t popn @ expandarray(num, flag)(..., ary)(...) */
rb_num_t
attr_popn_expandarray(
    MAYBE_UNUSED(rb_num_t num),
    MAYBE_UNUSED(rb_num_t flag)
)
{
    return 1;
}

/* attr rb_num_t retn @ expandarray(num, flag)(..., ary)(...) */
rb_num_t
attr_retn_expandarray(
    MAYBE_UNUSED(rb_num_t num),
    MAYBE_UNUSED(rb_num_t flag)
)
{
    return 0;
}

/* attr rb_snum_t sp_inc @ expandarray(num, flag)(..., ary)(...) */
rb_snum_t
attr_sp_inc_expandarray(
    MAYBE_UNUSED(rb_num_t num),
    MAYBE_UNUSED(rb_num_t flag)
)
{
    return
#line 492 "insns.def"
(rb_snum_t)num - 1 + (flag & 1 ? 1 : 0);
#line 3677 "insns_info.inc"
}

/* attr rb_num_t width @ expandarray(num, flag)(..., ary)(...) */
rb_num_t
attr_width_expandarray(
    MAYBE_UNUSED(rb_num_t num),
    MAYBE_UNUSED(rb_num_t flag)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ concatarray()(ary1, ary2)(ary) */
enum ruby_vminsn_type
attr_bin_concatarray(void)
{
    return BIN(concatarray);
}

/* attr bool handles_sp @ concatarray()(ary1, ary2)(ary) */
bool
attr_handles_sp_concatarray(void)
{
    return false;
}

/* attr bool leaf @ concatarray()(ary1, ary2)(ary) */
bool
attr_leaf_concatarray(void)
{
    return
#line 503 "insns.def"
false;
#line 3711 "insns_info.inc"
}

/* attr const char* name @ concatarray()(ary1, ary2)(ary) */
const char*
attr_name_concatarray(void)
{
    return insn_name(BIN(concatarray));
}

/* attr rb_num_t open @ concatarray()(ary1, ary2)(ary) */
rb_num_t
attr_open_concatarray(void)
{
    return 0;
}

/* attr rb_num_t popn @ concatarray()(ary1, ary2)(ary) */
rb_num_t
attr_popn_concatarray(void)
{
    return 2;
}

/* attr rb_num_t retn @ concatarray()(ary1, ary2)(ary) */
rb_num_t
attr_retn_concatarray(void)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ concatarray()(ary1, ary2)(ary) */
rb_snum_t
attr_sp_inc_concatarray(void)
{
    return -1;
}

/* attr rb_num_t width @ concatarray()(ary1, ary2)(ary) */
rb_num_t
attr_width_concatarray(void)
{
    return 1;
}

/* attr enum ruby_vminsn_type bin @ splatarray(flag)(ary)(obj) */
enum ruby_vminsn_type
attr_bin_splatarray(MAYBE_UNUSED(VALUE flag))
{
    return BIN(splatarray);
}

/* attr bool handles_sp @ splatarray(flag)(ary)(obj) */
bool
attr_handles_sp_splatarray(MAYBE_UNUSED(VALUE flag))
{
    return false;
}

/* attr bool leaf @ splatarray(flag)(ary)(obj) */
bool
attr_leaf_splatarray(MAYBE_UNUSED(VALUE flag))
{
    return
#line 514 "insns.def"
false;
#line 3777 "insns_info.inc"
}

/* attr const char* name @ splatarray(flag)(ary)(obj) */
const char*
attr_name_splatarray(MAYBE_UNUSED(VALUE flag))
{
    return insn_name(BIN(splatarray));
}

/* attr rb_num_t open @ splatarray(flag)(ary)(obj) */
rb_num_t
attr_open_splatarray(MAYBE_UNUSED(VALUE flag))
{
    return 1;
}

/* attr rb_num_t popn @ splatarray(flag)(ary)(obj) */
rb_num_t
attr_popn_splatarray(MAYBE_UNUSED(VALUE flag))
{
    return 1;
}

/* attr rb_num_t retn @ splatarray(flag)(ary)(obj) */
rb_num_t
attr_retn_splatarray(MAYBE_UNUSED(VALUE flag))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ splatarray(flag)(ary)(obj) */
rb_snum_t
attr_sp_inc_splatarray(MAYBE_UNUSED(VALUE flag))
{
    return 0;
}

/* attr rb_num_t width @ splatarray(flag)(ary)(obj) */
rb_num_t
attr_width_splatarray(MAYBE_UNUSED(VALUE flag))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ newhash(num)(...)(val) */
enum ruby_vminsn_type
attr_bin_newhash(MAYBE_UNUSED(rb_num_t num))
{
    return BIN(newhash);
}

/* attr bool handles_sp @ newhash(num)(...)(val) */
bool
attr_handles_sp_newhash(MAYBE_UNUSED(rb_num_t num))
{
    return false;
}

/* attr bool leaf @ newhash(num)(...)(val) */
bool
attr_leaf_newhash(MAYBE_UNUSED(rb_num_t num))
{
    return
#line 525 "insns.def"
false;
#line 3843 "insns_info.inc"
}

/* attr const char* name @ newhash(num)(...)(val) */
const char*
attr_name_newhash(MAYBE_UNUSED(rb_num_t num))
{
    return insn_name(BIN(newhash));
}

/* attr rb_num_t open @ newhash(num)(...)(val) */
rb_num_t
attr_open_newhash(MAYBE_UNUSED(rb_num_t num))
{
    return 1;
}

/* attr rb_num_t popn @ newhash(num)(...)(val) */
rb_num_t
attr_popn_newhash(MAYBE_UNUSED(rb_num_t num))
{
    return 0;
}

/* attr rb_num_t retn @ newhash(num)(...)(val) */
rb_num_t
attr_retn_newhash(MAYBE_UNUSED(rb_num_t num))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ newhash(num)(...)(val) */
rb_snum_t
attr_sp_inc_newhash(MAYBE_UNUSED(rb_num_t num))
{
    return
#line 526 "insns.def"
1 - (rb_snum_t)num;
#line 3881 "insns_info.inc"
}

/* attr rb_num_t width @ newhash(num)(...)(val) */
rb_num_t
attr_width_newhash(MAYBE_UNUSED(rb_num_t num))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ newrange(flag)(low, high)(val) */
enum ruby_vminsn_type
attr_bin_newrange(MAYBE_UNUSED(rb_num_t flag))
{
    return BIN(newrange);
}

/* attr bool handles_sp @ newrange(flag)(low, high)(val) */
bool
attr_handles_sp_newrange(MAYBE_UNUSED(rb_num_t flag))
{
    return false;
}

/* attr bool leaf @ newrange(flag)(low, high)(val) */
bool
attr_leaf_newrange(MAYBE_UNUSED(rb_num_t flag))
{
    return
#line 546 "insns.def"
false;
#line 3912 "insns_info.inc"
}

/* attr const char* name @ newrange(flag)(low, high)(val) */
const char*
attr_name_newrange(MAYBE_UNUSED(rb_num_t flag))
{
    return insn_name(BIN(newrange));
}

/* attr rb_num_t open @ newrange(flag)(low, high)(val) */
rb_num_t
attr_open_newrange(MAYBE_UNUSED(rb_num_t flag))
{
    return 1;
}

/* attr rb_num_t popn @ newrange(flag)(low, high)(val) */
rb_num_t
attr_popn_newrange(MAYBE_UNUSED(rb_num_t flag))
{
    return 2;
}

/* attr rb_num_t retn @ newrange(flag)(low, high)(val) */
rb_num_t
attr_retn_newrange(MAYBE_UNUSED(rb_num_t flag))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ newrange(flag)(low, high)(val) */
rb_snum_t
attr_sp_inc_newrange(MAYBE_UNUSED(rb_num_t flag))
{
    return -1;
}

/* attr rb_num_t width @ newrange(flag)(low, high)(val) */
rb_num_t
attr_width_newrange(MAYBE_UNUSED(rb_num_t flag))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ pop()(val)() */
enum ruby_vminsn_type
attr_bin_pop(void)
{
    return BIN(pop);
}

/* attr bool handles_sp @ pop()(val)() */
bool
attr_handles_sp_pop(void)
{
    return false;
}

/* attr bool leaf @ pop()(val)() */
bool
attr_leaf_pop(void)
{
    return true;
}

/* attr const char* name @ pop()(val)() */
const char*
attr_name_pop(void)
{
    return insn_name(BIN(pop));
}

/* attr rb_num_t open @ pop()(val)() */
rb_num_t
attr_open_pop(void)
{
    return 0;
}

/* attr rb_num_t popn @ pop()(val)() */
rb_num_t
attr_popn_pop(void)
{
    return 1;
}

/* attr rb_num_t retn @ pop()(val)() */
rb_num_t
attr_retn_pop(void)
{
    return 0;
}

/* attr rb_snum_t sp_inc @ pop()(val)() */
rb_snum_t
attr_sp_inc_pop(void)
{
    return -1;
}

/* attr rb_num_t width @ pop()(val)() */
rb_num_t
attr_width_pop(void)
{
    return 1;
}

/* attr enum ruby_vminsn_type bin @ dup()(val)(val1, val2) */
enum ruby_vminsn_type
attr_bin_dup(void)
{
    return BIN(dup);
}

/* attr bool handles_sp @ dup()(val)(val1, val2) */
bool
attr_handles_sp_dup(void)
{
    return false;
}

/* attr bool leaf @ dup()(val)(val1, val2) */
bool
attr_leaf_dup(void)
{
    return true;
}

/* attr const char* name @ dup()(val)(val1, val2) */
const char*
attr_name_dup(void)
{
    return insn_name(BIN(dup));
}

/* attr rb_num_t open @ dup()(val)(val1, val2) */
rb_num_t
attr_open_dup(void)
{
    return 0;
}

/* attr rb_num_t popn @ dup()(val)(val1, val2) */
rb_num_t
attr_popn_dup(void)
{
    return 1;
}

/* attr rb_num_t retn @ dup()(val)(val1, val2) */
rb_num_t
attr_retn_dup(void)
{
    return 2;
}

/* attr rb_snum_t sp_inc @ dup()(val)(val1, val2) */
rb_snum_t
attr_sp_inc_dup(void)
{
    return 1;
}

/* attr rb_num_t width @ dup()(val)(val1, val2) */
rb_num_t
attr_width_dup(void)
{
    return 1;
}

/* attr enum ruby_vminsn_type bin @ dupn(n)(...)(...) */
enum ruby_vminsn_type
attr_bin_dupn(MAYBE_UNUSED(rb_num_t n))
{
    return BIN(dupn);
}

/* attr bool handles_sp @ dupn(n)(...)(...) */
bool
attr_handles_sp_dupn(MAYBE_UNUSED(rb_num_t n))
{
    return false;
}

/* attr bool leaf @ dupn(n)(...)(...) */
bool
attr_leaf_dupn(MAYBE_UNUSED(rb_num_t n))
{
    return true;
}

/* attr const char* name @ dupn(n)(...)(...) */
const char*
attr_name_dupn(MAYBE_UNUSED(rb_num_t n))
{
    return insn_name(BIN(dupn));
}

/* attr rb_num_t open @ dupn(n)(...)(...) */
rb_num_t
attr_open_dupn(MAYBE_UNUSED(rb_num_t n))
{
    return 1;
}

/* attr rb_num_t popn @ dupn(n)(...)(...) */
rb_num_t
attr_popn_dupn(MAYBE_UNUSED(rb_num_t n))
{
    return 0;
}

/* attr rb_num_t retn @ dupn(n)(...)(...) */
rb_num_t
attr_retn_dupn(MAYBE_UNUSED(rb_num_t n))
{
    return 0;
}

/* attr rb_snum_t sp_inc @ dupn(n)(...)(...) */
rb_snum_t
attr_sp_inc_dupn(MAYBE_UNUSED(rb_num_t n))
{
    return
#line 582 "insns.def"
n;
#line 4139 "insns_info.inc"
}

/* attr rb_num_t width @ dupn(n)(...)(...) */
rb_num_t
attr_width_dupn(MAYBE_UNUSED(rb_num_t n))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ swap()(val, obj)(obj, val) */
enum ruby_vminsn_type
attr_bin_swap(void)
{
    return BIN(swap);
}

/* attr bool handles_sp @ swap()(val, obj)(obj, val) */
bool
attr_handles_sp_swap(void)
{
    return false;
}

/* attr bool leaf @ swap()(val, obj)(obj, val) */
bool
attr_leaf_swap(void)
{
    return true;
}

/* attr const char* name @ swap()(val, obj)(obj, val) */
const char*
attr_name_swap(void)
{
    return insn_name(BIN(swap));
}

/* attr rb_num_t open @ swap()(val, obj)(obj, val) */
rb_num_t
attr_open_swap(void)
{
    return 0;
}

/* attr rb_num_t popn @ swap()(val, obj)(obj, val) */
rb_num_t
attr_popn_swap(void)
{
    return 2;
}

/* attr rb_num_t retn @ swap()(val, obj)(obj, val) */
rb_num_t
attr_retn_swap(void)
{
    return 2;
}

/* attr rb_snum_t sp_inc @ swap()(val, obj)(obj, val) */
rb_snum_t
attr_sp_inc_swap(void)
{
    return 0;
}

/* attr rb_num_t width @ swap()(val, obj)(obj, val) */
rb_num_t
attr_width_swap(void)
{
    return 1;
}

/* attr enum ruby_vminsn_type bin @ topn(n)(...)(val) */
enum ruby_vminsn_type
attr_bin_topn(MAYBE_UNUSED(rb_num_t n))
{
    return BIN(topn);
}

/* attr bool handles_sp @ topn(n)(...)(val) */
bool
attr_handles_sp_topn(MAYBE_UNUSED(rb_num_t n))
{
    return false;
}

/* attr bool leaf @ topn(n)(...)(val) */
bool
attr_leaf_topn(MAYBE_UNUSED(rb_num_t n))
{
    return true;
}

/* attr const char* name @ topn(n)(...)(val) */
const char*
attr_name_topn(MAYBE_UNUSED(rb_num_t n))
{
    return insn_name(BIN(topn));
}

/* attr rb_num_t open @ topn(n)(...)(val) */
rb_num_t
attr_open_topn(MAYBE_UNUSED(rb_num_t n))
{
    return 1;
}

/* attr rb_num_t popn @ topn(n)(...)(val) */
rb_num_t
attr_popn_topn(MAYBE_UNUSED(rb_num_t n))
{
    return 0;
}

/* attr rb_num_t retn @ topn(n)(...)(val) */
rb_num_t
attr_retn_topn(MAYBE_UNUSED(rb_num_t n))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ topn(n)(...)(val) */
rb_snum_t
attr_sp_inc_topn(MAYBE_UNUSED(rb_num_t n))
{
    return
#line 617 "insns.def"
1;
#line 4268 "insns_info.inc"
}

/* attr rb_num_t width @ topn(n)(...)(val) */
rb_num_t
attr_width_topn(MAYBE_UNUSED(rb_num_t n))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ setn(n)(..., val)(val) */
enum ruby_vminsn_type
attr_bin_setn(MAYBE_UNUSED(rb_num_t n))
{
    return BIN(setn);
}

/* attr bool handles_sp @ setn(n)(..., val)(val) */
bool
attr_handles_sp_setn(MAYBE_UNUSED(rb_num_t n))
{
    return false;
}

/* attr bool leaf @ setn(n)(..., val)(val) */
bool
attr_leaf_setn(MAYBE_UNUSED(rb_num_t n))
{
    return true;
}

/* attr const char* name @ setn(n)(..., val)(val) */
const char*
attr_name_setn(MAYBE_UNUSED(rb_num_t n))
{
    return insn_name(BIN(setn));
}

/* attr rb_num_t open @ setn(n)(..., val)(val) */
rb_num_t
attr_open_setn(MAYBE_UNUSED(rb_num_t n))
{
    return 1;
}

/* attr rb_num_t popn @ setn(n)(..., val)(val) */
rb_num_t
attr_popn_setn(MAYBE_UNUSED(rb_num_t n))
{
    return 1;
}

/* attr rb_num_t retn @ setn(n)(..., val)(val) */
rb_num_t
attr_retn_setn(MAYBE_UNUSED(rb_num_t n))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ setn(n)(..., val)(val) */
rb_snum_t
attr_sp_inc_setn(MAYBE_UNUSED(rb_num_t n))
{
    return
#line 628 "insns.def"
0;
#line 4334 "insns_info.inc"
}

/* attr rb_num_t width @ setn(n)(..., val)(val) */
rb_num_t
attr_width_setn(MAYBE_UNUSED(rb_num_t n))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ adjuststack(n)(...)(...) */
enum ruby_vminsn_type
attr_bin_adjuststack(MAYBE_UNUSED(rb_num_t n))
{
    return BIN(adjuststack);
}

/* attr bool handles_sp @ adjuststack(n)(...)(...) */
bool
attr_handles_sp_adjuststack(MAYBE_UNUSED(rb_num_t n))
{
    return false;
}

/* attr bool leaf @ adjuststack(n)(...)(...) */
bool
attr_leaf_adjuststack(MAYBE_UNUSED(rb_num_t n))
{
    return true;
}

/* attr const char* name @ adjuststack(n)(...)(...) */
const char*
attr_name_adjuststack(MAYBE_UNUSED(rb_num_t n))
{
    return insn_name(BIN(adjuststack));
}

/* attr rb_num_t open @ adjuststack(n)(...)(...) */
rb_num_t
attr_open_adjuststack(MAYBE_UNUSED(rb_num_t n))
{
    return 1;
}

/* attr rb_num_t popn @ adjuststack(n)(...)(...) */
rb_num_t
attr_popn_adjuststack(MAYBE_UNUSED(rb_num_t n))
{
    return 0;
}

/* attr rb_num_t retn @ adjuststack(n)(...)(...) */
rb_num_t
attr_retn_adjuststack(MAYBE_UNUSED(rb_num_t n))
{
    return 0;
}

/* attr rb_snum_t sp_inc @ adjuststack(n)(...)(...) */
rb_snum_t
attr_sp_inc_adjuststack(MAYBE_UNUSED(rb_num_t n))
{
    return
#line 639 "insns.def"
-(rb_snum_t)n;
#line 4400 "insns_info.inc"
}

/* attr rb_num_t width @ adjuststack(n)(...)(...) */
rb_num_t
attr_width_adjuststack(MAYBE_UNUSED(rb_num_t n))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ defined(op_type, obj, pushval)(v)(val) */
enum ruby_vminsn_type
attr_bin_defined(
    MAYBE_UNUSED(rb_num_t op_type),
    MAYBE_UNUSED(VALUE obj),
    MAYBE_UNUSED(VALUE pushval)
)
{
    return BIN(defined);
}

/* attr bool handles_sp @ defined(op_type, obj, pushval)(v)(val) */
bool
attr_handles_sp_defined(
    MAYBE_UNUSED(rb_num_t op_type),
    MAYBE_UNUSED(VALUE obj),
    MAYBE_UNUSED(VALUE pushval)
)
{
    return false;
}

/* attr bool leaf @ defined(op_type, obj, pushval)(v)(val) */
bool
attr_leaf_defined(
    MAYBE_UNUSED(rb_num_t op_type),
    MAYBE_UNUSED(VALUE obj),
    MAYBE_UNUSED(VALUE pushval)
)
{
    return
#line 654 "insns.def"
leafness_of_defined(op_type);
#line 4443 "insns_info.inc"
}

/* attr const char* name @ defined(op_type, obj, pushval)(v)(val) */
const char*
attr_name_defined(
    MAYBE_UNUSED(rb_num_t op_type),
    MAYBE_UNUSED(VALUE obj),
    MAYBE_UNUSED(VALUE pushval)
)
{
    return insn_name(BIN(defined));
}

/* attr rb_num_t open @ defined(op_type, obj, pushval)(v)(val) */
rb_num_t
attr_open_defined(
    MAYBE_UNUSED(rb_num_t op_type),
    MAYBE_UNUSED(VALUE obj),
    MAYBE_UNUSED(VALUE pushval)
)
{
    return 3;
}

/* attr rb_num_t popn @ defined(op_type, obj, pushval)(v)(val) */
rb_num_t
attr_popn_defined(
    MAYBE_UNUSED(rb_num_t op_type),
    MAYBE_UNUSED(VALUE obj),
    MAYBE_UNUSED(VALUE pushval)
)
{
    return 1;
}

/* attr rb_num_t retn @ defined(op_type, obj, pushval)(v)(val) */
rb_num_t
attr_retn_defined(
    MAYBE_UNUSED(rb_num_t op_type),
    MAYBE_UNUSED(VALUE obj),
    MAYBE_UNUSED(VALUE pushval)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ defined(op_type, obj, pushval)(v)(val) */
rb_snum_t
attr_sp_inc_defined(
    MAYBE_UNUSED(rb_num_t op_type),
    MAYBE_UNUSED(VALUE obj),
    MAYBE_UNUSED(VALUE pushval)
)
{
    return 0;
}

/* attr rb_num_t width @ defined(op_type, obj, pushval)(v)(val) */
rb_num_t
attr_width_defined(
    MAYBE_UNUSED(rb_num_t op_type),
    MAYBE_UNUSED(VALUE obj),
    MAYBE_UNUSED(VALUE pushval)
)
{
    return 4;
}

/* attr enum ruby_vminsn_type bin @ checkmatch(flag)(target, pattern)(result) */
enum ruby_vminsn_type
attr_bin_checkmatch(MAYBE_UNUSED(rb_num_t flag))
{
    return BIN(checkmatch);
}

/* attr bool handles_sp @ checkmatch(flag)(target, pattern)(result) */
bool
attr_handles_sp_checkmatch(MAYBE_UNUSED(rb_num_t flag))
{
    return false;
}

/* attr bool leaf @ checkmatch(flag)(target, pattern)(result) */
bool
attr_leaf_checkmatch(MAYBE_UNUSED(rb_num_t flag))
{
    return
#line 674 "insns.def"
leafness_of_checkmatch(flag);
#line 4533 "insns_info.inc"
}

/* attr const char* name @ checkmatch(flag)(target, pattern)(result) */
const char*
attr_name_checkmatch(MAYBE_UNUSED(rb_num_t flag))
{
    return insn_name(BIN(checkmatch));
}

/* attr rb_num_t open @ checkmatch(flag)(target, pattern)(result) */
rb_num_t
attr_open_checkmatch(MAYBE_UNUSED(rb_num_t flag))
{
    return 1;
}

/* attr rb_num_t popn @ checkmatch(flag)(target, pattern)(result) */
rb_num_t
attr_popn_checkmatch(MAYBE_UNUSED(rb_num_t flag))
{
    return 2;
}

/* attr rb_num_t retn @ checkmatch(flag)(target, pattern)(result) */
rb_num_t
attr_retn_checkmatch(MAYBE_UNUSED(rb_num_t flag))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ checkmatch(flag)(target, pattern)(result) */
rb_snum_t
attr_sp_inc_checkmatch(MAYBE_UNUSED(rb_num_t flag))
{
    return -1;
}

/* attr rb_num_t width @ checkmatch(flag)(target, pattern)(result) */
rb_num_t
attr_width_checkmatch(MAYBE_UNUSED(rb_num_t flag))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ checkkeyword(kw_bits_index, keyword_index)()(ret) */
enum ruby_vminsn_type
attr_bin_checkkeyword(
    MAYBE_UNUSED(lindex_t kw_bits_index),
    MAYBE_UNUSED(lindex_t keyword_index)
)
{
    return BIN(checkkeyword);
}

/* attr bool handles_sp @ checkkeyword(kw_bits_index, keyword_index)()(ret) */
bool
attr_handles_sp_checkkeyword(
    MAYBE_UNUSED(lindex_t kw_bits_index),
    MAYBE_UNUSED(lindex_t keyword_index)
)
{
    return false;
}

/* attr bool leaf @ checkkeyword(kw_bits_index, keyword_index)()(ret) */
bool
attr_leaf_checkkeyword(
    MAYBE_UNUSED(lindex_t kw_bits_index),
    MAYBE_UNUSED(lindex_t keyword_index)
)
{
    return true;
}

/* attr const char* name @ checkkeyword(kw_bits_index, keyword_index)()(ret) */
const char*
attr_name_checkkeyword(
    MAYBE_UNUSED(lindex_t kw_bits_index),
    MAYBE_UNUSED(lindex_t keyword_index)
)
{
    return insn_name(BIN(checkkeyword));
}

/* attr rb_num_t open @ checkkeyword(kw_bits_index, keyword_index)()(ret) */
rb_num_t
attr_open_checkkeyword(
    MAYBE_UNUSED(lindex_t kw_bits_index),
    MAYBE_UNUSED(lindex_t keyword_index)
)
{
    return 2;
}

/* attr rb_num_t popn @ checkkeyword(kw_bits_index, keyword_index)()(ret) */
rb_num_t
attr_popn_checkkeyword(
    MAYBE_UNUSED(lindex_t kw_bits_index),
    MAYBE_UNUSED(lindex_t keyword_index)
)
{
    return 0;
}

/* attr rb_num_t retn @ checkkeyword(kw_bits_index, keyword_index)()(ret) */
rb_num_t
attr_retn_checkkeyword(
    MAYBE_UNUSED(lindex_t kw_bits_index),
    MAYBE_UNUSED(lindex_t keyword_index)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ checkkeyword(kw_bits_index, keyword_index)()(ret) */
rb_snum_t
attr_sp_inc_checkkeyword(
    MAYBE_UNUSED(lindex_t kw_bits_index),
    MAYBE_UNUSED(lindex_t keyword_index)
)
{
    return 1;
}

/* attr rb_num_t width @ checkkeyword(kw_bits_index, keyword_index)()(ret) */
rb_num_t
attr_width_checkkeyword(
    MAYBE_UNUSED(lindex_t kw_bits_index),
    MAYBE_UNUSED(lindex_t keyword_index)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ checktype(type)(val)(ret) */
enum ruby_vminsn_type
attr_bin_checktype(MAYBE_UNUSED(rb_num_t type))
{
    return BIN(checktype);
}

/* attr bool handles_sp @ checktype(type)(val)(ret) */
bool
attr_handles_sp_checktype(MAYBE_UNUSED(rb_num_t type))
{
    return false;
}

/* attr bool leaf @ checktype(type)(val)(ret) */
bool
attr_leaf_checktype(MAYBE_UNUSED(rb_num_t type))
{
    return true;
}

/* attr const char* name @ checktype(type)(val)(ret) */
const char*
attr_name_checktype(MAYBE_UNUSED(rb_num_t type))
{
    return insn_name(BIN(checktype));
}

/* attr rb_num_t open @ checktype(type)(val)(ret) */
rb_num_t
attr_open_checktype(MAYBE_UNUSED(rb_num_t type))
{
    return 1;
}

/* attr rb_num_t popn @ checktype(type)(val)(ret) */
rb_num_t
attr_popn_checktype(MAYBE_UNUSED(rb_num_t type))
{
    return 1;
}

/* attr rb_num_t retn @ checktype(type)(val)(ret) */
rb_num_t
attr_retn_checktype(MAYBE_UNUSED(rb_num_t type))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ checktype(type)(val)(ret) */
rb_snum_t
attr_sp_inc_checktype(MAYBE_UNUSED(rb_num_t type))
{
    return 0;
}

/* attr rb_num_t width @ checktype(type)(val)(ret) */
rb_num_t
attr_width_checktype(MAYBE_UNUSED(rb_num_t type))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ defineclass(id, class_iseq, flags)(cbase, super)(val) */
enum ruby_vminsn_type
attr_bin_defineclass(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(ISEQ class_iseq),
    MAYBE_UNUSED(rb_num_t flags)
)
{
    return BIN(defineclass);
}

/* attr bool handles_sp @ defineclass(id, class_iseq, flags)(cbase, super)(val) */
bool
attr_handles_sp_defineclass(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(ISEQ class_iseq),
    MAYBE_UNUSED(rb_num_t flags)
)
{
    return true;
}

/* attr bool leaf @ defineclass(id, class_iseq, flags)(cbase, super)(val) */
bool
attr_leaf_defineclass(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(ISEQ class_iseq),
    MAYBE_UNUSED(rb_num_t flags)
)
{
    return false;
}

/* attr const char* name @ defineclass(id, class_iseq, flags)(cbase, super)(val) */
const char*
attr_name_defineclass(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(ISEQ class_iseq),
    MAYBE_UNUSED(rb_num_t flags)
)
{
    return insn_name(BIN(defineclass));
}

/* attr rb_num_t open @ defineclass(id, class_iseq, flags)(cbase, super)(val) */
rb_num_t
attr_open_defineclass(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(ISEQ class_iseq),
    MAYBE_UNUSED(rb_num_t flags)
)
{
    return 3;
}

/* attr rb_num_t popn @ defineclass(id, class_iseq, flags)(cbase, super)(val) */
rb_num_t
attr_popn_defineclass(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(ISEQ class_iseq),
    MAYBE_UNUSED(rb_num_t flags)
)
{
    return 2;
}

/* attr rb_num_t retn @ defineclass(id, class_iseq, flags)(cbase, super)(val) */
rb_num_t
attr_retn_defineclass(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(ISEQ class_iseq),
    MAYBE_UNUSED(rb_num_t flags)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ defineclass(id, class_iseq, flags)(cbase, super)(val) */
rb_snum_t
attr_sp_inc_defineclass(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(ISEQ class_iseq),
    MAYBE_UNUSED(rb_num_t flags)
)
{
    return -1;
}

/* attr rb_num_t width @ defineclass(id, class_iseq, flags)(cbase, super)(val) */
rb_num_t
attr_width_defineclass(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(ISEQ class_iseq),
    MAYBE_UNUSED(rb_num_t flags)
)
{
    return 4;
}

/* attr enum ruby_vminsn_type bin @ definemethod(id, iseq)()() */
enum ruby_vminsn_type
attr_bin_definemethod(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(ISEQ iseq)
)
{
    return BIN(definemethod);
}

/* attr bool handles_sp @ definemethod(id, iseq)()() */
bool
attr_handles_sp_definemethod(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(ISEQ iseq)
)
{
    return true;
}

/* attr bool leaf @ definemethod(id, iseq)()() */
bool
attr_leaf_definemethod(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(ISEQ iseq)
)
{
    return false;
}

/* attr const char* name @ definemethod(id, iseq)()() */
const char*
attr_name_definemethod(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(ISEQ iseq)
)
{
    return insn_name(BIN(definemethod));
}

/* attr rb_num_t open @ definemethod(id, iseq)()() */
rb_num_t
attr_open_definemethod(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(ISEQ iseq)
)
{
    return 2;
}

/* attr rb_num_t popn @ definemethod(id, iseq)()() */
rb_num_t
attr_popn_definemethod(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(ISEQ iseq)
)
{
    return 0;
}

/* attr rb_num_t retn @ definemethod(id, iseq)()() */
rb_num_t
attr_retn_definemethod(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(ISEQ iseq)
)
{
    return 0;
}

/* attr rb_snum_t sp_inc @ definemethod(id, iseq)()() */
rb_snum_t
attr_sp_inc_definemethod(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(ISEQ iseq)
)
{
    return 0;
}

/* attr rb_num_t width @ definemethod(id, iseq)()() */
rb_num_t
attr_width_definemethod(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(ISEQ iseq)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ definesmethod(id, iseq)(obj)() */
enum ruby_vminsn_type
attr_bin_definesmethod(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(ISEQ iseq)
)
{
    return BIN(definesmethod);
}

/* attr bool handles_sp @ definesmethod(id, iseq)(obj)() */
bool
attr_handles_sp_definesmethod(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(ISEQ iseq)
)
{
    return true;
}

/* attr bool leaf @ definesmethod(id, iseq)(obj)() */
bool
attr_leaf_definesmethod(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(ISEQ iseq)
)
{
    return false;
}

/* attr const char* name @ definesmethod(id, iseq)(obj)() */
const char*
attr_name_definesmethod(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(ISEQ iseq)
)
{
    return insn_name(BIN(definesmethod));
}

/* attr rb_num_t open @ definesmethod(id, iseq)(obj)() */
rb_num_t
attr_open_definesmethod(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(ISEQ iseq)
)
{
    return 2;
}

/* attr rb_num_t popn @ definesmethod(id, iseq)(obj)() */
rb_num_t
attr_popn_definesmethod(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(ISEQ iseq)
)
{
    return 1;
}

/* attr rb_num_t retn @ definesmethod(id, iseq)(obj)() */
rb_num_t
attr_retn_definesmethod(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(ISEQ iseq)
)
{
    return 0;
}

/* attr rb_snum_t sp_inc @ definesmethod(id, iseq)(obj)() */
rb_snum_t
attr_sp_inc_definesmethod(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(ISEQ iseq)
)
{
    return -1;
}

/* attr rb_num_t width @ definesmethod(id, iseq)(obj)() */
rb_num_t
attr_width_definesmethod(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(ISEQ iseq)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ send(cd, blockiseq)(...)(val) */
enum ruby_vminsn_type
attr_bin_send(
    MAYBE_UNUSED(CALL_DATA cd),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return BIN(send);
}

/* attr rb_snum_t comptime_sp_inc @ send(cd, blockiseq)(...)(val) */
rb_snum_t
attr_comptime_sp_inc_send(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return
#line 756 "insns.def"
sp_inc_of_sendish(ci);
#line 5030 "insns_info.inc"
}

/* attr bool handles_sp @ send(cd, blockiseq)(...)(val) */
bool
attr_handles_sp_send(
    MAYBE_UNUSED(CALL_DATA cd),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return true;
}

/* attr bool leaf @ send(cd, blockiseq)(...)(val) */
bool
attr_leaf_send(
    MAYBE_UNUSED(CALL_DATA cd),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return false;
}

/* attr const char* name @ send(cd, blockiseq)(...)(val) */
const char*
attr_name_send(
    MAYBE_UNUSED(CALL_DATA cd),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return insn_name(BIN(send));
}

/* attr rb_num_t open @ send(cd, blockiseq)(...)(val) */
rb_num_t
attr_open_send(
    MAYBE_UNUSED(CALL_DATA cd),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return 2;
}

/* attr rb_num_t popn @ send(cd, blockiseq)(...)(val) */
rb_num_t
attr_popn_send(
    MAYBE_UNUSED(CALL_DATA cd),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return 0;
}

/* attr rb_num_t retn @ send(cd, blockiseq)(...)(val) */
rb_num_t
attr_retn_send(
    MAYBE_UNUSED(CALL_DATA cd),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ send(cd, blockiseq)(...)(val) */
rb_snum_t
attr_sp_inc_send(
    MAYBE_UNUSED(CALL_DATA cd),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return
#line 755 "insns.def"
sp_inc_of_sendish(cd->ci);
#line 5103 "insns_info.inc"
}

/* attr rb_num_t width @ send(cd, blockiseq)(...)(val) */
rb_num_t
attr_width_send(
    MAYBE_UNUSED(CALL_DATA cd),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ opt_send_without_block(cd)(...)(val) */
enum ruby_vminsn_type
attr_bin_opt_send_without_block(MAYBE_UNUSED(CALL_DATA cd))
{
    return BIN(opt_send_without_block);
}

/* attr rb_snum_t comptime_sp_inc @ opt_send_without_block(cd)(...)(val) */
rb_snum_t
attr_comptime_sp_inc_opt_send_without_block(MAYBE_UNUSED(CALL_INFO ci))
{
    return
#line 775 "insns.def"
sp_inc_of_sendish(ci);
#line 5130 "insns_info.inc"
}

/* attr bool handles_sp @ opt_send_without_block(cd)(...)(val) */
bool
attr_handles_sp_opt_send_without_block(MAYBE_UNUSED(CALL_DATA cd))
{
    return
#line 773 "insns.def"
true;
#line 5140 "insns_info.inc"
}

/* attr bool leaf @ opt_send_without_block(cd)(...)(val) */
bool
attr_leaf_opt_send_without_block(MAYBE_UNUSED(CALL_DATA cd))
{
    return ! attr_handles_sp_opt_send_without_block(cd);
}

/* attr const char* name @ opt_send_without_block(cd)(...)(val) */
const char*
attr_name_opt_send_without_block(MAYBE_UNUSED(CALL_DATA cd))
{
    return insn_name(BIN(opt_send_without_block));
}

/* attr rb_num_t open @ opt_send_without_block(cd)(...)(val) */
rb_num_t
attr_open_opt_send_without_block(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_num_t popn @ opt_send_without_block(cd)(...)(val) */
rb_num_t
attr_popn_opt_send_without_block(MAYBE_UNUSED(CALL_DATA cd))
{
    return 0;
}

/* attr rb_num_t retn @ opt_send_without_block(cd)(...)(val) */
rb_num_t
attr_retn_opt_send_without_block(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_send_without_block(cd)(...)(val) */
rb_snum_t
attr_sp_inc_opt_send_without_block(MAYBE_UNUSED(CALL_DATA cd))
{
    return
#line 774 "insns.def"
sp_inc_of_sendish(cd->ci);
#line 5185 "insns_info.inc"
}

/* attr rb_num_t width @ opt_send_without_block(cd)(...)(val) */
rb_num_t
attr_width_opt_send_without_block(MAYBE_UNUSED(CALL_DATA cd))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ objtostring(cd)(recv)(val) */
enum ruby_vminsn_type
attr_bin_objtostring(MAYBE_UNUSED(CALL_DATA cd))
{
    return BIN(objtostring);
}

/* attr bool handles_sp @ objtostring(cd)(recv)(val) */
bool
attr_handles_sp_objtostring(MAYBE_UNUSED(CALL_DATA cd))
{
    return false;
}

/* attr bool leaf @ objtostring(cd)(recv)(val) */
bool
attr_leaf_objtostring(MAYBE_UNUSED(CALL_DATA cd))
{
    return
#line 792 "insns.def"
false;
#line 5216 "insns_info.inc"
}

/* attr const char* name @ objtostring(cd)(recv)(val) */
const char*
attr_name_objtostring(MAYBE_UNUSED(CALL_DATA cd))
{
    return insn_name(BIN(objtostring));
}

/* attr rb_num_t open @ objtostring(cd)(recv)(val) */
rb_num_t
attr_open_objtostring(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_num_t popn @ objtostring(cd)(recv)(val) */
rb_num_t
attr_popn_objtostring(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_num_t retn @ objtostring(cd)(recv)(val) */
rb_num_t
attr_retn_objtostring(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ objtostring(cd)(recv)(val) */
rb_snum_t
attr_sp_inc_objtostring(MAYBE_UNUSED(CALL_DATA cd))
{
    return 0;
}

/* attr rb_num_t width @ objtostring(cd)(recv)(val) */
rb_num_t
attr_width_objtostring(MAYBE_UNUSED(CALL_DATA cd))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ opt_str_freeze(str, cd)()(val) */
enum ruby_vminsn_type
attr_bin_opt_str_freeze(
    MAYBE_UNUSED(VALUE str),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return BIN(opt_str_freeze);
}

/* attr bool handles_sp @ opt_str_freeze(str, cd)()(val) */
bool
attr_handles_sp_opt_str_freeze(
    MAYBE_UNUSED(VALUE str),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return false;
}

/* attr bool leaf @ opt_str_freeze(str, cd)()(val) */
bool
attr_leaf_opt_str_freeze(
    MAYBE_UNUSED(VALUE str),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return true;
}

/* attr const char* name @ opt_str_freeze(str, cd)()(val) */
const char*
attr_name_opt_str_freeze(
    MAYBE_UNUSED(VALUE str),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return insn_name(BIN(opt_str_freeze));
}

/* attr rb_num_t open @ opt_str_freeze(str, cd)()(val) */
rb_num_t
attr_open_opt_str_freeze(
    MAYBE_UNUSED(VALUE str),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return 2;
}

/* attr rb_num_t popn @ opt_str_freeze(str, cd)()(val) */
rb_num_t
attr_popn_opt_str_freeze(
    MAYBE_UNUSED(VALUE str),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return 0;
}

/* attr rb_num_t retn @ opt_str_freeze(str, cd)()(val) */
rb_num_t
attr_retn_opt_str_freeze(
    MAYBE_UNUSED(VALUE str),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_str_freeze(str, cd)()(val) */
rb_snum_t
attr_sp_inc_opt_str_freeze(
    MAYBE_UNUSED(VALUE str),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return 1;
}

/* attr rb_num_t width @ opt_str_freeze(str, cd)()(val) */
rb_num_t
attr_width_opt_str_freeze(
    MAYBE_UNUSED(VALUE str),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ opt_nil_p(cd)(recv)(val) */
enum ruby_vminsn_type
attr_bin_opt_nil_p(MAYBE_UNUSED(CALL_DATA cd))
{
    return BIN(opt_nil_p);
}

/* attr bool handles_sp @ opt_nil_p(cd)(recv)(val) */
bool
attr_handles_sp_opt_nil_p(MAYBE_UNUSED(CALL_DATA cd))
{
    return false;
}

/* attr bool leaf @ opt_nil_p(cd)(recv)(val) */
bool
attr_leaf_opt_nil_p(MAYBE_UNUSED(CALL_DATA cd))
{
    return true;
}

/* attr const char* name @ opt_nil_p(cd)(recv)(val) */
const char*
attr_name_opt_nil_p(MAYBE_UNUSED(CALL_DATA cd))
{
    return insn_name(BIN(opt_nil_p));
}

/* attr rb_num_t open @ opt_nil_p(cd)(recv)(val) */
rb_num_t
attr_open_opt_nil_p(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_num_t popn @ opt_nil_p(cd)(recv)(val) */
rb_num_t
attr_popn_opt_nil_p(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_num_t retn @ opt_nil_p(cd)(recv)(val) */
rb_num_t
attr_retn_opt_nil_p(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_nil_p(cd)(recv)(val) */
rb_snum_t
attr_sp_inc_opt_nil_p(MAYBE_UNUSED(CALL_DATA cd))
{
    return 0;
}

/* attr rb_num_t width @ opt_nil_p(cd)(recv)(val) */
rb_num_t
attr_width_opt_nil_p(MAYBE_UNUSED(CALL_DATA cd))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ opt_str_uminus(str, cd)()(val) */
enum ruby_vminsn_type
attr_bin_opt_str_uminus(
    MAYBE_UNUSED(VALUE str),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return BIN(opt_str_uminus);
}

/* attr bool handles_sp @ opt_str_uminus(str, cd)()(val) */
bool
attr_handles_sp_opt_str_uminus(
    MAYBE_UNUSED(VALUE str),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return false;
}

/* attr bool leaf @ opt_str_uminus(str, cd)()(val) */
bool
attr_leaf_opt_str_uminus(
    MAYBE_UNUSED(VALUE str),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return true;
}

/* attr const char* name @ opt_str_uminus(str, cd)()(val) */
const char*
attr_name_opt_str_uminus(
    MAYBE_UNUSED(VALUE str),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return insn_name(BIN(opt_str_uminus));
}

/* attr rb_num_t open @ opt_str_uminus(str, cd)()(val) */
rb_num_t
attr_open_opt_str_uminus(
    MAYBE_UNUSED(VALUE str),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return 2;
}

/* attr rb_num_t popn @ opt_str_uminus(str, cd)()(val) */
rb_num_t
attr_popn_opt_str_uminus(
    MAYBE_UNUSED(VALUE str),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return 0;
}

/* attr rb_num_t retn @ opt_str_uminus(str, cd)()(val) */
rb_num_t
attr_retn_opt_str_uminus(
    MAYBE_UNUSED(VALUE str),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_str_uminus(str, cd)()(val) */
rb_snum_t
attr_sp_inc_opt_str_uminus(
    MAYBE_UNUSED(VALUE str),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return 1;
}

/* attr rb_num_t width @ opt_str_uminus(str, cd)()(val) */
rb_num_t
attr_width_opt_str_uminus(
    MAYBE_UNUSED(VALUE str),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ opt_newarray_max(num)(...)(val) */
enum ruby_vminsn_type
attr_bin_opt_newarray_max(MAYBE_UNUSED(rb_num_t num))
{
    return BIN(opt_newarray_max);
}

/* attr bool handles_sp @ opt_newarray_max(num)(...)(val) */
bool
attr_handles_sp_opt_newarray_max(MAYBE_UNUSED(rb_num_t num))
{
    return false;
}

/* attr bool leaf @ opt_newarray_max(num)(...)(val) */
bool
attr_leaf_opt_newarray_max(MAYBE_UNUSED(rb_num_t num))
{
    return
#line 852 "insns.def"
false;
#line 5525 "insns_info.inc"
}

/* attr const char* name @ opt_newarray_max(num)(...)(val) */
const char*
attr_name_opt_newarray_max(MAYBE_UNUSED(rb_num_t num))
{
    return insn_name(BIN(opt_newarray_max));
}

/* attr rb_num_t open @ opt_newarray_max(num)(...)(val) */
rb_num_t
attr_open_opt_newarray_max(MAYBE_UNUSED(rb_num_t num))
{
    return 1;
}

/* attr rb_num_t popn @ opt_newarray_max(num)(...)(val) */
rb_num_t
attr_popn_opt_newarray_max(MAYBE_UNUSED(rb_num_t num))
{
    return 0;
}

/* attr rb_num_t retn @ opt_newarray_max(num)(...)(val) */
rb_num_t
attr_retn_opt_newarray_max(MAYBE_UNUSED(rb_num_t num))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_newarray_max(num)(...)(val) */
rb_snum_t
attr_sp_inc_opt_newarray_max(MAYBE_UNUSED(rb_num_t num))
{
    return
#line 853 "insns.def"
1 - (rb_snum_t)num;
#line 5563 "insns_info.inc"
}

/* attr rb_num_t width @ opt_newarray_max(num)(...)(val) */
rb_num_t
attr_width_opt_newarray_max(MAYBE_UNUSED(rb_num_t num))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ opt_newarray_min(num)(...)(val) */
enum ruby_vminsn_type
attr_bin_opt_newarray_min(MAYBE_UNUSED(rb_num_t num))
{
    return BIN(opt_newarray_min);
}

/* attr bool handles_sp @ opt_newarray_min(num)(...)(val) */
bool
attr_handles_sp_opt_newarray_min(MAYBE_UNUSED(rb_num_t num))
{
    return false;
}

/* attr bool leaf @ opt_newarray_min(num)(...)(val) */
bool
attr_leaf_opt_newarray_min(MAYBE_UNUSED(rb_num_t num))
{
    return
#line 864 "insns.def"
false;
#line 5594 "insns_info.inc"
}

/* attr const char* name @ opt_newarray_min(num)(...)(val) */
const char*
attr_name_opt_newarray_min(MAYBE_UNUSED(rb_num_t num))
{
    return insn_name(BIN(opt_newarray_min));
}

/* attr rb_num_t open @ opt_newarray_min(num)(...)(val) */
rb_num_t
attr_open_opt_newarray_min(MAYBE_UNUSED(rb_num_t num))
{
    return 1;
}

/* attr rb_num_t popn @ opt_newarray_min(num)(...)(val) */
rb_num_t
attr_popn_opt_newarray_min(MAYBE_UNUSED(rb_num_t num))
{
    return 0;
}

/* attr rb_num_t retn @ opt_newarray_min(num)(...)(val) */
rb_num_t
attr_retn_opt_newarray_min(MAYBE_UNUSED(rb_num_t num))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_newarray_min(num)(...)(val) */
rb_snum_t
attr_sp_inc_opt_newarray_min(MAYBE_UNUSED(rb_num_t num))
{
    return
#line 865 "insns.def"
1 - (rb_snum_t)num;
#line 5632 "insns_info.inc"
}

/* attr rb_num_t width @ opt_newarray_min(num)(...)(val) */
rb_num_t
attr_width_opt_newarray_min(MAYBE_UNUSED(rb_num_t num))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ invokesuper(cd, blockiseq)(...)(val) */
enum ruby_vminsn_type
attr_bin_invokesuper(
    MAYBE_UNUSED(CALL_DATA cd),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return BIN(invokesuper);
}

/* attr rb_snum_t comptime_sp_inc @ invokesuper(cd, blockiseq)(...)(val) */
rb_snum_t
attr_comptime_sp_inc_invokesuper(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return
#line 877 "insns.def"
sp_inc_of_sendish(ci);
#line 5662 "insns_info.inc"
}

/* attr bool handles_sp @ invokesuper(cd, blockiseq)(...)(val) */
bool
attr_handles_sp_invokesuper(
    MAYBE_UNUSED(CALL_DATA cd),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return true;
}

/* attr bool leaf @ invokesuper(cd, blockiseq)(...)(val) */
bool
attr_leaf_invokesuper(
    MAYBE_UNUSED(CALL_DATA cd),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return false;
}

/* attr const char* name @ invokesuper(cd, blockiseq)(...)(val) */
const char*
attr_name_invokesuper(
    MAYBE_UNUSED(CALL_DATA cd),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return insn_name(BIN(invokesuper));
}

/* attr rb_num_t open @ invokesuper(cd, blockiseq)(...)(val) */
rb_num_t
attr_open_invokesuper(
    MAYBE_UNUSED(CALL_DATA cd),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return 2;
}

/* attr rb_num_t popn @ invokesuper(cd, blockiseq)(...)(val) */
rb_num_t
attr_popn_invokesuper(
    MAYBE_UNUSED(CALL_DATA cd),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return 0;
}

/* attr rb_num_t retn @ invokesuper(cd, blockiseq)(...)(val) */
rb_num_t
attr_retn_invokesuper(
    MAYBE_UNUSED(CALL_DATA cd),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ invokesuper(cd, blockiseq)(...)(val) */
rb_snum_t
attr_sp_inc_invokesuper(
    MAYBE_UNUSED(CALL_DATA cd),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return
#line 876 "insns.def"
sp_inc_of_sendish(cd->ci);
#line 5735 "insns_info.inc"
}

/* attr rb_num_t width @ invokesuper(cd, blockiseq)(...)(val) */
rb_num_t
attr_width_invokesuper(
    MAYBE_UNUSED(CALL_DATA cd),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ invokeblock(cd)(...)(val) */
enum ruby_vminsn_type
attr_bin_invokeblock(MAYBE_UNUSED(CALL_DATA cd))
{
    return BIN(invokeblock);
}

/* attr rb_snum_t comptime_sp_inc @ invokeblock(cd)(...)(val) */
rb_snum_t
attr_comptime_sp_inc_invokeblock(MAYBE_UNUSED(CALL_INFO ci))
{
    return
#line 896 "insns.def"
sp_inc_of_invokeblock(ci);
#line 5762 "insns_info.inc"
}

/* attr bool handles_sp @ invokeblock(cd)(...)(val) */
bool
attr_handles_sp_invokeblock(MAYBE_UNUSED(CALL_DATA cd))
{
    return
#line 894 "insns.def"
true;
#line 5772 "insns_info.inc"
}

/* attr bool leaf @ invokeblock(cd)(...)(val) */
bool
attr_leaf_invokeblock(MAYBE_UNUSED(CALL_DATA cd))
{
    return ! attr_handles_sp_invokeblock(cd);
}

/* attr const char* name @ invokeblock(cd)(...)(val) */
const char*
attr_name_invokeblock(MAYBE_UNUSED(CALL_DATA cd))
{
    return insn_name(BIN(invokeblock));
}

/* attr rb_num_t open @ invokeblock(cd)(...)(val) */
rb_num_t
attr_open_invokeblock(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_num_t popn @ invokeblock(cd)(...)(val) */
rb_num_t
attr_popn_invokeblock(MAYBE_UNUSED(CALL_DATA cd))
{
    return 0;
}

/* attr rb_num_t retn @ invokeblock(cd)(...)(val) */
rb_num_t
attr_retn_invokeblock(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ invokeblock(cd)(...)(val) */
rb_snum_t
attr_sp_inc_invokeblock(MAYBE_UNUSED(CALL_DATA cd))
{
    return
#line 895 "insns.def"
sp_inc_of_invokeblock(cd->ci);
#line 5817 "insns_info.inc"
}

/* attr rb_num_t width @ invokeblock(cd)(...)(val) */
rb_num_t
attr_width_invokeblock(MAYBE_UNUSED(CALL_DATA cd))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ leave()(val)(val) */
enum ruby_vminsn_type
attr_bin_leave(void)
{
    return BIN(leave);
}

/* attr bool handles_sp @ leave()(val)(val) */
bool
attr_handles_sp_leave(void)
{
    return
#line 917 "insns.def"
true;
#line 5841 "insns_info.inc"
}

/* attr bool leaf @ leave()(val)(val) */
bool
attr_leaf_leave(void)
{
    return
#line 916 "insns.def"
false;
#line 5851 "insns_info.inc"
}

/* attr const char* name @ leave()(val)(val) */
const char*
attr_name_leave(void)
{
    return insn_name(BIN(leave));
}

/* attr rb_num_t open @ leave()(val)(val) */
rb_num_t
attr_open_leave(void)
{
    return 0;
}

/* attr rb_num_t popn @ leave()(val)(val) */
rb_num_t
attr_popn_leave(void)
{
    return 1;
}

/* attr rb_num_t retn @ leave()(val)(val) */
rb_num_t
attr_retn_leave(void)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ leave()(val)(val) */
rb_snum_t
attr_sp_inc_leave(void)
{
    return 0;
}

/* attr rb_num_t width @ leave()(val)(val) */
rb_num_t
attr_width_leave(void)
{
    return 1;
}

/* attr enum ruby_vminsn_type bin @ throw(throw_state)(throwobj)(val) */
enum ruby_vminsn_type
attr_bin_throw(MAYBE_UNUSED(rb_num_t throw_state))
{
    return BIN(throw);
}

/* attr bool handles_sp @ throw(throw_state)(throwobj)(val) */
bool
attr_handles_sp_throw(MAYBE_UNUSED(rb_num_t throw_state))
{
    return false;
}

/* attr bool leaf @ throw(throw_state)(throwobj)(val) */
bool
attr_leaf_throw(MAYBE_UNUSED(rb_num_t throw_state))
{
    return
#line 950 "insns.def"
false;
#line 5917 "insns_info.inc"
}

/* attr const char* name @ throw(throw_state)(throwobj)(val) */
const char*
attr_name_throw(MAYBE_UNUSED(rb_num_t throw_state))
{
    return insn_name(BIN(throw));
}

/* attr rb_num_t open @ throw(throw_state)(throwobj)(val) */
rb_num_t
attr_open_throw(MAYBE_UNUSED(rb_num_t throw_state))
{
    return 1;
}

/* attr rb_num_t popn @ throw(throw_state)(throwobj)(val) */
rb_num_t
attr_popn_throw(MAYBE_UNUSED(rb_num_t throw_state))
{
    return 1;
}

/* attr rb_num_t retn @ throw(throw_state)(throwobj)(val) */
rb_num_t
attr_retn_throw(MAYBE_UNUSED(rb_num_t throw_state))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ throw(throw_state)(throwobj)(val) */
rb_snum_t
attr_sp_inc_throw(MAYBE_UNUSED(rb_num_t throw_state))
{
    return 0;
}

/* attr rb_num_t width @ throw(throw_state)(throwobj)(val) */
rb_num_t
attr_width_throw(MAYBE_UNUSED(rb_num_t throw_state))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ jump(dst)()() */
enum ruby_vminsn_type
attr_bin_jump(MAYBE_UNUSED(OFFSET dst))
{
    return BIN(jump);
}

/* attr bool handles_sp @ jump(dst)()() */
bool
attr_handles_sp_jump(MAYBE_UNUSED(OFFSET dst))
{
    return false;
}

/* attr bool leaf @ jump(dst)()() */
bool
attr_leaf_jump(MAYBE_UNUSED(OFFSET dst))
{
    return
#line 968 "insns.def"
leafness_of_check_ints;
#line 5983 "insns_info.inc"
}

/* attr const char* name @ jump(dst)()() */
const char*
attr_name_jump(MAYBE_UNUSED(OFFSET dst))
{
    return insn_name(BIN(jump));
}

/* attr rb_num_t open @ jump(dst)()() */
rb_num_t
attr_open_jump(MAYBE_UNUSED(OFFSET dst))
{
    return 1;
}

/* attr rb_num_t popn @ jump(dst)()() */
rb_num_t
attr_popn_jump(MAYBE_UNUSED(OFFSET dst))
{
    return 0;
}

/* attr rb_num_t retn @ jump(dst)()() */
rb_num_t
attr_retn_jump(MAYBE_UNUSED(OFFSET dst))
{
    return 0;
}

/* attr rb_snum_t sp_inc @ jump(dst)()() */
rb_snum_t
attr_sp_inc_jump(MAYBE_UNUSED(OFFSET dst))
{
    return 0;
}

/* attr rb_num_t width @ jump(dst)()() */
rb_num_t
attr_width_jump(MAYBE_UNUSED(OFFSET dst))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ branchif(dst)(val)() */
enum ruby_vminsn_type
attr_bin_branchif(MAYBE_UNUSED(OFFSET dst))
{
    return BIN(branchif);
}

/* attr bool handles_sp @ branchif(dst)(val)() */
bool
attr_handles_sp_branchif(MAYBE_UNUSED(OFFSET dst))
{
    return false;
}

/* attr bool leaf @ branchif(dst)(val)() */
bool
attr_leaf_branchif(MAYBE_UNUSED(OFFSET dst))
{
    return
#line 981 "insns.def"
leafness_of_check_ints;
#line 6049 "insns_info.inc"
}

/* attr const char* name @ branchif(dst)(val)() */
const char*
attr_name_branchif(MAYBE_UNUSED(OFFSET dst))
{
    return insn_name(BIN(branchif));
}

/* attr rb_num_t open @ branchif(dst)(val)() */
rb_num_t
attr_open_branchif(MAYBE_UNUSED(OFFSET dst))
{
    return 1;
}

/* attr rb_num_t popn @ branchif(dst)(val)() */
rb_num_t
attr_popn_branchif(MAYBE_UNUSED(OFFSET dst))
{
    return 1;
}

/* attr rb_num_t retn @ branchif(dst)(val)() */
rb_num_t
attr_retn_branchif(MAYBE_UNUSED(OFFSET dst))
{
    return 0;
}

/* attr rb_snum_t sp_inc @ branchif(dst)(val)() */
rb_snum_t
attr_sp_inc_branchif(MAYBE_UNUSED(OFFSET dst))
{
    return -1;
}

/* attr rb_num_t width @ branchif(dst)(val)() */
rb_num_t
attr_width_branchif(MAYBE_UNUSED(OFFSET dst))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ branchunless(dst)(val)() */
enum ruby_vminsn_type
attr_bin_branchunless(MAYBE_UNUSED(OFFSET dst))
{
    return BIN(branchunless);
}

/* attr bool handles_sp @ branchunless(dst)(val)() */
bool
attr_handles_sp_branchunless(MAYBE_UNUSED(OFFSET dst))
{
    return false;
}

/* attr bool leaf @ branchunless(dst)(val)() */
bool
attr_leaf_branchunless(MAYBE_UNUSED(OFFSET dst))
{
    return
#line 996 "insns.def"
leafness_of_check_ints;
#line 6115 "insns_info.inc"
}

/* attr const char* name @ branchunless(dst)(val)() */
const char*
attr_name_branchunless(MAYBE_UNUSED(OFFSET dst))
{
    return insn_name(BIN(branchunless));
}

/* attr rb_num_t open @ branchunless(dst)(val)() */
rb_num_t
attr_open_branchunless(MAYBE_UNUSED(OFFSET dst))
{
    return 1;
}

/* attr rb_num_t popn @ branchunless(dst)(val)() */
rb_num_t
attr_popn_branchunless(MAYBE_UNUSED(OFFSET dst))
{
    return 1;
}

/* attr rb_num_t retn @ branchunless(dst)(val)() */
rb_num_t
attr_retn_branchunless(MAYBE_UNUSED(OFFSET dst))
{
    return 0;
}

/* attr rb_snum_t sp_inc @ branchunless(dst)(val)() */
rb_snum_t
attr_sp_inc_branchunless(MAYBE_UNUSED(OFFSET dst))
{
    return -1;
}

/* attr rb_num_t width @ branchunless(dst)(val)() */
rb_num_t
attr_width_branchunless(MAYBE_UNUSED(OFFSET dst))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ branchnil(dst)(val)() */
enum ruby_vminsn_type
attr_bin_branchnil(MAYBE_UNUSED(OFFSET dst))
{
    return BIN(branchnil);
}

/* attr bool handles_sp @ branchnil(dst)(val)() */
bool
attr_handles_sp_branchnil(MAYBE_UNUSED(OFFSET dst))
{
    return false;
}

/* attr bool leaf @ branchnil(dst)(val)() */
bool
attr_leaf_branchnil(MAYBE_UNUSED(OFFSET dst))
{
    return
#line 1011 "insns.def"
leafness_of_check_ints;
#line 6181 "insns_info.inc"
}

/* attr const char* name @ branchnil(dst)(val)() */
const char*
attr_name_branchnil(MAYBE_UNUSED(OFFSET dst))
{
    return insn_name(BIN(branchnil));
}

/* attr rb_num_t open @ branchnil(dst)(val)() */
rb_num_t
attr_open_branchnil(MAYBE_UNUSED(OFFSET dst))
{
    return 1;
}

/* attr rb_num_t popn @ branchnil(dst)(val)() */
rb_num_t
attr_popn_branchnil(MAYBE_UNUSED(OFFSET dst))
{
    return 1;
}

/* attr rb_num_t retn @ branchnil(dst)(val)() */
rb_num_t
attr_retn_branchnil(MAYBE_UNUSED(OFFSET dst))
{
    return 0;
}

/* attr rb_snum_t sp_inc @ branchnil(dst)(val)() */
rb_snum_t
attr_sp_inc_branchnil(MAYBE_UNUSED(OFFSET dst))
{
    return -1;
}

/* attr rb_num_t width @ branchnil(dst)(val)() */
rb_num_t
attr_width_branchnil(MAYBE_UNUSED(OFFSET dst))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ opt_getinlinecache(dst, ic)()(val) */
enum ruby_vminsn_type
attr_bin_opt_getinlinecache(
    MAYBE_UNUSED(OFFSET dst),
    MAYBE_UNUSED(IC ic)
)
{
    return BIN(opt_getinlinecache);
}

/* attr bool handles_sp @ opt_getinlinecache(dst, ic)()(val) */
bool
attr_handles_sp_opt_getinlinecache(
    MAYBE_UNUSED(OFFSET dst),
    MAYBE_UNUSED(IC ic)
)
{
    return false;
}

/* attr bool leaf @ opt_getinlinecache(dst, ic)()(val) */
bool
attr_leaf_opt_getinlinecache(
    MAYBE_UNUSED(OFFSET dst),
    MAYBE_UNUSED(IC ic)
)
{
    return true;
}

/* attr const char* name @ opt_getinlinecache(dst, ic)()(val) */
const char*
attr_name_opt_getinlinecache(
    MAYBE_UNUSED(OFFSET dst),
    MAYBE_UNUSED(IC ic)
)
{
    return insn_name(BIN(opt_getinlinecache));
}

/* attr rb_num_t open @ opt_getinlinecache(dst, ic)()(val) */
rb_num_t
attr_open_opt_getinlinecache(
    MAYBE_UNUSED(OFFSET dst),
    MAYBE_UNUSED(IC ic)
)
{
    return 2;
}

/* attr rb_num_t popn @ opt_getinlinecache(dst, ic)()(val) */
rb_num_t
attr_popn_opt_getinlinecache(
    MAYBE_UNUSED(OFFSET dst),
    MAYBE_UNUSED(IC ic)
)
{
    return 0;
}

/* attr rb_num_t retn @ opt_getinlinecache(dst, ic)()(val) */
rb_num_t
attr_retn_opt_getinlinecache(
    MAYBE_UNUSED(OFFSET dst),
    MAYBE_UNUSED(IC ic)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_getinlinecache(dst, ic)()(val) */
rb_snum_t
attr_sp_inc_opt_getinlinecache(
    MAYBE_UNUSED(OFFSET dst),
    MAYBE_UNUSED(IC ic)
)
{
    return 1;
}

/* attr rb_num_t width @ opt_getinlinecache(dst, ic)()(val) */
rb_num_t
attr_width_opt_getinlinecache(
    MAYBE_UNUSED(OFFSET dst),
    MAYBE_UNUSED(IC ic)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ opt_setinlinecache(ic)(val)(val) */
enum ruby_vminsn_type
attr_bin_opt_setinlinecache(MAYBE_UNUSED(IC ic))
{
    return BIN(opt_setinlinecache);
}

/* attr bool handles_sp @ opt_setinlinecache(ic)(val)(val) */
bool
attr_handles_sp_opt_setinlinecache(MAYBE_UNUSED(IC ic))
{
    return false;
}

/* attr bool leaf @ opt_setinlinecache(ic)(val)(val) */
bool
attr_leaf_opt_setinlinecache(MAYBE_UNUSED(IC ic))
{
    return
#line 1046 "insns.def"
false;
#line 6337 "insns_info.inc"
}

/* attr const char* name @ opt_setinlinecache(ic)(val)(val) */
const char*
attr_name_opt_setinlinecache(MAYBE_UNUSED(IC ic))
{
    return insn_name(BIN(opt_setinlinecache));
}

/* attr rb_num_t open @ opt_setinlinecache(ic)(val)(val) */
rb_num_t
attr_open_opt_setinlinecache(MAYBE_UNUSED(IC ic))
{
    return 1;
}

/* attr rb_num_t popn @ opt_setinlinecache(ic)(val)(val) */
rb_num_t
attr_popn_opt_setinlinecache(MAYBE_UNUSED(IC ic))
{
    return 1;
}

/* attr rb_num_t retn @ opt_setinlinecache(ic)(val)(val) */
rb_num_t
attr_retn_opt_setinlinecache(MAYBE_UNUSED(IC ic))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_setinlinecache(ic)(val)(val) */
rb_snum_t
attr_sp_inc_opt_setinlinecache(MAYBE_UNUSED(IC ic))
{
    return 0;
}

/* attr rb_num_t width @ opt_setinlinecache(ic)(val)(val) */
rb_num_t
attr_width_opt_setinlinecache(MAYBE_UNUSED(IC ic))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ once(iseq, ise)()(val) */
enum ruby_vminsn_type
attr_bin_once(
    MAYBE_UNUSED(ISEQ iseq),
    MAYBE_UNUSED(ISE ise)
)
{
    return BIN(once);
}

/* attr bool handles_sp @ once(iseq, ise)()(val) */
bool
attr_handles_sp_once(
    MAYBE_UNUSED(ISEQ iseq),
    MAYBE_UNUSED(ISE ise)
)
{
    return true;
}

/* attr bool leaf @ once(iseq, ise)()(val) */
bool
attr_leaf_once(
    MAYBE_UNUSED(ISEQ iseq),
    MAYBE_UNUSED(ISE ise)
)
{
    return false;
}

/* attr const char* name @ once(iseq, ise)()(val) */
const char*
attr_name_once(
    MAYBE_UNUSED(ISEQ iseq),
    MAYBE_UNUSED(ISE ise)
)
{
    return insn_name(BIN(once));
}

/* attr rb_num_t open @ once(iseq, ise)()(val) */
rb_num_t
attr_open_once(
    MAYBE_UNUSED(ISEQ iseq),
    MAYBE_UNUSED(ISE ise)
)
{
    return 2;
}

/* attr rb_num_t popn @ once(iseq, ise)()(val) */
rb_num_t
attr_popn_once(
    MAYBE_UNUSED(ISEQ iseq),
    MAYBE_UNUSED(ISE ise)
)
{
    return 0;
}

/* attr rb_num_t retn @ once(iseq, ise)()(val) */
rb_num_t
attr_retn_once(
    MAYBE_UNUSED(ISEQ iseq),
    MAYBE_UNUSED(ISE ise)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ once(iseq, ise)()(val) */
rb_snum_t
attr_sp_inc_once(
    MAYBE_UNUSED(ISEQ iseq),
    MAYBE_UNUSED(ISE ise)
)
{
    return 1;
}

/* attr rb_num_t width @ once(iseq, ise)()(val) */
rb_num_t
attr_width_once(
    MAYBE_UNUSED(ISEQ iseq),
    MAYBE_UNUSED(ISE ise)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ opt_case_dispatch(hash, else_offset)(..., key)() */
enum ruby_vminsn_type
attr_bin_opt_case_dispatch(
    MAYBE_UNUSED(CDHASH hash),
    MAYBE_UNUSED(OFFSET else_offset)
)
{
    return BIN(opt_case_dispatch);
}

/* attr bool handles_sp @ opt_case_dispatch(hash, else_offset)(..., key)() */
bool
attr_handles_sp_opt_case_dispatch(
    MAYBE_UNUSED(CDHASH hash),
    MAYBE_UNUSED(OFFSET else_offset)
)
{
    return false;
}

/* attr bool leaf @ opt_case_dispatch(hash, else_offset)(..., key)() */
bool
attr_leaf_opt_case_dispatch(
    MAYBE_UNUSED(CDHASH hash),
    MAYBE_UNUSED(OFFSET else_offset)
)
{
    return true;
}

/* attr const char* name @ opt_case_dispatch(hash, else_offset)(..., key)() */
const char*
attr_name_opt_case_dispatch(
    MAYBE_UNUSED(CDHASH hash),
    MAYBE_UNUSED(OFFSET else_offset)
)
{
    return insn_name(BIN(opt_case_dispatch));
}

/* attr rb_num_t open @ opt_case_dispatch(hash, else_offset)(..., key)() */
rb_num_t
attr_open_opt_case_dispatch(
    MAYBE_UNUSED(CDHASH hash),
    MAYBE_UNUSED(OFFSET else_offset)
)
{
    return 2;
}

/* attr rb_num_t popn @ opt_case_dispatch(hash, else_offset)(..., key)() */
rb_num_t
attr_popn_opt_case_dispatch(
    MAYBE_UNUSED(CDHASH hash),
    MAYBE_UNUSED(OFFSET else_offset)
)
{
    return 1;
}

/* attr rb_num_t retn @ opt_case_dispatch(hash, else_offset)(..., key)() */
rb_num_t
attr_retn_opt_case_dispatch(
    MAYBE_UNUSED(CDHASH hash),
    MAYBE_UNUSED(OFFSET else_offset)
)
{
    return 0;
}

/* attr rb_snum_t sp_inc @ opt_case_dispatch(hash, else_offset)(..., key)() */
rb_snum_t
attr_sp_inc_opt_case_dispatch(
    MAYBE_UNUSED(CDHASH hash),
    MAYBE_UNUSED(OFFSET else_offset)
)
{
    return
#line 1067 "insns.def"
-1;
#line 6552 "insns_info.inc"
}

/* attr rb_num_t width @ opt_case_dispatch(hash, else_offset)(..., key)() */
rb_num_t
attr_width_opt_case_dispatch(
    MAYBE_UNUSED(CDHASH hash),
    MAYBE_UNUSED(OFFSET else_offset)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ opt_plus(cd)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_plus(MAYBE_UNUSED(CALL_DATA cd))
{
    return BIN(opt_plus);
}

/* attr bool handles_sp @ opt_plus(cd)(recv, obj)(val) */
bool
attr_handles_sp_opt_plus(MAYBE_UNUSED(CALL_DATA cd))
{
    return false;
}

/* attr bool leaf @ opt_plus(cd)(recv, obj)(val) */
bool
attr_leaf_opt_plus(MAYBE_UNUSED(CALL_DATA cd))
{
    return true;
}

/* attr const char* name @ opt_plus(cd)(recv, obj)(val) */
const char*
attr_name_opt_plus(MAYBE_UNUSED(CALL_DATA cd))
{
    return insn_name(BIN(opt_plus));
}

/* attr rb_num_t open @ opt_plus(cd)(recv, obj)(val) */
rb_num_t
attr_open_opt_plus(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_num_t popn @ opt_plus(cd)(recv, obj)(val) */
rb_num_t
attr_popn_opt_plus(MAYBE_UNUSED(CALL_DATA cd))
{
    return 2;
}

/* attr rb_num_t retn @ opt_plus(cd)(recv, obj)(val) */
rb_num_t
attr_retn_opt_plus(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_plus(cd)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_plus(MAYBE_UNUSED(CALL_DATA cd))
{
    return -1;
}

/* attr rb_num_t width @ opt_plus(cd)(recv, obj)(val) */
rb_num_t
attr_width_opt_plus(MAYBE_UNUSED(CALL_DATA cd))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ opt_minus(cd)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_minus(MAYBE_UNUSED(CALL_DATA cd))
{
    return BIN(opt_minus);
}

/* attr bool handles_sp @ opt_minus(cd)(recv, obj)(val) */
bool
attr_handles_sp_opt_minus(MAYBE_UNUSED(CALL_DATA cd))
{
    return false;
}

/* attr bool leaf @ opt_minus(cd)(recv, obj)(val) */
bool
attr_leaf_opt_minus(MAYBE_UNUSED(CALL_DATA cd))
{
    return true;
}

/* attr const char* name @ opt_minus(cd)(recv, obj)(val) */
const char*
attr_name_opt_minus(MAYBE_UNUSED(CALL_DATA cd))
{
    return insn_name(BIN(opt_minus));
}

/* attr rb_num_t open @ opt_minus(cd)(recv, obj)(val) */
rb_num_t
attr_open_opt_minus(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_num_t popn @ opt_minus(cd)(recv, obj)(val) */
rb_num_t
attr_popn_opt_minus(MAYBE_UNUSED(CALL_DATA cd))
{
    return 2;
}

/* attr rb_num_t retn @ opt_minus(cd)(recv, obj)(val) */
rb_num_t
attr_retn_opt_minus(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_minus(cd)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_minus(MAYBE_UNUSED(CALL_DATA cd))
{
    return -1;
}

/* attr rb_num_t width @ opt_minus(cd)(recv, obj)(val) */
rb_num_t
attr_width_opt_minus(MAYBE_UNUSED(CALL_DATA cd))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ opt_mult(cd)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_mult(MAYBE_UNUSED(CALL_DATA cd))
{
    return BIN(opt_mult);
}

/* attr bool handles_sp @ opt_mult(cd)(recv, obj)(val) */
bool
attr_handles_sp_opt_mult(MAYBE_UNUSED(CALL_DATA cd))
{
    return false;
}

/* attr bool leaf @ opt_mult(cd)(recv, obj)(val) */
bool
attr_leaf_opt_mult(MAYBE_UNUSED(CALL_DATA cd))
{
    return true;
}

/* attr const char* name @ opt_mult(cd)(recv, obj)(val) */
const char*
attr_name_opt_mult(MAYBE_UNUSED(CALL_DATA cd))
{
    return insn_name(BIN(opt_mult));
}

/* attr rb_num_t open @ opt_mult(cd)(recv, obj)(val) */
rb_num_t
attr_open_opt_mult(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_num_t popn @ opt_mult(cd)(recv, obj)(val) */
rb_num_t
attr_popn_opt_mult(MAYBE_UNUSED(CALL_DATA cd))
{
    return 2;
}

/* attr rb_num_t retn @ opt_mult(cd)(recv, obj)(val) */
rb_num_t
attr_retn_opt_mult(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_mult(cd)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_mult(MAYBE_UNUSED(CALL_DATA cd))
{
    return -1;
}

/* attr rb_num_t width @ opt_mult(cd)(recv, obj)(val) */
rb_num_t
attr_width_opt_mult(MAYBE_UNUSED(CALL_DATA cd))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ opt_div(cd)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_div(MAYBE_UNUSED(CALL_DATA cd))
{
    return BIN(opt_div);
}

/* attr bool handles_sp @ opt_div(cd)(recv, obj)(val) */
bool
attr_handles_sp_opt_div(MAYBE_UNUSED(CALL_DATA cd))
{
    return false;
}

/* attr bool leaf @ opt_div(cd)(recv, obj)(val) */
bool
attr_leaf_opt_div(MAYBE_UNUSED(CALL_DATA cd))
{
    return
#line 1128 "insns.def"
false;
#line 6775 "insns_info.inc"
}

/* attr const char* name @ opt_div(cd)(recv, obj)(val) */
const char*
attr_name_opt_div(MAYBE_UNUSED(CALL_DATA cd))
{
    return insn_name(BIN(opt_div));
}

/* attr rb_num_t open @ opt_div(cd)(recv, obj)(val) */
rb_num_t
attr_open_opt_div(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_num_t popn @ opt_div(cd)(recv, obj)(val) */
rb_num_t
attr_popn_opt_div(MAYBE_UNUSED(CALL_DATA cd))
{
    return 2;
}

/* attr rb_num_t retn @ opt_div(cd)(recv, obj)(val) */
rb_num_t
attr_retn_opt_div(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_div(cd)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_div(MAYBE_UNUSED(CALL_DATA cd))
{
    return -1;
}

/* attr rb_num_t width @ opt_div(cd)(recv, obj)(val) */
rb_num_t
attr_width_opt_div(MAYBE_UNUSED(CALL_DATA cd))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ opt_mod(cd)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_mod(MAYBE_UNUSED(CALL_DATA cd))
{
    return BIN(opt_mod);
}

/* attr bool handles_sp @ opt_mod(cd)(recv, obj)(val) */
bool
attr_handles_sp_opt_mod(MAYBE_UNUSED(CALL_DATA cd))
{
    return false;
}

/* attr bool leaf @ opt_mod(cd)(recv, obj)(val) */
bool
attr_leaf_opt_mod(MAYBE_UNUSED(CALL_DATA cd))
{
    return
#line 1144 "insns.def"
false;
#line 6841 "insns_info.inc"
}

/* attr const char* name @ opt_mod(cd)(recv, obj)(val) */
const char*
attr_name_opt_mod(MAYBE_UNUSED(CALL_DATA cd))
{
    return insn_name(BIN(opt_mod));
}

/* attr rb_num_t open @ opt_mod(cd)(recv, obj)(val) */
rb_num_t
attr_open_opt_mod(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_num_t popn @ opt_mod(cd)(recv, obj)(val) */
rb_num_t
attr_popn_opt_mod(MAYBE_UNUSED(CALL_DATA cd))
{
    return 2;
}

/* attr rb_num_t retn @ opt_mod(cd)(recv, obj)(val) */
rb_num_t
attr_retn_opt_mod(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_mod(cd)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_mod(MAYBE_UNUSED(CALL_DATA cd))
{
    return -1;
}

/* attr rb_num_t width @ opt_mod(cd)(recv, obj)(val) */
rb_num_t
attr_width_opt_mod(MAYBE_UNUSED(CALL_DATA cd))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ opt_eq(cd)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_eq(MAYBE_UNUSED(CALL_DATA cd))
{
    return BIN(opt_eq);
}

/* attr bool handles_sp @ opt_eq(cd)(recv, obj)(val) */
bool
attr_handles_sp_opt_eq(MAYBE_UNUSED(CALL_DATA cd))
{
    return false;
}

/* attr bool leaf @ opt_eq(cd)(recv, obj)(val) */
bool
attr_leaf_opt_eq(MAYBE_UNUSED(CALL_DATA cd))
{
    return true;
}

/* attr const char* name @ opt_eq(cd)(recv, obj)(val) */
const char*
attr_name_opt_eq(MAYBE_UNUSED(CALL_DATA cd))
{
    return insn_name(BIN(opt_eq));
}

/* attr rb_num_t open @ opt_eq(cd)(recv, obj)(val) */
rb_num_t
attr_open_opt_eq(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_num_t popn @ opt_eq(cd)(recv, obj)(val) */
rb_num_t
attr_popn_opt_eq(MAYBE_UNUSED(CALL_DATA cd))
{
    return 2;
}

/* attr rb_num_t retn @ opt_eq(cd)(recv, obj)(val) */
rb_num_t
attr_retn_opt_eq(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_eq(cd)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_eq(MAYBE_UNUSED(CALL_DATA cd))
{
    return -1;
}

/* attr rb_num_t width @ opt_eq(cd)(recv, obj)(val) */
rb_num_t
attr_width_opt_eq(MAYBE_UNUSED(CALL_DATA cd))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ opt_neq(cd_eq, cd)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_neq(
    MAYBE_UNUSED(CALL_DATA cd_eq),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return BIN(opt_neq);
}

/* attr bool handles_sp @ opt_neq(cd_eq, cd)(recv, obj)(val) */
bool
attr_handles_sp_opt_neq(
    MAYBE_UNUSED(CALL_DATA cd_eq),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return false;
}

/* attr bool leaf @ opt_neq(cd_eq, cd)(recv, obj)(val) */
bool
attr_leaf_opt_neq(
    MAYBE_UNUSED(CALL_DATA cd_eq),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return true;
}

/* attr const char* name @ opt_neq(cd_eq, cd)(recv, obj)(val) */
const char*
attr_name_opt_neq(
    MAYBE_UNUSED(CALL_DATA cd_eq),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return insn_name(BIN(opt_neq));
}

/* attr rb_num_t open @ opt_neq(cd_eq, cd)(recv, obj)(val) */
rb_num_t
attr_open_opt_neq(
    MAYBE_UNUSED(CALL_DATA cd_eq),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return 2;
}

/* attr rb_num_t popn @ opt_neq(cd_eq, cd)(recv, obj)(val) */
rb_num_t
attr_popn_opt_neq(
    MAYBE_UNUSED(CALL_DATA cd_eq),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return 2;
}

/* attr rb_num_t retn @ opt_neq(cd_eq, cd)(recv, obj)(val) */
rb_num_t
attr_retn_opt_neq(
    MAYBE_UNUSED(CALL_DATA cd_eq),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_neq(cd_eq, cd)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_neq(
    MAYBE_UNUSED(CALL_DATA cd_eq),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return -1;
}

/* attr rb_num_t width @ opt_neq(cd_eq, cd)(recv, obj)(val) */
rb_num_t
attr_width_opt_neq(
    MAYBE_UNUSED(CALL_DATA cd_eq),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ opt_lt(cd)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_lt(MAYBE_UNUSED(CALL_DATA cd))
{
    return BIN(opt_lt);
}

/* attr bool handles_sp @ opt_lt(cd)(recv, obj)(val) */
bool
attr_handles_sp_opt_lt(MAYBE_UNUSED(CALL_DATA cd))
{
    return false;
}

/* attr bool leaf @ opt_lt(cd)(recv, obj)(val) */
bool
attr_leaf_opt_lt(MAYBE_UNUSED(CALL_DATA cd))
{
    return true;
}

/* attr const char* name @ opt_lt(cd)(recv, obj)(val) */
const char*
attr_name_opt_lt(MAYBE_UNUSED(CALL_DATA cd))
{
    return insn_name(BIN(opt_lt));
}

/* attr rb_num_t open @ opt_lt(cd)(recv, obj)(val) */
rb_num_t
attr_open_opt_lt(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_num_t popn @ opt_lt(cd)(recv, obj)(val) */
rb_num_t
attr_popn_opt_lt(MAYBE_UNUSED(CALL_DATA cd))
{
    return 2;
}

/* attr rb_num_t retn @ opt_lt(cd)(recv, obj)(val) */
rb_num_t
attr_retn_opt_lt(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_lt(cd)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_lt(MAYBE_UNUSED(CALL_DATA cd))
{
    return -1;
}

/* attr rb_num_t width @ opt_lt(cd)(recv, obj)(val) */
rb_num_t
attr_width_opt_lt(MAYBE_UNUSED(CALL_DATA cd))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ opt_le(cd)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_le(MAYBE_UNUSED(CALL_DATA cd))
{
    return BIN(opt_le);
}

/* attr bool handles_sp @ opt_le(cd)(recv, obj)(val) */
bool
attr_handles_sp_opt_le(MAYBE_UNUSED(CALL_DATA cd))
{
    return false;
}

/* attr bool leaf @ opt_le(cd)(recv, obj)(val) */
bool
attr_leaf_opt_le(MAYBE_UNUSED(CALL_DATA cd))
{
    return true;
}

/* attr const char* name @ opt_le(cd)(recv, obj)(val) */
const char*
attr_name_opt_le(MAYBE_UNUSED(CALL_DATA cd))
{
    return insn_name(BIN(opt_le));
}

/* attr rb_num_t open @ opt_le(cd)(recv, obj)(val) */
rb_num_t
attr_open_opt_le(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_num_t popn @ opt_le(cd)(recv, obj)(val) */
rb_num_t
attr_popn_opt_le(MAYBE_UNUSED(CALL_DATA cd))
{
    return 2;
}

/* attr rb_num_t retn @ opt_le(cd)(recv, obj)(val) */
rb_num_t
attr_retn_opt_le(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_le(cd)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_le(MAYBE_UNUSED(CALL_DATA cd))
{
    return -1;
}

/* attr rb_num_t width @ opt_le(cd)(recv, obj)(val) */
rb_num_t
attr_width_opt_le(MAYBE_UNUSED(CALL_DATA cd))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ opt_gt(cd)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_gt(MAYBE_UNUSED(CALL_DATA cd))
{
    return BIN(opt_gt);
}

/* attr bool handles_sp @ opt_gt(cd)(recv, obj)(val) */
bool
attr_handles_sp_opt_gt(MAYBE_UNUSED(CALL_DATA cd))
{
    return false;
}

/* attr bool leaf @ opt_gt(cd)(recv, obj)(val) */
bool
attr_leaf_opt_gt(MAYBE_UNUSED(CALL_DATA cd))
{
    return true;
}

/* attr const char* name @ opt_gt(cd)(recv, obj)(val) */
const char*
attr_name_opt_gt(MAYBE_UNUSED(CALL_DATA cd))
{
    return insn_name(BIN(opt_gt));
}

/* attr rb_num_t open @ opt_gt(cd)(recv, obj)(val) */
rb_num_t
attr_open_opt_gt(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_num_t popn @ opt_gt(cd)(recv, obj)(val) */
rb_num_t
attr_popn_opt_gt(MAYBE_UNUSED(CALL_DATA cd))
{
    return 2;
}

/* attr rb_num_t retn @ opt_gt(cd)(recv, obj)(val) */
rb_num_t
attr_retn_opt_gt(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_gt(cd)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_gt(MAYBE_UNUSED(CALL_DATA cd))
{
    return -1;
}

/* attr rb_num_t width @ opt_gt(cd)(recv, obj)(val) */
rb_num_t
attr_width_opt_gt(MAYBE_UNUSED(CALL_DATA cd))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ opt_ge(cd)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_ge(MAYBE_UNUSED(CALL_DATA cd))
{
    return BIN(opt_ge);
}

/* attr bool handles_sp @ opt_ge(cd)(recv, obj)(val) */
bool
attr_handles_sp_opt_ge(MAYBE_UNUSED(CALL_DATA cd))
{
    return false;
}

/* attr bool leaf @ opt_ge(cd)(recv, obj)(val) */
bool
attr_leaf_opt_ge(MAYBE_UNUSED(CALL_DATA cd))
{
    return true;
}

/* attr const char* name @ opt_ge(cd)(recv, obj)(val) */
const char*
attr_name_opt_ge(MAYBE_UNUSED(CALL_DATA cd))
{
    return insn_name(BIN(opt_ge));
}

/* attr rb_num_t open @ opt_ge(cd)(recv, obj)(val) */
rb_num_t
attr_open_opt_ge(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_num_t popn @ opt_ge(cd)(recv, obj)(val) */
rb_num_t
attr_popn_opt_ge(MAYBE_UNUSED(CALL_DATA cd))
{
    return 2;
}

/* attr rb_num_t retn @ opt_ge(cd)(recv, obj)(val) */
rb_num_t
attr_retn_opt_ge(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_ge(cd)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_ge(MAYBE_UNUSED(CALL_DATA cd))
{
    return -1;
}

/* attr rb_num_t width @ opt_ge(cd)(recv, obj)(val) */
rb_num_t
attr_width_opt_ge(MAYBE_UNUSED(CALL_DATA cd))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ opt_ltlt(cd)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_ltlt(MAYBE_UNUSED(CALL_DATA cd))
{
    return BIN(opt_ltlt);
}

/* attr bool handles_sp @ opt_ltlt(cd)(recv, obj)(val) */
bool
attr_handles_sp_opt_ltlt(MAYBE_UNUSED(CALL_DATA cd))
{
    return false;
}

/* attr bool leaf @ opt_ltlt(cd)(recv, obj)(val) */
bool
attr_leaf_opt_ltlt(MAYBE_UNUSED(CALL_DATA cd))
{
    return
#line 1246 "insns.def"
false;
#line 7312 "insns_info.inc"
}

/* attr const char* name @ opt_ltlt(cd)(recv, obj)(val) */
const char*
attr_name_opt_ltlt(MAYBE_UNUSED(CALL_DATA cd))
{
    return insn_name(BIN(opt_ltlt));
}

/* attr rb_num_t open @ opt_ltlt(cd)(recv, obj)(val) */
rb_num_t
attr_open_opt_ltlt(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_num_t popn @ opt_ltlt(cd)(recv, obj)(val) */
rb_num_t
attr_popn_opt_ltlt(MAYBE_UNUSED(CALL_DATA cd))
{
    return 2;
}

/* attr rb_num_t retn @ opt_ltlt(cd)(recv, obj)(val) */
rb_num_t
attr_retn_opt_ltlt(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_ltlt(cd)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_ltlt(MAYBE_UNUSED(CALL_DATA cd))
{
    return -1;
}

/* attr rb_num_t width @ opt_ltlt(cd)(recv, obj)(val) */
rb_num_t
attr_width_opt_ltlt(MAYBE_UNUSED(CALL_DATA cd))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ opt_and(cd)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_and(MAYBE_UNUSED(CALL_DATA cd))
{
    return BIN(opt_and);
}

/* attr bool handles_sp @ opt_and(cd)(recv, obj)(val) */
bool
attr_handles_sp_opt_and(MAYBE_UNUSED(CALL_DATA cd))
{
    return false;
}

/* attr bool leaf @ opt_and(cd)(recv, obj)(val) */
bool
attr_leaf_opt_and(MAYBE_UNUSED(CALL_DATA cd))
{
    return true;
}

/* attr const char* name @ opt_and(cd)(recv, obj)(val) */
const char*
attr_name_opt_and(MAYBE_UNUSED(CALL_DATA cd))
{
    return insn_name(BIN(opt_and));
}

/* attr rb_num_t open @ opt_and(cd)(recv, obj)(val) */
rb_num_t
attr_open_opt_and(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_num_t popn @ opt_and(cd)(recv, obj)(val) */
rb_num_t
attr_popn_opt_and(MAYBE_UNUSED(CALL_DATA cd))
{
    return 2;
}

/* attr rb_num_t retn @ opt_and(cd)(recv, obj)(val) */
rb_num_t
attr_retn_opt_and(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_and(cd)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_and(MAYBE_UNUSED(CALL_DATA cd))
{
    return -1;
}

/* attr rb_num_t width @ opt_and(cd)(recv, obj)(val) */
rb_num_t
attr_width_opt_and(MAYBE_UNUSED(CALL_DATA cd))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ opt_or(cd)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_or(MAYBE_UNUSED(CALL_DATA cd))
{
    return BIN(opt_or);
}

/* attr bool handles_sp @ opt_or(cd)(recv, obj)(val) */
bool
attr_handles_sp_opt_or(MAYBE_UNUSED(CALL_DATA cd))
{
    return false;
}

/* attr bool leaf @ opt_or(cd)(recv, obj)(val) */
bool
attr_leaf_opt_or(MAYBE_UNUSED(CALL_DATA cd))
{
    return true;
}

/* attr const char* name @ opt_or(cd)(recv, obj)(val) */
const char*
attr_name_opt_or(MAYBE_UNUSED(CALL_DATA cd))
{
    return insn_name(BIN(opt_or));
}

/* attr rb_num_t open @ opt_or(cd)(recv, obj)(val) */
rb_num_t
attr_open_opt_or(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_num_t popn @ opt_or(cd)(recv, obj)(val) */
rb_num_t
attr_popn_opt_or(MAYBE_UNUSED(CALL_DATA cd))
{
    return 2;
}

/* attr rb_num_t retn @ opt_or(cd)(recv, obj)(val) */
rb_num_t
attr_retn_opt_or(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_or(cd)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_or(MAYBE_UNUSED(CALL_DATA cd))
{
    return -1;
}

/* attr rb_num_t width @ opt_or(cd)(recv, obj)(val) */
rb_num_t
attr_width_opt_or(MAYBE_UNUSED(CALL_DATA cd))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ opt_aref(cd)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_aref(MAYBE_UNUSED(CALL_DATA cd))
{
    return BIN(opt_aref);
}

/* attr bool handles_sp @ opt_aref(cd)(recv, obj)(val) */
bool
attr_handles_sp_opt_aref(MAYBE_UNUSED(CALL_DATA cd))
{
    return false;
}

/* attr bool leaf @ opt_aref(cd)(recv, obj)(val) */
bool
attr_leaf_opt_aref(MAYBE_UNUSED(CALL_DATA cd))
{
    return
#line 1293 "insns.def"
false;
#line 7504 "insns_info.inc"
}

/* attr const char* name @ opt_aref(cd)(recv, obj)(val) */
const char*
attr_name_opt_aref(MAYBE_UNUSED(CALL_DATA cd))
{
    return insn_name(BIN(opt_aref));
}

/* attr rb_num_t open @ opt_aref(cd)(recv, obj)(val) */
rb_num_t
attr_open_opt_aref(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_num_t popn @ opt_aref(cd)(recv, obj)(val) */
rb_num_t
attr_popn_opt_aref(MAYBE_UNUSED(CALL_DATA cd))
{
    return 2;
}

/* attr rb_num_t retn @ opt_aref(cd)(recv, obj)(val) */
rb_num_t
attr_retn_opt_aref(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_aref(cd)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_aref(MAYBE_UNUSED(CALL_DATA cd))
{
    return -1;
}

/* attr rb_num_t width @ opt_aref(cd)(recv, obj)(val) */
rb_num_t
attr_width_opt_aref(MAYBE_UNUSED(CALL_DATA cd))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ opt_aset(cd)(recv, obj, set)(val) */
enum ruby_vminsn_type
attr_bin_opt_aset(MAYBE_UNUSED(CALL_DATA cd))
{
    return BIN(opt_aset);
}

/* attr bool handles_sp @ opt_aset(cd)(recv, obj, set)(val) */
bool
attr_handles_sp_opt_aset(MAYBE_UNUSED(CALL_DATA cd))
{
    return false;
}

/* attr bool leaf @ opt_aset(cd)(recv, obj, set)(val) */
bool
attr_leaf_opt_aset(MAYBE_UNUSED(CALL_DATA cd))
{
    return
#line 1310 "insns.def"
false;
#line 7570 "insns_info.inc"
}

/* attr const char* name @ opt_aset(cd)(recv, obj, set)(val) */
const char*
attr_name_opt_aset(MAYBE_UNUSED(CALL_DATA cd))
{
    return insn_name(BIN(opt_aset));
}

/* attr rb_num_t open @ opt_aset(cd)(recv, obj, set)(val) */
rb_num_t
attr_open_opt_aset(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_num_t popn @ opt_aset(cd)(recv, obj, set)(val) */
rb_num_t
attr_popn_opt_aset(MAYBE_UNUSED(CALL_DATA cd))
{
    return 3;
}

/* attr rb_num_t retn @ opt_aset(cd)(recv, obj, set)(val) */
rb_num_t
attr_retn_opt_aset(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_aset(cd)(recv, obj, set)(val) */
rb_snum_t
attr_sp_inc_opt_aset(MAYBE_UNUSED(CALL_DATA cd))
{
    return -2;
}

/* attr rb_num_t width @ opt_aset(cd)(recv, obj, set)(val) */
rb_num_t
attr_width_opt_aset(MAYBE_UNUSED(CALL_DATA cd))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ opt_aset_with(key, cd)(recv, val)(val) */
enum ruby_vminsn_type
attr_bin_opt_aset_with(
    MAYBE_UNUSED(VALUE key),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return BIN(opt_aset_with);
}

/* attr bool handles_sp @ opt_aset_with(key, cd)(recv, val)(val) */
bool
attr_handles_sp_opt_aset_with(
    MAYBE_UNUSED(VALUE key),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return false;
}

/* attr bool leaf @ opt_aset_with(key, cd)(recv, val)(val) */
bool
attr_leaf_opt_aset_with(
    MAYBE_UNUSED(VALUE key),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return
#line 1326 "insns.def"
false;
#line 7645 "insns_info.inc"
}

/* attr const char* name @ opt_aset_with(key, cd)(recv, val)(val) */
const char*
attr_name_opt_aset_with(
    MAYBE_UNUSED(VALUE key),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return insn_name(BIN(opt_aset_with));
}

/* attr rb_num_t open @ opt_aset_with(key, cd)(recv, val)(val) */
rb_num_t
attr_open_opt_aset_with(
    MAYBE_UNUSED(VALUE key),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return 2;
}

/* attr rb_num_t popn @ opt_aset_with(key, cd)(recv, val)(val) */
rb_num_t
attr_popn_opt_aset_with(
    MAYBE_UNUSED(VALUE key),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return 2;
}

/* attr rb_num_t retn @ opt_aset_with(key, cd)(recv, val)(val) */
rb_num_t
attr_retn_opt_aset_with(
    MAYBE_UNUSED(VALUE key),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_aset_with(key, cd)(recv, val)(val) */
rb_snum_t
attr_sp_inc_opt_aset_with(
    MAYBE_UNUSED(VALUE key),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return -1;
}

/* attr rb_num_t width @ opt_aset_with(key, cd)(recv, val)(val) */
rb_num_t
attr_width_opt_aset_with(
    MAYBE_UNUSED(VALUE key),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ opt_aref_with(key, cd)(recv)(val) */
enum ruby_vminsn_type
attr_bin_opt_aref_with(
    MAYBE_UNUSED(VALUE key),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return BIN(opt_aref_with);
}

/* attr bool handles_sp @ opt_aref_with(key, cd)(recv)(val) */
bool
attr_handles_sp_opt_aref_with(
    MAYBE_UNUSED(VALUE key),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return false;
}

/* attr bool leaf @ opt_aref_with(key, cd)(recv)(val) */
bool
attr_leaf_opt_aref_with(
    MAYBE_UNUSED(VALUE key),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return
#line 1349 "insns.def"
false;
#line 7738 "insns_info.inc"
}

/* attr const char* name @ opt_aref_with(key, cd)(recv)(val) */
const char*
attr_name_opt_aref_with(
    MAYBE_UNUSED(VALUE key),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return insn_name(BIN(opt_aref_with));
}

/* attr rb_num_t open @ opt_aref_with(key, cd)(recv)(val) */
rb_num_t
attr_open_opt_aref_with(
    MAYBE_UNUSED(VALUE key),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return 2;
}

/* attr rb_num_t popn @ opt_aref_with(key, cd)(recv)(val) */
rb_num_t
attr_popn_opt_aref_with(
    MAYBE_UNUSED(VALUE key),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return 1;
}

/* attr rb_num_t retn @ opt_aref_with(key, cd)(recv)(val) */
rb_num_t
attr_retn_opt_aref_with(
    MAYBE_UNUSED(VALUE key),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_aref_with(key, cd)(recv)(val) */
rb_snum_t
attr_sp_inc_opt_aref_with(
    MAYBE_UNUSED(VALUE key),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return 0;
}

/* attr rb_num_t width @ opt_aref_with(key, cd)(recv)(val) */
rb_num_t
attr_width_opt_aref_with(
    MAYBE_UNUSED(VALUE key),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ opt_length(cd)(recv)(val) */
enum ruby_vminsn_type
attr_bin_opt_length(MAYBE_UNUSED(CALL_DATA cd))
{
    return BIN(opt_length);
}

/* attr bool handles_sp @ opt_length(cd)(recv)(val) */
bool
attr_handles_sp_opt_length(MAYBE_UNUSED(CALL_DATA cd))
{
    return false;
}

/* attr bool leaf @ opt_length(cd)(recv)(val) */
bool
attr_leaf_opt_length(MAYBE_UNUSED(CALL_DATA cd))
{
    return true;
}

/* attr const char* name @ opt_length(cd)(recv)(val) */
const char*
attr_name_opt_length(MAYBE_UNUSED(CALL_DATA cd))
{
    return insn_name(BIN(opt_length));
}

/* attr rb_num_t open @ opt_length(cd)(recv)(val) */
rb_num_t
attr_open_opt_length(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_num_t popn @ opt_length(cd)(recv)(val) */
rb_num_t
attr_popn_opt_length(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_num_t retn @ opt_length(cd)(recv)(val) */
rb_num_t
attr_retn_opt_length(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_length(cd)(recv)(val) */
rb_snum_t
attr_sp_inc_opt_length(MAYBE_UNUSED(CALL_DATA cd))
{
    return 0;
}

/* attr rb_num_t width @ opt_length(cd)(recv)(val) */
rb_num_t
attr_width_opt_length(MAYBE_UNUSED(CALL_DATA cd))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ opt_size(cd)(recv)(val) */
enum ruby_vminsn_type
attr_bin_opt_size(MAYBE_UNUSED(CALL_DATA cd))
{
    return BIN(opt_size);
}

/* attr bool handles_sp @ opt_size(cd)(recv)(val) */
bool
attr_handles_sp_opt_size(MAYBE_UNUSED(CALL_DATA cd))
{
    return false;
}

/* attr bool leaf @ opt_size(cd)(recv)(val) */
bool
attr_leaf_opt_size(MAYBE_UNUSED(CALL_DATA cd))
{
    return true;
}

/* attr const char* name @ opt_size(cd)(recv)(val) */
const char*
attr_name_opt_size(MAYBE_UNUSED(CALL_DATA cd))
{
    return insn_name(BIN(opt_size));
}

/* attr rb_num_t open @ opt_size(cd)(recv)(val) */
rb_num_t
attr_open_opt_size(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_num_t popn @ opt_size(cd)(recv)(val) */
rb_num_t
attr_popn_opt_size(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_num_t retn @ opt_size(cd)(recv)(val) */
rb_num_t
attr_retn_opt_size(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_size(cd)(recv)(val) */
rb_snum_t
attr_sp_inc_opt_size(MAYBE_UNUSED(CALL_DATA cd))
{
    return 0;
}

/* attr rb_num_t width @ opt_size(cd)(recv)(val) */
rb_num_t
attr_width_opt_size(MAYBE_UNUSED(CALL_DATA cd))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ opt_empty_p(cd)(recv)(val) */
enum ruby_vminsn_type
attr_bin_opt_empty_p(MAYBE_UNUSED(CALL_DATA cd))
{
    return BIN(opt_empty_p);
}

/* attr bool handles_sp @ opt_empty_p(cd)(recv)(val) */
bool
attr_handles_sp_opt_empty_p(MAYBE_UNUSED(CALL_DATA cd))
{
    return false;
}

/* attr bool leaf @ opt_empty_p(cd)(recv)(val) */
bool
attr_leaf_opt_empty_p(MAYBE_UNUSED(CALL_DATA cd))
{
    return true;
}

/* attr const char* name @ opt_empty_p(cd)(recv)(val) */
const char*
attr_name_opt_empty_p(MAYBE_UNUSED(CALL_DATA cd))
{
    return insn_name(BIN(opt_empty_p));
}

/* attr rb_num_t open @ opt_empty_p(cd)(recv)(val) */
rb_num_t
attr_open_opt_empty_p(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_num_t popn @ opt_empty_p(cd)(recv)(val) */
rb_num_t
attr_popn_opt_empty_p(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_num_t retn @ opt_empty_p(cd)(recv)(val) */
rb_num_t
attr_retn_opt_empty_p(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_empty_p(cd)(recv)(val) */
rb_snum_t
attr_sp_inc_opt_empty_p(MAYBE_UNUSED(CALL_DATA cd))
{
    return 0;
}

/* attr rb_num_t width @ opt_empty_p(cd)(recv)(val) */
rb_num_t
attr_width_opt_empty_p(MAYBE_UNUSED(CALL_DATA cd))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ opt_succ(cd)(recv)(val) */
enum ruby_vminsn_type
attr_bin_opt_succ(MAYBE_UNUSED(CALL_DATA cd))
{
    return BIN(opt_succ);
}

/* attr bool handles_sp @ opt_succ(cd)(recv)(val) */
bool
attr_handles_sp_opt_succ(MAYBE_UNUSED(CALL_DATA cd))
{
    return false;
}

/* attr bool leaf @ opt_succ(cd)(recv)(val) */
bool
attr_leaf_opt_succ(MAYBE_UNUSED(CALL_DATA cd))
{
    return true;
}

/* attr const char* name @ opt_succ(cd)(recv)(val) */
const char*
attr_name_opt_succ(MAYBE_UNUSED(CALL_DATA cd))
{
    return insn_name(BIN(opt_succ));
}

/* attr rb_num_t open @ opt_succ(cd)(recv)(val) */
rb_num_t
attr_open_opt_succ(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_num_t popn @ opt_succ(cd)(recv)(val) */
rb_num_t
attr_popn_opt_succ(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_num_t retn @ opt_succ(cd)(recv)(val) */
rb_num_t
attr_retn_opt_succ(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_succ(cd)(recv)(val) */
rb_snum_t
attr_sp_inc_opt_succ(MAYBE_UNUSED(CALL_DATA cd))
{
    return 0;
}

/* attr rb_num_t width @ opt_succ(cd)(recv)(val) */
rb_num_t
attr_width_opt_succ(MAYBE_UNUSED(CALL_DATA cd))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ opt_not(cd)(recv)(val) */
enum ruby_vminsn_type
attr_bin_opt_not(MAYBE_UNUSED(CALL_DATA cd))
{
    return BIN(opt_not);
}

/* attr bool handles_sp @ opt_not(cd)(recv)(val) */
bool
attr_handles_sp_opt_not(MAYBE_UNUSED(CALL_DATA cd))
{
    return false;
}

/* attr bool leaf @ opt_not(cd)(recv)(val) */
bool
attr_leaf_opt_not(MAYBE_UNUSED(CALL_DATA cd))
{
    return true;
}

/* attr const char* name @ opt_not(cd)(recv)(val) */
const char*
attr_name_opt_not(MAYBE_UNUSED(CALL_DATA cd))
{
    return insn_name(BIN(opt_not));
}

/* attr rb_num_t open @ opt_not(cd)(recv)(val) */
rb_num_t
attr_open_opt_not(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_num_t popn @ opt_not(cd)(recv)(val) */
rb_num_t
attr_popn_opt_not(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_num_t retn @ opt_not(cd)(recv)(val) */
rb_num_t
attr_retn_opt_not(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_not(cd)(recv)(val) */
rb_snum_t
attr_sp_inc_opt_not(MAYBE_UNUSED(CALL_DATA cd))
{
    return 0;
}

/* attr rb_num_t width @ opt_not(cd)(recv)(val) */
rb_num_t
attr_width_opt_not(MAYBE_UNUSED(CALL_DATA cd))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ opt_regexpmatch2(cd)(obj2, obj1)(val) */
enum ruby_vminsn_type
attr_bin_opt_regexpmatch2(MAYBE_UNUSED(CALL_DATA cd))
{
    return BIN(opt_regexpmatch2);
}

/* attr bool handles_sp @ opt_regexpmatch2(cd)(obj2, obj1)(val) */
bool
attr_handles_sp_opt_regexpmatch2(MAYBE_UNUSED(CALL_DATA cd))
{
    return false;
}

/* attr bool leaf @ opt_regexpmatch2(cd)(obj2, obj1)(val) */
bool
attr_leaf_opt_regexpmatch2(MAYBE_UNUSED(CALL_DATA cd))
{
    return
#line 1437 "insns.def"
false;
#line 8137 "insns_info.inc"
}

/* attr const char* name @ opt_regexpmatch2(cd)(obj2, obj1)(val) */
const char*
attr_name_opt_regexpmatch2(MAYBE_UNUSED(CALL_DATA cd))
{
    return insn_name(BIN(opt_regexpmatch2));
}

/* attr rb_num_t open @ opt_regexpmatch2(cd)(obj2, obj1)(val) */
rb_num_t
attr_open_opt_regexpmatch2(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_num_t popn @ opt_regexpmatch2(cd)(obj2, obj1)(val) */
rb_num_t
attr_popn_opt_regexpmatch2(MAYBE_UNUSED(CALL_DATA cd))
{
    return 2;
}

/* attr rb_num_t retn @ opt_regexpmatch2(cd)(obj2, obj1)(val) */
rb_num_t
attr_retn_opt_regexpmatch2(MAYBE_UNUSED(CALL_DATA cd))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_regexpmatch2(cd)(obj2, obj1)(val) */
rb_snum_t
attr_sp_inc_opt_regexpmatch2(MAYBE_UNUSED(CALL_DATA cd))
{
    return -1;
}

/* attr rb_num_t width @ opt_regexpmatch2(cd)(obj2, obj1)(val) */
rb_num_t
attr_width_opt_regexpmatch2(MAYBE_UNUSED(CALL_DATA cd))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ invokebuiltin(bf)(...)(val) */
enum ruby_vminsn_type
attr_bin_invokebuiltin(MAYBE_UNUSED(RB_BUILTIN bf))
{
    return BIN(invokebuiltin);
}

/* attr bool handles_sp @ invokebuiltin(bf)(...)(val) */
bool
attr_handles_sp_invokebuiltin(MAYBE_UNUSED(RB_BUILTIN bf))
{
    return false;
}

/* attr bool leaf @ invokebuiltin(bf)(...)(val) */
bool
attr_leaf_invokebuiltin(MAYBE_UNUSED(RB_BUILTIN bf))
{
    return
#line 1473 "insns.def"
false;
#line 8203 "insns_info.inc"
}

/* attr const char* name @ invokebuiltin(bf)(...)(val) */
const char*
attr_name_invokebuiltin(MAYBE_UNUSED(RB_BUILTIN bf))
{
    return insn_name(BIN(invokebuiltin));
}

/* attr rb_num_t open @ invokebuiltin(bf)(...)(val) */
rb_num_t
attr_open_invokebuiltin(MAYBE_UNUSED(RB_BUILTIN bf))
{
    return 1;
}

/* attr rb_num_t popn @ invokebuiltin(bf)(...)(val) */
rb_num_t
attr_popn_invokebuiltin(MAYBE_UNUSED(RB_BUILTIN bf))
{
    return 0;
}

/* attr rb_num_t retn @ invokebuiltin(bf)(...)(val) */
rb_num_t
attr_retn_invokebuiltin(MAYBE_UNUSED(RB_BUILTIN bf))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ invokebuiltin(bf)(...)(val) */
rb_snum_t
attr_sp_inc_invokebuiltin(MAYBE_UNUSED(RB_BUILTIN bf))
{
    return
#line 1474 "insns.def"
1 - bf->argc;
#line 8241 "insns_info.inc"
}

/* attr rb_num_t width @ invokebuiltin(bf)(...)(val) */
rb_num_t
attr_width_invokebuiltin(MAYBE_UNUSED(RB_BUILTIN bf))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ opt_invokebuiltin_delegate(bf, index)()(val) */
enum ruby_vminsn_type
attr_bin_opt_invokebuiltin_delegate(
    MAYBE_UNUSED(RB_BUILTIN bf),
    MAYBE_UNUSED(rb_num_t index)
)
{
    return BIN(opt_invokebuiltin_delegate);
}

/* attr bool handles_sp @ opt_invokebuiltin_delegate(bf, index)()(val) */
bool
attr_handles_sp_opt_invokebuiltin_delegate(
    MAYBE_UNUSED(RB_BUILTIN bf),
    MAYBE_UNUSED(rb_num_t index)
)
{
    return false;
}

/* attr bool leaf @ opt_invokebuiltin_delegate(bf, index)()(val) */
bool
attr_leaf_opt_invokebuiltin_delegate(
    MAYBE_UNUSED(RB_BUILTIN bf),
    MAYBE_UNUSED(rb_num_t index)
)
{
    return
#line 1485 "insns.def"
false;
#line 8281 "insns_info.inc"
}

/* attr const char* name @ opt_invokebuiltin_delegate(bf, index)()(val) */
const char*
attr_name_opt_invokebuiltin_delegate(
    MAYBE_UNUSED(RB_BUILTIN bf),
    MAYBE_UNUSED(rb_num_t index)
)
{
    return insn_name(BIN(opt_invokebuiltin_delegate));
}

/* attr rb_num_t open @ opt_invokebuiltin_delegate(bf, index)()(val) */
rb_num_t
attr_open_opt_invokebuiltin_delegate(
    MAYBE_UNUSED(RB_BUILTIN bf),
    MAYBE_UNUSED(rb_num_t index)
)
{
    return 2;
}

/* attr rb_num_t popn @ opt_invokebuiltin_delegate(bf, index)()(val) */
rb_num_t
attr_popn_opt_invokebuiltin_delegate(
    MAYBE_UNUSED(RB_BUILTIN bf),
    MAYBE_UNUSED(rb_num_t index)
)
{
    return 0;
}

/* attr rb_num_t retn @ opt_invokebuiltin_delegate(bf, index)()(val) */
rb_num_t
attr_retn_opt_invokebuiltin_delegate(
    MAYBE_UNUSED(RB_BUILTIN bf),
    MAYBE_UNUSED(rb_num_t index)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_invokebuiltin_delegate(bf, index)()(val) */
rb_snum_t
attr_sp_inc_opt_invokebuiltin_delegate(
    MAYBE_UNUSED(RB_BUILTIN bf),
    MAYBE_UNUSED(rb_num_t index)
)
{
    return 1;
}

/* attr rb_num_t width @ opt_invokebuiltin_delegate(bf, index)()(val) */
rb_num_t
attr_width_opt_invokebuiltin_delegate(
    MAYBE_UNUSED(RB_BUILTIN bf),
    MAYBE_UNUSED(rb_num_t index)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ opt_invokebuiltin_delegate_leave(bf, index)()(val) */
enum ruby_vminsn_type
attr_bin_opt_invokebuiltin_delegate_leave(
    MAYBE_UNUSED(RB_BUILTIN bf),
    MAYBE_UNUSED(rb_num_t index)
)
{
    return BIN(opt_invokebuiltin_delegate_leave);
}

/* attr bool handles_sp @ opt_invokebuiltin_delegate_leave(bf, index)()(val) */
bool
attr_handles_sp_opt_invokebuiltin_delegate_leave(
    MAYBE_UNUSED(RB_BUILTIN bf),
    MAYBE_UNUSED(rb_num_t index)
)
{
    return false;
}

/* attr bool leaf @ opt_invokebuiltin_delegate_leave(bf, index)()(val) */
bool
attr_leaf_opt_invokebuiltin_delegate_leave(
    MAYBE_UNUSED(RB_BUILTIN bf),
    MAYBE_UNUSED(rb_num_t index)
)
{
    return
#line 1496 "insns.def"
false;
#line 8374 "insns_info.inc"
}

/* attr const char* name @ opt_invokebuiltin_delegate_leave(bf, index)()(val) */
const char*
attr_name_opt_invokebuiltin_delegate_leave(
    MAYBE_UNUSED(RB_BUILTIN bf),
    MAYBE_UNUSED(rb_num_t index)
)
{
    return insn_name(BIN(opt_invokebuiltin_delegate_leave));
}

/* attr rb_num_t open @ opt_invokebuiltin_delegate_leave(bf, index)()(val) */
rb_num_t
attr_open_opt_invokebuiltin_delegate_leave(
    MAYBE_UNUSED(RB_BUILTIN bf),
    MAYBE_UNUSED(rb_num_t index)
)
{
    return 2;
}

/* attr rb_num_t popn @ opt_invokebuiltin_delegate_leave(bf, index)()(val) */
rb_num_t
attr_popn_opt_invokebuiltin_delegate_leave(
    MAYBE_UNUSED(RB_BUILTIN bf),
    MAYBE_UNUSED(rb_num_t index)
)
{
    return 0;
}

/* attr rb_num_t retn @ opt_invokebuiltin_delegate_leave(bf, index)()(val) */
rb_num_t
attr_retn_opt_invokebuiltin_delegate_leave(
    MAYBE_UNUSED(RB_BUILTIN bf),
    MAYBE_UNUSED(rb_num_t index)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_invokebuiltin_delegate_leave(bf, index)()(val) */
rb_snum_t
attr_sp_inc_opt_invokebuiltin_delegate_leave(
    MAYBE_UNUSED(RB_BUILTIN bf),
    MAYBE_UNUSED(rb_num_t index)
)
{
    return 1;
}

/* attr rb_num_t width @ opt_invokebuiltin_delegate_leave(bf, index)()(val) */
rb_num_t
attr_width_opt_invokebuiltin_delegate_leave(
    MAYBE_UNUSED(RB_BUILTIN bf),
    MAYBE_UNUSED(rb_num_t index)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ getlocal_WC_0(idx)()(val) */
enum ruby_vminsn_type
attr_bin_getlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
    return BIN(getlocal_WC_0);
}

/* attr bool handles_sp @ getlocal_WC_0(idx)()(val) */
bool
attr_handles_sp_getlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
    return false;
}

/* attr bool leaf @ getlocal_WC_0(idx)()(val) */
bool
attr_leaf_getlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
    return true;
}

/* attr const char* name @ getlocal_WC_0(idx)()(val) */
const char*
attr_name_getlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
    return insn_name(BIN(getlocal_WC_0));
}

/* attr rb_num_t open @ getlocal_WC_0(idx)()(val) */
rb_num_t
attr_open_getlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
    return 1;
}

/* attr rb_num_t popn @ getlocal_WC_0(idx)()(val) */
rb_num_t
attr_popn_getlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
    return 0;
}

/* attr rb_num_t retn @ getlocal_WC_0(idx)()(val) */
rb_num_t
attr_retn_getlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ getlocal_WC_0(idx)()(val) */
rb_snum_t
attr_sp_inc_getlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
    return 1;
}

/* attr rb_num_t width @ getlocal_WC_0(idx)()(val) */
rb_num_t
attr_width_getlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ getlocal_WC_1(idx)()(val) */
enum ruby_vminsn_type
attr_bin_getlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
    return BIN(getlocal_WC_1);
}

/* attr bool handles_sp @ getlocal_WC_1(idx)()(val) */
bool
attr_handles_sp_getlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
    return false;
}

/* attr bool leaf @ getlocal_WC_1(idx)()(val) */
bool
attr_leaf_getlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
    return true;
}

/* attr const char* name @ getlocal_WC_1(idx)()(val) */
const char*
attr_name_getlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
    return insn_name(BIN(getlocal_WC_1));
}

/* attr rb_num_t open @ getlocal_WC_1(idx)()(val) */
rb_num_t
attr_open_getlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
    return 1;
}

/* attr rb_num_t popn @ getlocal_WC_1(idx)()(val) */
rb_num_t
attr_popn_getlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
    return 0;
}

/* attr rb_num_t retn @ getlocal_WC_1(idx)()(val) */
rb_num_t
attr_retn_getlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ getlocal_WC_1(idx)()(val) */
rb_snum_t
attr_sp_inc_getlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
    return 1;
}

/* attr rb_num_t width @ getlocal_WC_1(idx)()(val) */
rb_num_t
attr_width_getlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ setlocal_WC_0(idx)(val)() */
enum ruby_vminsn_type
attr_bin_setlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
    return BIN(setlocal_WC_0);
}

/* attr bool handles_sp @ setlocal_WC_0(idx)(val)() */
bool
attr_handles_sp_setlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
    return false;
}

/* attr bool leaf @ setlocal_WC_0(idx)(val)() */
bool
attr_leaf_setlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
    return true;
}

/* attr const char* name @ setlocal_WC_0(idx)(val)() */
const char*
attr_name_setlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
    return insn_name(BIN(setlocal_WC_0));
}

/* attr rb_num_t open @ setlocal_WC_0(idx)(val)() */
rb_num_t
attr_open_setlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
    return 1;
}

/* attr rb_num_t popn @ setlocal_WC_0(idx)(val)() */
rb_num_t
attr_popn_setlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
    return 1;
}

/* attr rb_num_t retn @ setlocal_WC_0(idx)(val)() */
rb_num_t
attr_retn_setlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
    return 0;
}

/* attr rb_snum_t sp_inc @ setlocal_WC_0(idx)(val)() */
rb_snum_t
attr_sp_inc_setlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
    return -1;
}

/* attr rb_num_t width @ setlocal_WC_0(idx)(val)() */
rb_num_t
attr_width_setlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ setlocal_WC_1(idx)(val)() */
enum ruby_vminsn_type
attr_bin_setlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
    return BIN(setlocal_WC_1);
}

/* attr bool handles_sp @ setlocal_WC_1(idx)(val)() */
bool
attr_handles_sp_setlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
    return false;
}

/* attr bool leaf @ setlocal_WC_1(idx)(val)() */
bool
attr_leaf_setlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
    return true;
}

/* attr const char* name @ setlocal_WC_1(idx)(val)() */
const char*
attr_name_setlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
    return insn_name(BIN(setlocal_WC_1));
}

/* attr rb_num_t open @ setlocal_WC_1(idx)(val)() */
rb_num_t
attr_open_setlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
    return 1;
}

/* attr rb_num_t popn @ setlocal_WC_1(idx)(val)() */
rb_num_t
attr_popn_setlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
    return 1;
}

/* attr rb_num_t retn @ setlocal_WC_1(idx)(val)() */
rb_num_t
attr_retn_setlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
    return 0;
}

/* attr rb_snum_t sp_inc @ setlocal_WC_1(idx)(val)() */
rb_snum_t
attr_sp_inc_setlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
    return -1;
}

/* attr rb_num_t width @ setlocal_WC_1(idx)(val)() */
rb_num_t
attr_width_setlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ putobject_INT2FIX_0_()()(val) */
enum ruby_vminsn_type
attr_bin_putobject_INT2FIX_0_(void)
{
    return BIN(putobject_INT2FIX_0_);
}

/* attr bool handles_sp @ putobject_INT2FIX_0_()()(val) */
bool
attr_handles_sp_putobject_INT2FIX_0_(void)
{
    return false;
}

/* attr bool leaf @ putobject_INT2FIX_0_()()(val) */
bool
attr_leaf_putobject_INT2FIX_0_(void)
{
    return true;
}

/* attr const char* name @ putobject_INT2FIX_0_()()(val) */
const char*
attr_name_putobject_INT2FIX_0_(void)
{
    return insn_name(BIN(putobject_INT2FIX_0_));
}

/* attr rb_num_t open @ putobject_INT2FIX_0_()()(val) */
rb_num_t
attr_open_putobject_INT2FIX_0_(void)
{
    return 0;
}

/* attr rb_num_t popn @ putobject_INT2FIX_0_()()(val) */
rb_num_t
attr_popn_putobject_INT2FIX_0_(void)
{
    return 0;
}

/* attr rb_num_t retn @ putobject_INT2FIX_0_()()(val) */
rb_num_t
attr_retn_putobject_INT2FIX_0_(void)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ putobject_INT2FIX_0_()()(val) */
rb_snum_t
attr_sp_inc_putobject_INT2FIX_0_(void)
{
    return 1;
}

/* attr rb_num_t width @ putobject_INT2FIX_0_()()(val) */
rb_num_t
attr_width_putobject_INT2FIX_0_(void)
{
    return 1;
}

/* attr enum ruby_vminsn_type bin @ putobject_INT2FIX_1_()()(val) */
enum ruby_vminsn_type
attr_bin_putobject_INT2FIX_1_(void)
{
    return BIN(putobject_INT2FIX_1_);
}

/* attr bool handles_sp @ putobject_INT2FIX_1_()()(val) */
bool
attr_handles_sp_putobject_INT2FIX_1_(void)
{
    return false;
}

/* attr bool leaf @ putobject_INT2FIX_1_()()(val) */
bool
attr_leaf_putobject_INT2FIX_1_(void)
{
    return true;
}

/* attr const char* name @ putobject_INT2FIX_1_()()(val) */
const char*
attr_name_putobject_INT2FIX_1_(void)
{
    return insn_name(BIN(putobject_INT2FIX_1_));
}

/* attr rb_num_t open @ putobject_INT2FIX_1_()()(val) */
rb_num_t
attr_open_putobject_INT2FIX_1_(void)
{
    return 0;
}

/* attr rb_num_t popn @ putobject_INT2FIX_1_()()(val) */
rb_num_t
attr_popn_putobject_INT2FIX_1_(void)
{
    return 0;
}

/* attr rb_num_t retn @ putobject_INT2FIX_1_()()(val) */
rb_num_t
attr_retn_putobject_INT2FIX_1_(void)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ putobject_INT2FIX_1_()()(val) */
rb_snum_t
attr_sp_inc_putobject_INT2FIX_1_(void)
{
    return 1;
}

/* attr rb_num_t width @ putobject_INT2FIX_1_()()(val) */
rb_num_t
attr_width_putobject_INT2FIX_1_(void)
{
    return 1;
}

PUREFUNC(MAYBE_UNUSED(static int comptime_insn_stack_increase(int depth, int insn, const VALUE *opes)));
PUREFUNC(static rb_snum_t comptime_insn_stack_increase_dispatch(enum ruby_vminsn_type insn, const VALUE *opes));

rb_snum_t
comptime_insn_stack_increase_dispatch(enum ruby_vminsn_type insn, const VALUE *opes)
{
    static const signed char t[] = {
           0,    1,   -1,    1,   -1,    1,    1,   -1,
           1,   -1,    1,   -1,   -1,   -2,    1,   -1,
           1,    1,    1,    1,    1, -127,   -1, -127,
           0, -127, -127,    1,    1, -127,   -1,    0,
        -127,   -1,   -1,    1, -127,    0, -127, -127,
        -127,    0,   -1,    1,    0,   -1,    0,   -1,
        -127, -127,    0,    1,    0,    1, -127, -127,
        -127, -127,    0,    0,    0,   -1,   -1,   -1,
           1,    0,    1, -127,   -1,   -1,   -1,   -1,
          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
          -1,   -1,   -1,   -2,   -1,    0,    0,    0,
           0,    0,    0,   -1, -127,    1,    1,    1,
           1,   -1,   -1,    1,    1,    0,    0,    0,
           0,    0,    0,    0,    0,    0,    0,    0,
           0,    0,    0,    0,    0,    0,    0,    0,
           0,    0,    0,    0,    0,    0,    0,    0,
           0,    0,    0,    0,    0,    0,    0,    0,
           0,    0,    0,    0,    0,    0,    0,    0,
           0,    0,    0,    0,    0,    0,    0,    0,
           0,    0,    0,    0,    0,    0,    0,    0,
           0,    0,    0,    0,    0,    0,    0,    0,
           0,    0,    0,    0,    0,    0,    0,    0,
           0,    0,    0,    0,    0,    0,    0,    0,
           0,    0,    0,    0,    0,    0,    0,    0,
           0,    0,    0,    0,    0,    0,    0,    0,
           0,    0,
    };
    signed char c = t[insn];

    ASSERT_VM_INSTRUCTION_SIZE(t);
    if (c != -127) {
        return c;
    }
    else switch(insn) {
    default:
        UNREACHABLE;
    case BIN(concatstrings):
        return attr_sp_inc_concatstrings(NUM2LONG(opes[0]));
    case BIN(toregexp):
        return attr_sp_inc_toregexp(NUM2LONG(opes[0]), NUM2LONG(opes[1]));
    case BIN(newarray):
        return attr_sp_inc_newarray(NUM2LONG(opes[0]));
    case BIN(newarraykwsplat):
        return attr_sp_inc_newarraykwsplat(NUM2LONG(opes[0]));
    case BIN(expandarray):
        return attr_sp_inc_expandarray(NUM2LONG(opes[0]), NUM2LONG(opes[1]));
    case BIN(newhash):
        return attr_sp_inc_newhash(NUM2LONG(opes[0]));
    case BIN(dupn):
        return attr_sp_inc_dupn(NUM2LONG(opes[0]));
    case BIN(topn):
        return attr_sp_inc_topn(NUM2LONG(opes[0]));
    case BIN(setn):
        return attr_sp_inc_setn(NUM2LONG(opes[0]));
    case BIN(adjuststack):
        return attr_sp_inc_adjuststack(NUM2LONG(opes[0]));
    case BIN(send):
        return attr_comptime_sp_inc_send((CALL_INFO)(opes[0]), (ISEQ)(opes[1]));
    case BIN(opt_send_without_block):
        return attr_comptime_sp_inc_opt_send_without_block((CALL_INFO)(opes[0]));
    case BIN(opt_newarray_max):
        return attr_sp_inc_opt_newarray_max(NUM2LONG(opes[0]));
    case BIN(opt_newarray_min):
        return attr_sp_inc_opt_newarray_min(NUM2LONG(opes[0]));
    case BIN(invokesuper):
        return attr_comptime_sp_inc_invokesuper((CALL_INFO)(opes[0]), (ISEQ)(opes[1]));
    case BIN(invokeblock):
        return attr_comptime_sp_inc_invokeblock((CALL_INFO)(opes[0]));
    case BIN(opt_case_dispatch):
        return attr_sp_inc_opt_case_dispatch((CDHASH)(opes[0]), (OFFSET)(opes[1]));
    case BIN(invokebuiltin):
        return attr_sp_inc_invokebuiltin((RB_BUILTIN)(opes[0]));
    }
}

int
comptime_insn_stack_increase(int depth, int insn, const VALUE *opes)
{
    enum ruby_vminsn_type itype = (enum ruby_vminsn_type)insn;
    return depth + (int)comptime_insn_stack_increase_dispatch(itype, opes);
}

PUREFUNC(MAYBE_UNUSED(static bool insn_may_depend_on_sp_or_pc(int insn, const VALUE *opes)));

static bool
insn_may_depend_on_sp_or_pc(int insn, const VALUE *opes)
{
    switch (insn) {
      case BIN(getspecial):
      case BIN(getinstancevariable):
      case BIN(setinstancevariable):
      case BIN(getclassvariable):
      case BIN(setclassvariable):
      case BIN(getconstant):
      case BIN(setconstant):
      case BIN(getglobal):
      case BIN(setglobal):
      case BIN(putspecialobject):
      case BIN(concatstrings):
      case BIN(toregexp):
      case BIN(expandarray):
      case BIN(concatarray):
      case BIN(splatarray):
      case BIN(newhash):
      case BIN(newrange):
      case BIN(defined):
      case BIN(checkmatch):
      case BIN(defineclass):
      case BIN(definemethod):
      case BIN(definesmethod):
      case BIN(send):
      case BIN(opt_send_without_block):
      case BIN(objtostring):
      case BIN(opt_newarray_max):
      case BIN(opt_newarray_min):
      case BIN(invokesuper):
      case BIN(invokeblock):
      case BIN(leave):
      case BIN(throw):
      case BIN(jump):
      case BIN(branchif):
      case BIN(branchunless):
      case BIN(branchnil):
      case BIN(opt_setinlinecache):
      case BIN(once):
      case BIN(opt_div):
      case BIN(opt_mod):
      case BIN(opt_ltlt):
      case BIN(opt_aref):
      case BIN(opt_aset):
      case BIN(opt_aset_with):
      case BIN(opt_aref_with):
      case BIN(opt_regexpmatch2):
      case BIN(invokebuiltin):
      case BIN(opt_invokebuiltin_delegate):
      case BIN(opt_invokebuiltin_delegate_leave):
      case BIN(trace_nop):
      case BIN(trace_getlocal):
      case BIN(trace_setlocal):
      case BIN(trace_getblockparam):
      case BIN(trace_setblockparam):
      case BIN(trace_getblockparamproxy):
      case BIN(trace_getspecial):
      case BIN(trace_setspecial):
      case BIN(trace_getinstancevariable):
      case BIN(trace_setinstancevariable):
      case BIN(trace_getclassvariable):
      case BIN(trace_setclassvariable):
      case BIN(trace_getconstant):
      case BIN(trace_setconstant):
      case BIN(trace_getglobal):
      case BIN(trace_setglobal):
      case BIN(trace_putnil):
      case BIN(trace_putself):
      case BIN(trace_putobject):
      case BIN(trace_putspecialobject):
      case BIN(trace_putstring):
      case BIN(trace_concatstrings):
      case BIN(trace_anytostring):
      case BIN(trace_toregexp):
      case BIN(trace_intern):
      case BIN(trace_newarray):
      case BIN(trace_newarraykwsplat):
      case BIN(trace_duparray):
      case BIN(trace_duphash):
      case BIN(trace_expandarray):
      case BIN(trace_concatarray):
      case BIN(trace_splatarray):
      case BIN(trace_newhash):
      case BIN(trace_newrange):
      case BIN(trace_pop):
      case BIN(trace_dup):
      case BIN(trace_dupn):
      case BIN(trace_swap):
      case BIN(trace_topn):
      case BIN(trace_setn):
      case BIN(trace_adjuststack):
      case BIN(trace_defined):
      case BIN(trace_checkmatch):
      case BIN(trace_checkkeyword):
      case BIN(trace_checktype):
      case BIN(trace_defineclass):
      case BIN(trace_definemethod):
      case BIN(trace_definesmethod):
      case BIN(trace_send):
      case BIN(trace_opt_send_without_block):
      case BIN(trace_objtostring):
      case BIN(trace_opt_str_freeze):
      case BIN(trace_opt_nil_p):
      case BIN(trace_opt_str_uminus):
      case BIN(trace_opt_newarray_max):
      case BIN(trace_opt_newarray_min):
      case BIN(trace_invokesuper):
      case BIN(trace_invokeblock):
      case BIN(trace_leave):
      case BIN(trace_throw):
      case BIN(trace_jump):
      case BIN(trace_branchif):
      case BIN(trace_branchunless):
      case BIN(trace_branchnil):
      case BIN(trace_opt_getinlinecache):
      case BIN(trace_opt_setinlinecache):
      case BIN(trace_once):
      case BIN(trace_opt_case_dispatch):
      case BIN(trace_opt_plus):
      case BIN(trace_opt_minus):
      case BIN(trace_opt_mult):
      case BIN(trace_opt_div):
      case BIN(trace_opt_mod):
      case BIN(trace_opt_eq):
      case BIN(trace_opt_neq):
      case BIN(trace_opt_lt):
      case BIN(trace_opt_le):
      case BIN(trace_opt_gt):
      case BIN(trace_opt_ge):
      case BIN(trace_opt_ltlt):
      case BIN(trace_opt_and):
      case BIN(trace_opt_or):
      case BIN(trace_opt_aref):
      case BIN(trace_opt_aset):
      case BIN(trace_opt_aset_with):
      case BIN(trace_opt_aref_with):
      case BIN(trace_opt_length):
      case BIN(trace_opt_size):
      case BIN(trace_opt_empty_p):
      case BIN(trace_opt_succ):
      case BIN(trace_opt_not):
      case BIN(trace_opt_regexpmatch2):
      case BIN(trace_invokebuiltin):
      case BIN(trace_opt_invokebuiltin_delegate):
      case BIN(trace_opt_invokebuiltin_delegate_leave):
      case BIN(trace_getlocal_WC_0):
      case BIN(trace_getlocal_WC_1):
      case BIN(trace_setlocal_WC_0):
      case BIN(trace_setlocal_WC_1):
      case BIN(trace_putobject_INT2FIX_0_):
      case BIN(trace_putobject_INT2FIX_1_):
        return true;
      default:
        return false;
    }
}

