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

#ifndef INSNS_INFO_INC
#define INSNS_INFO_INC 1
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"
    "opt_new" "\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_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_opt_new" "\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_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"
#if USE_ZJIT
    "zjit_getinstancevariable" "\0"
    "zjit_setinstancevariable" "\0"
    "zjit_definedivar" "\0"
    "zjit_send" "\0"
    "zjit_opt_send_without_block" "\0"
    "zjit_objtostring" "\0"
    "zjit_opt_nil_p" "\0"
    "zjit_invokeblock" "\0"
    "zjit_opt_plus" "\0"
    "zjit_opt_minus" "\0"
    "zjit_opt_mult" "\0"
    "zjit_opt_div" "\0"
    "zjit_opt_mod" "\0"
    "zjit_opt_eq" "\0"
    "zjit_opt_neq" "\0"
    "zjit_opt_lt" "\0"
    "zjit_opt_le" "\0"
    "zjit_opt_gt" "\0"
    "zjit_opt_ge" "\0"
    "zjit_opt_ltlt" "\0"
    "zjit_opt_and" "\0"
    "zjit_opt_or" "\0"
    "zjit_opt_aref" "\0"
    "zjit_opt_aset" "\0"
    "zjit_opt_length" "\0"
    "zjit_opt_size" "\0"
    "zjit_opt_empty_p" "\0"
    "zjit_opt_succ" "\0"
    "zjit_opt_not" "\0"
    "zjit_opt_regexpmatch2" "\0"
#endif
    ;

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,  665,
     677,  692,  708,  723,  733,  748,  766,  784,  796,  815,  827,  833,
     839,  844,  853,  866,  876,  881,  899,  908,  918,  927,  935,  943,
     950,  958,  965,  972,  979,  986,  995, 1003, 1010, 1019, 1028, 1039,
    1048, 1060, 1069, 1077, 1094, 1108, 1135, 1168, 1182, 1196, 1210, 1224,
    1245, 1266, 1276, 1291, 1306, 1326, 1346, 1371, 1388, 1405, 1431, 1457,
    1480, 1503, 1530, 1548, 1566, 1582, 1598, 1611, 1625, 1641, 1664, 1680,
    1703, 1723, 1741, 1756, 1769, 1784, 1809, 1824, 1838, 1856, 1874, 1894,
    1912, 1929, 1943, 1957, 1972, 1982, 1992, 2003, 2014, 2032, 2043, 2054,
    2072, 2086, 2104, 2121, 2140, 2156, 2174, 2193, 2213, 2224, 2242, 2271,
    2285, 2303, 2324, 2346, 2367, 2383, 2404, 2428, 2452, 2470, 2495, 2513,
    2525, 2537, 2548, 2563, 2582, 2598, 2609, 2633, 2648, 2664, 2679, 2693,
    2707, 2720, 2734, 2747, 2760, 2773, 2786, 2801, 2815, 2828, 2843, 2858,
    2875, 2890, 2908, 2923, 2937, 2960, 2980, 3013, 3052, 3072, 3092, 3112,
    3132, 3159,
#if USE_ZJIT
    3186, 3211, 3236, 3253, 3263, 3291, 3308, 3323, 3340, 3354, 3369, 3383,
    3396, 3409, 3421, 3434, 3446, 3458, 3470, 3482, 3496, 3509, 3521, 3535,
    3549, 3565, 3579, 3596, 3610, 3623,
#endif
};

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, 3, 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, 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, 3, 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, 2, 2, 2, 2,
    2, 2, 2, 3, 3, 2, 2, 2, 2, 1, 1,
#if USE_ZJIT
    3, 3, 4, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2,
    2, 2, 2, 2, 2, 2, 2,
#endif
};

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" "CO"   "\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" "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" "CO"   "\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" "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"
#if USE_ZJIT
    "IA"   "\0" "IA"   "\0" "IAV"  "\0" "CS"   "\0" "C"    "\0"
    "C"    "\0" "C"    "\0" "C"    "\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" "C"    "\0"
    "C"    "\0" "C"    "\0" "C"    "\0" "C"    "\0" "C"    "\0"
#endif
    ;

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, 130,
    132, 135, 138, 141, 143, 146, 150, 153, 156, 159, 161, 162,
    164, 166, 168, 170, 172, 175, 178, 180, 182, 184, 186, 188,
    190, 193, 195, 197, 199, 201, 203, 205, 207, 209, 211, 213,
    215, 217, 219, 221, 223, 225, 228, 231, 233, 235, 237, 239,
    240, 241, 242, 245, 248, 251, 254, 257, 260, 262, 265, 268,
    271, 274, 276, 278, 280, 282, 284, 285, 286, 288, 290, 292,
    294, 296, 297, 300, 301, 303, 304, 306, 308, 311, 312, 313,
    315, 317, 318, 320, 322, 323, 324, 326, 327, 329, 331, 333,
    335, 339, 343, 345, 348, 350, 354, 357, 360, 363, 366, 368,
    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,
    454, 456, 458, 460, 462, 464, 466, 469, 472, 474, 476, 478,
    480, 481,
#if USE_ZJIT
    482, 485, 488, 492, 495, 497, 499, 501, 503, 505, 507, 509,
    511, 513, 515, 518, 520, 522, 524, 526, 528, 530, 532, 534,
    536, 538, 540, 542, 544, 546,
#endif
};

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"

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 true;
      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 564 "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 594 "insns_info.inc"

#if USE_ZJIT

MAYBE_UNUSED(static int vm_bare_insn_to_zjit_insn(int insn));
static int
vm_bare_insn_to_zjit_insn(int insn)
{
    switch (insn) {
      case BIN(getinstancevariable):
        return BIN(zjit_getinstancevariable);
      case BIN(setinstancevariable):
        return BIN(zjit_setinstancevariable);
      case BIN(definedivar):
        return BIN(zjit_definedivar);
      case BIN(send):
        return BIN(zjit_send);
      case BIN(opt_send_without_block):
        return BIN(zjit_opt_send_without_block);
      case BIN(objtostring):
        return BIN(zjit_objtostring);
      case BIN(opt_nil_p):
        return BIN(zjit_opt_nil_p);
      case BIN(invokeblock):
        return BIN(zjit_invokeblock);
      case BIN(opt_plus):
        return BIN(zjit_opt_plus);
      case BIN(opt_minus):
        return BIN(zjit_opt_minus);
      case BIN(opt_mult):
        return BIN(zjit_opt_mult);
      case BIN(opt_div):
        return BIN(zjit_opt_div);
      case BIN(opt_mod):
        return BIN(zjit_opt_mod);
      case BIN(opt_eq):
        return BIN(zjit_opt_eq);
      case BIN(opt_neq):
        return BIN(zjit_opt_neq);
      case BIN(opt_lt):
        return BIN(zjit_opt_lt);
      case BIN(opt_le):
        return BIN(zjit_opt_le);
      case BIN(opt_gt):
        return BIN(zjit_opt_gt);
      case BIN(opt_ge):
        return BIN(zjit_opt_ge);
      case BIN(opt_ltlt):
        return BIN(zjit_opt_ltlt);
      case BIN(opt_and):
        return BIN(zjit_opt_and);
      case BIN(opt_or):
        return BIN(zjit_opt_or);
      case BIN(opt_aref):
        return BIN(zjit_opt_aref);
      case BIN(opt_aset):
        return BIN(zjit_opt_aset);
      case BIN(opt_length):
        return BIN(zjit_opt_length);
      case BIN(opt_size):
        return BIN(zjit_opt_size);
      case BIN(opt_empty_p):
        return BIN(zjit_opt_empty_p);
      case BIN(opt_succ):
        return BIN(zjit_opt_succ);
      case BIN(opt_not):
        return BIN(zjit_opt_not);
      case BIN(opt_regexpmatch2):
        return BIN(zjit_opt_regexpmatch2);
      default:
        return insn;
    }
}

MAYBE_UNUSED(static int vm_zjit_insn_to_bare_insn(int insn));
static int
vm_zjit_insn_to_bare_insn(int insn)
{
    switch (insn) {
      case BIN(zjit_getinstancevariable):
        return BIN(getinstancevariable);
      case BIN(zjit_setinstancevariable):
        return BIN(setinstancevariable);
      case BIN(zjit_definedivar):
        return BIN(definedivar);
      case BIN(zjit_send):
        return BIN(send);
      case BIN(zjit_opt_send_without_block):
        return BIN(opt_send_without_block);
      case BIN(zjit_objtostring):
        return BIN(objtostring);
      case BIN(zjit_opt_nil_p):
        return BIN(opt_nil_p);
      case BIN(zjit_invokeblock):
        return BIN(invokeblock);
      case BIN(zjit_opt_plus):
        return BIN(opt_plus);
      case BIN(zjit_opt_minus):
        return BIN(opt_minus);
      case BIN(zjit_opt_mult):
        return BIN(opt_mult);
      case BIN(zjit_opt_div):
        return BIN(opt_div);
      case BIN(zjit_opt_mod):
        return BIN(opt_mod);
      case BIN(zjit_opt_eq):
        return BIN(opt_eq);
      case BIN(zjit_opt_neq):
        return BIN(opt_neq);
      case BIN(zjit_opt_lt):
        return BIN(opt_lt);
      case BIN(zjit_opt_le):
        return BIN(opt_le);
      case BIN(zjit_opt_gt):
        return BIN(opt_gt);
      case BIN(zjit_opt_ge):
        return BIN(opt_ge);
      case BIN(zjit_opt_ltlt):
        return BIN(opt_ltlt);
      case BIN(zjit_opt_and):
        return BIN(opt_and);
      case BIN(zjit_opt_or):
        return BIN(opt_or);
      case BIN(zjit_opt_aref):
        return BIN(opt_aref);
      case BIN(zjit_opt_aset):
        return BIN(opt_aset);
      case BIN(zjit_opt_length):
        return BIN(opt_length);
      case BIN(zjit_opt_size):
        return BIN(opt_size);
      case BIN(zjit_opt_empty_p):
        return BIN(opt_empty_p);
      case BIN(zjit_opt_succ):
        return BIN(opt_succ);
      case BIN(zjit_opt_not):
        return BIN(opt_not);
      case BIN(zjit_opt_regexpmatch2):
        return BIN(opt_regexpmatch2);
      default:
        return insn;
    }
}

#endif

#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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_opt_send_without_block(CALL_DATA cd)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_new(CALL_DATA cd, OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_sp_opt_new(CALL_DATA cd, OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static bool attr_leaf_opt_new(CALL_DATA cd, OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_new(CALL_DATA cd, OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_new(CALL_DATA cd, OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_new(CALL_DATA cd, OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_new(CALL_DATA cd, OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_new(CALL_DATA cd, OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_new(CALL_DATA cd, OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static bool attr_zjit_profile_opt_new(CALL_DATA cd, OFFSET dst)));
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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_opt_aset(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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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 bool attr_zjit_profile_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)));
PUREFUNC(MAYBE_UNUSED(static bool attr_zjit_profile_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 bool zjit_profile @ nop()()() */
bool
attr_zjit_profile_nop(void)
{
    return false;
}

/* 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 bool zjit_profile @ getlocal(idx, level)()(val) */
bool
attr_zjit_profile_getlocal(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return false;
}

/* 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 bool zjit_profile @ setlocal(idx, level)(val)() */
bool
attr_zjit_profile_setlocal(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return false;
}

/* 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 bool zjit_profile @ getblockparam(idx, level)()(val) */
bool
attr_zjit_profile_getblockparam(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return false;
}

/* 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 bool zjit_profile @ setblockparam(idx, level)(val)() */
bool
attr_zjit_profile_setblockparam(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return false;
}

/* 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 bool zjit_profile @ getblockparamproxy(idx, level)()(val) */
bool
attr_zjit_profile_getblockparamproxy(
    MAYBE_UNUSED(lindex_t idx),
    MAYBE_UNUSED(rb_num_t level)
)
{
    return false;
}

/* 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 2447 "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 bool zjit_profile @ getspecial(key, type)()(val) */
bool
attr_zjit_profile_getspecial(
    MAYBE_UNUSED(rb_num_t key),
    MAYBE_UNUSED(rb_num_t type)
)
{
    return false;
}

/* 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 bool zjit_profile @ setspecial(key)(obj)() */
bool
attr_zjit_profile_setspecial(MAYBE_UNUSED(rb_num_t key))
{
    return false;
}

/* 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 2620 "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 bool zjit_profile @ getinstancevariable(id, ic)()(val) */
bool
attr_zjit_profile_getinstancevariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic)
)
{
    return
#line 215 "insns.def"
true;
#line 2693 "insns_info.inc"
}

/* 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 226 "insns.def"
false;
#line 2726 "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 bool zjit_profile @ setinstancevariable(id, ic)(val)() */
bool
attr_zjit_profile_setinstancevariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic)
)
{
    return
#line 227 "insns.def"
true;
#line 2799 "insns_info.inc"
}

/* 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 239 "insns.def"
false;
#line 2832 "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 bool zjit_profile @ getclassvariable(id, ic)()(val) */
bool
attr_zjit_profile_getclassvariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(ICVARC ic)
)
{
    return false;
}

/* 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 252 "insns.def"
false;
#line 2935 "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 bool zjit_profile @ setclassvariable(id, ic)(val)() */
bool
attr_zjit_profile_setclassvariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(ICVARC ic)
)
{
    return false;
}

/* 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 263 "insns.def"
false;
#line 3029 "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 bool zjit_profile @ opt_getconstant_path(ic)()(val) */
bool
attr_zjit_profile_opt_getconstant_path(MAYBE_UNUSED(IC ic))
{
    return false;
}

/* 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 278 "insns.def"
false;
#line 3102 "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 bool zjit_profile @ getconstant(id)(klass, allow_nil)(val) */
bool
attr_zjit_profile_getconstant(MAYBE_UNUSED(ID id))
{
    return false;
}

/* 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 294 "insns.def"
false;
#line 3175 "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 bool zjit_profile @ setconstant(id)(val, cbase)() */
bool
attr_zjit_profile_setconstant(MAYBE_UNUSED(ID id))
{
    return false;
}

/* 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 307 "insns.def"
false;
#line 3248 "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 bool zjit_profile @ getglobal(gid)()(val) */
bool
attr_zjit_profile_getglobal(MAYBE_UNUSED(ID gid))
{
    return false;
}

/* 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 318 "insns.def"
false;
#line 3321 "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 bool zjit_profile @ setglobal(gid)(val)() */
bool
attr_zjit_profile_setglobal(MAYBE_UNUSED(ID gid))
{
    return false;
}

/* 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 bool zjit_profile @ putnil()()(val) */
bool
attr_zjit_profile_putnil(void)
{
    return false;
}

/* 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 bool zjit_profile @ putself()()(val) */
bool
attr_zjit_profile_putself(void)
{
    return false;
}

/* 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 bool zjit_profile @ putobject(val)()(val) */
bool
attr_zjit_profile_putobject(MAYBE_UNUSED(VALUE val))
{
    return false;
}

/* 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 365 "insns.def"
(value_type == VM_SPECIAL_OBJECT_VMCORE);
#line 3604 "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 bool zjit_profile @ putspecialobject(value_type)()(val) */
bool
attr_zjit_profile_putspecialobject(MAYBE_UNUSED(rb_num_t value_type))
{
    return false;
}

/* 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 bool zjit_profile @ putstring(str)()(val) */
bool
attr_zjit_profile_putstring(MAYBE_UNUSED(VALUE str))
{
    return false;
}

/* 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 bool zjit_profile @ putchilledstring(str)()(val) */
bool
attr_zjit_profile_putchilledstring(MAYBE_UNUSED(VALUE str))
{
    return false;
}

/* 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 401 "insns.def"
false;
#line 3817 "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 402 "insns.def"
1 - (rb_snum_t)num;
#line 3855 "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 bool zjit_profile @ concatstrings(num)(...)(val) */
bool
attr_zjit_profile_concatstrings(MAYBE_UNUSED(rb_num_t num))
{
    return false;
}

/* 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 bool zjit_profile @ anytostring()(val, str)(val) */
bool
attr_zjit_profile_anytostring(void)
{
    return false;
}

/* 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 428 "insns.def"
false;
#line 3972 "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 429 "insns.def"
1 - (rb_snum_t)cnt;
#line 4025 "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 bool zjit_profile @ toregexp(opt, cnt)(...)(val) */
bool
attr_zjit_profile_toregexp(
    MAYBE_UNUSED(rb_num_t opt),
    MAYBE_UNUSED(rb_num_t cnt)
)
{
    return false;
}

/* 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 bool zjit_profile @ intern()(str)(sym) */
bool
attr_zjit_profile_intern(void)
{
    return false;
}

/* 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 452 "insns.def"
1 - (rb_snum_t)num;
#line 4174 "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 bool zjit_profile @ newarray(num)(...)(val) */
bool
attr_zjit_profile_newarray(MAYBE_UNUSED(rb_num_t num))
{
    return false;
}

/* 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 bool zjit_profile @ pushtoarraykwsplat()(ary, hash)(ary) */
bool
attr_zjit_profile_pushtoarraykwsplat(void)
{
    return false;
}

/* 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 bool zjit_profile @ duparray(ary)()(val) */
bool
attr_zjit_profile_duparray(MAYBE_UNUSED(VALUE ary))
{
    return false;
}

/* 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 bool zjit_profile @ duphash(hash)()(val) */
bool
attr_zjit_profile_duphash(MAYBE_UNUSED(VALUE hash))
{
    return false;
}

/* 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 507 "insns.def"
true;
#line 4421 "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 508 "insns.def"
false;
#line 4434 "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 509 "insns.def"
(rb_snum_t)num - 1 + (flag & 1 ? 1 : 0);
#line 4487 "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 bool zjit_profile @ expandarray(num, flag)(..., ary)(...) */
bool
attr_zjit_profile_expandarray(
    MAYBE_UNUSED(rb_num_t num),
    MAYBE_UNUSED(rb_num_t flag)
)
{
    return false;
}

/* 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 522 "insns.def"
false;
#line 4531 "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 bool zjit_profile @ concatarray()(ary1, ary2)(ary) */
bool
attr_zjit_profile_concatarray(void)
{
    return false;
}

/* 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 536 "insns.def"
false;
#line 4604 "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 bool zjit_profile @ concattoarray()(ary1, ary2)(ary) */
bool
attr_zjit_profile_concattoarray(void)
{
    return false;
}

/* 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 547 "insns.def"
-(rb_snum_t)num;
#line 4712 "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 bool zjit_profile @ pushtoarray(num)(...)(val) */
bool
attr_zjit_profile_pushtoarray(MAYBE_UNUSED(rb_num_t num))
{
    return false;
}

/* 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 559 "insns.def"
false;
#line 4750 "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 bool zjit_profile @ splatarray(flag)(ary)(obj) */
bool
attr_zjit_profile_splatarray(MAYBE_UNUSED(VALUE flag))
{
    return false;
}

/* 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 570 "insns.def"
false;
#line 4823 "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 bool zjit_profile @ splatkw()(hash, block)(obj, block) */
bool
attr_zjit_profile_splatkw(void)
{
    return false;
}

/* 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 586 "insns.def"
false;
#line 4896 "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 587 "insns.def"
1 - (rb_snum_t)num;
#line 4934 "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 bool zjit_profile @ newhash(num)(...)(val) */
bool
attr_zjit_profile_newhash(MAYBE_UNUSED(rb_num_t num))
{
    return false;
}

/* 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 607 "insns.def"
false;
#line 4972 "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 bool zjit_profile @ newrange(flag)(low, high)(val) */
bool
attr_zjit_profile_newrange(MAYBE_UNUSED(rb_num_t flag))
{
    return false;
}

/* 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 bool zjit_profile @ pop()(val)() */
bool
attr_zjit_profile_pop(void)
{
    return false;
}

/* 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 bool zjit_profile @ dup()(val)(val1, val2) */
bool
attr_zjit_profile_dup(void)
{
    return false;
}

/* 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 643 "insns.def"
n;
#line 5220 "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 bool zjit_profile @ dupn(n)(...)(...) */
bool
attr_zjit_profile_dupn(MAYBE_UNUSED(rb_num_t n))
{
    return false;
}

/* 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 bool zjit_profile @ swap()(val, obj)(obj, val) */
bool
attr_zjit_profile_swap(void)
{
    return false;
}

/* 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 667 "insns.def"
0;
#line 5363 "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 bool zjit_profile @ opt_reverse(n)(...)(...) */
bool
attr_zjit_profile_opt_reverse(MAYBE_UNUSED(rb_num_t n))
{
    return false;
}

/* 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 697 "insns.def"
1;
#line 5436 "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 bool zjit_profile @ topn(n)(...)(val) */
bool
attr_zjit_profile_topn(MAYBE_UNUSED(rb_num_t n))
{
    return false;
}

/* 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 708 "insns.def"
0;
#line 5509 "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 bool zjit_profile @ setn(n)(..., val)(val) */
bool
attr_zjit_profile_setn(MAYBE_UNUSED(rb_num_t n))
{
    return false;
}

/* 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 719 "insns.def"
-(rb_snum_t)n;
#line 5582 "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 bool zjit_profile @ adjuststack(n)(...)(...) */
bool
attr_zjit_profile_adjuststack(MAYBE_UNUSED(rb_num_t n))
{
    return false;
}

/* 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 734 "insns.def"
leafness_of_defined(op_type);
#line 5632 "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 bool zjit_profile @ defined(op_type, obj, pushval)(v)(val) */
bool
attr_zjit_profile_defined(
    MAYBE_UNUSED(rb_num_t op_type),
    MAYBE_UNUSED(VALUE obj),
    MAYBE_UNUSED(VALUE pushval)
)
{
    return false;
}

/* 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 748 "insns.def"
false;
#line 5745 "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 bool zjit_profile @ definedivar(id, ic, pushval)()(val) */
bool
attr_zjit_profile_definedivar(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IVC ic),
    MAYBE_UNUSED(VALUE pushval)
)
{
    return
#line 749 "insns.def"
true;
#line 5825 "insns_info.inc"
}

/* 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 769 "insns.def"
leafness_of_checkmatch(flag);
#line 5849 "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 bool zjit_profile @ checkmatch(flag)(target, pattern)(result) */
bool
attr_zjit_profile_checkmatch(MAYBE_UNUSED(rb_num_t flag))
{
    return false;
}

/* 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 bool zjit_profile @ checkkeyword(kw_bits_index, keyword_index)()(ret) */
bool
attr_zjit_profile_checkkeyword(
    MAYBE_UNUSED(lindex_t kw_bits_index),
    MAYBE_UNUSED(lindex_t keyword_index)
)
{
    return false;
}

/* 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 bool zjit_profile @ checktype(type)(val)(ret) */
bool
attr_zjit_profile_checktype(MAYBE_UNUSED(rb_num_t type))
{
    return false;
}

/* 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 bool zjit_profile @ defineclass(id, class_iseq, flags)(cbase, super)(val) */
bool
attr_zjit_profile_defineclass(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(ISEQ class_iseq),
    MAYBE_UNUSED(rb_num_t flags)
)
{
    return false;
}

/* 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 bool zjit_profile @ definemethod(id, iseq)()() */
bool
attr_zjit_profile_definemethod(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(ISEQ iseq)
)
{
    return false;
}

/* 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 bool zjit_profile @ definesmethod(id, iseq)(obj)() */
bool
attr_zjit_profile_definesmethod(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(ISEQ iseq)
)
{
    return false;
}

/* 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 853 "insns.def"
sp_inc_of_sendish(ci);
#line 6401 "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 852 "insns.def"
sp_inc_of_sendish(cd->ci);
#line 6474 "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 bool zjit_profile @ send(cd, blockiseq)(...)(val) */
bool
attr_zjit_profile_send(
    MAYBE_UNUSED(CALL_DATA cd),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return
#line 851 "insns.def"
true;
#line 6497 "insns_info.inc"
}

/* 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 872 "insns.def"
sp_inc_of_sendish(ci);
#line 6520 "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 871 "insns.def"
sp_inc_of_sendish(cd->ci);
#line 6593 "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 bool zjit_profile @ sendforward(cd, blockiseq)(...)(val) */
bool
attr_zjit_profile_sendforward(
    MAYBE_UNUSED(CALL_DATA cd),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return false;
}

/* 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 901 "insns.def"
sp_inc_of_sendish(ci);
#line 6630 "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 899 "insns.def"
true;
#line 6640 "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 900 "insns.def"
sp_inc_of_sendish(cd->ci);
#line 6685 "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 bool zjit_profile @ opt_send_without_block(cd)(...)(val) */
bool
attr_zjit_profile_opt_send_without_block(MAYBE_UNUSED(CALL_DATA cd))
{
    return
#line 898 "insns.def"
true;
#line 6702 "insns_info.inc"
}

/* attr enum ruby_vminsn_type bin @ opt_new(cd, dst)()() */
enum ruby_vminsn_type
attr_bin_opt_new(
    MAYBE_UNUSED(CALL_DATA cd),
    MAYBE_UNUSED(OFFSET dst)
)
{
    return BIN(opt_new);
}

/* attr bool handles_sp @ opt_new(cd, dst)()() */
bool
attr_handles_sp_opt_new(
    MAYBE_UNUSED(CALL_DATA cd),
    MAYBE_UNUSED(OFFSET dst)
)
{
    return false;
}

/* attr bool leaf @ opt_new(cd, dst)()() */
bool
attr_leaf_opt_new(
    MAYBE_UNUSED(CALL_DATA cd),
    MAYBE_UNUSED(OFFSET dst)
)
{
    return
#line 919 "insns.def"
false;
#line 6735 "insns_info.inc"
}

/* attr const char* name @ opt_new(cd, dst)()() */
const char*
attr_name_opt_new(
    MAYBE_UNUSED(CALL_DATA cd),
    MAYBE_UNUSED(OFFSET dst)
)
{
    return insn_name(BIN(opt_new));
}

/* attr rb_num_t open @ opt_new(cd, dst)()() */
rb_num_t
attr_open_opt_new(
    MAYBE_UNUSED(CALL_DATA cd),
    MAYBE_UNUSED(OFFSET dst)
)
{
    return 2;
}

/* attr rb_num_t popn @ opt_new(cd, dst)()() */
rb_num_t
attr_popn_opt_new(
    MAYBE_UNUSED(CALL_DATA cd),
    MAYBE_UNUSED(OFFSET dst)
)
{
    return 0;
}

/* attr rb_num_t retn @ opt_new(cd, dst)()() */
rb_num_t
attr_retn_opt_new(
    MAYBE_UNUSED(CALL_DATA cd),
    MAYBE_UNUSED(OFFSET dst)
)
{
    return 0;
}

/* attr rb_snum_t sp_inc @ opt_new(cd, dst)()() */
rb_snum_t
attr_sp_inc_opt_new(
    MAYBE_UNUSED(CALL_DATA cd),
    MAYBE_UNUSED(OFFSET dst)
)
{
    return 0;
}

/* attr rb_num_t width @ opt_new(cd, dst)()() */
rb_num_t
attr_width_opt_new(
    MAYBE_UNUSED(CALL_DATA cd),
    MAYBE_UNUSED(OFFSET dst)
)
{
    return 3;
}

/* attr bool zjit_profile @ opt_new(cd, dst)()() */
bool
attr_zjit_profile_opt_new(
    MAYBE_UNUSED(CALL_DATA cd),
    MAYBE_UNUSED(OFFSET dst)
)
{
    return false;
}

/* 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 945 "insns.def"
false;
#line 6829 "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 bool zjit_profile @ objtostring(cd)(recv)(val) */
bool
attr_zjit_profile_objtostring(MAYBE_UNUSED(CALL_DATA cd))
{
    return
#line 946 "insns.def"
true;
#line 6881 "insns_info.inc"
}

/* 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 bool zjit_profile @ opt_ary_freeze(ary, cd)()(val) */
bool
attr_zjit_profile_opt_ary_freeze(
    MAYBE_UNUSED(VALUE ary),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return false;
}

/* 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 bool zjit_profile @ opt_hash_freeze(hash, cd)()(val) */
bool
attr_zjit_profile_opt_hash_freeze(
    MAYBE_UNUSED(VALUE hash),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return false;
}

/* 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 bool zjit_profile @ opt_str_freeze(str, cd)()(val) */
bool
attr_zjit_profile_opt_str_freeze(
    MAYBE_UNUSED(VALUE str),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return false;
}

/* 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 bool zjit_profile @ opt_nil_p(cd)(recv)(val) */
bool
attr_zjit_profile_opt_nil_p(MAYBE_UNUSED(CALL_DATA cd))
{
    return
#line 1005 "insns.def"
true;
#line 7254 "insns_info.inc"
}

/* 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 bool zjit_profile @ opt_str_uminus(str, cd)()(val) */
bool
attr_zjit_profile_opt_str_uminus(
    MAYBE_UNUSED(VALUE str),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return false;
}

/* 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 1039 "insns.def"
1 - (rb_snum_t)argc;
#line 7379 "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 1037 "insns.def"
false;
#line 7404 "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 1038 "insns.def"
1 - (rb_snum_t)argc;
#line 7462 "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 bool zjit_profile @ opt_duparray_send(ary, method, argc)(...)(val) */
bool
attr_zjit_profile_opt_duparray_send(
    MAYBE_UNUSED(VALUE ary),
    MAYBE_UNUSED(ID method),
    MAYBE_UNUSED(rb_num_t argc)
)
{
    return false;
}

/* 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 1061 "insns.def"
1 - (rb_snum_t)num;
#line 7507 "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 1059 "insns.def"
false;
#line 7530 "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 1060 "insns.def"
1 - (rb_snum_t)num;
#line 7583 "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 bool zjit_profile @ opt_newarray_send(num, method)(...)(val) */
bool
attr_zjit_profile_opt_newarray_send(
    MAYBE_UNUSED(rb_num_t num),
    MAYBE_UNUSED(rb_num_t method)
)
{
    return false;
}

/* 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 1094 "insns.def"
sp_inc_of_sendish(ci);
#line 7626 "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 1093 "insns.def"
sp_inc_of_sendish(cd->ci);
#line 7699 "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 bool zjit_profile @ invokesuper(cd, blockiseq)(...)(val) */
bool
attr_zjit_profile_invokesuper(
    MAYBE_UNUSED(CALL_DATA cd),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return false;
}

/* 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 1128 "insns.def"
sp_inc_of_sendish(ci);
#line 7742 "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 1127 "insns.def"
sp_inc_of_sendish(cd->ci);
#line 7815 "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 bool zjit_profile @ invokesuperforward(cd, blockiseq)(...)(val) */
bool
attr_zjit_profile_invokesuperforward(
    MAYBE_UNUSED(CALL_DATA cd),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return false;
}

/* 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 1156 "insns.def"
sp_inc_of_invokeblock(ci);
#line 7852 "insns_info.inc"
}

/* attr bool handles_sp @ invokeblock(cd)(...)(val) */
bool
attr_handles_sp_invokeblock(MAYBE_UNUSED(CALL_DATA cd))
{
    return
#line 1154 "insns.def"
true;
#line 7862 "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 1155 "insns.def"
sp_inc_of_invokeblock(cd->ci);
#line 7907 "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 bool zjit_profile @ invokeblock(cd)(...)(val) */
bool
attr_zjit_profile_invokeblock(MAYBE_UNUSED(CALL_DATA cd))
{
    return
#line 1157 "insns.def"
true;
#line 7924 "insns_info.inc"
}

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

/* attr bool leaf @ leave()(val)(val) */
bool
attr_leaf_leave(void)
{
    return
#line 1178 "insns.def"
false;
#line 7951 "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 bool zjit_profile @ leave()(val)(val) */
bool
attr_zjit_profile_leave(void)
{
    return false;
}

/* 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 1212 "insns.def"
false;
#line 8024 "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 bool zjit_profile @ throw(throw_state)(throwobj)(val) */
bool
attr_zjit_profile_throw(MAYBE_UNUSED(rb_num_t throw_state))
{
    return false;
}

/* 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 1230 "insns.def"
false;
#line 8097 "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 bool zjit_profile @ jump(dst)()() */
bool
attr_zjit_profile_jump(MAYBE_UNUSED(OFFSET dst))
{
    return false;
}

/* 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 1243 "insns.def"
false;
#line 8170 "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 bool zjit_profile @ branchif(dst)(val)() */
bool
attr_zjit_profile_branchif(MAYBE_UNUSED(OFFSET dst))
{
    return false;
}

/* 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 1258 "insns.def"
false;
#line 8243 "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 bool zjit_profile @ branchunless(dst)(val)() */
bool
attr_zjit_profile_branchunless(MAYBE_UNUSED(OFFSET dst))
{
    return false;
}

/* 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 1273 "insns.def"
false;
#line 8316 "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 bool zjit_profile @ branchnil(dst)(val)() */
bool
attr_zjit_profile_branchnil(MAYBE_UNUSED(OFFSET dst))
{
    return false;
}

/* 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 bool zjit_profile @ once(iseq, ise)()(val) */
bool
attr_zjit_profile_once(
    MAYBE_UNUSED(ISEQ iseq),
    MAYBE_UNUSED(ISE ise)
)
{
    return false;
}

/* 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 1301 "insns.def"
-1;
#line 8548 "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 bool zjit_profile @ opt_case_dispatch(hash, else_offset)(..., key)() */
bool
attr_zjit_profile_opt_case_dispatch(
    MAYBE_UNUSED(CDHASH hash),
    MAYBE_UNUSED(OFFSET else_offset)
)
{
    return false;
}

/* 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 bool zjit_profile @ opt_plus(cd)(recv, obj)(val) */
bool
attr_zjit_profile_opt_plus(MAYBE_UNUSED(CALL_DATA cd))
{
    return
#line 1318 "insns.def"
true;
#line 8641 "insns_info.inc"
}

/* 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 bool zjit_profile @ opt_minus(cd)(recv, obj)(val) */
bool
attr_zjit_profile_opt_minus(MAYBE_UNUSED(CALL_DATA cd))
{
    return
#line 1333 "insns.def"
true;
#line 8714 "insns_info.inc"
}

/* 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 bool zjit_profile @ opt_mult(cd)(recv, obj)(val) */
bool
attr_zjit_profile_opt_mult(MAYBE_UNUSED(CALL_DATA cd))
{
    return
#line 1348 "insns.def"
true;
#line 8787 "insns_info.inc"
}

/* 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 1365 "insns.def"
false;
#line 8811 "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 bool zjit_profile @ opt_div(cd)(recv, obj)(val) */
bool
attr_zjit_profile_opt_div(MAYBE_UNUSED(CALL_DATA cd))
{
    return
#line 1366 "insns.def"
true;
#line 8863 "insns_info.inc"
}

/* 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 1382 "insns.def"
false;
#line 8887 "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 bool zjit_profile @ opt_mod(cd)(recv, obj)(val) */
bool
attr_zjit_profile_opt_mod(MAYBE_UNUSED(CALL_DATA cd))
{
    return
#line 1383 "insns.def"
true;
#line 8939 "insns_info.inc"
}

/* 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 bool zjit_profile @ opt_eq(cd)(recv, obj)(val) */
bool
attr_zjit_profile_opt_eq(MAYBE_UNUSED(CALL_DATA cd))
{
    return
#line 1398 "insns.def"
true;
#line 9012 "insns_info.inc"
}

/* 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 bool zjit_profile @ opt_neq(cd_eq, cd)(recv, obj)(val) */
bool
attr_zjit_profile_opt_neq(
    MAYBE_UNUSED(CALL_DATA cd_eq),
    MAYBE_UNUSED(CALL_DATA cd)
)
{
    return
#line 1413 "insns.def"
true;
#line 9115 "insns_info.inc"
}

/* 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 bool zjit_profile @ opt_lt(cd)(recv, obj)(val) */
bool
attr_zjit_profile_opt_lt(MAYBE_UNUSED(CALL_DATA cd))
{
    return
#line 1428 "insns.def"
true;
#line 9188 "insns_info.inc"
}

/* 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 bool zjit_profile @ opt_le(cd)(recv, obj)(val) */
bool
attr_zjit_profile_opt_le(MAYBE_UNUSED(CALL_DATA cd))
{
    return
#line 1443 "insns.def"
true;
#line 9261 "insns_info.inc"
}

/* 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 bool zjit_profile @ opt_gt(cd)(recv, obj)(val) */
bool
attr_zjit_profile_opt_gt(MAYBE_UNUSED(CALL_DATA cd))
{
    return
#line 1458 "insns.def"
true;
#line 9334 "insns_info.inc"
}

/* 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 bool zjit_profile @ opt_ge(cd)(recv, obj)(val) */
bool
attr_zjit_profile_opt_ge(MAYBE_UNUSED(CALL_DATA cd))
{
    return
#line 1473 "insns.def"
true;
#line 9407 "insns_info.inc"
}

/* 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 1491 "insns.def"
false;
#line 9431 "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 bool zjit_profile @ opt_ltlt(cd)(recv, obj)(val) */
bool
attr_zjit_profile_opt_ltlt(MAYBE_UNUSED(CALL_DATA cd))
{
    return
#line 1492 "insns.def"
true;
#line 9483 "insns_info.inc"
}

/* 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 bool zjit_profile @ opt_and(cd)(recv, obj)(val) */
bool
attr_zjit_profile_opt_and(MAYBE_UNUSED(CALL_DATA cd))
{
    return
#line 1507 "insns.def"
true;
#line 9556 "insns_info.inc"
}

/* 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 bool zjit_profile @ opt_or(cd)(recv, obj)(val) */
bool
attr_zjit_profile_opt_or(MAYBE_UNUSED(CALL_DATA cd))
{
    return
#line 1522 "insns.def"
true;
#line 9629 "insns_info.inc"
}

/* 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 1541 "insns.def"
false;
#line 9653 "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 bool zjit_profile @ opt_aref(cd)(recv, obj)(val) */
bool
attr_zjit_profile_opt_aref(MAYBE_UNUSED(CALL_DATA cd))
{
    return
#line 1542 "insns.def"
true;
#line 9705 "insns_info.inc"
}

/* 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 1559 "insns.def"
false;
#line 9729 "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 bool zjit_profile @ opt_aset(cd)(recv, obj, set)(val) */
bool
attr_zjit_profile_opt_aset(MAYBE_UNUSED(CALL_DATA cd))
{
    return
#line 1560 "insns.def"
true;
#line 9781 "insns_info.inc"
}

/* 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 bool zjit_profile @ opt_length(cd)(recv)(val) */
bool
attr_zjit_profile_opt_length(MAYBE_UNUSED(CALL_DATA cd))
{
    return
#line 1575 "insns.def"
true;
#line 9854 "insns_info.inc"
}

/* 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 bool zjit_profile @ opt_size(cd)(recv)(val) */
bool
attr_zjit_profile_opt_size(MAYBE_UNUSED(CALL_DATA cd))
{
    return
#line 1590 "insns.def"
true;
#line 9927 "insns_info.inc"
}

/* 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 bool zjit_profile @ opt_empty_p(cd)(recv)(val) */
bool
attr_zjit_profile_opt_empty_p(MAYBE_UNUSED(CALL_DATA cd))
{
    return
#line 1605 "insns.def"
true;
#line 10000 "insns_info.inc"
}

/* 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 bool zjit_profile @ opt_succ(cd)(recv)(val) */
bool
attr_zjit_profile_opt_succ(MAYBE_UNUSED(CALL_DATA cd))
{
    return
#line 1620 "insns.def"
true;
#line 10073 "insns_info.inc"
}

/* 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 bool zjit_profile @ opt_not(cd)(recv)(val) */
bool
attr_zjit_profile_opt_not(MAYBE_UNUSED(CALL_DATA cd))
{
    return
#line 1635 "insns.def"
true;
#line 10146 "insns_info.inc"
}

/* 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 1650 "insns.def"
false;
#line 10170 "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 bool zjit_profile @ opt_regexpmatch2(cd)(obj2, obj1)(val) */
bool
attr_zjit_profile_opt_regexpmatch2(MAYBE_UNUSED(CALL_DATA cd))
{
    return
#line 1651 "insns.def"
true;
#line 10222 "insns_info.inc"
}

/* 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 1666 "insns.def"
false;
#line 10246 "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 1667 "insns.def"
1 - bf->argc;
#line 10284 "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 bool zjit_profile @ invokebuiltin(bf)(...)(val) */
bool
attr_zjit_profile_invokebuiltin(MAYBE_UNUSED(RB_BUILTIN bf))
{
    return false;
}

/* 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 1678 "insns.def"
false;
#line 10331 "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 bool zjit_profile @ opt_invokebuiltin_delegate(bf, index)()(val) */
bool
attr_zjit_profile_opt_invokebuiltin_delegate(
    MAYBE_UNUSED(RB_BUILTIN bf),
    MAYBE_UNUSED(rb_num_t index)
)
{
    return false;
}

/* 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 1689 "insns.def"
false;
#line 10434 "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 bool zjit_profile @ opt_invokebuiltin_delegate_leave(bf, index)()(val) */
bool
attr_zjit_profile_opt_invokebuiltin_delegate_leave(
    MAYBE_UNUSED(RB_BUILTIN bf),
    MAYBE_UNUSED(rb_num_t index)
)
{
    return false;
}

/* 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 bool zjit_profile @ getlocal_WC_0(idx)()(val) */
bool
attr_zjit_profile_getlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
    return false;
}

/* 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 bool zjit_profile @ getlocal_WC_1(idx)()(val) */
bool
attr_zjit_profile_getlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
    return false;
}

/* 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 bool zjit_profile @ setlocal_WC_0(idx)(val)() */
bool
attr_zjit_profile_setlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
    return false;
}

/* 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 bool zjit_profile @ setlocal_WC_1(idx)(val)() */
bool
attr_zjit_profile_setlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
    return false;
}

/* 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 bool zjit_profile @ putobject_INT2FIX_0_()()(val) */
bool
attr_zjit_profile_putobject_INT2FIX_0_(void)
{
    return false;
}

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

/* attr bool zjit_profile @ putobject_INT2FIX_1_()()(val) */
bool
attr_zjit_profile_putobject_INT2FIX_1_(void)
{
    return false;
}

MAYBE_UNUSED(static bool insn_leaf(int insn, const VALUE *opes));
static bool
insn_leaf(int insn, const VALUE *opes)
{
    switch (insn) {
      case BIN(nop):
        return attr_leaf_nop();
      case BIN(getlocal):
        return attr_leaf_getlocal((lindex_t)opes[0], (rb_num_t)opes[1]);
      case BIN(setlocal):
        return attr_leaf_setlocal((lindex_t)opes[0], (rb_num_t)opes[1]);
      case BIN(getblockparam):
        return attr_leaf_getblockparam((lindex_t)opes[0], (rb_num_t)opes[1]);
      case BIN(setblockparam):
        return attr_leaf_setblockparam((lindex_t)opes[0], (rb_num_t)opes[1]);
      case BIN(getblockparamproxy):
        return attr_leaf_getblockparamproxy((lindex_t)opes[0], (rb_num_t)opes[1]);
      case BIN(getspecial):
        return attr_leaf_getspecial((rb_num_t)opes[0], (rb_num_t)opes[1]);
      case BIN(setspecial):
        return attr_leaf_setspecial((rb_num_t)opes[0]);
      case BIN(getinstancevariable):
        return attr_leaf_getinstancevariable((ID)opes[0], (IVC)opes[1]);
      case BIN(setinstancevariable):
        return attr_leaf_setinstancevariable((ID)opes[0], (IVC)opes[1]);
      case BIN(getclassvariable):
        return attr_leaf_getclassvariable((ID)opes[0], (ICVARC)opes[1]);
      case BIN(setclassvariable):
        return attr_leaf_setclassvariable((ID)opes[0], (ICVARC)opes[1]);
      case BIN(opt_getconstant_path):
        return attr_leaf_opt_getconstant_path((IC)opes[0]);
      case BIN(getconstant):
        return attr_leaf_getconstant((ID)opes[0]);
      case BIN(setconstant):
        return attr_leaf_setconstant((ID)opes[0]);
      case BIN(getglobal):
        return attr_leaf_getglobal((ID)opes[0]);
      case BIN(setglobal):
        return attr_leaf_setglobal((ID)opes[0]);
      case BIN(putnil):
        return attr_leaf_putnil();
      case BIN(putself):
        return attr_leaf_putself();
      case BIN(putobject):
        return attr_leaf_putobject((VALUE)opes[0]);
      case BIN(putspecialobject):
        return attr_leaf_putspecialobject((rb_num_t)opes[0]);
      case BIN(putstring):
        return attr_leaf_putstring((VALUE)opes[0]);
      case BIN(putchilledstring):
        return attr_leaf_putchilledstring((VALUE)opes[0]);
      case BIN(concatstrings):
        return attr_leaf_concatstrings((rb_num_t)opes[0]);
      case BIN(anytostring):
        return attr_leaf_anytostring();
      case BIN(toregexp):
        return attr_leaf_toregexp((rb_num_t)opes[0], (rb_num_t)opes[1]);
      case BIN(intern):
        return attr_leaf_intern();
      case BIN(newarray):
        return attr_leaf_newarray((rb_num_t)opes[0]);
      case BIN(pushtoarraykwsplat):
        return attr_leaf_pushtoarraykwsplat();
      case BIN(duparray):
        return attr_leaf_duparray((VALUE)opes[0]);
      case BIN(duphash):
        return attr_leaf_duphash((VALUE)opes[0]);
      case BIN(expandarray):
        return attr_leaf_expandarray((rb_num_t)opes[0], (rb_num_t)opes[1]);
      case BIN(concatarray):
        return attr_leaf_concatarray();
      case BIN(concattoarray):
        return attr_leaf_concattoarray();
      case BIN(pushtoarray):
        return attr_leaf_pushtoarray((rb_num_t)opes[0]);
      case BIN(splatarray):
        return attr_leaf_splatarray((VALUE)opes[0]);
      case BIN(splatkw):
        return attr_leaf_splatkw();
      case BIN(newhash):
        return attr_leaf_newhash((rb_num_t)opes[0]);
      case BIN(newrange):
        return attr_leaf_newrange((rb_num_t)opes[0]);
      case BIN(pop):
        return attr_leaf_pop();
      case BIN(dup):
        return attr_leaf_dup();
      case BIN(dupn):
        return attr_leaf_dupn((rb_num_t)opes[0]);
      case BIN(swap):
        return attr_leaf_swap();
      case BIN(opt_reverse):
        return attr_leaf_opt_reverse((rb_num_t)opes[0]);
      case BIN(topn):
        return attr_leaf_topn((rb_num_t)opes[0]);
      case BIN(setn):
        return attr_leaf_setn((rb_num_t)opes[0]);
      case BIN(adjuststack):
        return attr_leaf_adjuststack((rb_num_t)opes[0]);
      case BIN(defined):
        return attr_leaf_defined((rb_num_t)opes[0], (VALUE)opes[1], (VALUE)opes[2]);
      case BIN(definedivar):
        return attr_leaf_definedivar((ID)opes[0], (IVC)opes[1], (VALUE)opes[2]);
      case BIN(checkmatch):
        return attr_leaf_checkmatch((rb_num_t)opes[0]);
      case BIN(checkkeyword):
        return attr_leaf_checkkeyword((lindex_t)opes[0], (lindex_t)opes[1]);
      case BIN(checktype):
        return attr_leaf_checktype((rb_num_t)opes[0]);
      case BIN(defineclass):
        return attr_leaf_defineclass((ID)opes[0], (ISEQ)opes[1], (rb_num_t)opes[2]);
      case BIN(definemethod):
        return attr_leaf_definemethod((ID)opes[0], (ISEQ)opes[1]);
      case BIN(definesmethod):
        return attr_leaf_definesmethod((ID)opes[0], (ISEQ)opes[1]);
      case BIN(send):
        return attr_leaf_send((CALL_DATA)opes[0], (ISEQ)opes[1]);
      case BIN(sendforward):
        return attr_leaf_sendforward((CALL_DATA)opes[0], (ISEQ)opes[1]);
      case BIN(opt_send_without_block):
        return attr_leaf_opt_send_without_block((CALL_DATA)opes[0]);
      case BIN(opt_new):
        return attr_leaf_opt_new((CALL_DATA)opes[0], (OFFSET)opes[1]);
      case BIN(objtostring):
        return attr_leaf_objtostring((CALL_DATA)opes[0]);
      case BIN(opt_ary_freeze):
        return attr_leaf_opt_ary_freeze((VALUE)opes[0], (CALL_DATA)opes[1]);
      case BIN(opt_hash_freeze):
        return attr_leaf_opt_hash_freeze((VALUE)opes[0], (CALL_DATA)opes[1]);
      case BIN(opt_str_freeze):
        return attr_leaf_opt_str_freeze((VALUE)opes[0], (CALL_DATA)opes[1]);
      case BIN(opt_nil_p):
        return attr_leaf_opt_nil_p((CALL_DATA)opes[0]);
      case BIN(opt_str_uminus):
        return attr_leaf_opt_str_uminus((VALUE)opes[0], (CALL_DATA)opes[1]);
      case BIN(opt_duparray_send):
        return attr_leaf_opt_duparray_send((VALUE)opes[0], (ID)opes[1], (rb_num_t)opes[2]);
      case BIN(opt_newarray_send):
        return attr_leaf_opt_newarray_send((rb_num_t)opes[0], (rb_num_t)opes[1]);
      case BIN(invokesuper):
        return attr_leaf_invokesuper((CALL_DATA)opes[0], (ISEQ)opes[1]);
      case BIN(invokesuperforward):
        return attr_leaf_invokesuperforward((CALL_DATA)opes[0], (ISEQ)opes[1]);
      case BIN(invokeblock):
        return attr_leaf_invokeblock((CALL_DATA)opes[0]);
      case BIN(leave):
        return attr_leaf_leave();
      case BIN(throw):
        return attr_leaf_throw((rb_num_t)opes[0]);
      case BIN(jump):
        return attr_leaf_jump((OFFSET)opes[0]);
      case BIN(branchif):
        return attr_leaf_branchif((OFFSET)opes[0]);
      case BIN(branchunless):
        return attr_leaf_branchunless((OFFSET)opes[0]);
      case BIN(branchnil):
        return attr_leaf_branchnil((OFFSET)opes[0]);
      case BIN(once):
        return attr_leaf_once((ISEQ)opes[0], (ISE)opes[1]);
      case BIN(opt_case_dispatch):
        return attr_leaf_opt_case_dispatch((CDHASH)opes[0], (OFFSET)opes[1]);
      case BIN(opt_plus):
        return attr_leaf_opt_plus((CALL_DATA)opes[0]);
      case BIN(opt_minus):
        return attr_leaf_opt_minus((CALL_DATA)opes[0]);
      case BIN(opt_mult):
        return attr_leaf_opt_mult((CALL_DATA)opes[0]);
      case BIN(opt_div):
        return attr_leaf_opt_div((CALL_DATA)opes[0]);
      case BIN(opt_mod):
        return attr_leaf_opt_mod((CALL_DATA)opes[0]);
      case BIN(opt_eq):
        return attr_leaf_opt_eq((CALL_DATA)opes[0]);
      case BIN(opt_neq):
        return attr_leaf_opt_neq((CALL_DATA)opes[0], (CALL_DATA)opes[1]);
      case BIN(opt_lt):
        return attr_leaf_opt_lt((CALL_DATA)opes[0]);
      case BIN(opt_le):
        return attr_leaf_opt_le((CALL_DATA)opes[0]);
      case BIN(opt_gt):
        return attr_leaf_opt_gt((CALL_DATA)opes[0]);
      case BIN(opt_ge):
        return attr_leaf_opt_ge((CALL_DATA)opes[0]);
      case BIN(opt_ltlt):
        return attr_leaf_opt_ltlt((CALL_DATA)opes[0]);
      case BIN(opt_and):
        return attr_leaf_opt_and((CALL_DATA)opes[0]);
      case BIN(opt_or):
        return attr_leaf_opt_or((CALL_DATA)opes[0]);
      case BIN(opt_aref):
        return attr_leaf_opt_aref((CALL_DATA)opes[0]);
      case BIN(opt_aset):
        return attr_leaf_opt_aset((CALL_DATA)opes[0]);
      case BIN(opt_length):
        return attr_leaf_opt_length((CALL_DATA)opes[0]);
      case BIN(opt_size):
        return attr_leaf_opt_size((CALL_DATA)opes[0]);
      case BIN(opt_empty_p):
        return attr_leaf_opt_empty_p((CALL_DATA)opes[0]);
      case BIN(opt_succ):
        return attr_leaf_opt_succ((CALL_DATA)opes[0]);
      case BIN(opt_not):
        return attr_leaf_opt_not((CALL_DATA)opes[0]);
      case BIN(opt_regexpmatch2):
        return attr_leaf_opt_regexpmatch2((CALL_DATA)opes[0]);
      case BIN(invokebuiltin):
        return attr_leaf_invokebuiltin((RB_BUILTIN)opes[0]);
      case BIN(opt_invokebuiltin_delegate):
        return attr_leaf_opt_invokebuiltin_delegate((RB_BUILTIN)opes[0], (rb_num_t)opes[1]);
      case BIN(opt_invokebuiltin_delegate_leave):
        return attr_leaf_opt_invokebuiltin_delegate_leave((RB_BUILTIN)opes[0], (rb_num_t)opes[1]);
      case BIN(getlocal_WC_0):
        return attr_leaf_getlocal_WC_0((lindex_t)opes[0]);
      case BIN(getlocal_WC_1):
        return attr_leaf_getlocal_WC_1((lindex_t)opes[0]);
      case BIN(setlocal_WC_0):
        return attr_leaf_setlocal_WC_0((lindex_t)opes[0]);
      case BIN(setlocal_WC_1):
        return attr_leaf_setlocal_WC_1((lindex_t)opes[0]);
      case BIN(putobject_INT2FIX_0_):
        return attr_leaf_putobject_INT2FIX_0_();
      case BIN(putobject_INT2FIX_1_):
        return attr_leaf_putobject_INT2FIX_1_();
      default:
        return false;
    }
}

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,    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,    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,
#if USE_ZJIT
           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,
#endif
    };
    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);
}

#endif
