/* -*- 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)));

#ifdef RUBY_VM_INSNS_INFO
const int rb_vm_max_insn_name_size = 38;
#endif

const char *
insn_name(VALUE i)
{
    static const char x[] =
        "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"
        "tostring" "\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"
        "reverse" "\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"
        "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_tostring" "\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_reverse" "\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_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"
        ;

    static const unsigned short y[] = {
           0,    4,   13,   22,   36,   50,   69,   80,   91,  111,  131,  148,
         165,  177,  189,  199,  209,  216,  224,  234,  251,  261,  275,  284,
         293,  300,  309,  325,  334,  342,  354,  366,  377,  385,  394,  398,
         402,  407,  412,  420,  425,  430,  442,  450,  461,  474,  484,  496,
         509,  523,  528,  551,  566,  576,  591,  608,  625,  637,  649,  655,
         661,  666,  675,  688,  698,  717,  736,  741,  759,  768,  778,  787,
         795,  803,  810,  818,  825,  832,  839,  846,  855,  863,  870,  879,
         888,  902,  916,  927,  936,  948,  957,  965,  982,  996, 1023, 1056,
        1070, 1084, 1098, 1112, 1133, 1154, 1164, 1179, 1194, 1214, 1234, 1259,
        1276, 1293, 1319, 1345, 1368, 1391, 1409, 1427, 1443, 1459, 1472, 1486,
        1502, 1525, 1541, 1561, 1576, 1591, 1604, 1619, 1641, 1656, 1670, 1688,
        1706, 1723, 1737, 1752, 1762, 1772, 1783, 1794, 1808, 1819, 1830, 1848,
        1862, 1879, 1898, 1914, 1932, 1951, 1971, 1982, 2011, 2032, 2048, 2069,
        2092, 2115, 2133, 2151, 2163, 2175, 2186, 2201, 2220, 2236, 2261, 2286,
        2297, 2321, 2336, 2352, 2367, 2381, 2395, 2408, 2422, 2435, 2448, 2461,
        2474, 2489, 2503, 2516, 2531, 2546, 2566, 2586, 2603, 2618, 2636, 2651,
        2665, 2688, 2708, 2741, 2780, 2800, 2820, 2840, 2860, 2887,
    };

    ASSERT_VM_INSTRUCTION_SIZE(y);

    return &x[y[i]];
}

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

int
insn_len(VALUE i)
{
    static const char t[] = {
        1, 3, 3, 3, 3, 3, 3, 2, 3, 3, 2, 2, 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, 2, 4, 2, 3, 2,
        4, 3, 3, 3, 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, 2, 2, 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, 2, 4, 2, 3, 2, 4, 3, 3, 3, 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(t);
    return t[i];
}

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

const char *
insn_op_types(VALUE i)
{
    static const char x[] =
        ""     "\0" "LN"   "\0" "LN"   "\0" "LN"   "\0" "LN"   "\0"
        "LN"   "\0" "NN"   "\0" "N"    "\0" "IA"   "\0" "IA"   "\0"
        "I"    "\0" "I"    "\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" "N"    "\0" "NVV"  "\0" "N"    "\0" "LL"   "\0"
        "N"    "\0" "ISN"  "\0" "IS"   "\0" "IS"   "\0" "CS"   "\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" "I"    "\0" "I"    "\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" "N"    "\0" "NVV"  "\0" "N"    "\0"
        "LL"   "\0" "N"    "\0" "ISN"  "\0" "IS"   "\0" "IS"   "\0"
        "CS"   "\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"
        ;

    static const unsigned short y[] = {
          0,   1,   4,   7,  10,  13,  16,  19,  21,  24,  27,  29,
         31,  33,  35,  37,  39,  40,  41,  43,  45,  47,  49,  50,
         53,  54,  56,  58,  60,  62,  65,  66,  68,  70,  72,  73,
         74,  76,  77,  79,  81,  83,  85,  89,  91,  94,  96, 100,
        103, 106, 109, 111, 114, 116, 119, 121, 123, 126, 128, 129,
        131, 133, 135, 137, 139, 142, 144, 147, 150, 152, 154, 156,
        158, 160, 162, 165, 167, 169, 171, 173, 175, 177, 179, 181,
        183, 186, 189, 191, 193, 195, 197, 199, 201, 203, 206, 209,
        211, 213, 215, 217, 218, 219, 220, 223, 226, 229, 232, 235,
        238, 240, 243, 246, 248, 250, 252, 254, 256, 258, 259, 260,
        262, 264, 266, 268, 269, 272, 273, 275, 277, 279, 281, 284,
        285, 287, 289, 291, 292, 293, 295, 296, 298, 300, 302, 304,
        308, 310, 313, 315, 319, 322, 325, 328, 330, 333, 335, 338,
        340, 342, 345, 347, 348, 350, 352, 354, 356, 358, 361, 363,
        366, 369, 371, 373, 375, 377, 379, 381, 384, 386, 388, 390,
        392, 394, 396, 398, 400, 402, 405, 408, 410, 412, 414, 416,
        418, 420, 422, 425, 428, 430, 432, 434, 436, 437,
    };

    ASSERT_VM_INSTRUCTION_SIZE(y);

    return &x[y[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_IVAR2:
      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 449 "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 479 "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)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_getclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_getclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_getclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_getclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_getclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_getclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_getclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_setclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_setclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_setclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_setclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_setclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_setclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_setclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_setclassvariable(ID id)));
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_tostring(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_tostring(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_tostring(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_tostring(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_tostring(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_tostring(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_tostring(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_tostring(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_tostring(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_reverse(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_reverse(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_reverse(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_reverse(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_reverse(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_reverse(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_reverse(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_reverse(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_reverse(rb_num_t n)));
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 needstr)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_defined(rb_num_t op_type, VALUE obj, VALUE needstr)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_defined(rb_num_t op_type, VALUE obj, VALUE needstr)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_defined(rb_num_t op_type, VALUE obj, VALUE needstr)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_defined(rb_num_t op_type, VALUE obj, VALUE needstr)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_defined(rb_num_t op_type, VALUE obj, VALUE needstr)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_defined(rb_num_t op_type, VALUE obj, VALUE needstr)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_defined(rb_num_t op_type, VALUE obj, VALUE needstr)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_defined(rb_num_t op_type, VALUE obj, VALUE needstr)));
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_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 1946 "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 2102 "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 2195 "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)()(val) */
enum ruby_vminsn_type
attr_bin_getclassvariable(MAYBE_UNUSED(ID id))
{
    return BIN(getclassvariable);
}

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

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

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

/* attr rb_num_t open @ getclassvariable(id)()(val) */
rb_num_t
attr_open_getclassvariable(MAYBE_UNUSED(ID id))
{
    return 1;
}

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

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

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

/* attr rb_num_t width @ getclassvariable(id)()(val) */
rb_num_t
attr_width_getclassvariable(MAYBE_UNUSED(ID id))
{
    return 2;
}

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

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

/* attr bool leaf @ setclassvariable(id)(val)() */
bool
attr_leaf_setclassvariable(MAYBE_UNUSED(ID id))
{
    return
#line 249 "insns.def"
false;
#line 2345 "insns_info.inc"
}

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

/* attr rb_num_t open @ setclassvariable(id)(val)() */
rb_num_t
attr_open_setclassvariable(MAYBE_UNUSED(ID id))
{
    return 1;
}

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

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

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

/* attr rb_num_t width @ setclassvariable(id)(val)() */
rb_num_t
attr_width_setclassvariable(MAYBE_UNUSED(ID id))
{
    return 2;
}

/* 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 265 "insns.def"
false;
#line 2411 "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 281 "insns.def"
false;
#line 2477 "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 294 "insns.def"
false;
#line 2543 "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 305 "insns.def"
false;
#line 2609 "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 true;
}

/* 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 377 "insns.def"
false;
#line 2990 "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 378 "insns.def"
1 - (rb_snum_t)num;
#line 3028 "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 @ tostring()(val, str)(val) */
enum ruby_vminsn_type
attr_bin_tostring(void)
{
    return BIN(tostring);
}

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

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

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

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

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

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

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

/* attr rb_num_t width @ tostring()(val, str)(val) */
rb_num_t
attr_width_tostring(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 403 "insns.def"
false;
#line 3131 "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 404 "insns.def"
1 - (rb_snum_t)cnt;
#line 3184 "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 427 "insns.def"
1 - (rb_snum_t)num;
#line 3316 "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 442 "insns.def"
1 - (rb_snum_t)num;
#line 3382 "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 488 "insns.def"
false;
#line 3548 "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 489 "insns.def"
(rb_snum_t)num - 1 + (flag & 1 ? 1 : 0);
#line 3601 "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 500 "insns.def"
false;
#line 3635 "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 511 "insns.def"
false;
#line 3701 "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 522 "insns.def"
false;
#line 3767 "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 523 "insns.def"
1 - (rb_snum_t)num;
#line 3805 "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 541 "insns.def"
false;
#line 3836 "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 577 "insns.def"
n;
#line 4063 "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 @ reverse(n)(...)(...) */
enum ruby_vminsn_type
attr_bin_reverse(MAYBE_UNUSED(rb_num_t n))
{
    return BIN(reverse);
}

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

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

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

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

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

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

/* attr rb_snum_t sp_inc @ reverse(n)(...)(...) */
rb_snum_t
attr_sp_inc_reverse(MAYBE_UNUSED(rb_num_t n))
{
    return
#line 601 "insns.def"
0;
#line 4192 "insns_info.inc"
}

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

/* 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 631 "insns.def"
1;
#line 4258 "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 642 "insns.def"
0;
#line 4324 "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 653 "insns.def"
-(rb_snum_t)n;
#line 4390 "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, needstr)(v)(val) */
enum ruby_vminsn_type
attr_bin_defined(
    MAYBE_UNUSED(rb_num_t op_type),
    MAYBE_UNUSED(VALUE obj),
    MAYBE_UNUSED(VALUE needstr)
)
{
    return BIN(defined);
}

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

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

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

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

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

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

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

/* attr rb_num_t width @ defined(op_type, obj, needstr)(v)(val) */
rb_num_t
attr_width_defined(
    MAYBE_UNUSED(rb_num_t op_type),
    MAYBE_UNUSED(VALUE obj),
    MAYBE_UNUSED(VALUE needstr)
)
{
    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 685 "insns.def"
leafness_of_checkmatch(flag);
#line 4523 "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 767 "insns.def"
sp_inc_of_sendish(ci);
#line 5020 "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 766 "insns.def"
sp_inc_of_sendish(cd->ci);
#line 5093 "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 786 "insns.def"
sp_inc_of_sendish(ci);
#line 5120 "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 784 "insns.def"
true;
#line 5130 "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 785 "insns.def"
sp_inc_of_sendish(cd->ci);
#line 5175 "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 @ 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 848 "insns.def"
false;
#line 5449 "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 849 "insns.def"
1 - (rb_snum_t)num;
#line 5487 "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 860 "insns.def"
false;
#line 5518 "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 861 "insns.def"
1 - (rb_snum_t)num;
#line 5556 "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 873 "insns.def"
sp_inc_of_sendish(ci);
#line 5586 "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 872 "insns.def"
sp_inc_of_sendish(cd->ci);
#line 5659 "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 892 "insns.def"
sp_inc_of_invokeblock(ci);
#line 5686 "insns_info.inc"
}

/* attr bool handles_sp @ invokeblock(cd)(...)(val) */
bool
attr_handles_sp_invokeblock(MAYBE_UNUSED(CALL_DATA cd))
{
    return
#line 890 "insns.def"
true;
#line 5696 "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 891 "insns.def"
sp_inc_of_invokeblock(cd->ci);
#line 5741 "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 913 "insns.def"
true;
#line 5765 "insns_info.inc"
}

/* attr bool leaf @ leave()(val)(val) */
bool
attr_leaf_leave(void)
{
    return
#line 912 "insns.def"
false;
#line 5775 "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 946 "insns.def"
false;
#line 5841 "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 964 "insns.def"
leafness_of_check_ints;
#line 5907 "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 977 "insns.def"
leafness_of_check_ints;
#line 5973 "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 992 "insns.def"
leafness_of_check_ints;
#line 6039 "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 1007 "insns.def"
leafness_of_check_ints;
#line 6105 "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 true;
}

/* 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 1061 "insns.def"
-1;
#line 6473 "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 1122 "insns.def"
false;
#line 6696 "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 1138 "insns.def"
false;
#line 6762 "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 1240 "insns.def"
false;
#line 7233 "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 1287 "insns.def"
false;
#line 7425 "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 1304 "insns.def"
false;
#line 7491 "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 1320 "insns.def"
false;
#line 7566 "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 1343 "insns.def"
false;
#line 7659 "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 1431 "insns.def"
false;
#line 8058 "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 1467 "insns.def"
false;
#line 8124 "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 1468 "insns.def"
1 - bf->argc;
#line 8162 "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 1479 "insns.def"
false;
#line 8202 "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 1490 "insns.def"
false;
#line 8295 "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, -127,    0,   -1,    1,    0,   -1,    0,
          -1, -127, -127,    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(reverse):
        return attr_sp_inc_reverse(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(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(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(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_tostring):
      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_reverse):
      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_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;
    }
}

