/* -*- 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_ICVARC = 'J',
    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',
};

static inline union iseq_inline_storage_entry *
ISEQ_IS_ENTRY_START(const struct rb_iseq_constant_body *body, char op_type)
{
    unsigned int relative_ic_offset = 0;
    switch (op_type) {
      case TS_IC:
        relative_ic_offset += body->ise_size;
      case TS_ISE:
        relative_ic_offset += body->icvarc_size;
      case TS_ICVARC:
        relative_ic_offset += body->ivc_size;
      case TS_IVC:
        break;
      default:
        rb_bug("Wrong op type");
    }
    return &body->is_entries[relative_ic_offset];
}

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

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

#ifdef RUBY_VM_INSNS_INFO
const int rb_vm_max_insn_name_size = 38;

const char rb_vm_insn_name_base[] =
    "nop" "\0"
    "getlocal" "\0"
    "setlocal" "\0"
    "getblockparam" "\0"
    "setblockparam" "\0"
    "getblockparamproxy" "\0"
    "getspecial" "\0"
    "setspecial" "\0"
    "getinstancevariable" "\0"
    "setinstancevariable" "\0"
    "getclassvariable" "\0"
    "setclassvariable" "\0"
    "opt_getconstant_path" "\0"
    "getconstant" "\0"
    "setconstant" "\0"
    "getglobal" "\0"
    "setglobal" "\0"
    "putnil" "\0"
    "putself" "\0"
    "putobject" "\0"
    "putspecialobject" "\0"
    "putstring" "\0"
    "putchilledstring" "\0"
    "concatstrings" "\0"
    "anytostring" "\0"
    "toregexp" "\0"
    "intern" "\0"
    "newarray" "\0"
    "pushtoarraykwsplat" "\0"
    "duparray" "\0"
    "duphash" "\0"
    "expandarray" "\0"
    "concatarray" "\0"
    "concattoarray" "\0"
    "pushtoarray" "\0"
    "splatarray" "\0"
    "splatkw" "\0"
    "newhash" "\0"
    "newrange" "\0"
    "pop" "\0"
    "dup" "\0"
    "dupn" "\0"
    "swap" "\0"
    "opt_reverse" "\0"
    "topn" "\0"
    "setn" "\0"
    "adjuststack" "\0"
    "defined" "\0"
    "definedivar" "\0"
    "checkmatch" "\0"
    "checkkeyword" "\0"
    "checktype" "\0"
    "defineclass" "\0"
    "definemethod" "\0"
    "definesmethod" "\0"
    "send" "\0"
    "sendforward" "\0"
    "opt_send_without_block" "\0"
    "objtostring" "\0"
    "opt_ary_freeze" "\0"
    "opt_hash_freeze" "\0"
    "opt_str_freeze" "\0"
    "opt_nil_p" "\0"
    "opt_str_uminus" "\0"
    "opt_duparray_send" "\0"
    "opt_newarray_send" "\0"
    "invokesuper" "\0"
    "invokesuperforward" "\0"
    "invokeblock" "\0"
    "leave" "\0"
    "throw" "\0"
    "jump" "\0"
    "branchif" "\0"
    "branchunless" "\0"
    "branchnil" "\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_opt_getconstant_path" "\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_putchilledstring" "\0"
    "trace_concatstrings" "\0"
    "trace_anytostring" "\0"
    "trace_toregexp" "\0"
    "trace_intern" "\0"
    "trace_newarray" "\0"
    "trace_pushtoarraykwsplat" "\0"
    "trace_duparray" "\0"
    "trace_duphash" "\0"
    "trace_expandarray" "\0"
    "trace_concatarray" "\0"
    "trace_concattoarray" "\0"
    "trace_pushtoarray" "\0"
    "trace_splatarray" "\0"
    "trace_splatkw" "\0"
    "trace_newhash" "\0"
    "trace_newrange" "\0"
    "trace_pop" "\0"
    "trace_dup" "\0"
    "trace_dupn" "\0"
    "trace_swap" "\0"
    "trace_opt_reverse" "\0"
    "trace_topn" "\0"
    "trace_setn" "\0"
    "trace_adjuststack" "\0"
    "trace_defined" "\0"
    "trace_definedivar" "\0"
    "trace_checkmatch" "\0"
    "trace_checkkeyword" "\0"
    "trace_checktype" "\0"
    "trace_defineclass" "\0"
    "trace_definemethod" "\0"
    "trace_definesmethod" "\0"
    "trace_send" "\0"
    "trace_sendforward" "\0"
    "trace_opt_send_without_block" "\0"
    "trace_objtostring" "\0"
    "trace_opt_ary_freeze" "\0"
    "trace_opt_hash_freeze" "\0"
    "trace_opt_str_freeze" "\0"
    "trace_opt_nil_p" "\0"
    "trace_opt_str_uminus" "\0"
    "trace_opt_duparray_send" "\0"
    "trace_opt_newarray_send" "\0"
    "trace_invokesuper" "\0"
    "trace_invokesuperforward" "\0"
    "trace_invokeblock" "\0"
    "trace_leave" "\0"
    "trace_throw" "\0"
    "trace_jump" "\0"
    "trace_branchif" "\0"
    "trace_branchunless" "\0"
    "trace_branchnil" "\0"
    "trace_once" "\0"
    "trace_opt_case_dispatch" "\0"
    "trace_opt_plus" "\0"
    "trace_opt_minus" "\0"
    "trace_opt_mult" "\0"
    "trace_opt_div" "\0"
    "trace_opt_mod" "\0"
    "trace_opt_eq" "\0"
    "trace_opt_neq" "\0"
    "trace_opt_lt" "\0"
    "trace_opt_le" "\0"
    "trace_opt_gt" "\0"
    "trace_opt_ge" "\0"
    "trace_opt_ltlt" "\0"
    "trace_opt_and" "\0"
    "trace_opt_or" "\0"
    "trace_opt_aref" "\0"
    "trace_opt_aset" "\0"
    "trace_opt_aset_with" "\0"
    "trace_opt_aref_with" "\0"
    "trace_opt_length" "\0"
    "trace_opt_size" "\0"
    "trace_opt_empty_p" "\0"
    "trace_opt_succ" "\0"
    "trace_opt_not" "\0"
    "trace_opt_regexpmatch2" "\0"
    "trace_invokebuiltin" "\0"
    "trace_opt_invokebuiltin_delegate" "\0"
    "trace_opt_invokebuiltin_delegate_leave" "\0"
    "trace_getlocal_WC_0" "\0"
    "trace_getlocal_WC_1" "\0"
    "trace_setlocal_WC_0" "\0"
    "trace_setlocal_WC_1" "\0"
    "trace_putobject_INT2FIX_0_" "\0"
    "trace_putobject_INT2FIX_1_" "\0"
    ;

const unsigned short rb_vm_insn_name_offset[] = {
       0,    4,   13,   22,   36,   50,   69,   80,   91,  111,  131,  148,
     165,  186,  198,  210,  220,  230,  237,  245,  255,  272,  282,  299,
     313,  325,  334,  341,  350,  369,  378,  386,  398,  410,  424,  436,
     447,  455,  463,  472,  476,  480,  485,  490,  502,  507,  512,  524,
     532,  544,  555,  568,  578,  590,  603,  617,  622,  634,  657,  669,
     684,  700,  715,  725,  740,  758,  776,  788,  807,  819,  825,  831,
     836,  845,  858,  868,  873,  891,  900,  910,  919,  927,  935,  942,
     950,  957,  964,  971,  978,  987,  995, 1002, 1011, 1020, 1034, 1048,
    1059, 1068, 1080, 1089, 1097, 1114, 1128, 1155, 1188, 1202, 1216, 1230,
    1244, 1265, 1286, 1296, 1311, 1326, 1346, 1366, 1391, 1408, 1425, 1451,
    1477, 1500, 1523, 1550, 1568, 1586, 1602, 1618, 1631, 1645, 1661, 1684,
    1700, 1723, 1743, 1761, 1776, 1789, 1804, 1829, 1844, 1858, 1876, 1894,
    1914, 1932, 1949, 1963, 1977, 1992, 2002, 2012, 2023, 2034, 2052, 2063,
    2074, 2092, 2106, 2124, 2141, 2160, 2176, 2194, 2213, 2233, 2244, 2262,
    2291, 2309, 2330, 2352, 2373, 2389, 2410, 2434, 2458, 2476, 2501, 2519,
    2531, 2543, 2554, 2569, 2588, 2604, 2615, 2639, 2654, 2670, 2685, 2699,
    2713, 2726, 2740, 2753, 2766, 2779, 2792, 2807, 2821, 2834, 2849, 2864,
    2884, 2904, 2921, 2936, 2954, 2969, 2983, 3006, 3026, 3059, 3098, 3118,
    3138, 3158, 3178, 3205,
};

ASSERT_VM_INSTRUCTION_SIZE(rb_vm_insn_name_offset);
#endif

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

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

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

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

ASSERT_VM_INSTRUCTION_SIZE(rb_vm_insn_len_info);
#endif

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

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

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

#ifdef RUBY_VM_INSNS_INFO
const char rb_vm_insn_op_base[] =
    ""     "\0" "LN"   "\0" "LN"   "\0" "LN"   "\0" "LN"   "\0"
    "LN"   "\0" "NN"   "\0" "N"    "\0" "IA"   "\0" "IA"   "\0"
    "IJ"   "\0" "IJ"   "\0" "K"    "\0" "I"    "\0" "I"    "\0"
    "I"    "\0" "I"    "\0" ""     "\0" ""     "\0" "V"    "\0"
    "N"    "\0" "V"    "\0" "V"    "\0" "N"    "\0" ""     "\0"
    "NN"   "\0" ""     "\0" "N"    "\0" ""     "\0" "V"    "\0"
    "V"    "\0" "NN"   "\0" ""     "\0" ""     "\0" "N"    "\0"
    "V"    "\0" ""     "\0" "N"    "\0" "N"    "\0" ""     "\0"
    ""     "\0" "N"    "\0" ""     "\0" "N"    "\0" "N"    "\0"
    "N"    "\0" "N"    "\0" "NVV"  "\0" "IAV"  "\0" "N"    "\0"
    "LL"   "\0" "N"    "\0" "ISN"  "\0" "IS"   "\0" "IS"   "\0"
    "CS"   "\0" "CS"   "\0" "C"    "\0" "C"    "\0" "VC"   "\0"
    "VC"   "\0" "VC"   "\0" "C"    "\0" "VC"   "\0" "VIN"  "\0"
    "NN"   "\0" "CS"   "\0" "CS"   "\0" "C"    "\0" ""     "\0"
    "N"    "\0" "O"    "\0" "O"    "\0" "O"    "\0" "O"    "\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"
    "IJ"   "\0" "IJ"   "\0" "K"    "\0" "I"    "\0" "I"    "\0"
    "I"    "\0" "I"    "\0" ""     "\0" ""     "\0" "V"    "\0"
    "N"    "\0" "V"    "\0" "V"    "\0" "N"    "\0" ""     "\0"
    "NN"   "\0" ""     "\0" "N"    "\0" ""     "\0" "V"    "\0"
    "V"    "\0" "NN"   "\0" ""     "\0" ""     "\0" "N"    "\0"
    "V"    "\0" ""     "\0" "N"    "\0" "N"    "\0" ""     "\0"
    ""     "\0" "N"    "\0" ""     "\0" "N"    "\0" "N"    "\0"
    "N"    "\0" "N"    "\0" "NVV"  "\0" "IAV"  "\0" "N"    "\0"
    "LL"   "\0" "N"    "\0" "ISN"  "\0" "IS"   "\0" "IS"   "\0"
    "CS"   "\0" "CS"   "\0" "C"    "\0" "C"    "\0" "VC"   "\0"
    "VC"   "\0" "VC"   "\0" "C"    "\0" "VC"   "\0" "VIN"  "\0"
    "NN"   "\0" "CS"   "\0" "CS"   "\0" "C"    "\0" ""     "\0"
    "N"    "\0" "O"    "\0" "O"    "\0" "O"    "\0" "O"    "\0"
    "ST"   "\0" "HO"   "\0" "C"    "\0" "C"    "\0" "C"    "\0"
    "C"    "\0" "C"    "\0" "C"    "\0" "CC"   "\0" "C"    "\0"
    "C"    "\0" "C"    "\0" "C"    "\0" "C"    "\0" "C"    "\0"
    "C"    "\0" "C"    "\0" "C"    "\0" "VC"   "\0" "VC"   "\0"
    "C"    "\0" "C"    "\0" "C"    "\0" "C"    "\0" "C"    "\0"
    "C"    "\0" "R"    "\0" "RN"   "\0" "RN"   "\0" "L"    "\0"
    "L"    "\0" "L"    "\0" "L"    "\0" ""     "\0" ""     "\0"
    ;

const unsigned short rb_vm_insn_op_offset[] = {
      0,   1,   4,   7,  10,  13,  16,  19,  21,  24,  27,  30,
     33,  35,  37,  39,  41,  43,  44,  45,  47,  49,  51,  53,
     55,  56,  59,  60,  62,  63,  65,  67,  70,  71,  72,  74,
     76,  77,  79,  81,  82,  83,  85,  86,  88,  90,  92,  94,
     98, 102, 104, 107, 109, 113, 116, 119, 122, 125, 127, 129,
    132, 135, 138, 140, 143, 147, 150, 153, 156, 158, 159, 161,
    163, 165, 167, 169, 172, 175, 177, 179, 181, 183, 185, 187,
    190, 192, 194, 196, 198, 200, 202, 204, 206, 208, 211, 214,
    216, 218, 220, 222, 224, 226, 228, 231, 234, 236, 238, 240,
    242, 243, 244, 245, 248, 251, 254, 257, 260, 263, 265, 268,
    271, 274, 277, 279, 281, 283, 285, 287, 288, 289, 291, 293,
    295, 297, 299, 300, 303, 304, 306, 307, 309, 311, 314, 315,
    316, 318, 320, 321, 323, 325, 326, 327, 329, 330, 332, 334,
    336, 338, 342, 346, 348, 351, 353, 357, 360, 363, 366, 369,
    371, 373, 376, 379, 382, 384, 387, 391, 394, 397, 400, 402,
    403, 405, 407, 409, 411, 413, 416, 419, 421, 423, 425, 427,
    429, 431, 434, 436, 438, 440, 442, 444, 446, 448, 450, 452,
    455, 458, 460, 462, 464, 466, 468, 470, 472, 475, 478, 480,
    482, 484, 486, 487,
};

ASSERT_VM_INSTRUCTION_SIZE(rb_vm_insn_op_offset);
#endif

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

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

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

#include "iseq.h"

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

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

static bool
leafness_of_checkmatch(rb_num_t flag)
{
    /* see also: vm_insnhelper.c:check_match() */
    if (flag == VM_CHECKMATCH_TYPE_WHEN) {
        return true;
    }
    else {
        /* has rb_funcallv() */
        return false;
    }
}
#line 514 "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 | VM_CALL_FORWARDING)) ? 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 544 "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, ICVARC ic)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_getclassvariable(ID id, ICVARC ic)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_getclassvariable(ID id, ICVARC ic)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getclassvariable(ID id, ICVARC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_getclassvariable(ID id, ICVARC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_getclassvariable(ID id, ICVARC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_getclassvariable(ID id, ICVARC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_getclassvariable(ID id, ICVARC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_getclassvariable(ID id, ICVARC ic)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_setclassvariable(ID id, ICVARC ic)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_setclassvariable(ID id, ICVARC ic)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_setclassvariable(ID id, ICVARC ic)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setclassvariable(ID id, ICVARC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_setclassvariable(ID id, ICVARC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_setclassvariable(ID id, ICVARC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_setclassvariable(ID id, ICVARC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_setclassvariable(ID id, ICVARC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_setclassvariable(ID id, ICVARC ic)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_getconstant_path(IC ic)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_getconstant_path(IC ic)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_getconstant_path(IC ic)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_getconstant_path(IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_getconstant_path(IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_getconstant_path(IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_getconstant_path(IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_getconstant_path(IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_getconstant_path(IC ic)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_getconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_getconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_getconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_getconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_getconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_getconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_getconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_getconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_setconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_setconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_setconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_setconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_setconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_setconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_setconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_setconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_getglobal(ID gid)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_getglobal(ID gid)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_getglobal(ID gid)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getglobal(ID gid)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_getglobal(ID gid)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_getglobal(ID gid)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_getglobal(ID gid)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_getglobal(ID gid)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_getglobal(ID gid)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_setglobal(ID gid)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_setglobal(ID gid)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_setglobal(ID gid)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setglobal(ID gid)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_setglobal(ID gid)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_setglobal(ID gid)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_setglobal(ID gid)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_setglobal(ID gid)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_setglobal(ID gid)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_putnil(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_putnil(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_putnil(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_putnil(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_putnil(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_putnil(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_putnil(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_putnil(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_putnil(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_putself(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_putself(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_putself(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_putself(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_putself(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_putself(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_putself(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_putself(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_putself(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_putobject(VALUE val)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_putobject(VALUE val)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_putobject(VALUE val)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_putobject(VALUE val)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_putobject(VALUE val)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_putobject(VALUE val)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_putobject(VALUE val)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_putobject(VALUE val)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_putobject(VALUE val)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_putspecialobject(rb_num_t value_type)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_putspecialobject(rb_num_t value_type)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_putspecialobject(rb_num_t value_type)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_putspecialobject(rb_num_t value_type)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_putspecialobject(rb_num_t value_type)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_putspecialobject(rb_num_t value_type)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_putspecialobject(rb_num_t value_type)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_putspecialobject(rb_num_t value_type)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_putspecialobject(rb_num_t value_type)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_putstring(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_putstring(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_putstring(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_putstring(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_putstring(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_putstring(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_putstring(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_putstring(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_putstring(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_putchilledstring(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_putchilledstring(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_putchilledstring(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_putchilledstring(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_putchilledstring(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_putchilledstring(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_putchilledstring(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_putchilledstring(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_putchilledstring(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_concatstrings(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_concatstrings(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_concatstrings(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_concatstrings(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_concatstrings(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_concatstrings(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_concatstrings(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_concatstrings(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_concatstrings(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_anytostring(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_anytostring(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_anytostring(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_anytostring(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_anytostring(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_anytostring(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_anytostring(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_anytostring(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_anytostring(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_toregexp(rb_num_t opt, rb_num_t cnt)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_toregexp(rb_num_t opt, rb_num_t cnt)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_toregexp(rb_num_t opt, rb_num_t cnt)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_toregexp(rb_num_t opt, rb_num_t cnt)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_toregexp(rb_num_t opt, rb_num_t cnt)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_toregexp(rb_num_t opt, rb_num_t cnt)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_toregexp(rb_num_t opt, rb_num_t cnt)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_toregexp(rb_num_t opt, rb_num_t cnt)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_toregexp(rb_num_t opt, rb_num_t cnt)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_intern(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_intern(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_intern(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_intern(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_intern(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_intern(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_intern(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_intern(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_intern(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_newarray(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_newarray(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_newarray(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_newarray(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_newarray(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_newarray(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_newarray(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_newarray(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_newarray(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_pushtoarraykwsplat(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_pushtoarraykwsplat(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_pushtoarraykwsplat(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_pushtoarraykwsplat(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_pushtoarraykwsplat(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_pushtoarraykwsplat(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_pushtoarraykwsplat(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_pushtoarraykwsplat(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_pushtoarraykwsplat(void)));
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_concattoarray(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_concattoarray(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_concattoarray(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_concattoarray(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_concattoarray(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_concattoarray(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_concattoarray(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_concattoarray(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_concattoarray(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_pushtoarray(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_pushtoarray(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_pushtoarray(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_pushtoarray(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_pushtoarray(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_pushtoarray(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_pushtoarray(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_pushtoarray(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_pushtoarray(rb_num_t num)));
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_splatkw(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_splatkw(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_splatkw(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_splatkw(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_splatkw(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_splatkw(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_splatkw(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_splatkw(void)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_splatkw(void)));
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_opt_reverse(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_reverse(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_reverse(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_reverse(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_reverse(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_reverse(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_reverse(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_reverse(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_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 pushval)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_defined(rb_num_t op_type, VALUE obj, VALUE pushval)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_defined(rb_num_t op_type, VALUE obj, VALUE pushval)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_defined(rb_num_t op_type, VALUE obj, VALUE pushval)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_defined(rb_num_t op_type, VALUE obj, VALUE pushval)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_defined(rb_num_t op_type, VALUE obj, VALUE pushval)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_defined(rb_num_t op_type, VALUE obj, VALUE pushval)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_defined(rb_num_t op_type, VALUE obj, VALUE pushval)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_defined(rb_num_t op_type, VALUE obj, VALUE pushval)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_definedivar(ID id, IVC ic, VALUE pushval)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_definedivar(ID id, IVC ic, VALUE pushval)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_definedivar(ID id, IVC ic, VALUE pushval)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_definedivar(ID id, IVC ic, VALUE pushval)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_definedivar(ID id, IVC ic, VALUE pushval)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_definedivar(ID id, IVC ic, VALUE pushval)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_definedivar(ID id, IVC ic, VALUE pushval)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_definedivar(ID id, IVC ic, VALUE pushval)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_definedivar(ID id, IVC ic, VALUE pushval)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_checkmatch(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_checkmatch(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_checkmatch(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_checkmatch(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_checkmatch(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_checkmatch(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_checkmatch(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_checkmatch(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_checkmatch(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_checkkeyword(lindex_t kw_bits_index, lindex_t keyword_index)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_checkkeyword(lindex_t kw_bits_index, lindex_t keyword_index)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_checkkeyword(lindex_t kw_bits_index, lindex_t keyword_index)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_checkkeyword(lindex_t kw_bits_index, lindex_t keyword_index)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_checkkeyword(lindex_t kw_bits_index, lindex_t keyword_index)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_checkkeyword(lindex_t kw_bits_index, lindex_t keyword_index)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_checkkeyword(lindex_t kw_bits_index, lindex_t keyword_index)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_checkkeyword(lindex_t kw_bits_index, lindex_t keyword_index)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_checkkeyword(lindex_t kw_bits_index, lindex_t keyword_index)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_checktype(rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_checktype(rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_checktype(rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_checktype(rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_checktype(rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_checktype(rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_checktype(rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_checktype(rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_checktype(rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_defineclass(ID id, ISEQ class_iseq, rb_num_t flags)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_defineclass(ID id, ISEQ class_iseq, rb_num_t flags)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_defineclass(ID id, ISEQ class_iseq, rb_num_t flags)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_defineclass(ID id, ISEQ class_iseq, rb_num_t flags)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_defineclass(ID id, ISEQ class_iseq, rb_num_t flags)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_defineclass(ID id, ISEQ class_iseq, rb_num_t flags)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_defineclass(ID id, ISEQ class_iseq, rb_num_t flags)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_defineclass(ID id, ISEQ class_iseq, rb_num_t flags)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_defineclass(ID id, ISEQ class_iseq, rb_num_t flags)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_definemethod(ID id, ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_definemethod(ID id, ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_definemethod(ID id, ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_definemethod(ID id, ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_definemethod(ID id, ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_definemethod(ID id, ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_definemethod(ID id, ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_definemethod(ID id, ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_definemethod(ID id, ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_definesmethod(ID id, ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_definesmethod(ID id, ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_definesmethod(ID id, ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_definesmethod(ID id, ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_definesmethod(ID id, ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_definesmethod(ID id, ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_definesmethod(ID id, ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_definesmethod(ID id, ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_definesmethod(ID id, ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_send(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_comptime_sp_inc_send(CALL_INFO ci, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_send(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_send(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_send(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_send(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_send(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_send(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_send(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_send(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_sendforward(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_comptime_sp_inc_sendforward(CALL_INFO ci, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_sendforward(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_sendforward(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_sendforward(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_sendforward(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_sendforward(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_sendforward(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_sendforward(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_sendforward(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_send_without_block(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_comptime_sp_inc_opt_send_without_block(CALL_INFO ci)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_send_without_block(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_send_without_block(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_send_without_block(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_send_without_block(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_send_without_block(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_send_without_block(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_send_without_block(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_send_without_block(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_objtostring(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_objtostring(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_objtostring(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_objtostring(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_objtostring(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_objtostring(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_objtostring(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_objtostring(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_objtostring(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_ary_freeze(VALUE ary, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_ary_freeze(VALUE ary, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_ary_freeze(VALUE ary, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_ary_freeze(VALUE ary, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_ary_freeze(VALUE ary, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_ary_freeze(VALUE ary, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_ary_freeze(VALUE ary, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_ary_freeze(VALUE ary, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_ary_freeze(VALUE ary, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_hash_freeze(VALUE hash, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_hash_freeze(VALUE hash, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_hash_freeze(VALUE hash, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_hash_freeze(VALUE hash, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_hash_freeze(VALUE hash, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_hash_freeze(VALUE hash, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_hash_freeze(VALUE hash, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_hash_freeze(VALUE hash, CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_hash_freeze(VALUE hash, 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_duparray_send(VALUE ary, ID method, rb_num_t argc)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_comptime_sp_inc_opt_duparray_send(VALUE ary, ID method, rb_num_t argc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_duparray_send(VALUE ary, ID method, rb_num_t argc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_duparray_send(VALUE ary, ID method, rb_num_t argc)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_duparray_send(VALUE ary, ID method, rb_num_t argc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_duparray_send(VALUE ary, ID method, rb_num_t argc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_duparray_send(VALUE ary, ID method, rb_num_t argc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_duparray_send(VALUE ary, ID method, rb_num_t argc)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_duparray_send(VALUE ary, ID method, rb_num_t argc)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_duparray_send(VALUE ary, ID method, rb_num_t argc)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_newarray_send(rb_num_t num, rb_num_t method)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_comptime_sp_inc_opt_newarray_send(rb_num_t num, rb_num_t method)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_newarray_send(rb_num_t num, rb_num_t method)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_newarray_send(rb_num_t num, rb_num_t method)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_newarray_send(rb_num_t num, rb_num_t method)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_newarray_send(rb_num_t num, rb_num_t method)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_newarray_send(rb_num_t num, rb_num_t method)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_newarray_send(rb_num_t num, rb_num_t method)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_newarray_send(rb_num_t num, rb_num_t method)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_newarray_send(rb_num_t num, rb_num_t method)));
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_invokesuperforward(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_comptime_sp_inc_invokesuperforward(CALL_INFO ci, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_invokesuperforward(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_invokesuperforward(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_invokesuperforward(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_invokesuperforward(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_invokesuperforward(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_invokesuperforward(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_invokesuperforward(CALL_DATA cd, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_invokesuperforward(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_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 2096 "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 2252 "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 2345 "insns_info.inc"
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/* attr bool leaf @ opt_getconstant_path(ic)()(val) */
bool
attr_leaf_opt_getconstant_path(MAYBE_UNUSED(IC ic))
{
    return
#line 261 "insns.def"
false;
#line 2615 "insns_info.inc"
}

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

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

/* attr rb_num_t popn @ opt_getconstant_path(ic)()(val) */
rb_num_t
attr_popn_opt_getconstant_path(MAYBE_UNUSED(IC ic))
{
    return 0;
}

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

/* attr rb_snum_t sp_inc @ opt_getconstant_path(ic)()(val) */
rb_snum_t
attr_sp_inc_opt_getconstant_path(MAYBE_UNUSED(IC ic))
{
    return 1;
}

/* attr rb_num_t width @ opt_getconstant_path(ic)()(val) */
rb_num_t
attr_width_opt_getconstant_path(MAYBE_UNUSED(IC ic))
{
    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 276 "insns.def"
false;
#line 2681 "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 292 "insns.def"
false;
#line 2747 "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 305 "insns.def"
false;
#line 2813 "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 316 "insns.def"
false;
#line 2879 "insns_info.inc"
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/* attr rb_num_t width @ putchilledstring(str)()(val) */
rb_num_t
attr_width_putchilledstring(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 399 "insns.def"
false;
#line 3326 "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 400 "insns.def"
1 - (rb_snum_t)num;
#line 3364 "insns_info.inc"
}

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

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

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

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

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

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

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

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

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

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

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

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

/* attr bool leaf @ toregexp(opt, cnt)(...)(val) */
bool
attr_leaf_toregexp(
    MAYBE_UNUSED(rb_num_t opt),
    MAYBE_UNUSED(rb_num_t cnt)
)
{
    return
#line 426 "insns.def"
false;
#line 3467 "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 427 "insns.def"
1 - (rb_snum_t)cnt;
#line 3520 "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 450 "insns.def"
1 - (rb_snum_t)num;
#line 3652 "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 @ pushtoarraykwsplat()(ary, hash)(ary) */
enum ruby_vminsn_type
attr_bin_pushtoarraykwsplat(void)
{
    return BIN(pushtoarraykwsplat);
}

/* attr bool handles_sp @ pushtoarraykwsplat()(ary, hash)(ary) */
bool
attr_handles_sp_pushtoarraykwsplat(void)
{
    return false;
}

/* attr bool leaf @ pushtoarraykwsplat()(ary, hash)(ary) */
bool
attr_leaf_pushtoarraykwsplat(void)
{
    return true;
}

/* attr const char* name @ pushtoarraykwsplat()(ary, hash)(ary) */
const char*
attr_name_pushtoarraykwsplat(void)
{
    return insn_name(BIN(pushtoarraykwsplat));
}

/* attr rb_num_t open @ pushtoarraykwsplat()(ary, hash)(ary) */
rb_num_t
attr_open_pushtoarraykwsplat(void)
{
    return 0;
}

/* attr rb_num_t popn @ pushtoarraykwsplat()(ary, hash)(ary) */
rb_num_t
attr_popn_pushtoarraykwsplat(void)
{
    return 2;
}

/* attr rb_num_t retn @ pushtoarraykwsplat()(ary, hash)(ary) */
rb_num_t
attr_retn_pushtoarraykwsplat(void)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ pushtoarraykwsplat()(ary, hash)(ary) */
rb_snum_t
attr_sp_inc_pushtoarraykwsplat(void)
{
    return -1;
}

/* attr rb_num_t width @ pushtoarraykwsplat()(ary, hash)(ary) */
rb_num_t
attr_width_pushtoarraykwsplat(void)
{
    return 1;
}

/* 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
#line 505 "insns.def"
true;
#line 3871 "insns_info.inc"
}

/* 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 506 "insns.def"
false;
#line 3884 "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 507 "insns.def"
(rb_snum_t)num - 1 + (flag & 1 ? 1 : 0);
#line 3937 "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 520 "insns.def"
false;
#line 3971 "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 @ concattoarray()(ary1, ary2)(ary) */
enum ruby_vminsn_type
attr_bin_concattoarray(void)
{
    return BIN(concattoarray);
}

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

/* attr bool leaf @ concattoarray()(ary1, ary2)(ary) */
bool
attr_leaf_concattoarray(void)
{
    return
#line 534 "insns.def"
false;
#line 4037 "insns_info.inc"
}

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

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

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

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

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

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

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

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

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

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

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

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

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

/* attr rb_snum_t sp_inc @ pushtoarray(num)(...)(val) */
rb_snum_t
attr_sp_inc_pushtoarray(MAYBE_UNUSED(rb_num_t num))
{
    return
#line 545 "insns.def"
-(rb_snum_t)num;
#line 4138 "insns_info.inc"
}

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

/* 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 557 "insns.def"
false;
#line 4169 "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 @ splatkw()(hash, block)(obj, block) */
enum ruby_vminsn_type
attr_bin_splatkw(void)
{
    return BIN(splatkw);
}

/* attr bool handles_sp @ splatkw()(hash, block)(obj, block) */
bool
attr_handles_sp_splatkw(void)
{
    return false;
}

/* attr bool leaf @ splatkw()(hash, block)(obj, block) */
bool
attr_leaf_splatkw(void)
{
    return
#line 568 "insns.def"
false;
#line 4235 "insns_info.inc"
}

/* attr const char* name @ splatkw()(hash, block)(obj, block) */
const char*
attr_name_splatkw(void)
{
    return insn_name(BIN(splatkw));
}

/* attr rb_num_t open @ splatkw()(hash, block)(obj, block) */
rb_num_t
attr_open_splatkw(void)
{
    return 0;
}

/* attr rb_num_t popn @ splatkw()(hash, block)(obj, block) */
rb_num_t
attr_popn_splatkw(void)
{
    return 2;
}

/* attr rb_num_t retn @ splatkw()(hash, block)(obj, block) */
rb_num_t
attr_retn_splatkw(void)
{
    return 2;
}

/* attr rb_snum_t sp_inc @ splatkw()(hash, block)(obj, block) */
rb_snum_t
attr_sp_inc_splatkw(void)
{
    return 0;
}

/* attr rb_num_t width @ splatkw()(hash, block)(obj, block) */
rb_num_t
attr_width_splatkw(void)
{
    return 1;
}

/* 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 584 "insns.def"
false;
#line 4301 "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 585 "insns.def"
1 - (rb_snum_t)num;
#line 4339 "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 605 "insns.def"
false;
#line 4370 "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 641 "insns.def"
n;
#line 4597 "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 @ opt_reverse(n)(...)(...) */
enum ruby_vminsn_type
attr_bin_opt_reverse(MAYBE_UNUSED(rb_num_t n))
{
    return BIN(opt_reverse);
}

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

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

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

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

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

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

/* attr rb_snum_t sp_inc @ opt_reverse(n)(...)(...) */
rb_snum_t
attr_sp_inc_opt_reverse(MAYBE_UNUSED(rb_num_t n))
{
    return
#line 665 "insns.def"
0;
#line 4726 "insns_info.inc"
}

/* attr rb_num_t width @ opt_reverse(n)(...)(...) */
rb_num_t
attr_width_opt_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 695 "insns.def"
1;
#line 4792 "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 706 "insns.def"
0;
#line 4858 "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 717 "insns.def"
-(rb_snum_t)n;
#line 4924 "insns_info.inc"
}

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

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

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

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

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

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

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

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

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

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

/* attr enum ruby_vminsn_type bin @ definedivar(id, ic, pushval)()(val) */
enum ruby_vminsn_type
attr_bin_definedivar(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic),
    MAYBE_UNUSED(VALUE pushval)
)
{
    return BIN(definedivar);
}

/* attr bool handles_sp @ definedivar(id, ic, pushval)()(val) */
bool
attr_handles_sp_definedivar(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic),
    MAYBE_UNUSED(VALUE pushval)
)
{
    return false;
}

/* attr bool leaf @ definedivar(id, ic, pushval)()(val) */
bool
attr_leaf_definedivar(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic),
    MAYBE_UNUSED(VALUE pushval)
)
{
    return
#line 746 "insns.def"
false;
#line 5069 "insns_info.inc"
}

/* attr const char* name @ definedivar(id, ic, pushval)()(val) */
const char*
attr_name_definedivar(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic),
    MAYBE_UNUSED(VALUE pushval)
)
{
    return insn_name(BIN(definedivar));
}

/* attr rb_num_t open @ definedivar(id, ic, pushval)()(val) */
rb_num_t
attr_open_definedivar(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic),
    MAYBE_UNUSED(VALUE pushval)
)
{
    return 3;
}

/* attr rb_num_t popn @ definedivar(id, ic, pushval)()(val) */
rb_num_t
attr_popn_definedivar(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic),
    MAYBE_UNUSED(VALUE pushval)
)
{
    return 0;
}

/* attr rb_num_t retn @ definedivar(id, ic, pushval)()(val) */
rb_num_t
attr_retn_definedivar(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic),
    MAYBE_UNUSED(VALUE pushval)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ definedivar(id, ic, pushval)()(val) */
rb_snum_t
attr_sp_inc_definedivar(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic),
    MAYBE_UNUSED(VALUE pushval)
)
{
    return 1;
}

/* attr rb_num_t width @ definedivar(id, ic, pushval)()(val) */
rb_num_t
attr_width_definedivar(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic),
    MAYBE_UNUSED(VALUE pushval)
)
{
    return 4;
}

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

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

/* attr bool leaf @ checkmatch(flag)(target, pattern)(result) */
bool
attr_leaf_checkmatch(MAYBE_UNUSED(rb_num_t flag))
{
    return
#line 766 "insns.def"
leafness_of_checkmatch(flag);
#line 5159 "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 848 "insns.def"
sp_inc_of_sendish(ci);
#line 5656 "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 847 "insns.def"
sp_inc_of_sendish(cd->ci);
#line 5729 "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 @ sendforward(cd, blockiseq)(...)(val) */
enum ruby_vminsn_type
attr_bin_sendforward(
    MAYBE_UNUSED(CALL_DATA cd),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return BIN(sendforward);
}

/* attr rb_snum_t comptime_sp_inc @ sendforward(cd, blockiseq)(...)(val) */
rb_snum_t
attr_comptime_sp_inc_sendforward(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return
#line 867 "insns.def"
sp_inc_of_sendish(ci);
#line 5762 "insns_info.inc"
}

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

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

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

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

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

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

/* attr rb_snum_t sp_inc @ sendforward(cd, blockiseq)(...)(val) */
rb_snum_t
attr_sp_inc_sendforward(
    MAYBE_UNUSED(CALL_DATA cd),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return
#line 866 "insns.def"
sp_inc_of_sendish(cd->ci);
#line 5835 "insns_info.inc"
}

/* attr rb_num_t width @ sendforward(cd, blockiseq)(...)(val) */
rb_num_t
attr_width_sendforward(
    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 895 "insns.def"
sp_inc_of_sendish(ci);
#line 5862 "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 893 "insns.def"
true;
#line 5872 "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 894 "insns.def"
sp_inc_of_sendish(cd->ci);
#line 5917 "insns_info.inc"
}

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

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

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

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

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

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

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

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

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

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

/* attr enum ruby_vminsn_type bin @ opt_ary_freeze(ary, cd)()(val) */
enum ruby_vminsn_type
attr_bin_opt_ary_freeze(
    MAYBE_UNUSED(VALUE ary),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return BIN(opt_ary_freeze);
}

/* attr bool handles_sp @ opt_ary_freeze(ary, cd)()(val) */
bool
attr_handles_sp_opt_ary_freeze(
    MAYBE_UNUSED(VALUE ary),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return false;
}

/* attr bool leaf @ opt_ary_freeze(ary, cd)()(val) */
bool
attr_leaf_opt_ary_freeze(
    MAYBE_UNUSED(VALUE ary),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return true;
}

/* attr const char* name @ opt_ary_freeze(ary, cd)()(val) */
const char*
attr_name_opt_ary_freeze(
    MAYBE_UNUSED(VALUE ary),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return insn_name(BIN(opt_ary_freeze));
}

/* attr rb_num_t open @ opt_ary_freeze(ary, cd)()(val) */
rb_num_t
attr_open_opt_ary_freeze(
    MAYBE_UNUSED(VALUE ary),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return 2;
}

/* attr rb_num_t popn @ opt_ary_freeze(ary, cd)()(val) */
rb_num_t
attr_popn_opt_ary_freeze(
    MAYBE_UNUSED(VALUE ary),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return 0;
}

/* attr rb_num_t retn @ opt_ary_freeze(ary, cd)()(val) */
rb_num_t
attr_retn_opt_ary_freeze(
    MAYBE_UNUSED(VALUE ary),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_ary_freeze(ary, cd)()(val) */
rb_snum_t
attr_sp_inc_opt_ary_freeze(
    MAYBE_UNUSED(VALUE ary),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return 1;
}

/* attr rb_num_t width @ opt_ary_freeze(ary, cd)()(val) */
rb_num_t
attr_width_opt_ary_freeze(
    MAYBE_UNUSED(VALUE ary),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ opt_hash_freeze(hash, cd)()(val) */
enum ruby_vminsn_type
attr_bin_opt_hash_freeze(
    MAYBE_UNUSED(VALUE hash),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return BIN(opt_hash_freeze);
}

/* attr bool handles_sp @ opt_hash_freeze(hash, cd)()(val) */
bool
attr_handles_sp_opt_hash_freeze(
    MAYBE_UNUSED(VALUE hash),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return false;
}

/* attr bool leaf @ opt_hash_freeze(hash, cd)()(val) */
bool
attr_leaf_opt_hash_freeze(
    MAYBE_UNUSED(VALUE hash),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return true;
}

/* attr const char* name @ opt_hash_freeze(hash, cd)()(val) */
const char*
attr_name_opt_hash_freeze(
    MAYBE_UNUSED(VALUE hash),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return insn_name(BIN(opt_hash_freeze));
}

/* attr rb_num_t open @ opt_hash_freeze(hash, cd)()(val) */
rb_num_t
attr_open_opt_hash_freeze(
    MAYBE_UNUSED(VALUE hash),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return 2;
}

/* attr rb_num_t popn @ opt_hash_freeze(hash, cd)()(val) */
rb_num_t
attr_popn_opt_hash_freeze(
    MAYBE_UNUSED(VALUE hash),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return 0;
}

/* attr rb_num_t retn @ opt_hash_freeze(hash, cd)()(val) */
rb_num_t
attr_retn_opt_hash_freeze(
    MAYBE_UNUSED(VALUE hash),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_hash_freeze(hash, cd)()(val) */
rb_snum_t
attr_sp_inc_opt_hash_freeze(
    MAYBE_UNUSED(VALUE hash),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return 1;
}

/* attr rb_num_t width @ opt_hash_freeze(hash, cd)()(val) */
rb_num_t
attr_width_opt_hash_freeze(
    MAYBE_UNUSED(VALUE hash),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return 3;
}

/* 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_duparray_send(ary, method, argc)(...)(val) */
enum ruby_vminsn_type
attr_bin_opt_duparray_send(
    MAYBE_UNUSED(VALUE ary),
    MAYBE_UNUSED(ID method),
    MAYBE_UNUSED(rb_num_t argc)
)
{
    return BIN(opt_duparray_send);
}

/* attr rb_snum_t comptime_sp_inc @ opt_duparray_send(ary, method, argc)(...)(val) */
rb_snum_t
attr_comptime_sp_inc_opt_duparray_send(
    MAYBE_UNUSED(VALUE ary),
    MAYBE_UNUSED(ID method),
    MAYBE_UNUSED(rb_num_t argc)
)
{
    return
#line 1005 "insns.def"
1 - (rb_snum_t)argc;
#line 6438 "insns_info.inc"
}

/* attr bool handles_sp @ opt_duparray_send(ary, method, argc)(...)(val) */
bool
attr_handles_sp_opt_duparray_send(
    MAYBE_UNUSED(VALUE ary),
    MAYBE_UNUSED(ID method),
    MAYBE_UNUSED(rb_num_t argc)
)
{
    return false;
}

/* attr bool leaf @ opt_duparray_send(ary, method, argc)(...)(val) */
bool
attr_leaf_opt_duparray_send(
    MAYBE_UNUSED(VALUE ary),
    MAYBE_UNUSED(ID method),
    MAYBE_UNUSED(rb_num_t argc)
)
{
    return
#line 1003 "insns.def"
false;
#line 6463 "insns_info.inc"
}

/* attr const char* name @ opt_duparray_send(ary, method, argc)(...)(val) */
const char*
attr_name_opt_duparray_send(
    MAYBE_UNUSED(VALUE ary),
    MAYBE_UNUSED(ID method),
    MAYBE_UNUSED(rb_num_t argc)
)
{
    return insn_name(BIN(opt_duparray_send));
}

/* attr rb_num_t open @ opt_duparray_send(ary, method, argc)(...)(val) */
rb_num_t
attr_open_opt_duparray_send(
    MAYBE_UNUSED(VALUE ary),
    MAYBE_UNUSED(ID method),
    MAYBE_UNUSED(rb_num_t argc)
)
{
    return 3;
}

/* attr rb_num_t popn @ opt_duparray_send(ary, method, argc)(...)(val) */
rb_num_t
attr_popn_opt_duparray_send(
    MAYBE_UNUSED(VALUE ary),
    MAYBE_UNUSED(ID method),
    MAYBE_UNUSED(rb_num_t argc)
)
{
    return 0;
}

/* attr rb_num_t retn @ opt_duparray_send(ary, method, argc)(...)(val) */
rb_num_t
attr_retn_opt_duparray_send(
    MAYBE_UNUSED(VALUE ary),
    MAYBE_UNUSED(ID method),
    MAYBE_UNUSED(rb_num_t argc)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_duparray_send(ary, method, argc)(...)(val) */
rb_snum_t
attr_sp_inc_opt_duparray_send(
    MAYBE_UNUSED(VALUE ary),
    MAYBE_UNUSED(ID method),
    MAYBE_UNUSED(rb_num_t argc)
)
{
    return
#line 1004 "insns.def"
1 - (rb_snum_t)argc;
#line 6521 "insns_info.inc"
}

/* attr rb_num_t width @ opt_duparray_send(ary, method, argc)(...)(val) */
rb_num_t
attr_width_opt_duparray_send(
    MAYBE_UNUSED(VALUE ary),
    MAYBE_UNUSED(ID method),
    MAYBE_UNUSED(rb_num_t argc)
)
{
    return 4;
}

/* attr enum ruby_vminsn_type bin @ opt_newarray_send(num, method)(...)(val) */
enum ruby_vminsn_type
attr_bin_opt_newarray_send(
    MAYBE_UNUSED(rb_num_t num),
    MAYBE_UNUSED(rb_num_t method)
)
{
    return BIN(opt_newarray_send);
}

/* attr rb_snum_t comptime_sp_inc @ opt_newarray_send(num, method)(...)(val) */
rb_snum_t
attr_comptime_sp_inc_opt_newarray_send(
    MAYBE_UNUSED(rb_num_t num),
    MAYBE_UNUSED(rb_num_t method)
)
{
    return
#line 1027 "insns.def"
1 - (rb_snum_t)num;
#line 6555 "insns_info.inc"
}

/* attr bool handles_sp @ opt_newarray_send(num, method)(...)(val) */
bool
attr_handles_sp_opt_newarray_send(
    MAYBE_UNUSED(rb_num_t num),
    MAYBE_UNUSED(rb_num_t method)
)
{
    return false;
}

/* attr bool leaf @ opt_newarray_send(num, method)(...)(val) */
bool
attr_leaf_opt_newarray_send(
    MAYBE_UNUSED(rb_num_t num),
    MAYBE_UNUSED(rb_num_t method)
)
{
    return
#line 1025 "insns.def"
false;
#line 6578 "insns_info.inc"
}

/* attr const char* name @ opt_newarray_send(num, method)(...)(val) */
const char*
attr_name_opt_newarray_send(
    MAYBE_UNUSED(rb_num_t num),
    MAYBE_UNUSED(rb_num_t method)
)
{
    return insn_name(BIN(opt_newarray_send));
}

/* attr rb_num_t open @ opt_newarray_send(num, method)(...)(val) */
rb_num_t
attr_open_opt_newarray_send(
    MAYBE_UNUSED(rb_num_t num),
    MAYBE_UNUSED(rb_num_t method)
)
{
    return 2;
}

/* attr rb_num_t popn @ opt_newarray_send(num, method)(...)(val) */
rb_num_t
attr_popn_opt_newarray_send(
    MAYBE_UNUSED(rb_num_t num),
    MAYBE_UNUSED(rb_num_t method)
)
{
    return 0;
}

/* attr rb_num_t retn @ opt_newarray_send(num, method)(...)(val) */
rb_num_t
attr_retn_opt_newarray_send(
    MAYBE_UNUSED(rb_num_t num),
    MAYBE_UNUSED(rb_num_t method)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_newarray_send(num, method)(...)(val) */
rb_snum_t
attr_sp_inc_opt_newarray_send(
    MAYBE_UNUSED(rb_num_t num),
    MAYBE_UNUSED(rb_num_t method)
)
{
    return
#line 1026 "insns.def"
1 - (rb_snum_t)num;
#line 6631 "insns_info.inc"
}

/* attr rb_num_t width @ opt_newarray_send(num, method)(...)(val) */
rb_num_t
attr_width_opt_newarray_send(
    MAYBE_UNUSED(rb_num_t num),
    MAYBE_UNUSED(rb_num_t method)
)
{
    return 3;
}

/* 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 1060 "insns.def"
sp_inc_of_sendish(ci);
#line 6664 "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 1059 "insns.def"
sp_inc_of_sendish(cd->ci);
#line 6737 "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 @ invokesuperforward(cd, blockiseq)(...)(val) */
enum ruby_vminsn_type
attr_bin_invokesuperforward(
    MAYBE_UNUSED(CALL_DATA cd),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return BIN(invokesuperforward);
}

/* attr rb_snum_t comptime_sp_inc @ invokesuperforward(cd, blockiseq)(...)(val) */
rb_snum_t
attr_comptime_sp_inc_invokesuperforward(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return
#line 1079 "insns.def"
sp_inc_of_sendish(ci);
#line 6770 "insns_info.inc"
}

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

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

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

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

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

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

/* attr rb_snum_t sp_inc @ invokesuperforward(cd, blockiseq)(...)(val) */
rb_snum_t
attr_sp_inc_invokesuperforward(
    MAYBE_UNUSED(CALL_DATA cd),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return
#line 1078 "insns.def"
sp_inc_of_sendish(cd->ci);
#line 6843 "insns_info.inc"
}

/* attr rb_num_t width @ invokesuperforward(cd, blockiseq)(...)(val) */
rb_num_t
attr_width_invokesuperforward(
    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 1107 "insns.def"
sp_inc_of_invokeblock(ci);
#line 6870 "insns_info.inc"
}

/* attr bool handles_sp @ invokeblock(cd)(...)(val) */
bool
attr_handles_sp_invokeblock(MAYBE_UNUSED(CALL_DATA cd))
{
    return
#line 1105 "insns.def"
true;
#line 6880 "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 1106 "insns.def"
sp_inc_of_invokeblock(cd->ci);
#line 6925 "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 1129 "insns.def"
true;
#line 6949 "insns_info.inc"
}

/* attr bool leaf @ leave()(val)(val) */
bool
attr_leaf_leave(void)
{
    return
#line 1128 "insns.def"
false;
#line 6959 "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 1162 "insns.def"
false;
#line 7025 "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 1180 "insns.def"
leafness_of_check_ints;
#line 7091 "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 1193 "insns.def"
leafness_of_check_ints;
#line 7157 "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 1208 "insns.def"
leafness_of_check_ints;
#line 7223 "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 1223 "insns.def"
leafness_of_check_ints;
#line 7289 "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 @ 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 1251 "insns.def"
-1;
#line 7504 "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 1312 "insns.def"
false;
#line 7727 "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 1328 "insns.def"
false;
#line 7793 "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 1430 "insns.def"
false;
#line 8264 "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 1477 "insns.def"
false;
#line 8456 "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 1494 "insns.def"
false;
#line 8522 "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 1510 "insns.def"
false;
#line 8597 "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 1531 "insns.def"
false;
#line 8690 "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 1617 "insns.def"
false;
#line 9089 "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 1632 "insns.def"
false;
#line 9155 "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 1633 "insns.def"
1 - bf->argc;
#line 9193 "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 1644 "insns.def"
false;
#line 9233 "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 1655 "insns.def"
false;
#line 9326 "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,   -1,   -2,    1,
          -1,    1,    1,    1,    1,    1,    1, -127,
          -1, -127,    0, -127,   -1,    1,    1, -127,
          -1,   -1, -127,    0,    0, -127,   -1,   -1,
           1, -127,    0, -127, -127, -127, -127,    0,
           1,   -1,    1,    0,   -1,    0,   -1, -127,
        -127, -127,    0,    1,    1,    1,    0,    1,
        -127, -127, -127, -127, -127,    0,    0,    0,
          -1,   -1,   -1,    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,    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(expandarray):
        return attr_sp_inc_expandarray(NUM2LONG(opes[0]), NUM2LONG(opes[1]));
    case BIN(pushtoarray):
        return attr_sp_inc_pushtoarray(NUM2LONG(opes[0]));
    case BIN(newhash):
        return attr_sp_inc_newhash(NUM2LONG(opes[0]));
    case BIN(dupn):
        return attr_sp_inc_dupn(NUM2LONG(opes[0]));
    case BIN(opt_reverse):
        return attr_sp_inc_opt_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(sendforward):
        return attr_comptime_sp_inc_sendforward((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_duparray_send):
        return attr_comptime_sp_inc_opt_duparray_send(opes[0], SYM2ID(opes[1]), NUM2LONG(opes[2]));
    case BIN(opt_newarray_send):
        return attr_comptime_sp_inc_opt_newarray_send(NUM2LONG(opes[0]), NUM2LONG(opes[1]));
    case BIN(invokesuper):
        return attr_comptime_sp_inc_invokesuper((CALL_INFO)(opes[0]), (ISEQ)(opes[1]));
    case BIN(invokesuperforward):
        return attr_comptime_sp_inc_invokesuperforward((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(opt_getconstant_path):
      case BIN(getconstant):
      case BIN(setconstant):
      case BIN(getglobal):
      case BIN(setglobal):
      case BIN(putspecialobject):
      case BIN(concatstrings):
      case BIN(toregexp):
      case BIN(expandarray):
      case BIN(concatarray):
      case BIN(concattoarray):
      case BIN(splatarray):
      case BIN(splatkw):
      case BIN(newhash):
      case BIN(newrange):
      case BIN(defined):
      case BIN(definedivar):
      case BIN(checkmatch):
      case BIN(defineclass):
      case BIN(definemethod):
      case BIN(definesmethod):
      case BIN(send):
      case BIN(sendforward):
      case BIN(opt_send_without_block):
      case BIN(objtostring):
      case BIN(opt_duparray_send):
      case BIN(opt_newarray_send):
      case BIN(invokesuper):
      case BIN(invokesuperforward):
      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_opt_getconstant_path):
      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_putchilledstring):
      case BIN(trace_concatstrings):
      case BIN(trace_anytostring):
      case BIN(trace_toregexp):
      case BIN(trace_intern):
      case BIN(trace_newarray):
      case BIN(trace_pushtoarraykwsplat):
      case BIN(trace_duparray):
      case BIN(trace_duphash):
      case BIN(trace_expandarray):
      case BIN(trace_concatarray):
      case BIN(trace_concattoarray):
      case BIN(trace_pushtoarray):
      case BIN(trace_splatarray):
      case BIN(trace_splatkw):
      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_opt_reverse):
      case BIN(trace_topn):
      case BIN(trace_setn):
      case BIN(trace_adjuststack):
      case BIN(trace_defined):
      case BIN(trace_definedivar):
      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_sendforward):
      case BIN(trace_opt_send_without_block):
      case BIN(trace_objtostring):
      case BIN(trace_opt_ary_freeze):
      case BIN(trace_opt_hash_freeze):
      case BIN(trace_opt_str_freeze):
      case BIN(trace_opt_nil_p):
      case BIN(trace_opt_str_uminus):
      case BIN(trace_opt_duparray_send):
      case BIN(trace_opt_newarray_send):
      case BIN(trace_invokesuper):
      case BIN(trace_invokesuperforward):
      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_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;
    }
}

