/* -*- mode:c; style:ruby; coding: utf-8; indent-tabs-mode: nil -*- */

/* 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 consist of many small  parts of codes copyrighted by each authors,
 * 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 do not automatically define that of generated ones.  This is
 * the reason  why this file  is under unclear situation.   All that I  know is
 * that above provision guarantees this file to exist.
 *
 * Please let me  hesitate to declare something about this  nuanced contract. I
 * am not in the position to take  over other authors' license to merge into my
 * one.  Changing them to (say) GPLv3  is not doable by myself. Perhaps someday
 * it might turn out to be okay to say this file is under a license. I wish the
 * situation would become more clear in the future. */

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

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

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

enum ruby_insn_type_chars {
    TS_VARIABLE = '.',
    TS_CALLCACHE = 'E',
    TS_CALLINFO = 'C',
    TS_CDHASH = 'H',
    TS_GENTRY = 'G',
    TS_IC = 'K',
    TS_ID = 'I',
    TS_ISE = 'T',
    TS_ISEQ = 'S',
    TS_OFFSET = 'O',
    TS_VALUE = 'V',
    TS_LINDEX = 'L',
    TS_FUNCPTR = 'F',
    TS_NUM = 'N'
};

CONSTFUNC(MAYBE_UNUSED(static const char *insn_name(VALUE insn)));
extern const char *rb_vm_insn_name_info;
MJIT_SYMBOL_EXPORT_BEGIN
extern const unsigned short rb_vm_insn_name_offset[];
MJIT_SYMBOL_EXPORT_END

#ifdef RUBY_VM_INSNS_INFO
const unsigned short rb_vm_insn_name_offset[] = {
       0,    4,   13,   22,   36,   50,   69,   80,   91,  111,  131,  148,
     165,  177,  189,  199,  209,  216,  224,  234,  251,  259,  269,  283,
     292,  305,  314,  321,  330,  339,  347,  359,  371,  382,  390,  399,
     403,  407,  412,  417,  425,  431,  436,  441,  453,  461,  472,  485,
     495,  507,  512,  535,  550,  565,  582,  599,  611,  623,  629,  635,
     640,  649,  662,  672,  691,  710,  715,  733,  742,  752,  761,  769,
     777,  784,  792,  799,  806,  813,  820,  829,  837,  844,  853,  862,
     876,  890,  901,  910,  922,  931,  939,  956,  973,  993, 1000, 1007,
    1021, 1035, 1049, 1063, 1084, 1105, 1115, 1130, 1145, 1165, 1185, 1210,
    1227, 1244, 1270, 1296, 1319, 1342, 1360, 1378, 1394, 1410, 1423, 1437,
    1453, 1476, 1490, 1506, 1526, 1541, 1560, 1575, 1588, 1603, 1618, 1632,
    1650, 1668, 1685, 1699, 1714, 1724, 1734, 1745, 1756, 1770, 1782, 1793,
    1804, 1822, 1836, 1853, 1872, 1888, 1906, 1917, 1946, 1967, 1988, 2011,
    2034, 2052, 2070, 2082, 2094, 2105, 2120, 2139, 2155, 2180, 2205, 2216,
    2240, 2255, 2271, 2286, 2300, 2314, 2327, 2341, 2354, 2367, 2380, 2393,
    2408, 2422, 2435, 2450, 2465, 2485, 2505, 2522, 2537, 2555, 2570, 2584,
    2607, 2630, 2656, 2669, 2682, 2702, 2722, 2742, 2762, 2789,
};
const int rb_vm_max_insn_name_size = 28;
ASSERT_VM_INSTRUCTION_SIZE(rb_vm_insn_name_offset);

PACKED_STRUCT(struct rb_vm_insn_name_info_tag {
    const char L000[ 4]; const char L001[ 9]; const char L002[ 9];
    const char L003[14]; const char L004[14]; const char L005[19];
    const char L006[11]; const char L007[11]; const char L008[20];
    const char L009[20]; const char L010[17]; const char L011[17];
    const char L012[12]; const char L013[12]; const char L014[10];
    const char L015[10]; const char L016[ 7]; const char L017[ 8];
    const char L018[10]; const char L019[17]; const char L020[ 8];
    const char L021[10]; const char L022[14]; const char L023[ 9];
    const char L024[13]; const char L025[ 9]; const char L026[ 7];
    const char L027[ 9]; const char L028[ 9]; const char L029[ 8];
    const char L030[12]; const char L031[12]; const char L032[11];
    const char L033[ 8]; const char L034[ 9]; const char L035[ 4];
    const char L036[ 4]; const char L037[ 5]; const char L038[ 5];
    const char L039[ 8]; const char L040[ 6]; const char L041[ 5];
    const char L042[ 5]; const char L043[12]; const char L044[ 8];
    const char L045[11]; const char L046[13]; const char L047[10];
    const char L048[12]; const char L049[ 5]; const char L050[23];
    const char L051[15]; const char L052[15]; const char L053[17];
    const char L054[17]; const char L055[12]; const char L056[12];
    const char L057[ 6]; const char L058[ 6]; const char L059[ 5];
    const char L060[ 9]; const char L061[13]; const char L062[10];
    const char L063[19]; const char L064[19]; const char L065[ 5];
    const char L066[18]; const char L067[ 9]; const char L068[10];
    const char L069[ 9]; const char L070[ 8]; const char L071[ 8];
    const char L072[ 7]; const char L073[ 8]; const char L074[ 7];
    const char L075[ 7]; const char L076[ 7]; const char L077[ 7];
    const char L078[ 9]; const char L079[ 8]; const char L080[ 7];
    const char L081[ 9]; const char L082[ 9]; const char L083[14];
    const char L084[14]; const char L085[11]; const char L086[ 9];
    const char L087[12]; const char L088[ 9]; const char L089[ 8];
    const char L090[17]; const char L091[17]; const char L092[20];
    const char L093[ 7]; const char L094[ 7]; const char L095[14];
    const char L096[14]; const char L097[14]; const char L098[14];
    const char L099[21]; const char L100[21]; const char L101[10];
    const char L102[15]; const char L103[15]; const char L104[20];
    const char L105[20]; const char L106[25]; const char L107[17];
    const char L108[17]; const char L109[26]; const char L110[26];
    const char L111[23]; const char L112[23]; const char L113[18];
    const char L114[18]; const char L115[16]; const char L116[16];
    const char L117[13]; const char L118[14]; const char L119[16];
    const char L120[23]; const char L121[14]; const char L122[16];
    const char L123[20]; const char L124[15]; const char L125[19];
    const char L126[15]; const char L127[13]; const char L128[15];
    const char L129[15]; const char L130[14]; const char L131[18];
    const char L132[18]; const char L133[17]; const char L134[14];
    const char L135[15]; const char L136[10]; const char L137[10];
    const char L138[11]; const char L139[11]; const char L140[14];
    const char L141[12]; const char L142[11]; const char L143[11];
    const char L144[18]; const char L145[14]; const char L146[17];
    const char L147[19]; const char L148[16]; const char L149[18];
    const char L150[11]; const char L151[29]; const char L152[21];
    const char L153[21]; const char L154[23]; const char L155[23];
    const char L156[18]; const char L157[18]; const char L158[12];
    const char L159[12]; const char L160[11]; const char L161[15];
    const char L162[19]; const char L163[16]; const char L164[25];
    const char L165[25]; const char L166[11]; const char L167[24];
    const char L168[15]; const char L169[16]; const char L170[15];
    const char L171[14]; const char L172[14]; const char L173[13];
    const char L174[14]; const char L175[13]; const char L176[13];
    const char L177[13]; const char L178[13]; const char L179[15];
    const char L180[14]; const char L181[13]; const char L182[15];
    const char L183[15]; const char L184[20]; const char L185[20];
    const char L186[17]; const char L187[15]; const char L188[18];
    const char L189[15]; const char L190[14]; const char L191[23];
    const char L192[23]; const char L193[26]; const char L194[13];
    const char L195[13]; const char L196[20]; const char L197[20];
    const char L198[20]; const char L199[20]; const char L200[27];
    const char L201[27];
});

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

const char *rb_vm_insn_name_info = (const char *)&rb_vm_insn_name_base;
#endif

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

CONSTFUNC(MAYBE_UNUSED(static int insn_len(VALUE insn)));
extern const char rb_vm_insn_len_info[];

#ifdef RUBY_VM_INSNS_INFO
const char rb_vm_insn_len_info[] = {
    1, 3, 3, 3, 3, 3, 3, 2, 3, 3, 2, 2, 2, 2, 2, 2, 1, 1, 2, 2, 2, 2, 2, 1, 2,
    3, 1, 2, 2, 2, 3, 1, 2, 2, 2, 1, 1, 2, 1, 2, 1, 2, 2, 2, 4, 2, 3, 2, 4, 4,
    3, 4, 4, 2, 2, 4, 2, 1, 2, 2, 2, 2, 2, 3, 2, 3, 3, 3, 3, 3, 3, 3, 3, 5, 3,
    3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 3, 3, 3, 3, 3, 2, 3, 2, 1, 1, 2, 2, 2, 2, 1,
    1, 1, 3, 3, 3, 3, 3, 3, 2, 3, 3, 2, 2, 2, 2, 2, 2, 1, 1, 2, 2, 2, 2, 2, 1,
    2, 3, 1, 2, 2, 2, 3, 1, 2, 2, 2, 1, 1, 2, 1, 2, 1, 2, 2, 2, 4, 2, 3, 2, 4,
    4, 3, 4, 4, 2, 2, 4, 2, 1, 2, 2, 2, 2, 2, 3, 2, 3, 3, 3, 3, 3, 3, 3, 3, 5,
    3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 3, 3, 3, 3, 3, 2, 3, 2, 1, 1, 2, 2, 2, 2,
    1, 1,
};
#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)));
extern const char *rb_vm_insn_op_info;
extern const unsigned short rb_vm_insn_op_offset[];

#ifdef RUBY_VM_INSNS_INFO
const unsigned short rb_vm_insn_op_offset[] = {
      0,   1,   4,   7,  10,  13,  16,  19,  21,  24,  27,  29,  31,  33,
     35,  37,  39,  40,  41,  43,  45,  47,  49,  51,  52,  54,  57,  58,
     60,  62,  64,  67,  68,  70,  72,  74,  75,  76,  78,  79,  81,  82,
     84,  86,  88,  92,  94,  97,  99, 103, 107, 110, 114, 118, 120, 122,
    126, 128, 129, 131, 133, 135, 137, 139, 142, 144, 147, 150, 153, 156,
    159, 162, 165, 168, 173, 176, 179, 182, 185, 188, 191, 194, 197, 200,
    204, 208, 211, 214, 217, 220, 223, 225, 228, 230, 231, 232, 234, 236,
    238, 240, 241, 242, 243, 246, 249, 252, 255, 258, 261, 263, 266, 269,
    271, 273, 275, 277, 279, 281, 282, 283, 285, 287, 289, 291, 293, 294,
    296, 299, 300, 302, 304, 306, 309, 310, 312, 314, 316, 317, 318, 320,
    321, 323, 324, 326, 328, 330, 334, 336, 339, 341, 345, 349, 352, 356,
    360, 362, 364, 368, 370, 371, 373, 375, 377, 379, 381, 384, 386, 389,
    392, 395, 398, 401, 404, 407, 410, 415, 418, 421, 424, 427, 430, 433,
    436, 439, 442, 446, 450, 453, 456, 459, 462, 465, 467, 470, 472, 473,
    474, 476, 478, 480, 482, 483,
};
ASSERT_VM_INSTRUCTION_SIZE(rb_vm_insn_op_offset);

PACKED_STRUCT(struct rb_vm_insn_op_info_tag {
    const char L000[ 1]; const char L001[ 3]; const char L002[ 3];
    const char L003[ 3]; const char L004[ 3]; const char L005[ 3];
    const char L006[ 3]; const char L007[ 2]; const char L008[ 3];
    const char L009[ 3]; const char L010[ 2]; const char L011[ 2];
    const char L012[ 2]; const char L013[ 2]; const char L014[ 2];
    const char L015[ 2]; const char L016[ 1]; const char L017[ 1];
    const char L018[ 2]; const char L019[ 2]; const char L020[ 2];
    const char L021[ 2]; const char L022[ 2]; const char L023[ 1];
    const char L024[ 2]; const char L025[ 3]; const char L026[ 1];
    const char L027[ 2]; const char L028[ 2]; const char L029[ 2];
    const char L030[ 3]; const char L031[ 1]; const char L032[ 2];
    const char L033[ 2]; const char L034[ 2]; const char L035[ 1];
    const char L036[ 1]; const char L037[ 2]; const char L038[ 1];
    const char L039[ 2]; const char L040[ 1]; const char L041[ 2];
    const char L042[ 2]; const char L043[ 2]; const char L044[ 4];
    const char L045[ 2]; const char L046[ 3]; const char L047[ 2];
    const char L048[ 4]; const char L049[ 4]; const char L050[ 3];
    const char L051[ 4]; const char L052[ 4]; const char L053[ 2];
    const char L054[ 2]; const char L055[ 4]; const char L056[ 2];
    const char L057[ 1]; const char L058[ 2]; const char L059[ 2];
    const char L060[ 2]; const char L061[ 2]; const char L062[ 2];
    const char L063[ 3]; const char L064[ 2]; const char L065[ 3];
    const char L066[ 3]; const char L067[ 3]; const char L068[ 3];
    const char L069[ 3]; const char L070[ 3]; const char L071[ 3];
    const char L072[ 3]; const char L073[ 5]; const char L074[ 3];
    const char L075[ 3]; const char L076[ 3]; const char L077[ 3];
    const char L078[ 3]; const char L079[ 3]; const char L080[ 3];
    const char L081[ 3]; const char L082[ 3]; const char L083[ 4];
    const char L084[ 4]; const char L085[ 3]; const char L086[ 3];
    const char L087[ 3]; const char L088[ 3]; const char L089[ 3];
    const char L090[ 2]; const char L091[ 3]; const char L092[ 2];
    const char L093[ 1]; const char L094[ 1]; const char L095[ 2];
    const char L096[ 2]; const char L097[ 2]; const char L098[ 2];
    const char L099[ 1]; const char L100[ 1]; const char L101[ 1];
    const char L102[ 3]; const char L103[ 3]; const char L104[ 3];
    const char L105[ 3]; const char L106[ 3]; const char L107[ 3];
    const char L108[ 2]; const char L109[ 3]; const char L110[ 3];
    const char L111[ 2]; const char L112[ 2]; const char L113[ 2];
    const char L114[ 2]; const char L115[ 2]; const char L116[ 2];
    const char L117[ 1]; const char L118[ 1]; const char L119[ 2];
    const char L120[ 2]; const char L121[ 2]; const char L122[ 2];
    const char L123[ 2]; const char L124[ 1]; const char L125[ 2];
    const char L126[ 3]; const char L127[ 1]; const char L128[ 2];
    const char L129[ 2]; const char L130[ 2]; const char L131[ 3];
    const char L132[ 1]; const char L133[ 2]; const char L134[ 2];
    const char L135[ 2]; const char L136[ 1]; const char L137[ 1];
    const char L138[ 2]; const char L139[ 1]; const char L140[ 2];
    const char L141[ 1]; const char L142[ 2]; const char L143[ 2];
    const char L144[ 2]; const char L145[ 4]; const char L146[ 2];
    const char L147[ 3]; const char L148[ 2]; const char L149[ 4];
    const char L150[ 4]; const char L151[ 3]; const char L152[ 4];
    const char L153[ 4]; const char L154[ 2]; const char L155[ 2];
    const char L156[ 4]; const char L157[ 2]; const char L158[ 1];
    const char L159[ 2]; const char L160[ 2]; const char L161[ 2];
    const char L162[ 2]; const char L163[ 2]; const char L164[ 3];
    const char L165[ 2]; const char L166[ 3]; const char L167[ 3];
    const char L168[ 3]; const char L169[ 3]; const char L170[ 3];
    const char L171[ 3]; const char L172[ 3]; const char L173[ 3];
    const char L174[ 5]; const char L175[ 3]; const char L176[ 3];
    const char L177[ 3]; const char L178[ 3]; const char L179[ 3];
    const char L180[ 3]; const char L181[ 3]; const char L182[ 3];
    const char L183[ 3]; const char L184[ 4]; const char L185[ 4];
    const char L186[ 3]; const char L187[ 3]; const char L188[ 3];
    const char L189[ 3]; const char L190[ 3]; const char L191[ 2];
    const char L192[ 3]; const char L193[ 2]; const char L194[ 1];
    const char L195[ 1]; const char L196[ 2]; const char L197[ 2];
    const char L198[ 2]; const char L199[ 2]; const char L200[ 1];
    const char L201[ 1];
});

static const struct rb_vm_insn_op_info_tag rb_vm_insn_op_base = {
    ""    , "LN"  , "LN"  , "LN"  , "LN"  , "LN"  , "NN"  , "N"   ,
    "IK"  , "IK"  , "I"   , "I"   , "I"   , "I"   , "G"   , "G"   ,
    ""    , ""    , "V"   , "N"   , "S"   , "V"   , "N"   , ""    ,
    "V"   , "NN"  , ""    , "N"   , "V"   , "V"   , "NN"  , ""    ,
    "V"   , "N"   , "N"   , ""    , ""    , "N"   , ""    , "N"   ,
    ""    , "N"   , "N"   , "N"   , "NVV" , "N"   , "LL"  , "N"   ,
    "ISN" , "CES" , "CE"  , "VCE" , "VCE" , "N"   , "N"   , "CES" ,
    "C"   , ""    , "N"   , "O"   , "O"   , "O"   , "O"   , "OK"  ,
    "K"   , "ST"  , "HO"  , "CE"  , "CE"  , "CE"  , "CE"  , "CE"  ,
    "CE"  , "CECE", "CE"  , "CE"  , "CE"  , "CE"  , "CE"  , "CE"  ,
    "CE"  , "CE"  , "CE"  , "VCE" , "VCE" , "CE"  , "CE"  , "CE"  ,
    "CE"  , "CE"  , "V"   , "CE"  , "F"   , ""    , ""    , "L"   ,
    "L"   , "L"   , "L"   , ""    , ""    , ""    , "LN"  , "LN"  ,
    "LN"  , "LN"  , "LN"  , "NN"  , "N"   , "IK"  , "IK"  , "I"   ,
    "I"   , "I"   , "I"   , "G"   , "G"   , ""    , ""    , "V"   ,
    "N"   , "S"   , "V"   , "N"   , ""    , "V"   , "NN"  , ""    ,
    "N"   , "V"   , "V"   , "NN"  , ""    , "V"   , "N"   , "N"   ,
    ""    , ""    , "N"   , ""    , "N"   , ""    , "N"   , "N"   ,
    "N"   , "NVV" , "N"   , "LL"  , "N"   , "ISN" , "CES" , "CE"  ,
    "VCE" , "VCE" , "N"   , "N"   , "CES" , "C"   , ""    , "N"   ,
    "O"   , "O"   , "O"   , "O"   , "OK"  , "K"   , "ST"  , "HO"  ,
    "CE"  , "CE"  , "CE"  , "CE"  , "CE"  , "CE"  , "CECE", "CE"  ,
    "CE"  , "CE"  , "CE"  , "CE"  , "CE"  , "CE"  , "CE"  , "CE"  ,
    "VCE" , "VCE" , "CE"  , "CE"  , "CE"  , "CE"  , "CE"  , "V"   ,
    "CE"  , "F"   , ""    , ""    , "L"   , "L"   , "L"   , "L"   ,
    ""    , ""    ,
};

const char *rb_vm_insn_op_info = (const char *)&rb_vm_insn_op_base;
#endif

const char *
insn_op_types(VALUE i)
{
    return &rb_vm_insn_op_info[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];
    }
}


static bool
leafness_of_getglobal(VALUE gentry)
{
    const struct rb_global_entry *e = (void *)gentry;

    if (UNLIKELY(rb_gvar_is_traced(e))) {
        return false;
    }
    else {
        /* We cannot write this function using a switch() because a
         * case label cannot be a function pointer. */
        static rb_gvar_getter_t *const allowlist[] = {
            rb_gvar_val_getter,
            rb_gvar_var_getter,
            rb_gvar_undef_getter,
        };
        rb_gvar_getter_t *f = rb_gvar_getter_function_of(e);
        int i;

        for (i = 0; i < numberof(allowlist); i++) {
            if (f == allowlist[i]) {
                return true;
            }
        }
        return false;
    }
}

static bool
leafness_of_setglobal(VALUE gentry)
{
    const struct rb_global_entry *e = (void *)gentry;

    if (UNLIKELY(rb_gvar_is_traced(e))) {
        return false;
    }
    else {
        /* We cannot write this function using a switch() because a
         * case label cannot be a function pointer. */
        static rb_gvar_setter_t *const allowlist[] = {
            rb_gvar_val_setter,
            rb_gvar_readonly_setter,
            rb_gvar_var_setter,
            rb_gvar_undef_setter,
        };
        rb_gvar_setter_t *f = rb_gvar_setter_function_of(e);
        int i;

        for (i = 0; i < numberof(allowlist); i++) {
            if (f == allowlist[i]) {
                return true;
            }
        }
        return false;
    }
}

#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_IVAR2:
      case DEFINED_GVAR:
      case DEFINED_CVAR:
      case DEFINED_YIELD:
      case DEFINED_REF:
      case DEFINED_ZSUPER:
        return false;
      case DEFINED_CONST:
        /* 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;
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/* attr bool leaf @ getspecial(key, type)()(val) */
bool
attr_leaf_getspecial(
    MAYBE_UNUSED(rb_num_t key),
    MAYBE_UNUSED(rb_num_t type)
)
{
    return true;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/* attr const char* name @ getinstancevariable(id, ic)()(val) */
const char*
attr_name_getinstancevariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IC 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(IC ic)
)
{
    return 2;
}

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

/* attr rb_num_t retn @ getinstancevariable(id, ic)()(val) */
rb_num_t
attr_retn_getinstancevariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IC 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(IC ic)
)
{
    return 1;
}

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

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

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

/* attr bool leaf @ setinstancevariable(id, ic)(val)() */
bool
attr_leaf_setinstancevariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IC ic)
)
{
    return true;
}

/* attr const char* name @ setinstancevariable(id, ic)(val)() */
const char*
attr_name_setinstancevariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IC 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(IC ic)
)
{
    return 2;
}

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

/* attr rb_num_t retn @ setinstancevariable(id, ic)(val)() */
rb_num_t
attr_retn_setinstancevariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IC 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(IC ic)
)
{
    return -1;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/* attr rb_snum_t sp_inc @ getconstant(id)(klass)(val) */
rb_snum_t
attr_sp_inc_getconstant(MAYBE_UNUSED(ID id))
{
    return 0;
}

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

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

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

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

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

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

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

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

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

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

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

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

/* attr bool leaf @ getglobal(entry)()(val) */
bool
attr_leaf_getglobal(MAYBE_UNUSED(GENTRY entry))
{
    return
#line 291 "insns.def"
leafness_of_getglobal(entry);
#line 2588 "insns_info.inc"
}

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

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

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

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

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

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

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

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

/* attr bool leaf @ setglobal(entry)(val)() */
bool
attr_leaf_setglobal(MAYBE_UNUSED(GENTRY entry))
{
    return
#line 302 "insns.def"
leafness_of_setglobal(entry);
#line 2654 "insns_info.inc"
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/* attr bool leaf @ putspecialobject(value_type)()(val) */
bool
attr_leaf_putspecialobject(MAYBE_UNUSED(rb_num_t value_type))
{
    return true;
}

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

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

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

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

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

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

/* attr enum ruby_vminsn_type bin @ putiseq(iseq)()(ret) */
enum ruby_vminsn_type
attr_bin_putiseq(MAYBE_UNUSED(ISEQ iseq))
{
    return BIN(putiseq);
}

/* attr bool handles_sp @ putiseq(iseq)()(ret) */
bool
attr_handles_sp_putiseq(MAYBE_UNUSED(ISEQ iseq))
{
    return
#line 362 "insns.def"
false;
#line 2965 "insns_info.inc"
}

/* attr bool leaf @ putiseq(iseq)()(ret) */
bool
attr_leaf_putiseq(MAYBE_UNUSED(ISEQ iseq))
{
    return true;
}

/* attr const char* name @ putiseq(iseq)()(ret) */
const char*
attr_name_putiseq(MAYBE_UNUSED(ISEQ iseq))
{
    return insn_name(BIN(putiseq));
}

/* attr rb_num_t open @ putiseq(iseq)()(ret) */
rb_num_t
attr_open_putiseq(MAYBE_UNUSED(ISEQ iseq))
{
    return 1;
}

/* attr rb_num_t popn @ putiseq(iseq)()(ret) */
rb_num_t
attr_popn_putiseq(MAYBE_UNUSED(ISEQ iseq))
{
    return 0;
}

/* attr rb_num_t retn @ putiseq(iseq)()(ret) */
rb_num_t
attr_retn_putiseq(MAYBE_UNUSED(ISEQ iseq))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ putiseq(iseq)()(ret) */
rb_snum_t
attr_sp_inc_putiseq(MAYBE_UNUSED(ISEQ iseq))
{
    return 1;
}

/* attr rb_num_t width @ putiseq(iseq)()(ret) */
rb_num_t
attr_width_putiseq(MAYBE_UNUSED(ISEQ iseq))
{
    return 2;
}

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

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

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

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

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

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

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

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

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

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

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

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

/* 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 383 "insns.def"
1 - (rb_snum_t)num;
#line 3136 "insns_info.inc"
}

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

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

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

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

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

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

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

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

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

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

/* attr enum ruby_vminsn_type bin @ freezestring(debug_info)(str)(str) */
enum ruby_vminsn_type
attr_bin_freezestring(MAYBE_UNUSED(VALUE debug_info))
{
    return BIN(freezestring);
}

/* attr bool handles_sp @ freezestring(debug_info)(str)(str) */
bool
attr_handles_sp_freezestring(MAYBE_UNUSED(VALUE debug_info))
{
    return false;
}

/* attr bool leaf @ freezestring(debug_info)(str)(str) */
bool
attr_leaf_freezestring(MAYBE_UNUSED(VALUE debug_info))
{
    return true;
}

/* attr const char* name @ freezestring(debug_info)(str)(str) */
const char*
attr_name_freezestring(MAYBE_UNUSED(VALUE debug_info))
{
    return insn_name(BIN(freezestring));
}

/* attr rb_num_t open @ freezestring(debug_info)(str)(str) */
rb_num_t
attr_open_freezestring(MAYBE_UNUSED(VALUE debug_info))
{
    return 1;
}

/* attr rb_num_t popn @ freezestring(debug_info)(str)(str) */
rb_num_t
attr_popn_freezestring(MAYBE_UNUSED(VALUE debug_info))
{
    return 1;
}

/* attr rb_num_t retn @ freezestring(debug_info)(str)(str) */
rb_num_t
attr_retn_freezestring(MAYBE_UNUSED(VALUE debug_info))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ freezestring(debug_info)(str)(str) */
rb_snum_t
attr_sp_inc_freezestring(MAYBE_UNUSED(VALUE debug_info))
{
    return 0;
}

/* attr rb_num_t width @ freezestring(debug_info)(str)(str) */
rb_num_t
attr_width_freezestring(MAYBE_UNUSED(VALUE debug_info))
{
    return 2;
}

/* 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 418 "insns.def"
true;
#line 3302 "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 419 "insns.def"
1 - (rb_snum_t)cnt;
#line 3355 "insns_info.inc"
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/* attr bool leaf @ expandarray(num, flag)(..., ary)(...) */
bool
attr_leaf_expandarray(
    MAYBE_UNUSED(rb_num_t num),
    MAYBE_UNUSED(rb_num_t flag)
)
{
    return
#line 483 "insns.def"
false;
#line 3653 "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 484 "insns.def"
(rb_snum_t)num - 1 + (flag & 1 ? 1 : 0);
#line 3706 "insns_info.inc"
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/* attr bool leaf @ newhash(num)(...)(val) */
bool
attr_leaf_newhash(MAYBE_UNUSED(rb_num_t num))
{
    return
#line 517 "insns.def"
false;
#line 3872 "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 518 "insns.def"
1 - (rb_snum_t)num;
#line 3910 "insns_info.inc"
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/* attr enum ruby_vminsn_type bin @ reput()(..., val)(val) */
enum ruby_vminsn_type
attr_bin_reput(void)
{
    return BIN(reput);
}

/* attr bool handles_sp @ reput()(..., val)(val) */
bool
attr_handles_sp_reput(void)
{
    return false;
}

/* attr bool leaf @ reput()(..., val)(val) */
bool
attr_leaf_reput(void)
{
    return true;
}

/* attr const char* name @ reput()(..., val)(val) */
const char*
attr_name_reput(void)
{
    return insn_name(BIN(reput));
}

/* attr rb_num_t open @ reput()(..., val)(val) */
rb_num_t
attr_open_reput(void)
{
    return 0;
}

/* attr rb_num_t popn @ reput()(..., val)(val) */
rb_num_t
attr_popn_reput(void)
{
    return 1;
}

/* attr rb_num_t retn @ reput()(..., val)(val) */
rb_num_t
attr_retn_reput(void)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ reput()(..., val)(val) */
rb_snum_t
attr_sp_inc_reput(void)
{
    return
#line 615 "insns.def"
0;
#line 4363 "insns_info.inc"
}

/* attr rb_num_t width @ reput()(..., val)(val) */
rb_num_t
attr_width_reput(void)
{
    return 1;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/* attr enum ruby_vminsn_type bin @ send(ci, cc, blockiseq)(...)(val) */
enum ruby_vminsn_type
attr_bin_send(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return BIN(send);
}

/* attr bool handles_sp @ send(ci, cc, blockiseq)(...)(val) */
bool
attr_handles_sp_send(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return true;
}

/* attr bool leaf @ send(ci, cc, blockiseq)(...)(val) */
bool
attr_leaf_send(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return false;
}

/* attr const char* name @ send(ci, cc, blockiseq)(...)(val) */
const char*
attr_name_send(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return insn_name(BIN(send));
}

/* attr rb_num_t open @ send(ci, cc, blockiseq)(...)(val) */
rb_num_t
attr_open_send(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return 3;
}

/* attr rb_num_t popn @ send(ci, cc, blockiseq)(...)(val) */
rb_num_t
attr_popn_send(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return 0;
}

/* attr rb_num_t retn @ send(ci, cc, blockiseq)(...)(val) */
rb_num_t
attr_retn_send(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ send(ci, cc, blockiseq)(...)(val) */
rb_snum_t
attr_sp_inc_send(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return
#line 743 "insns.def"
- (int)(ci->orig_argc + ((ci->flag & VM_CALL_ARGS_BLOCKARG) ? 1 : 0));
#line 5079 "insns_info.inc"
}

/* attr rb_num_t width @ send(ci, cc, blockiseq)(...)(val) */
rb_num_t
attr_width_send(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return 4;
}

/* attr enum ruby_vminsn_type bin @ opt_send_without_block(ci, cc)(...)(val) */
enum ruby_vminsn_type
attr_bin_opt_send_without_block(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return BIN(opt_send_without_block);
}

/* attr bool handles_sp @ opt_send_without_block(ci, cc)(...)(val) */
bool
attr_handles_sp_opt_send_without_block(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return
#line 759 "insns.def"
true;
#line 5113 "insns_info.inc"
}

/* attr bool leaf @ opt_send_without_block(ci, cc)(...)(val) */
bool
attr_leaf_opt_send_without_block(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return ! attr_handles_sp_opt_send_without_block(ci, cc);
}

/* attr const char* name @ opt_send_without_block(ci, cc)(...)(val) */
const char*
attr_name_opt_send_without_block(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return insn_name(BIN(opt_send_without_block));
}

/* attr rb_num_t open @ opt_send_without_block(ci, cc)(...)(val) */
rb_num_t
attr_open_opt_send_without_block(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 2;
}

/* attr rb_num_t popn @ opt_send_without_block(ci, cc)(...)(val) */
rb_num_t
attr_popn_opt_send_without_block(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 0;
}

/* attr rb_num_t retn @ opt_send_without_block(ci, cc)(...)(val) */
rb_num_t
attr_retn_opt_send_without_block(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_send_without_block(ci, cc)(...)(val) */
rb_snum_t
attr_sp_inc_opt_send_without_block(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return
#line 760 "insns.def"
-ci->orig_argc;
#line 5176 "insns_info.inc"
}

/* attr rb_num_t width @ opt_send_without_block(ci, cc)(...)(val) */
rb_num_t
attr_width_opt_send_without_block(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ opt_str_freeze(str, ci, cc)()(val) */
enum ruby_vminsn_type
attr_bin_opt_str_freeze(
    MAYBE_UNUSED(VALUE str),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return BIN(opt_str_freeze);
}

/* attr bool handles_sp @ opt_str_freeze(str, ci, cc)()(val) */
bool
attr_handles_sp_opt_str_freeze(
    MAYBE_UNUSED(VALUE str),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* attr bool leaf @ opt_str_freeze(str, ci, cc)()(val) */
bool
attr_leaf_opt_str_freeze(
    MAYBE_UNUSED(VALUE str),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return true;
}

/* attr const char* name @ opt_str_freeze(str, ci, cc)()(val) */
const char*
attr_name_opt_str_freeze(
    MAYBE_UNUSED(VALUE str),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return insn_name(BIN(opt_str_freeze));
}

/* attr rb_num_t open @ opt_str_freeze(str, ci, cc)()(val) */
rb_num_t
attr_open_opt_str_freeze(
    MAYBE_UNUSED(VALUE str),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 3;
}

/* attr rb_num_t popn @ opt_str_freeze(str, ci, cc)()(val) */
rb_num_t
attr_popn_opt_str_freeze(
    MAYBE_UNUSED(VALUE str),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 0;
}

/* attr rb_num_t retn @ opt_str_freeze(str, ci, cc)()(val) */
rb_num_t
attr_retn_opt_str_freeze(
    MAYBE_UNUSED(VALUE str),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_str_freeze(str, ci, cc)()(val) */
rb_snum_t
attr_sp_inc_opt_str_freeze(
    MAYBE_UNUSED(VALUE str),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 1;
}

/* attr rb_num_t width @ opt_str_freeze(str, ci, cc)()(val) */
rb_num_t
attr_width_opt_str_freeze(
    MAYBE_UNUSED(VALUE str),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 4;
}

/* attr enum ruby_vminsn_type bin @ opt_str_uminus(str, ci, cc)()(val) */
enum ruby_vminsn_type
attr_bin_opt_str_uminus(
    MAYBE_UNUSED(VALUE str),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return BIN(opt_str_uminus);
}

/* attr bool handles_sp @ opt_str_uminus(str, ci, cc)()(val) */
bool
attr_handles_sp_opt_str_uminus(
    MAYBE_UNUSED(VALUE str),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* attr bool leaf @ opt_str_uminus(str, ci, cc)()(val) */
bool
attr_leaf_opt_str_uminus(
    MAYBE_UNUSED(VALUE str),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return true;
}

/* attr const char* name @ opt_str_uminus(str, ci, cc)()(val) */
const char*
attr_name_opt_str_uminus(
    MAYBE_UNUSED(VALUE str),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return insn_name(BIN(opt_str_uminus));
}

/* attr rb_num_t open @ opt_str_uminus(str, ci, cc)()(val) */
rb_num_t
attr_open_opt_str_uminus(
    MAYBE_UNUSED(VALUE str),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 3;
}

/* attr rb_num_t popn @ opt_str_uminus(str, ci, cc)()(val) */
rb_num_t
attr_popn_opt_str_uminus(
    MAYBE_UNUSED(VALUE str),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 0;
}

/* attr rb_num_t retn @ opt_str_uminus(str, ci, cc)()(val) */
rb_num_t
attr_retn_opt_str_uminus(
    MAYBE_UNUSED(VALUE str),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_str_uminus(str, ci, cc)()(val) */
rb_snum_t
attr_sp_inc_opt_str_uminus(
    MAYBE_UNUSED(VALUE str),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 1;
}

/* attr rb_num_t width @ opt_str_uminus(str, ci, cc)()(val) */
rb_num_t
attr_width_opt_str_uminus(
    MAYBE_UNUSED(VALUE str),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 4;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/* attr enum ruby_vminsn_type bin @ invokesuper(ci, cc, blockiseq)(...)(val) */
enum ruby_vminsn_type
attr_bin_invokesuper(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return BIN(invokesuper);
}

/* attr bool handles_sp @ invokesuper(ci, cc, blockiseq)(...)(val) */
bool
attr_handles_sp_invokesuper(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return true;
}

/* attr bool leaf @ invokesuper(ci, cc, blockiseq)(...)(val) */
bool
attr_leaf_invokesuper(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return false;
}

/* attr const char* name @ invokesuper(ci, cc, blockiseq)(...)(val) */
const char*
attr_name_invokesuper(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return insn_name(BIN(invokesuper));
}

/* attr rb_num_t open @ invokesuper(ci, cc, blockiseq)(...)(val) */
rb_num_t
attr_open_invokesuper(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return 3;
}

/* attr rb_num_t popn @ invokesuper(ci, cc, blockiseq)(...)(val) */
rb_num_t
attr_popn_invokesuper(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return 0;
}

/* attr rb_num_t retn @ invokesuper(ci, cc, blockiseq)(...)(val) */
rb_num_t
attr_retn_invokesuper(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ invokesuper(ci, cc, blockiseq)(...)(val) */
rb_snum_t
attr_sp_inc_invokesuper(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return
#line 829 "insns.def"
- (int)(ci->orig_argc + ((ci->flag & VM_CALL_ARGS_BLOCKARG) ? 1 : 0));
#line 5613 "insns_info.inc"
}

/* attr rb_num_t width @ invokesuper(ci, cc, blockiseq)(...)(val) */
rb_num_t
attr_width_invokesuper(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return 4;
}

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

/* attr bool handles_sp @ invokeblock(ci)(...)(val) */
bool
attr_handles_sp_invokeblock(MAYBE_UNUSED(CALL_INFO ci))
{
    return
#line 845 "insns.def"
true;
#line 5641 "insns_info.inc"
}

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

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

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

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

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

/* attr rb_snum_t sp_inc @ invokeblock(ci)(...)(val) */
rb_snum_t
attr_sp_inc_invokeblock(MAYBE_UNUSED(CALL_INFO ci))
{
    return
#line 846 "insns.def"
1 - ci->orig_argc;
#line 5686 "insns_info.inc"
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/* attr bool leaf @ opt_setinlinecache(ic)(val)(val) */
bool
attr_leaf_opt_setinlinecache(MAYBE_UNUSED(IC ic))
{
    return true;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/* attr enum ruby_vminsn_type bin @ opt_plus(ci, cc)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_plus(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return BIN(opt_plus);
}

/* attr bool handles_sp @ opt_plus(ci, cc)(recv, obj)(val) */
bool
attr_handles_sp_opt_plus(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* attr bool leaf @ opt_plus(ci, cc)(recv, obj)(val) */
bool
attr_leaf_opt_plus(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return
#line 1046 "insns.def"
false;
#line 6461 "insns_info.inc"
}

/* attr const char* name @ opt_plus(ci, cc)(recv, obj)(val) */
const char*
attr_name_opt_plus(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return insn_name(BIN(opt_plus));
}

/* attr rb_num_t open @ opt_plus(ci, cc)(recv, obj)(val) */
rb_num_t
attr_open_opt_plus(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 2;
}

/* attr rb_num_t popn @ opt_plus(ci, cc)(recv, obj)(val) */
rb_num_t
attr_popn_opt_plus(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 2;
}

/* attr rb_num_t retn @ opt_plus(ci, cc)(recv, obj)(val) */
rb_num_t
attr_retn_opt_plus(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_plus(ci, cc)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_plus(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return -1;
}

/* attr rb_num_t width @ opt_plus(ci, cc)(recv, obj)(val) */
rb_num_t
attr_width_opt_plus(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ opt_minus(ci, cc)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_minus(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return BIN(opt_minus);
}

/* attr bool handles_sp @ opt_minus(ci, cc)(recv, obj)(val) */
bool
attr_handles_sp_opt_minus(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* attr bool leaf @ opt_minus(ci, cc)(recv, obj)(val) */
bool
attr_leaf_opt_minus(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return true;
}

/* attr const char* name @ opt_minus(ci, cc)(recv, obj)(val) */
const char*
attr_name_opt_minus(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return insn_name(BIN(opt_minus));
}

/* attr rb_num_t open @ opt_minus(ci, cc)(recv, obj)(val) */
rb_num_t
attr_open_opt_minus(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 2;
}

/* attr rb_num_t popn @ opt_minus(ci, cc)(recv, obj)(val) */
rb_num_t
attr_popn_opt_minus(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 2;
}

/* attr rb_num_t retn @ opt_minus(ci, cc)(recv, obj)(val) */
rb_num_t
attr_retn_opt_minus(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_minus(ci, cc)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_minus(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return -1;
}

/* attr rb_num_t width @ opt_minus(ci, cc)(recv, obj)(val) */
rb_num_t
attr_width_opt_minus(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ opt_mult(ci, cc)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_mult(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return BIN(opt_mult);
}

/* attr bool handles_sp @ opt_mult(ci, cc)(recv, obj)(val) */
bool
attr_handles_sp_opt_mult(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* attr bool leaf @ opt_mult(ci, cc)(recv, obj)(val) */
bool
attr_leaf_opt_mult(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return true;
}

/* attr const char* name @ opt_mult(ci, cc)(recv, obj)(val) */
const char*
attr_name_opt_mult(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return insn_name(BIN(opt_mult));
}

/* attr rb_num_t open @ opt_mult(ci, cc)(recv, obj)(val) */
rb_num_t
attr_open_opt_mult(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 2;
}

/* attr rb_num_t popn @ opt_mult(ci, cc)(recv, obj)(val) */
rb_num_t
attr_popn_opt_mult(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 2;
}

/* attr rb_num_t retn @ opt_mult(ci, cc)(recv, obj)(val) */
rb_num_t
attr_retn_opt_mult(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_mult(ci, cc)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_mult(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return -1;
}

/* attr rb_num_t width @ opt_mult(ci, cc)(recv, obj)(val) */
rb_num_t
attr_width_opt_mult(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ opt_div(ci, cc)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_div(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return BIN(opt_div);
}

/* attr bool handles_sp @ opt_div(ci, cc)(recv, obj)(val) */
bool
attr_handles_sp_opt_div(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* attr bool leaf @ opt_div(ci, cc)(recv, obj)(val) */
bool
attr_leaf_opt_div(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return true;
}

/* attr const char* name @ opt_div(ci, cc)(recv, obj)(val) */
const char*
attr_name_opt_div(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return insn_name(BIN(opt_div));
}

/* attr rb_num_t open @ opt_div(ci, cc)(recv, obj)(val) */
rb_num_t
attr_open_opt_div(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 2;
}

/* attr rb_num_t popn @ opt_div(ci, cc)(recv, obj)(val) */
rb_num_t
attr_popn_opt_div(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 2;
}

/* attr rb_num_t retn @ opt_div(ci, cc)(recv, obj)(val) */
rb_num_t
attr_retn_opt_div(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_div(ci, cc)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_div(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return -1;
}

/* attr rb_num_t width @ opt_div(ci, cc)(recv, obj)(val) */
rb_num_t
attr_width_opt_div(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ opt_mod(ci, cc)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_mod(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return BIN(opt_mod);
}

/* attr bool handles_sp @ opt_mod(ci, cc)(recv, obj)(val) */
bool
attr_handles_sp_opt_mod(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* attr bool leaf @ opt_mod(ci, cc)(recv, obj)(val) */
bool
attr_leaf_opt_mod(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return true;
}

/* attr const char* name @ opt_mod(ci, cc)(recv, obj)(val) */
const char*
attr_name_opt_mod(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return insn_name(BIN(opt_mod));
}

/* attr rb_num_t open @ opt_mod(ci, cc)(recv, obj)(val) */
rb_num_t
attr_open_opt_mod(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 2;
}

/* attr rb_num_t popn @ opt_mod(ci, cc)(recv, obj)(val) */
rb_num_t
attr_popn_opt_mod(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 2;
}

/* attr rb_num_t retn @ opt_mod(ci, cc)(recv, obj)(val) */
rb_num_t
attr_retn_opt_mod(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_mod(ci, cc)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_mod(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return -1;
}

/* attr rb_num_t width @ opt_mod(ci, cc)(recv, obj)(val) */
rb_num_t
attr_width_opt_mod(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ opt_eq(ci, cc)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_eq(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return BIN(opt_eq);
}

/* attr bool handles_sp @ opt_eq(ci, cc)(recv, obj)(val) */
bool
attr_handles_sp_opt_eq(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* attr bool leaf @ opt_eq(ci, cc)(recv, obj)(val) */
bool
attr_leaf_opt_eq(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return
#line 1120 "insns.def"
false;
#line 6914 "insns_info.inc"
}

/* attr const char* name @ opt_eq(ci, cc)(recv, obj)(val) */
const char*
attr_name_opt_eq(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return insn_name(BIN(opt_eq));
}

/* attr rb_num_t open @ opt_eq(ci, cc)(recv, obj)(val) */
rb_num_t
attr_open_opt_eq(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 2;
}

/* attr rb_num_t popn @ opt_eq(ci, cc)(recv, obj)(val) */
rb_num_t
attr_popn_opt_eq(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 2;
}

/* attr rb_num_t retn @ opt_eq(ci, cc)(recv, obj)(val) */
rb_num_t
attr_retn_opt_eq(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_eq(ci, cc)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_eq(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return -1;
}

/* attr rb_num_t width @ opt_eq(ci, cc)(recv, obj)(val) */
rb_num_t
attr_width_opt_eq(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ opt_neq(ci_eq, cc_eq, ci, cc)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_neq(
    MAYBE_UNUSED(CALL_INFO ci_eq),
    MAYBE_UNUSED(CALL_CACHE cc_eq),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return BIN(opt_neq);
}

/* attr bool handles_sp @ opt_neq(ci_eq, cc_eq, ci, cc)(recv, obj)(val) */
bool
attr_handles_sp_opt_neq(
    MAYBE_UNUSED(CALL_INFO ci_eq),
    MAYBE_UNUSED(CALL_CACHE cc_eq),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* attr bool leaf @ opt_neq(ci_eq, cc_eq, ci, cc)(recv, obj)(val) */
bool
attr_leaf_opt_neq(
    MAYBE_UNUSED(CALL_INFO ci_eq),
    MAYBE_UNUSED(CALL_CACHE cc_eq),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return
#line 1136 "insns.def"
false;
#line 7013 "insns_info.inc"
}

/* attr const char* name @ opt_neq(ci_eq, cc_eq, ci, cc)(recv, obj)(val) */
const char*
attr_name_opt_neq(
    MAYBE_UNUSED(CALL_INFO ci_eq),
    MAYBE_UNUSED(CALL_CACHE cc_eq),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return insn_name(BIN(opt_neq));
}

/* attr rb_num_t open @ opt_neq(ci_eq, cc_eq, ci, cc)(recv, obj)(val) */
rb_num_t
attr_open_opt_neq(
    MAYBE_UNUSED(CALL_INFO ci_eq),
    MAYBE_UNUSED(CALL_CACHE cc_eq),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 4;
}

/* attr rb_num_t popn @ opt_neq(ci_eq, cc_eq, ci, cc)(recv, obj)(val) */
rb_num_t
attr_popn_opt_neq(
    MAYBE_UNUSED(CALL_INFO ci_eq),
    MAYBE_UNUSED(CALL_CACHE cc_eq),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 2;
}

/* attr rb_num_t retn @ opt_neq(ci_eq, cc_eq, ci, cc)(recv, obj)(val) */
rb_num_t
attr_retn_opt_neq(
    MAYBE_UNUSED(CALL_INFO ci_eq),
    MAYBE_UNUSED(CALL_CACHE cc_eq),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_neq(ci_eq, cc_eq, ci, cc)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_neq(
    MAYBE_UNUSED(CALL_INFO ci_eq),
    MAYBE_UNUSED(CALL_CACHE cc_eq),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return -1;
}

/* attr rb_num_t width @ opt_neq(ci_eq, cc_eq, ci, cc)(recv, obj)(val) */
rb_num_t
attr_width_opt_neq(
    MAYBE_UNUSED(CALL_INFO ci_eq),
    MAYBE_UNUSED(CALL_CACHE cc_eq),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 5;
}

/* attr enum ruby_vminsn_type bin @ opt_lt(ci, cc)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_lt(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return BIN(opt_lt);
}

/* attr bool handles_sp @ opt_lt(ci, cc)(recv, obj)(val) */
bool
attr_handles_sp_opt_lt(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* attr bool leaf @ opt_lt(ci, cc)(recv, obj)(val) */
bool
attr_leaf_opt_lt(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return true;
}

/* attr const char* name @ opt_lt(ci, cc)(recv, obj)(val) */
const char*
attr_name_opt_lt(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return insn_name(BIN(opt_lt));
}

/* attr rb_num_t open @ opt_lt(ci, cc)(recv, obj)(val) */
rb_num_t
attr_open_opt_lt(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 2;
}

/* attr rb_num_t popn @ opt_lt(ci, cc)(recv, obj)(val) */
rb_num_t
attr_popn_opt_lt(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 2;
}

/* attr rb_num_t retn @ opt_lt(ci, cc)(recv, obj)(val) */
rb_num_t
attr_retn_opt_lt(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_lt(ci, cc)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_lt(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return -1;
}

/* attr rb_num_t width @ opt_lt(ci, cc)(recv, obj)(val) */
rb_num_t
attr_width_opt_lt(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ opt_le(ci, cc)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_le(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return BIN(opt_le);
}

/* attr bool handles_sp @ opt_le(ci, cc)(recv, obj)(val) */
bool
attr_handles_sp_opt_le(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* attr bool leaf @ opt_le(ci, cc)(recv, obj)(val) */
bool
attr_leaf_opt_le(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return true;
}

/* attr const char* name @ opt_le(ci, cc)(recv, obj)(val) */
const char*
attr_name_opt_le(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return insn_name(BIN(opt_le));
}

/* attr rb_num_t open @ opt_le(ci, cc)(recv, obj)(val) */
rb_num_t
attr_open_opt_le(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 2;
}

/* attr rb_num_t popn @ opt_le(ci, cc)(recv, obj)(val) */
rb_num_t
attr_popn_opt_le(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 2;
}

/* attr rb_num_t retn @ opt_le(ci, cc)(recv, obj)(val) */
rb_num_t
attr_retn_opt_le(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_le(ci, cc)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_le(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return -1;
}

/* attr rb_num_t width @ opt_le(ci, cc)(recv, obj)(val) */
rb_num_t
attr_width_opt_le(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ opt_gt(ci, cc)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_gt(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return BIN(opt_gt);
}

/* attr bool handles_sp @ opt_gt(ci, cc)(recv, obj)(val) */
bool
attr_handles_sp_opt_gt(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* attr bool leaf @ opt_gt(ci, cc)(recv, obj)(val) */
bool
attr_leaf_opt_gt(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return true;
}

/* attr const char* name @ opt_gt(ci, cc)(recv, obj)(val) */
const char*
attr_name_opt_gt(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return insn_name(BIN(opt_gt));
}

/* attr rb_num_t open @ opt_gt(ci, cc)(recv, obj)(val) */
rb_num_t
attr_open_opt_gt(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 2;
}

/* attr rb_num_t popn @ opt_gt(ci, cc)(recv, obj)(val) */
rb_num_t
attr_popn_opt_gt(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 2;
}

/* attr rb_num_t retn @ opt_gt(ci, cc)(recv, obj)(val) */
rb_num_t
attr_retn_opt_gt(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_gt(ci, cc)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_gt(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return -1;
}

/* attr rb_num_t width @ opt_gt(ci, cc)(recv, obj)(val) */
rb_num_t
attr_width_opt_gt(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ opt_ge(ci, cc)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_ge(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return BIN(opt_ge);
}

/* attr bool handles_sp @ opt_ge(ci, cc)(recv, obj)(val) */
bool
attr_handles_sp_opt_ge(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* attr bool leaf @ opt_ge(ci, cc)(recv, obj)(val) */
bool
attr_leaf_opt_ge(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return true;
}

/* attr const char* name @ opt_ge(ci, cc)(recv, obj)(val) */
const char*
attr_name_opt_ge(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return insn_name(BIN(opt_ge));
}

/* attr rb_num_t open @ opt_ge(ci, cc)(recv, obj)(val) */
rb_num_t
attr_open_opt_ge(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 2;
}

/* attr rb_num_t popn @ opt_ge(ci, cc)(recv, obj)(val) */
rb_num_t
attr_popn_opt_ge(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 2;
}

/* attr rb_num_t retn @ opt_ge(ci, cc)(recv, obj)(val) */
rb_num_t
attr_retn_opt_ge(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_ge(ci, cc)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_ge(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return -1;
}

/* attr rb_num_t width @ opt_ge(ci, cc)(recv, obj)(val) */
rb_num_t
attr_width_opt_ge(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ opt_ltlt(ci, cc)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_ltlt(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return BIN(opt_ltlt);
}

/* attr bool handles_sp @ opt_ltlt(ci, cc)(recv, obj)(val) */
bool
attr_handles_sp_opt_ltlt(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* attr bool leaf @ opt_ltlt(ci, cc)(recv, obj)(val) */
bool
attr_leaf_opt_ltlt(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return true;
}

/* attr const char* name @ opt_ltlt(ci, cc)(recv, obj)(val) */
const char*
attr_name_opt_ltlt(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return insn_name(BIN(opt_ltlt));
}

/* attr rb_num_t open @ opt_ltlt(ci, cc)(recv, obj)(val) */
rb_num_t
attr_open_opt_ltlt(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 2;
}

/* attr rb_num_t popn @ opt_ltlt(ci, cc)(recv, obj)(val) */
rb_num_t
attr_popn_opt_ltlt(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 2;
}

/* attr rb_num_t retn @ opt_ltlt(ci, cc)(recv, obj)(val) */
rb_num_t
attr_retn_opt_ltlt(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_ltlt(ci, cc)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_ltlt(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return -1;
}

/* attr rb_num_t width @ opt_ltlt(ci, cc)(recv, obj)(val) */
rb_num_t
attr_width_opt_ltlt(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ opt_and(ci, cc)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_and(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return BIN(opt_and);
}

/* attr bool handles_sp @ opt_and(ci, cc)(recv, obj)(val) */
bool
attr_handles_sp_opt_and(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* attr bool leaf @ opt_and(ci, cc)(recv, obj)(val) */
bool
attr_leaf_opt_and(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return true;
}

/* attr const char* name @ opt_and(ci, cc)(recv, obj)(val) */
const char*
attr_name_opt_and(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return insn_name(BIN(opt_and));
}

/* attr rb_num_t open @ opt_and(ci, cc)(recv, obj)(val) */
rb_num_t
attr_open_opt_and(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 2;
}

/* attr rb_num_t popn @ opt_and(ci, cc)(recv, obj)(val) */
rb_num_t
attr_popn_opt_and(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 2;
}

/* attr rb_num_t retn @ opt_and(ci, cc)(recv, obj)(val) */
rb_num_t
attr_retn_opt_and(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_and(ci, cc)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_and(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return -1;
}

/* attr rb_num_t width @ opt_and(ci, cc)(recv, obj)(val) */
rb_num_t
attr_width_opt_and(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ opt_or(ci, cc)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_or(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return BIN(opt_or);
}

/* attr bool handles_sp @ opt_or(ci, cc)(recv, obj)(val) */
bool
attr_handles_sp_opt_or(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* attr bool leaf @ opt_or(ci, cc)(recv, obj)(val) */
bool
attr_leaf_opt_or(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return true;
}

/* attr const char* name @ opt_or(ci, cc)(recv, obj)(val) */
const char*
attr_name_opt_or(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return insn_name(BIN(opt_or));
}

/* attr rb_num_t open @ opt_or(ci, cc)(recv, obj)(val) */
rb_num_t
attr_open_opt_or(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 2;
}

/* attr rb_num_t popn @ opt_or(ci, cc)(recv, obj)(val) */
rb_num_t
attr_popn_opt_or(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 2;
}

/* attr rb_num_t retn @ opt_or(ci, cc)(recv, obj)(val) */
rb_num_t
attr_retn_opt_or(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_or(ci, cc)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_or(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return -1;
}

/* attr rb_num_t width @ opt_or(ci, cc)(recv, obj)(val) */
rb_num_t
attr_width_opt_or(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ opt_aref(ci, cc)(recv, obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_aref(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return BIN(opt_aref);
}

/* attr bool handles_sp @ opt_aref(ci, cc)(recv, obj)(val) */
bool
attr_handles_sp_opt_aref(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* attr bool leaf @ opt_aref(ci, cc)(recv, obj)(val) */
bool
attr_leaf_opt_aref(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return
#line 1253 "insns.def"
false;
#line 7748 "insns_info.inc"
}

/* attr const char* name @ opt_aref(ci, cc)(recv, obj)(val) */
const char*
attr_name_opt_aref(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return insn_name(BIN(opt_aref));
}

/* attr rb_num_t open @ opt_aref(ci, cc)(recv, obj)(val) */
rb_num_t
attr_open_opt_aref(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 2;
}

/* attr rb_num_t popn @ opt_aref(ci, cc)(recv, obj)(val) */
rb_num_t
attr_popn_opt_aref(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 2;
}

/* attr rb_num_t retn @ opt_aref(ci, cc)(recv, obj)(val) */
rb_num_t
attr_retn_opt_aref(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_aref(ci, cc)(recv, obj)(val) */
rb_snum_t
attr_sp_inc_opt_aref(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return -1;
}

/* attr rb_num_t width @ opt_aref(ci, cc)(recv, obj)(val) */
rb_num_t
attr_width_opt_aref(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ opt_aset(ci, cc)(recv, obj, set)(val) */
enum ruby_vminsn_type
attr_bin_opt_aset(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return BIN(opt_aset);
}

/* attr bool handles_sp @ opt_aset(ci, cc)(recv, obj, set)(val) */
bool
attr_handles_sp_opt_aset(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* attr bool leaf @ opt_aset(ci, cc)(recv, obj, set)(val) */
bool
attr_leaf_opt_aset(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return
#line 1270 "insns.def"
false;
#line 7841 "insns_info.inc"
}

/* attr const char* name @ opt_aset(ci, cc)(recv, obj, set)(val) */
const char*
attr_name_opt_aset(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return insn_name(BIN(opt_aset));
}

/* attr rb_num_t open @ opt_aset(ci, cc)(recv, obj, set)(val) */
rb_num_t
attr_open_opt_aset(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 2;
}

/* attr rb_num_t popn @ opt_aset(ci, cc)(recv, obj, set)(val) */
rb_num_t
attr_popn_opt_aset(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 3;
}

/* attr rb_num_t retn @ opt_aset(ci, cc)(recv, obj, set)(val) */
rb_num_t
attr_retn_opt_aset(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_aset(ci, cc)(recv, obj, set)(val) */
rb_snum_t
attr_sp_inc_opt_aset(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return -2;
}

/* attr rb_num_t width @ opt_aset(ci, cc)(recv, obj, set)(val) */
rb_num_t
attr_width_opt_aset(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ opt_aset_with(key, ci, cc)(recv, val)(val) */
enum ruby_vminsn_type
attr_bin_opt_aset_with(
    MAYBE_UNUSED(VALUE key),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return BIN(opt_aset_with);
}

/* attr bool handles_sp @ opt_aset_with(key, ci, cc)(recv, val)(val) */
bool
attr_handles_sp_opt_aset_with(
    MAYBE_UNUSED(VALUE key),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* attr bool leaf @ opt_aset_with(key, ci, cc)(recv, val)(val) */
bool
attr_leaf_opt_aset_with(
    MAYBE_UNUSED(VALUE key),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return
#line 1286 "insns.def"
false;
#line 7937 "insns_info.inc"
}

/* attr const char* name @ opt_aset_with(key, ci, cc)(recv, val)(val) */
const char*
attr_name_opt_aset_with(
    MAYBE_UNUSED(VALUE key),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return insn_name(BIN(opt_aset_with));
}

/* attr rb_num_t open @ opt_aset_with(key, ci, cc)(recv, val)(val) */
rb_num_t
attr_open_opt_aset_with(
    MAYBE_UNUSED(VALUE key),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 3;
}

/* attr rb_num_t popn @ opt_aset_with(key, ci, cc)(recv, val)(val) */
rb_num_t
attr_popn_opt_aset_with(
    MAYBE_UNUSED(VALUE key),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 2;
}

/* attr rb_num_t retn @ opt_aset_with(key, ci, cc)(recv, val)(val) */
rb_num_t
attr_retn_opt_aset_with(
    MAYBE_UNUSED(VALUE key),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_aset_with(key, ci, cc)(recv, val)(val) */
rb_snum_t
attr_sp_inc_opt_aset_with(
    MAYBE_UNUSED(VALUE key),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return -1;
}

/* attr rb_num_t width @ opt_aset_with(key, ci, cc)(recv, val)(val) */
rb_num_t
attr_width_opt_aset_with(
    MAYBE_UNUSED(VALUE key),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 4;
}

/* attr enum ruby_vminsn_type bin @ opt_aref_with(key, ci, cc)(recv)(val) */
enum ruby_vminsn_type
attr_bin_opt_aref_with(
    MAYBE_UNUSED(VALUE key),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return BIN(opt_aref_with);
}

/* attr bool handles_sp @ opt_aref_with(key, ci, cc)(recv)(val) */
bool
attr_handles_sp_opt_aref_with(
    MAYBE_UNUSED(VALUE key),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* attr bool leaf @ opt_aref_with(key, ci, cc)(recv)(val) */
bool
attr_leaf_opt_aref_with(
    MAYBE_UNUSED(VALUE key),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return
#line 1309 "insns.def"
false;
#line 8039 "insns_info.inc"
}

/* attr const char* name @ opt_aref_with(key, ci, cc)(recv)(val) */
const char*
attr_name_opt_aref_with(
    MAYBE_UNUSED(VALUE key),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return insn_name(BIN(opt_aref_with));
}

/* attr rb_num_t open @ opt_aref_with(key, ci, cc)(recv)(val) */
rb_num_t
attr_open_opt_aref_with(
    MAYBE_UNUSED(VALUE key),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 3;
}

/* attr rb_num_t popn @ opt_aref_with(key, ci, cc)(recv)(val) */
rb_num_t
attr_popn_opt_aref_with(
    MAYBE_UNUSED(VALUE key),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 1;
}

/* attr rb_num_t retn @ opt_aref_with(key, ci, cc)(recv)(val) */
rb_num_t
attr_retn_opt_aref_with(
    MAYBE_UNUSED(VALUE key),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_aref_with(key, ci, cc)(recv)(val) */
rb_snum_t
attr_sp_inc_opt_aref_with(
    MAYBE_UNUSED(VALUE key),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 0;
}

/* attr rb_num_t width @ opt_aref_with(key, ci, cc)(recv)(val) */
rb_num_t
attr_width_opt_aref_with(
    MAYBE_UNUSED(VALUE key),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 4;
}

/* attr enum ruby_vminsn_type bin @ opt_length(ci, cc)(recv)(val) */
enum ruby_vminsn_type
attr_bin_opt_length(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return BIN(opt_length);
}

/* attr bool handles_sp @ opt_length(ci, cc)(recv)(val) */
bool
attr_handles_sp_opt_length(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* attr bool leaf @ opt_length(ci, cc)(recv)(val) */
bool
attr_leaf_opt_length(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return true;
}

/* attr const char* name @ opt_length(ci, cc)(recv)(val) */
const char*
attr_name_opt_length(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return insn_name(BIN(opt_length));
}

/* attr rb_num_t open @ opt_length(ci, cc)(recv)(val) */
rb_num_t
attr_open_opt_length(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 2;
}

/* attr rb_num_t popn @ opt_length(ci, cc)(recv)(val) */
rb_num_t
attr_popn_opt_length(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 1;
}

/* attr rb_num_t retn @ opt_length(ci, cc)(recv)(val) */
rb_num_t
attr_retn_opt_length(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_length(ci, cc)(recv)(val) */
rb_snum_t
attr_sp_inc_opt_length(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 0;
}

/* attr rb_num_t width @ opt_length(ci, cc)(recv)(val) */
rb_num_t
attr_width_opt_length(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ opt_size(ci, cc)(recv)(val) */
enum ruby_vminsn_type
attr_bin_opt_size(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return BIN(opt_size);
}

/* attr bool handles_sp @ opt_size(ci, cc)(recv)(val) */
bool
attr_handles_sp_opt_size(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* attr bool leaf @ opt_size(ci, cc)(recv)(val) */
bool
attr_leaf_opt_size(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return true;
}

/* attr const char* name @ opt_size(ci, cc)(recv)(val) */
const char*
attr_name_opt_size(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return insn_name(BIN(opt_size));
}

/* attr rb_num_t open @ opt_size(ci, cc)(recv)(val) */
rb_num_t
attr_open_opt_size(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 2;
}

/* attr rb_num_t popn @ opt_size(ci, cc)(recv)(val) */
rb_num_t
attr_popn_opt_size(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 1;
}

/* attr rb_num_t retn @ opt_size(ci, cc)(recv)(val) */
rb_num_t
attr_retn_opt_size(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_size(ci, cc)(recv)(val) */
rb_snum_t
attr_sp_inc_opt_size(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 0;
}

/* attr rb_num_t width @ opt_size(ci, cc)(recv)(val) */
rb_num_t
attr_width_opt_size(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ opt_empty_p(ci, cc)(recv)(val) */
enum ruby_vminsn_type
attr_bin_opt_empty_p(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return BIN(opt_empty_p);
}

/* attr bool handles_sp @ opt_empty_p(ci, cc)(recv)(val) */
bool
attr_handles_sp_opt_empty_p(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* attr bool leaf @ opt_empty_p(ci, cc)(recv)(val) */
bool
attr_leaf_opt_empty_p(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return true;
}

/* attr const char* name @ opt_empty_p(ci, cc)(recv)(val) */
const char*
attr_name_opt_empty_p(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return insn_name(BIN(opt_empty_p));
}

/* attr rb_num_t open @ opt_empty_p(ci, cc)(recv)(val) */
rb_num_t
attr_open_opt_empty_p(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 2;
}

/* attr rb_num_t popn @ opt_empty_p(ci, cc)(recv)(val) */
rb_num_t
attr_popn_opt_empty_p(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 1;
}

/* attr rb_num_t retn @ opt_empty_p(ci, cc)(recv)(val) */
rb_num_t
attr_retn_opt_empty_p(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_empty_p(ci, cc)(recv)(val) */
rb_snum_t
attr_sp_inc_opt_empty_p(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 0;
}

/* attr rb_num_t width @ opt_empty_p(ci, cc)(recv)(val) */
rb_num_t
attr_width_opt_empty_p(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ opt_succ(ci, cc)(recv)(val) */
enum ruby_vminsn_type
attr_bin_opt_succ(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return BIN(opt_succ);
}

/* attr bool handles_sp @ opt_succ(ci, cc)(recv)(val) */
bool
attr_handles_sp_opt_succ(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* attr bool leaf @ opt_succ(ci, cc)(recv)(val) */
bool
attr_leaf_opt_succ(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return true;
}

/* attr const char* name @ opt_succ(ci, cc)(recv)(val) */
const char*
attr_name_opt_succ(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return insn_name(BIN(opt_succ));
}

/* attr rb_num_t open @ opt_succ(ci, cc)(recv)(val) */
rb_num_t
attr_open_opt_succ(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 2;
}

/* attr rb_num_t popn @ opt_succ(ci, cc)(recv)(val) */
rb_num_t
attr_popn_opt_succ(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 1;
}

/* attr rb_num_t retn @ opt_succ(ci, cc)(recv)(val) */
rb_num_t
attr_retn_opt_succ(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_succ(ci, cc)(recv)(val) */
rb_snum_t
attr_sp_inc_opt_succ(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 0;
}

/* attr rb_num_t width @ opt_succ(ci, cc)(recv)(val) */
rb_num_t
attr_width_opt_succ(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ opt_not(ci, cc)(recv)(val) */
enum ruby_vminsn_type
attr_bin_opt_not(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return BIN(opt_not);
}

/* attr bool handles_sp @ opt_not(ci, cc)(recv)(val) */
bool
attr_handles_sp_opt_not(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* attr bool leaf @ opt_not(ci, cc)(recv)(val) */
bool
attr_leaf_opt_not(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return true;
}

/* attr const char* name @ opt_not(ci, cc)(recv)(val) */
const char*
attr_name_opt_not(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return insn_name(BIN(opt_not));
}

/* attr rb_num_t open @ opt_not(ci, cc)(recv)(val) */
rb_num_t
attr_open_opt_not(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 2;
}

/* attr rb_num_t popn @ opt_not(ci, cc)(recv)(val) */
rb_num_t
attr_popn_opt_not(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 1;
}

/* attr rb_num_t retn @ opt_not(ci, cc)(recv)(val) */
rb_num_t
attr_retn_opt_not(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_not(ci, cc)(recv)(val) */
rb_snum_t
attr_sp_inc_opt_not(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 0;
}

/* attr rb_num_t width @ opt_not(ci, cc)(recv)(val) */
rb_num_t
attr_width_opt_not(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ opt_regexpmatch1(recv)(obj)(val) */
enum ruby_vminsn_type
attr_bin_opt_regexpmatch1(MAYBE_UNUSED(VALUE recv))
{
    return BIN(opt_regexpmatch1);
}

/* attr bool handles_sp @ opt_regexpmatch1(recv)(obj)(val) */
bool
attr_handles_sp_opt_regexpmatch1(MAYBE_UNUSED(VALUE recv))
{
    return false;
}

/* attr bool leaf @ opt_regexpmatch1(recv)(obj)(val) */
bool
attr_leaf_opt_regexpmatch1(MAYBE_UNUSED(VALUE recv))
{
    return
#line 1397 "insns.def"
BASIC_OP_UNREDEFINED_P(BOP_MATCH, REGEXP_REDEFINED_OP_FLAG);
#line 8579 "insns_info.inc"
}

/* attr const char* name @ opt_regexpmatch1(recv)(obj)(val) */
const char*
attr_name_opt_regexpmatch1(MAYBE_UNUSED(VALUE recv))
{
    return insn_name(BIN(opt_regexpmatch1));
}

/* attr rb_num_t open @ opt_regexpmatch1(recv)(obj)(val) */
rb_num_t
attr_open_opt_regexpmatch1(MAYBE_UNUSED(VALUE recv))
{
    return 1;
}

/* attr rb_num_t popn @ opt_regexpmatch1(recv)(obj)(val) */
rb_num_t
attr_popn_opt_regexpmatch1(MAYBE_UNUSED(VALUE recv))
{
    return 1;
}

/* attr rb_num_t retn @ opt_regexpmatch1(recv)(obj)(val) */
rb_num_t
attr_retn_opt_regexpmatch1(MAYBE_UNUSED(VALUE recv))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_regexpmatch1(recv)(obj)(val) */
rb_snum_t
attr_sp_inc_opt_regexpmatch1(MAYBE_UNUSED(VALUE recv))
{
    return 0;
}

/* attr rb_num_t width @ opt_regexpmatch1(recv)(obj)(val) */
rb_num_t
attr_width_opt_regexpmatch1(MAYBE_UNUSED(VALUE recv))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ opt_regexpmatch2(ci, cc)(obj2, obj1)(val) */
enum ruby_vminsn_type
attr_bin_opt_regexpmatch2(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return BIN(opt_regexpmatch2);
}

/* attr bool handles_sp @ opt_regexpmatch2(ci, cc)(obj2, obj1)(val) */
bool
attr_handles_sp_opt_regexpmatch2(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* attr bool leaf @ opt_regexpmatch2(ci, cc)(obj2, obj1)(val) */
bool
attr_leaf_opt_regexpmatch2(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return true;
}

/* attr const char* name @ opt_regexpmatch2(ci, cc)(obj2, obj1)(val) */
const char*
attr_name_opt_regexpmatch2(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return insn_name(BIN(opt_regexpmatch2));
}

/* attr rb_num_t open @ opt_regexpmatch2(ci, cc)(obj2, obj1)(val) */
rb_num_t
attr_open_opt_regexpmatch2(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 2;
}

/* attr rb_num_t popn @ opt_regexpmatch2(ci, cc)(obj2, obj1)(val) */
rb_num_t
attr_popn_opt_regexpmatch2(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 2;
}

/* attr rb_num_t retn @ opt_regexpmatch2(ci, cc)(obj2, obj1)(val) */
rb_num_t
attr_retn_opt_regexpmatch2(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ opt_regexpmatch2(ci, cc)(obj2, obj1)(val) */
rb_snum_t
attr_sp_inc_opt_regexpmatch2(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return -1;
}

/* attr rb_num_t width @ opt_regexpmatch2(ci, cc)(obj2, obj1)(val) */
rb_num_t
attr_width_opt_regexpmatch2(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return 3;
}

/* attr enum ruby_vminsn_type bin @ opt_call_c_function(funcptr)()() */
enum ruby_vminsn_type
attr_bin_opt_call_c_function(MAYBE_UNUSED(rb_insn_func_t funcptr))
{
    return BIN(opt_call_c_function);
}

/* attr bool handles_sp @ opt_call_c_function(funcptr)()() */
bool
attr_handles_sp_opt_call_c_function(MAYBE_UNUSED(rb_insn_func_t funcptr))
{
    return
#line 1423 "insns.def"
true;
#line 8728 "insns_info.inc"
}

/* attr bool leaf @ opt_call_c_function(funcptr)()() */
bool
attr_leaf_opt_call_c_function(MAYBE_UNUSED(rb_insn_func_t funcptr))
{
    return
#line 1422 "insns.def"
false;
#line 8738 "insns_info.inc"
}

/* attr const char* name @ opt_call_c_function(funcptr)()() */
const char*
attr_name_opt_call_c_function(MAYBE_UNUSED(rb_insn_func_t funcptr))
{
    return insn_name(BIN(opt_call_c_function));
}

/* attr rb_num_t open @ opt_call_c_function(funcptr)()() */
rb_num_t
attr_open_opt_call_c_function(MAYBE_UNUSED(rb_insn_func_t funcptr))
{
    return 1;
}

/* attr rb_num_t popn @ opt_call_c_function(funcptr)()() */
rb_num_t
attr_popn_opt_call_c_function(MAYBE_UNUSED(rb_insn_func_t funcptr))
{
    return 0;
}

/* attr rb_num_t retn @ opt_call_c_function(funcptr)()() */
rb_num_t
attr_retn_opt_call_c_function(MAYBE_UNUSED(rb_insn_func_t funcptr))
{
    return 0;
}

/* attr rb_snum_t sp_inc @ opt_call_c_function(funcptr)()() */
rb_snum_t
attr_sp_inc_opt_call_c_function(MAYBE_UNUSED(rb_insn_func_t funcptr))
{
    return 0;
}

/* attr rb_num_t width @ opt_call_c_function(funcptr)()() */
rb_num_t
attr_width_opt_call_c_function(MAYBE_UNUSED(rb_insn_func_t funcptr))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ bitblt()()(ret) */
enum ruby_vminsn_type
attr_bin_bitblt(void)
{
    return BIN(bitblt);
}

/* attr bool handles_sp @ bitblt()()(ret) */
bool
attr_handles_sp_bitblt(void)
{
    return false;
}

/* attr bool leaf @ bitblt()()(ret) */
bool
attr_leaf_bitblt(void)
{
    return true;
}

/* attr const char* name @ bitblt()()(ret) */
const char*
attr_name_bitblt(void)
{
    return insn_name(BIN(bitblt));
}

/* attr rb_num_t open @ bitblt()()(ret) */
rb_num_t
attr_open_bitblt(void)
{
    return 0;
}

/* attr rb_num_t popn @ bitblt()()(ret) */
rb_num_t
attr_popn_bitblt(void)
{
    return 0;
}

/* attr rb_num_t retn @ bitblt()()(ret) */
rb_num_t
attr_retn_bitblt(void)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ bitblt()()(ret) */
rb_snum_t
attr_sp_inc_bitblt(void)
{
    return 1;
}

/* attr rb_num_t width @ bitblt()()(ret) */
rb_num_t
attr_width_bitblt(void)
{
    return 1;
}

/* attr enum ruby_vminsn_type bin @ answer()()(ret) */
enum ruby_vminsn_type
attr_bin_answer(void)
{
    return BIN(answer);
}

/* attr bool handles_sp @ answer()()(ret) */
bool
attr_handles_sp_answer(void)
{
    return false;
}

/* attr bool leaf @ answer()()(ret) */
bool
attr_leaf_answer(void)
{
    return true;
}

/* attr const char* name @ answer()()(ret) */
const char*
attr_name_answer(void)
{
    return insn_name(BIN(answer));
}

/* attr rb_num_t open @ answer()()(ret) */
rb_num_t
attr_open_answer(void)
{
    return 0;
}

/* attr rb_num_t popn @ answer()()(ret) */
rb_num_t
attr_popn_answer(void)
{
    return 0;
}

/* attr rb_num_t retn @ answer()()(ret) */
rb_num_t
attr_retn_answer(void)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ answer()()(ret) */
rb_snum_t
attr_sp_inc_answer(void)
{
    return 1;
}

/* attr rb_num_t width @ answer()()(ret) */
rb_num_t
attr_width_answer(void)
{
    return 1;
}

/* attr enum ruby_vminsn_type bin @ getlocal_WC_0(idx)()(val) */
enum ruby_vminsn_type
attr_bin_getlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
    return BIN(getlocal_WC_0);
}

/* attr bool handles_sp @ getlocal_WC_0(idx)()(val) */
bool
attr_handles_sp_getlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
    return false;
}

/* attr bool leaf @ getlocal_WC_0(idx)()(val) */
bool
attr_leaf_getlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
    return true;
}

/* attr const char* name @ getlocal_WC_0(idx)()(val) */
const char*
attr_name_getlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
    return insn_name(BIN(getlocal_WC_0));
}

/* attr rb_num_t open @ getlocal_WC_0(idx)()(val) */
rb_num_t
attr_open_getlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
    return 1;
}

/* attr rb_num_t popn @ getlocal_WC_0(idx)()(val) */
rb_num_t
attr_popn_getlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
    return 0;
}

/* attr rb_num_t retn @ getlocal_WC_0(idx)()(val) */
rb_num_t
attr_retn_getlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ getlocal_WC_0(idx)()(val) */
rb_snum_t
attr_sp_inc_getlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
    return 1;
}

/* attr rb_num_t width @ getlocal_WC_0(idx)()(val) */
rb_num_t
attr_width_getlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ getlocal_WC_1(idx)()(val) */
enum ruby_vminsn_type
attr_bin_getlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
    return BIN(getlocal_WC_1);
}

/* attr bool handles_sp @ getlocal_WC_1(idx)()(val) */
bool
attr_handles_sp_getlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
    return false;
}

/* attr bool leaf @ getlocal_WC_1(idx)()(val) */
bool
attr_leaf_getlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
    return true;
}

/* attr const char* name @ getlocal_WC_1(idx)()(val) */
const char*
attr_name_getlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
    return insn_name(BIN(getlocal_WC_1));
}

/* attr rb_num_t open @ getlocal_WC_1(idx)()(val) */
rb_num_t
attr_open_getlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
    return 1;
}

/* attr rb_num_t popn @ getlocal_WC_1(idx)()(val) */
rb_num_t
attr_popn_getlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
    return 0;
}

/* attr rb_num_t retn @ getlocal_WC_1(idx)()(val) */
rb_num_t
attr_retn_getlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
    return 1;
}

/* attr rb_snum_t sp_inc @ getlocal_WC_1(idx)()(val) */
rb_snum_t
attr_sp_inc_getlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
    return 1;
}

/* attr rb_num_t width @ getlocal_WC_1(idx)()(val) */
rb_num_t
attr_width_getlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ setlocal_WC_0(idx)(val)() */
enum ruby_vminsn_type
attr_bin_setlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
    return BIN(setlocal_WC_0);
}

/* attr bool handles_sp @ setlocal_WC_0(idx)(val)() */
bool
attr_handles_sp_setlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
    return false;
}

/* attr bool leaf @ setlocal_WC_0(idx)(val)() */
bool
attr_leaf_setlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
    return true;
}

/* attr const char* name @ setlocal_WC_0(idx)(val)() */
const char*
attr_name_setlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
    return insn_name(BIN(setlocal_WC_0));
}

/* attr rb_num_t open @ setlocal_WC_0(idx)(val)() */
rb_num_t
attr_open_setlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
    return 1;
}

/* attr rb_num_t popn @ setlocal_WC_0(idx)(val)() */
rb_num_t
attr_popn_setlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
    return 1;
}

/* attr rb_num_t retn @ setlocal_WC_0(idx)(val)() */
rb_num_t
attr_retn_setlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
    return 0;
}

/* attr rb_snum_t sp_inc @ setlocal_WC_0(idx)(val)() */
rb_snum_t
attr_sp_inc_setlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
    return -1;
}

/* attr rb_num_t width @ setlocal_WC_0(idx)(val)() */
rb_num_t
attr_width_setlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
    return 2;
}

/* attr enum ruby_vminsn_type bin @ setlocal_WC_1(idx)(val)() */
enum ruby_vminsn_type
attr_bin_setlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
    return BIN(setlocal_WC_1);
}

/* attr bool handles_sp @ setlocal_WC_1(idx)(val)() */
bool
attr_handles_sp_setlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
    return false;
}

/* attr bool leaf @ setlocal_WC_1(idx)(val)() */
bool
attr_leaf_setlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
    return true;
}

/* attr const char* name @ setlocal_WC_1(idx)(val)() */
const char*
attr_name_setlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
    return insn_name(BIN(setlocal_WC_1));
}

/* attr rb_num_t open @ setlocal_WC_1(idx)(val)() */
rb_num_t
attr_open_setlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
    return 1;
}

/* attr rb_num_t popn @ setlocal_WC_1(idx)(val)() */
rb_num_t
attr_popn_setlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
    return 1;
}

/* attr rb_num_t retn @ setlocal_WC_1(idx)(val)() */
rb_num_t
attr_retn_setlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
    return 0;
}

/* attr rb_snum_t sp_inc @ setlocal_WC_1(idx)(val)() */
rb_snum_t
attr_sp_inc_setlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
    return -1;
}

/* attr rb_num_t width @ setlocal_WC_1(idx)(val)() */
rb_num_t
attr_width_setlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
    return 2;
}

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

/* attr bool handles_sp @ putobject_INT2FIX_0_()()(val) */
bool
attr_handles_sp_putobject_INT2FIX_0_(void)
{
    return false;
}

/* attr bool leaf @ putobject_INT2FIX_0_()()(val) */
bool
attr_leaf_putobject_INT2FIX_0_(void)
{
    return true;
}

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

/* attr rb_num_t open @ putobject_INT2FIX_0_()()(val) */
rb_num_t
attr_open_putobject_INT2FIX_0_(void)
{
    return 0;
}

/* attr rb_num_t popn @ putobject_INT2FIX_0_()()(val) */
rb_num_t
attr_popn_putobject_INT2FIX_0_(void)
{
    return 0;
}

/* attr rb_num_t retn @ putobject_INT2FIX_0_()()(val) */
rb_num_t
attr_retn_putobject_INT2FIX_0_(void)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ putobject_INT2FIX_0_()()(val) */
rb_snum_t
attr_sp_inc_putobject_INT2FIX_0_(void)
{
    return 1;
}

/* attr rb_num_t width @ putobject_INT2FIX_0_()()(val) */
rb_num_t
attr_width_putobject_INT2FIX_0_(void)
{
    return 1;
}

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

/* attr bool handles_sp @ putobject_INT2FIX_1_()()(val) */
bool
attr_handles_sp_putobject_INT2FIX_1_(void)
{
    return false;
}

/* attr bool leaf @ putobject_INT2FIX_1_()()(val) */
bool
attr_leaf_putobject_INT2FIX_1_(void)
{
    return true;
}

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

/* attr rb_num_t open @ putobject_INT2FIX_1_()()(val) */
rb_num_t
attr_open_putobject_INT2FIX_1_(void)
{
    return 0;
}

/* attr rb_num_t popn @ putobject_INT2FIX_1_()()(val) */
rb_num_t
attr_popn_putobject_INT2FIX_1_(void)
{
    return 0;
}

/* attr rb_num_t retn @ putobject_INT2FIX_1_()()(val) */
rb_num_t
attr_retn_putobject_INT2FIX_1_(void)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ putobject_INT2FIX_1_()()(val) */
rb_snum_t
attr_sp_inc_putobject_INT2FIX_1_(void)
{
    return 1;
}

/* attr rb_num_t width @ putobject_INT2FIX_1_()()(val) */
rb_num_t
attr_width_putobject_INT2FIX_1_(void)
{
    return 1;
}

PUREFUNC(MAYBE_UNUSED(static int insn_stack_increase(int depth, int insn, const VALUE *opes)));
PUREFUNC(static rb_snum_t insn_stack_increase_dispatch(enum ruby_vminsn_type insn, const VALUE *opes));

rb_snum_t
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,    0,   -2,    1,   -1,
           1,    1,    1,    1,    1,    1, -127,   -1,
           0, -127,    0, -127,    1,    1, -127,   -1,
           0, -127,   -1,   -1,    1, -127,    0, -127,
        -127, -127, -127, -127,    0,   -1,    1,    0,
          -1, -127, -127,    1,    1, -127, -127, -127,
        -127,    0,    0,    0,   -1,   -1,   -1,    1,
           0,    1, -127,   -1,   -1,   -1,   -1,   -1,
          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
          -1,   -1,   -2,   -1,    0,    0,    0,    0,
           0,    0,    0,   -1,    0,    1,    1,    1,
           1,   -1,   -1,    1,    1,    0,    0,    0,
           0,    0,    0,    0,    0,    0,    0,    0,
           0,    0,    0,    0,    0,    0,    0,    0,
           0,    0,    0,    0,    0,    0,    0,    0,
           0,    0,    0,    0,    0,    0,    0,    0,
           0,    0,    0,    0,    0,    0,    0,    0,
           0,    0,    0,    0,    0,    0,    0,    0,
           0,    0,    0,    0,    0,    0,    0,    0,
           0,    0,    0,    0,    0,    0,    0,    0,
           0,    0,    0,    0,    0,    0,    0,    0,
           0,    0,    0,    0,    0,    0,    0,    0,
           0,    0,    0,    0,    0,    0,    0,    0,
           0,    0,    0,    0,    0,    0,    0,    0,
           0,    0,
    };
    signed char c = t[insn];

    ASSERT_VM_INSTRUCTION_SIZE(t);
    if (c != -127) {
        return c;
    }
    else switch(insn) {
    default:
        UNREACHABLE;
    case BIN(concatstrings):
        return attr_sp_inc_concatstrings(NUM2LONG(opes[0]));
    case BIN(toregexp):
        return attr_sp_inc_toregexp(NUM2LONG(opes[0]), NUM2LONG(opes[1]));
    case BIN(newarray):
        return attr_sp_inc_newarray(NUM2LONG(opes[0]));
    case BIN(expandarray):
        return attr_sp_inc_expandarray(NUM2LONG(opes[0]), NUM2LONG(opes[1]));
    case BIN(newhash):
        return attr_sp_inc_newhash(NUM2LONG(opes[0]));
    case BIN(dupn):
        return attr_sp_inc_dupn(NUM2LONG(opes[0]));
    case BIN(reverse):
        return attr_sp_inc_reverse(NUM2LONG(opes[0]));
    case BIN(reput):
        return attr_sp_inc_reput();
    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_sp_inc_send((CALL_INFO)(opes[0]), (CALL_CACHE)(opes[1]), (ISEQ)(opes[2]));
    case BIN(opt_send_without_block):
        return attr_sp_inc_opt_send_without_block((CALL_INFO)(opes[0]), (CALL_CACHE)(opes[1]));
    case BIN(opt_newarray_max):
        return attr_sp_inc_opt_newarray_max(NUM2LONG(opes[0]));
    case BIN(opt_newarray_min):
        return attr_sp_inc_opt_newarray_min(NUM2LONG(opes[0]));
    case BIN(invokesuper):
        return attr_sp_inc_invokesuper((CALL_INFO)(opes[0]), (CALL_CACHE)(opes[1]), (ISEQ)(opes[2]));
    case BIN(invokeblock):
        return attr_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]));
    }
}

int
insn_stack_increase(int depth, int insn, const VALUE *opes)
{
    enum ruby_vminsn_type itype = (enum ruby_vminsn_type)insn;
    return depth + (int)insn_stack_increase_dispatch(itype, opes);
}

