/* -*- 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 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/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,  351,  363,  374,  382,  391,  395,
     399,  404,  409,  417,  423,  428,  433,  445,  453,  464,  477,  487,
     501,  513,  518,  533,  548,  565,  582,  605,  617,  629,  635,  641,
     646,  655,  668,  678,  693,  708,  713,  731,  740,  750,  759,  767,
     775,  782,  790,  797,  804,  811,  818,  827,  836,  845,  859,  873,
     884,  893,  905,  914,  922,  939,  956,  976,  983,  990, 1004, 1018,
    1032, 1046, 1067, 1088, 1098, 1113, 1128, 1148, 1168, 1193, 1210, 1227,
    1253, 1279, 1302, 1325, 1343, 1361, 1377, 1393, 1406, 1420, 1436, 1459,
    1473, 1489, 1509, 1524, 1543, 1558, 1571, 1586, 1601, 1619, 1637, 1654,
    1668, 1683, 1693, 1703, 1714, 1725, 1739, 1751, 1762, 1773, 1791, 1805,
    1822, 1841, 1857, 1877, 1895, 1906, 1927, 1948, 1971, 1994, 2023, 2041,
    2059, 2071, 2083, 2094, 2109, 2128, 2144, 2165, 2186, 2197, 2221, 2236,
    2252, 2267, 2281, 2295, 2308, 2322, 2335, 2348, 2361, 2374, 2389, 2404,
    2419, 2439, 2459, 2476, 2491, 2509, 2524, 2538, 2561, 2584, 2610, 2623,
    2636, 2656, 2676, 2696, 2716, 2743,
};
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[12];
    const char L030[12]; const char L031[11]; const char L032[ 8];
    const char L033[ 9]; const char L034[ 4]; const char L035[ 4];
    const char L036[ 5]; const char L037[ 5]; const char L038[ 8];
    const char L039[ 6]; const char L040[ 5]; const char L041[ 5];
    const char L042[12]; const char L043[ 8]; const char L044[11];
    const char L045[13]; const char L046[10]; const char L047[14];
    const char L048[12]; const char L049[ 5]; const char L050[15];
    const char L051[15]; const char L052[17]; const char L053[17];
    const char L054[23]; 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[15]; const char L064[15]; 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[ 9]; const char L080[ 9];
    const char L081[14]; const char L082[14]; const char L083[11];
    const char L084[ 9]; const char L085[12]; const char L086[ 9];
    const char L087[ 8]; const char L088[17]; const char L089[17];
    const char L090[20]; const char L091[ 7]; const char L092[ 7];
    const char L093[14]; const char L094[14]; const char L095[14];
    const char L096[14]; const char L097[21]; const char L098[21];
    const char L099[10]; const char L100[15]; const char L101[15];
    const char L102[20]; const char L103[20]; const char L104[25];
    const char L105[17]; const char L106[17]; const char L107[26];
    const char L108[26]; const char L109[23]; const char L110[23];
    const char L111[18]; const char L112[18]; const char L113[16];
    const char L114[16]; const char L115[13]; const char L116[14];
    const char L117[16]; const char L118[23]; const char L119[14];
    const char L120[16]; const char L121[20]; const char L122[15];
    const char L123[19]; const char L124[15]; const char L125[13];
    const char L126[15]; const char L127[15]; const char L128[18];
    const char L129[18]; const char L130[17]; const char L131[14];
    const char L132[15]; const char L133[10]; const char L134[10];
    const char L135[11]; const char L136[11]; const char L137[14];
    const char L138[12]; const char L139[11]; const char L140[11];
    const char L141[18]; const char L142[14]; const char L143[17];
    const char L144[19]; const char L145[16]; const char L146[20];
    const char L147[18]; const char L148[11]; const char L149[21];
    const char L150[21]; const char L151[23]; const char L152[23];
    const char L153[29]; const char L154[18]; const char L155[18];
    const char L156[12]; const char L157[12]; const char L158[11];
    const char L159[15]; const char L160[19]; const char L161[16];
    const char L162[21]; const char L163[21]; const char L164[11];
    const char L165[24]; const char L166[15]; const char L167[16];
    const char L168[15]; const char L169[14]; const char L170[14];
    const char L171[13]; const char L172[14]; const char L173[13];
    const char L174[13]; const char L175[13]; const char L176[13];
    const char L177[15]; const char L178[15]; const char L179[15];
    const char L180[20]; const char L181[20]; const char L182[17];
    const char L183[15]; const char L184[18]; const char L185[15];
    const char L186[14]; const char L187[23]; const char L188[23];
    const char L189[26]; const char L190[13]; const char L191[13];
    const char L192[20]; const char L193[20]; const char L194[20];
    const char L195[20]; const char L196[27]; const char L197[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"                    , "expandarray"                 ,
    "concatarray"                 , "splatarray"                  ,
    "newhash"                     , "newrange"                    ,
    "pop"                         , "dup"                         ,
    "dupn"                        , "swap"                        ,
    "reverse"                     , "reput"                       ,
    "topn"                        , "setn"                        ,
    "adjuststack"                 , "defined"                     ,
    "checkmatch"                  , "checkkeyword"                ,
    "checktype"                   , "tracecoverage"               ,
    "defineclass"                 , "send"                        ,
    "opt_str_freeze"              , "opt_str_uminus"              ,
    "opt_newarray_max"            , "opt_newarray_min"            ,
    "opt_send_without_block"      , "invokesuper"                 ,
    "invokeblock"                 , "leave"                       ,
    "throw"                       , "jump"                        ,
    "branchif"                    , "branchunless"                ,
    "branchnil"                   , "getinlinecache"              ,
    "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_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_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_tracecoverage"         , "trace_defineclass"           ,
    "trace_send"                  , "trace_opt_str_freeze"        ,
    "trace_opt_str_uminus"        , "trace_opt_newarray_max"      ,
    "trace_opt_newarray_min"      , "trace_opt_send_without_block",
    "trace_invokesuper"           , "trace_invokeblock"           ,
    "trace_leave"                 , "trace_throw"                 ,
    "trace_jump"                  , "trace_branchif"              ,
    "trace_branchunless"          , "trace_branchnil"             ,
    "trace_getinlinecache"        , "trace_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_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, 3, 1, 2, 2, 2, 1, 1, 2, 1, 2, 1, 2, 2, 2, 4, 2, 3, 2, 3, 4, 4,
    2, 2, 2, 2, 3, 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, 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, 3, 1, 2, 2, 2, 1, 1, 2, 1, 2, 1, 2, 2, 2, 4, 2, 3, 2, 3, 4, 4, 2,
    2, 2, 2, 3, 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, 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,  65,  66,  68,  70,  72,  73,  74,  76,  77,  79,  80,  82,
     84,  86,  90,  92,  95,  97, 100, 104, 108, 110, 112, 114, 116, 119,
    123, 125, 126, 128, 130, 132, 134, 136, 139, 141, 144, 147, 150, 153,
    156, 159, 162, 165, 170, 173, 176, 179, 182, 185, 188, 191, 195, 199,
    202, 205, 208, 211, 214, 216, 219, 221, 222, 223, 225, 227, 229, 231,
    232, 233, 234, 237, 240, 243, 246, 249, 252, 254, 257, 260, 262, 264,
    266, 268, 270, 272, 273, 274, 276, 278, 280, 282, 284, 285, 287, 290,
    291, 293, 295, 298, 299, 301, 303, 305, 306, 307, 309, 310, 312, 313,
    315, 317, 319, 323, 325, 328, 330, 333, 337, 341, 343, 345, 347, 349,
    352, 356, 358, 359, 361, 363, 365, 367, 369, 372, 374, 377, 380, 383,
    386, 389, 392, 395, 398, 403, 406, 409, 412, 415, 418, 421, 424, 428,
    432, 435, 438, 441, 444, 447, 449, 452, 454, 455, 456, 458, 460, 462,
    464, 465,
};
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[ 3];
    const char L030[ 1]; const char L031[ 2]; const char L032[ 2];
    const char L033[ 2]; const char L034[ 1]; const char L035[ 1];
    const char L036[ 2]; const char L037[ 1]; const char L038[ 2];
    const char L039[ 1]; const char L040[ 2]; const char L041[ 2];
    const char L042[ 2]; const char L043[ 4]; const char L044[ 2];
    const char L045[ 3]; const char L046[ 2]; const char L047[ 3];
    const char L048[ 4]; const char L049[ 4]; const char L050[ 2];
    const char L051[ 2]; const char L052[ 2]; const char L053[ 2];
    const char L054[ 3]; 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[ 4]; const char L082[ 4]; const char L083[ 3];
    const char L084[ 3]; const char L085[ 3]; const char L086[ 3];
    const char L087[ 3]; const char L088[ 2]; const char L089[ 3];
    const char L090[ 2]; const char L091[ 1]; const char L092[ 1];
    const char L093[ 2]; const char L094[ 2]; const char L095[ 2];
    const char L096[ 2]; const char L097[ 1]; const char L098[ 1];
    const char L099[ 1]; const char L100[ 3]; const char L101[ 3];
    const char L102[ 3]; const char L103[ 3]; const char L104[ 3];
    const char L105[ 3]; const char L106[ 2]; const char L107[ 3];
    const char L108[ 3]; const char L109[ 2]; const char L110[ 2];
    const char L111[ 2]; const char L112[ 2]; const char L113[ 2];
    const char L114[ 2]; const char L115[ 1]; const char L116[ 1];
    const char L117[ 2]; const char L118[ 2]; const char L119[ 2];
    const char L120[ 2]; const char L121[ 2]; const char L122[ 1];
    const char L123[ 2]; const char L124[ 3]; const char L125[ 1];
    const char L126[ 2]; const char L127[ 2]; const char L128[ 3];
    const char L129[ 1]; const char L130[ 2]; const char L131[ 2];
    const char L132[ 2]; const char L133[ 1]; const char L134[ 1];
    const char L135[ 2]; const char L136[ 1]; const char L137[ 2];
    const char L138[ 1]; const char L139[ 2]; const char L140[ 2];
    const char L141[ 2]; const char L142[ 4]; const char L143[ 2];
    const char L144[ 3]; const char L145[ 2]; const char L146[ 3];
    const char L147[ 4]; const char L148[ 4]; const char L149[ 2];
    const char L150[ 2]; const char L151[ 2]; const char L152[ 2];
    const char L153[ 3]; const char L154[ 4]; const char L155[ 2];
    const char L156[ 1]; const char L157[ 2]; const char L158[ 2];
    const char L159[ 2]; const char L160[ 2]; const char L161[ 2];
    const char L162[ 3]; const char L163[ 2]; const char L164[ 3];
    const char L165[ 3]; 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[ 5]; const char L173[ 3];
    const char L174[ 3]; const char L175[ 3]; const char L176[ 3];
    const char L177[ 3]; const char L178[ 3]; const char L179[ 3];
    const char L180[ 4]; const char L181[ 4]; const char L182[ 3];
    const char L183[ 3]; const char L184[ 3]; const char L185[ 3];
    const char L186[ 3]; const char L187[ 2]; const char L188[ 3];
    const char L189[ 2]; const char L190[ 1]; const char L191[ 1];
    const char L192[ 2]; const char L193[ 2]; const char L194[ 2];
    const char L195[ 2]; const char L196[ 1]; const char L197[ 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"   , "NN"  , ""    , "V"   ,
    "N"   , "N"   , ""    , ""    , "N"   , ""    , "N"   , ""    ,
    "N"   , "N"   , "N"   , "NVV" , "N"   , "LL"  , "N"   , "NV"  ,
    "ISN" , "CES" , "V"   , "V"   , "N"   , "N"   , "CE"  , "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"  , "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"   ,
    "NN"  , ""    , "V"   , "N"   , "N"   , ""    , ""    , "N"   ,
    ""    , "N"   , ""    , "N"   , "N"   , "N"   , "NVV" , "N"   ,
    "LL"  , "N"   , "NV"  , "ISN" , "CES" , "V"   , "V"   , "N"   ,
    "N"   , "CE"  , "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"  , "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];
    }
}

#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 const char* attr_name_nop(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_nop(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_nop(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_nop(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getlocal(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_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 bool attr_handles_frame_getlocal(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 enum ruby_vminsn_type attr_bin_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_num_t attr_width_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 bool attr_handles_frame_setlocal(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 enum ruby_vminsn_type attr_bin_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_num_t attr_width_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 bool attr_handles_frame_getblockparam(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 enum ruby_vminsn_type attr_bin_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_num_t attr_width_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 bool attr_handles_frame_setblockparam(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 enum ruby_vminsn_type attr_bin_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_num_t attr_width_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 bool attr_handles_frame_getblockparamproxy(lindex_t idx, rb_num_t level)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getspecial(rb_num_t key, rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_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 bool attr_handles_frame_getspecial(rb_num_t key, rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setspecial(rb_num_t key)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_setspecial(rb_num_t key)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_setspecial(rb_num_t key)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_setspecial(rb_num_t key)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getinstancevariable(ID id, IC ic)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_getinstancevariable(ID id, IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_getinstancevariable(ID id, IC ic)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_getinstancevariable(ID id, IC ic)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setinstancevariable(ID id, IC ic)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_setinstancevariable(ID id, IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_setinstancevariable(ID id, IC ic)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_setinstancevariable(ID id, IC ic)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_getclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_getclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_getclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_setclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_setclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_setclassvariable(ID id)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_getconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_getconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_getconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_setconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_setconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_setconstant(ID id)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getglobal(GENTRY entry)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_getglobal(GENTRY entry)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_getglobal(GENTRY entry)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_getglobal(GENTRY entry)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setglobal(GENTRY entry)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_setglobal(GENTRY entry)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_setglobal(GENTRY entry)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_setglobal(GENTRY entry)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_putnil(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_putnil(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_putnil(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_putnil(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_putself(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_putself(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_putself(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_putself(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_putobject(VALUE val)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_putobject(VALUE val)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_putobject(VALUE val)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_putobject(VALUE val)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_putspecialobject(rb_num_t value_type)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_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 bool attr_handles_frame_putspecialobject(rb_num_t value_type)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_putiseq(ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_putiseq(ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_putiseq(ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_putiseq(ISEQ iseq)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_putstring(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_putstring(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_putstring(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_putstring(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_concatstrings(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_concatstrings(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_concatstrings(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_concatstrings(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_tostring(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_tostring(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_tostring(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_tostring(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_freezestring(VALUE debug_info)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_freezestring(VALUE debug_info)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_freezestring(VALUE debug_info)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_freezestring(VALUE debug_info)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_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 enum ruby_vminsn_type attr_bin_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_num_t attr_width_toregexp(rb_num_t opt, rb_num_t cnt)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_toregexp(rb_num_t opt, rb_num_t cnt)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_intern(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_intern(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_intern(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_intern(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_newarray(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_newarray(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_newarray(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_newarray(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_duparray(VALUE ary)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_duparray(VALUE ary)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_duparray(VALUE ary)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_duparray(VALUE ary)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_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 enum ruby_vminsn_type attr_bin_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_num_t attr_width_expandarray(rb_num_t num, rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_expandarray(rb_num_t num, rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_concatarray(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_concatarray(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_concatarray(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_concatarray(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_splatarray(VALUE flag)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_splatarray(VALUE flag)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_splatarray(VALUE flag)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_splatarray(VALUE flag)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_newhash(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_newhash(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_newhash(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_newhash(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_newrange(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_newrange(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_newrange(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_newrange(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_pop(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_pop(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_pop(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_pop(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_dup(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_dup(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_dup(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_dup(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_dupn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_dupn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_dupn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_dupn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_swap(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_swap(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_swap(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_swap(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_reverse(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_reverse(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_reverse(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_reverse(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_reput(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_reput(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_reput(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_reput(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_topn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_topn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_topn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_topn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_setn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_setn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_setn(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_adjuststack(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_adjuststack(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_adjuststack(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_adjuststack(rb_num_t n)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_defined(rb_num_t op_type, VALUE obj, VALUE needstr)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_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 bool attr_handles_frame_defined(rb_num_t op_type, VALUE obj, VALUE needstr)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_checkmatch(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_checkmatch(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_checkmatch(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_checkmatch(rb_num_t flag)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_checkkeyword(lindex_t kw_bits_index, lindex_t keyword_index)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_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 bool attr_handles_frame_checkkeyword(lindex_t kw_bits_index, lindex_t keyword_index)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_checktype(rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_checktype(rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_checktype(rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_checktype(rb_num_t type)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_tracecoverage(rb_num_t nf, VALUE data)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_tracecoverage(rb_num_t nf, VALUE data)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_tracecoverage(rb_num_t nf, VALUE data)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_tracecoverage(rb_num_t nf, VALUE data)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_tracecoverage(rb_num_t nf, VALUE data)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_tracecoverage(rb_num_t nf, VALUE data)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_tracecoverage(rb_num_t nf, VALUE data)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_tracecoverage(rb_num_t nf, VALUE data)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_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 enum ruby_vminsn_type attr_bin_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_num_t attr_width_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 bool attr_handles_frame_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 const char* attr_name_send(CALL_INFO ci, CALL_CACHE cc, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_send(CALL_INFO ci, CALL_CACHE cc, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_str_freeze(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_str_freeze(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_str_freeze(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_str_freeze(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_str_freeze(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_str_freeze(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_str_freeze(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_opt_str_freeze(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_str_uminus(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_opt_str_uminus(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_opt_str_uminus(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_opt_str_uminus(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_opt_str_uminus(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_opt_str_uminus(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_str_uminus(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_opt_str_uminus(VALUE str)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_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 enum ruby_vminsn_type attr_bin_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_num_t attr_width_opt_newarray_max(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_opt_newarray_max(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 const char* attr_name_opt_newarray_min(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 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_num_t attr_width_opt_newarray_min(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_opt_newarray_min(rb_num_t num)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_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 const char* attr_name_opt_send_without_block(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_opt_send_without_block(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_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 const char* attr_name_invokesuper(CALL_INFO ci, CALL_CACHE cc, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_invokesuper(CALL_INFO ci, CALL_CACHE cc, ISEQ blockiseq)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_invokeblock(CALL_INFO ci)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_invokeblock(CALL_INFO ci)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_invokeblock(CALL_INFO ci)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_invokeblock(CALL_INFO ci)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_leave(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_leave(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_leave(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_leave(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_throw(rb_num_t throw_state)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_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 bool attr_handles_frame_throw(rb_num_t throw_state)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_jump(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_jump(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_jump(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_jump(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_branchif(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_branchif(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_branchif(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_branchif(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_branchunless(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_branchunless(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_branchunless(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_branchunless(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_branchnil(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_branchnil(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_branchnil(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_branchnil(OFFSET dst)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getinlinecache(OFFSET dst, IC ic)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_getinlinecache(OFFSET dst, IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_getinlinecache(OFFSET dst, IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_getinlinecache(OFFSET dst, IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_getinlinecache(OFFSET dst, IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_getinlinecache(OFFSET dst, IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_getinlinecache(OFFSET dst, IC ic)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_getinlinecache(OFFSET dst, IC ic)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setinlinecache(IC ic)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_setinlinecache(IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_open_setinlinecache(IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_popn_setinlinecache(IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_retn_setinlinecache(IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_num_t attr_width_setinlinecache(IC ic)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_setinlinecache(IC ic)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_setinlinecache(IC ic)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_once(ISEQ iseq, ISE ise)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_once(ISEQ iseq, ISE ise)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_once(ISEQ iseq, ISE ise)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_once(ISEQ iseq, ISE ise)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_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 enum ruby_vminsn_type attr_bin_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_num_t attr_width_opt_case_dispatch(CDHASH hash, OFFSET else_offset)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_opt_case_dispatch(CDHASH hash, OFFSET else_offset)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_plus(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_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 bool attr_handles_frame_opt_plus(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 enum ruby_vminsn_type attr_bin_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_num_t attr_width_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 bool attr_handles_frame_opt_minus(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 enum ruby_vminsn_type attr_bin_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_num_t attr_width_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 bool attr_handles_frame_opt_mult(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 enum ruby_vminsn_type attr_bin_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_num_t attr_width_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 bool attr_handles_frame_opt_div(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 enum ruby_vminsn_type attr_bin_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_num_t attr_width_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 bool attr_handles_frame_opt_mod(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 enum ruby_vminsn_type attr_bin_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_num_t attr_width_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 bool attr_handles_frame_opt_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 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 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_num_t attr_width_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 bool attr_handles_frame_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_lt(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 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_num_t attr_width_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 bool attr_handles_frame_opt_lt(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 enum ruby_vminsn_type attr_bin_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_num_t attr_width_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 bool attr_handles_frame_opt_le(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 enum ruby_vminsn_type attr_bin_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_num_t attr_width_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 bool attr_handles_frame_opt_gt(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 enum ruby_vminsn_type attr_bin_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_num_t attr_width_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 bool attr_handles_frame_opt_ge(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 enum ruby_vminsn_type attr_bin_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_num_t attr_width_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 bool attr_handles_frame_opt_ltlt(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 enum ruby_vminsn_type attr_bin_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_num_t attr_width_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 bool attr_handles_frame_opt_aref(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 enum ruby_vminsn_type attr_bin_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_num_t attr_width_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 bool attr_handles_frame_opt_aset(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 enum ruby_vminsn_type attr_bin_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_num_t attr_width_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 bool attr_handles_frame_opt_aset_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 enum ruby_vminsn_type attr_bin_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_num_t attr_width_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 bool attr_handles_frame_opt_aref_with(VALUE key, 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 enum ruby_vminsn_type attr_bin_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_num_t attr_width_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 bool attr_handles_frame_opt_length(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 enum ruby_vminsn_type attr_bin_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_num_t attr_width_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 bool attr_handles_frame_opt_size(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 enum ruby_vminsn_type attr_bin_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_num_t attr_width_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 bool attr_handles_frame_opt_empty_p(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 enum ruby_vminsn_type attr_bin_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_num_t attr_width_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 bool attr_handles_frame_opt_succ(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 enum ruby_vminsn_type attr_bin_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_num_t attr_width_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 bool attr_handles_frame_opt_not(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_regexpmatch1(VALUE recv)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_opt_regexpmatch1(VALUE recv)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_opt_regexpmatch1(VALUE recv)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_opt_regexpmatch1(VALUE recv)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_opt_regexpmatch2(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_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 bool attr_handles_frame_opt_regexpmatch2(CALL_INFO ci, CALL_CACHE cc)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_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 enum ruby_vminsn_type attr_bin_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_num_t attr_width_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 const char* attr_name_bitblt(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_bitblt(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_bitblt(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_bitblt(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_answer(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_answer(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_answer(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_answer(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getlocal_WC_0(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_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 bool attr_handles_frame_getlocal_WC_0(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_getlocal_WC_1(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_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 bool attr_handles_frame_getlocal_WC_1(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setlocal_WC_0(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_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 bool attr_handles_frame_setlocal_WC_0(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_setlocal_WC_1(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_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 bool attr_handles_frame_setlocal_WC_1(lindex_t idx)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_putobject_INT2FIX_0_(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_putobject_INT2FIX_0_(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_putobject_INT2FIX_0_(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_putobject_INT2FIX_0_(void)));
PUREFUNC(MAYBE_UNUSED(static const char* attr_name_putobject_INT2FIX_1_(void)));
PUREFUNC(MAYBE_UNUSED(static enum ruby_vminsn_type attr_bin_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_num_t attr_width_putobject_INT2FIX_1_(void)));
PUREFUNC(MAYBE_UNUSED(static rb_snum_t attr_sp_inc_putobject_INT2FIX_1_(void)));
PUREFUNC(MAYBE_UNUSED(static bool attr_handles_frame_putobject_INT2FIX_1_(void)));

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

/* attr enum ruby_vminsn_type bin @ nop()()() */
enum ruby_vminsn_type
attr_bin_nop(void)
{
    return 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_num_t width @ nop()()() */
rb_num_t
attr_width_nop(void)
{
    return 1;
}

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

/* attr bool handles_frame @ nop()()() */
bool
attr_handles_frame_nop(void)
{
    return false;
}

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

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

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

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

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

/* 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 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 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_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 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 bool handles_frame @ getspecial(key, type)()(val) */
bool
attr_handles_frame_getspecial(
    MAYBE_UNUSED(rb_num_t key),
    MAYBE_UNUSED(rb_num_t type)
)
{
    return false;
}

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

/* 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 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_num_t width @ setspecial(key)(obj)() */
rb_num_t
attr_width_setspecial(MAYBE_UNUSED(rb_num_t key))
{
    return 2;
}

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

/* 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 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 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_num_t width @ getinstancevariable(id, ic)()(val) */
rb_num_t
attr_width_getinstancevariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IC ic)
)
{
    return 3;
}

/* 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 bool handles_frame @ getinstancevariable(id, ic)()(val) */
bool
attr_handles_frame_getinstancevariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IC ic)
)
{
    return false;
}

/* 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 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 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_num_t width @ setinstancevariable(id, ic)(val)() */
rb_num_t
attr_width_setinstancevariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IC ic)
)
{
    return 3;
}

/* 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 bool handles_frame @ setinstancevariable(id, ic)(val)() */
bool
attr_handles_frame_setinstancevariable(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(IC ic)
)
{
    return false;
}

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

/* attr enum ruby_vminsn_type bin @ getclassvariable(id)()(val) */
enum ruby_vminsn_type
attr_bin_getclassvariable(MAYBE_UNUSED(ID id))
{
    return 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_num_t width @ getclassvariable(id)()(val) */
rb_num_t
attr_width_getclassvariable(MAYBE_UNUSED(ID id))
{
    return 2;
}

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

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

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

/* attr enum ruby_vminsn_type bin @ setclassvariable(id)(val)() */
enum ruby_vminsn_type
attr_bin_setclassvariable(MAYBE_UNUSED(ID id))
{
    return 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_num_t width @ setclassvariable(id)(val)() */
rb_num_t
attr_width_setclassvariable(MAYBE_UNUSED(ID id))
{
    return 2;
}

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

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

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

/* 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 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_num_t width @ getconstant(id)(klass)(val) */
rb_num_t
attr_width_getconstant(MAYBE_UNUSED(ID id))
{
    return 2;
}

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

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

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

/* 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 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_num_t width @ setconstant(id)(val, cbase)() */
rb_num_t
attr_width_setconstant(MAYBE_UNUSED(ID id))
{
    return 2;
}

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

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

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

/* attr enum ruby_vminsn_type bin @ getglobal(entry)()(val) */
enum ruby_vminsn_type
attr_bin_getglobal(MAYBE_UNUSED(GENTRY entry))
{
    return 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_num_t width @ getglobal(entry)()(val) */
rb_num_t
attr_width_getglobal(MAYBE_UNUSED(GENTRY entry))
{
    return 2;
}

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

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

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

/* attr enum ruby_vminsn_type bin @ setglobal(entry)(val)() */
enum ruby_vminsn_type
attr_bin_setglobal(MAYBE_UNUSED(GENTRY entry))
{
    return 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_num_t width @ setglobal(entry)(val)() */
rb_num_t
attr_width_setglobal(MAYBE_UNUSED(GENTRY entry))
{
    return 2;
}

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

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

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

/* attr enum ruby_vminsn_type bin @ putnil()()(val) */
enum ruby_vminsn_type
attr_bin_putnil(void)
{
    return 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_num_t width @ putnil()()(val) */
rb_num_t
attr_width_putnil(void)
{
    return 1;
}

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

/* attr bool handles_frame @ putnil()()(val) */
bool
attr_handles_frame_putnil(void)
{
    return false;
}

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

/* attr enum ruby_vminsn_type bin @ putself()()(val) */
enum ruby_vminsn_type
attr_bin_putself(void)
{
    return 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_num_t width @ putself()()(val) */
rb_num_t
attr_width_putself(void)
{
    return 1;
}

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

/* attr bool handles_frame @ putself()()(val) */
bool
attr_handles_frame_putself(void)
{
    return false;
}

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

/* attr enum ruby_vminsn_type bin @ putobject(val)()(val) */
enum ruby_vminsn_type
attr_bin_putobject(MAYBE_UNUSED(VALUE val))
{
    return 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_num_t width @ putobject(val)()(val) */
rb_num_t
attr_width_putobject(MAYBE_UNUSED(VALUE val))
{
    return 2;
}

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

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

/* 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 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 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_num_t width @ putspecialobject(value_type)()(val) */
rb_num_t
attr_width_putspecialobject(MAYBE_UNUSED(rb_num_t value_type))
{
    return 2;
}

/* 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 bool handles_frame @ putspecialobject(value_type)()(val) */
bool
attr_handles_frame_putspecialobject(MAYBE_UNUSED(rb_num_t value_type))
{
    return false;
}

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

/* attr enum ruby_vminsn_type bin @ putiseq(iseq)()(ret) */
enum ruby_vminsn_type
attr_bin_putiseq(MAYBE_UNUSED(ISEQ iseq))
{
    return 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_num_t width @ putiseq(iseq)()(ret) */
rb_num_t
attr_width_putiseq(MAYBE_UNUSED(ISEQ iseq))
{
    return 2;
}

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

/* attr bool handles_frame @ putiseq(iseq)()(ret) */
bool
attr_handles_frame_putiseq(MAYBE_UNUSED(ISEQ iseq))
{
    return false;
}

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

/* attr enum ruby_vminsn_type bin @ putstring(str)()(val) */
enum ruby_vminsn_type
attr_bin_putstring(MAYBE_UNUSED(VALUE str))
{
    return 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_num_t width @ putstring(str)()(val) */
rb_num_t
attr_width_putstring(MAYBE_UNUSED(VALUE str))
{
    return 2;
}

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

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

/* attr rb_snum_t sp_inc @ concatstrings(num)(...)(val) */
rb_snum_t
attr_sp_inc_concatstrings(MAYBE_UNUSED(rb_num_t num))
{
    return
#line 366 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns.def"
1 - num;
#line 2662 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns_info.inc"
}

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

/* attr 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 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_num_t width @ concatstrings(num)(...)(val) */
rb_num_t
attr_width_concatstrings(MAYBE_UNUSED(rb_num_t num))
{
    return 2;
}

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

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

/* attr enum ruby_vminsn_type bin @ tostring()(val, str)(val) */
enum ruby_vminsn_type
attr_bin_tostring(void)
{
    return 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_num_t width @ tostring()(val, str)(val) */
rb_num_t
attr_width_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 bool handles_frame @ tostring()(val, str)(val) */
bool
attr_handles_frame_tostring(void)
{
    return false;
}

/* 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 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 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_num_t width @ freezestring(debug_info)(str)(str) */
rb_num_t
attr_width_freezestring(MAYBE_UNUSED(VALUE debug_info))
{
    return 2;
}

/* 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 bool handles_frame @ freezestring(debug_info)(str)(str) */
bool
attr_handles_frame_freezestring(MAYBE_UNUSED(VALUE debug_info))
{
    return false;
}

/* 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 400 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns.def"
1 - cnt;
#line 2836 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/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 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 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_num_t width @ toregexp(opt, cnt)(...)(val) */
rb_num_t
attr_width_toregexp(
    MAYBE_UNUSED(rb_num_t opt),
    MAYBE_UNUSED(rb_num_t cnt)
)
{
    return 3;
}

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

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

/* attr enum ruby_vminsn_type bin @ intern()(str)(sym) */
enum ruby_vminsn_type
attr_bin_intern(void)
{
    return 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_num_t width @ intern()(str)(sym) */
rb_num_t
attr_width_intern(void)
{
    return 1;
}

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

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

/* attr rb_snum_t sp_inc @ newarray(num)(...)(val) */
rb_snum_t
attr_sp_inc_newarray(MAYBE_UNUSED(rb_num_t num))
{
    return
#line 425 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns.def"
1 - num;
#line 2972 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns_info.inc"
}

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

/* 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 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_num_t width @ newarray(num)(...)(val) */
rb_num_t
attr_width_newarray(MAYBE_UNUSED(rb_num_t num))
{
    return 2;
}

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

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

/* attr enum ruby_vminsn_type bin @ duparray(ary)()(val) */
enum ruby_vminsn_type
attr_bin_duparray(MAYBE_UNUSED(VALUE ary))
{
    return 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_num_t width @ duparray(ary)()(val) */
rb_num_t
attr_width_duparray(MAYBE_UNUSED(VALUE ary))
{
    return 2;
}

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

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

/* 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 454 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns.def"
num - 1 + (flag & 1 ? 1 : 0);
#line 3090 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/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 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 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_num_t width @ expandarray(num, flag)(..., ary)(...) */
rb_num_t
attr_width_expandarray(
    MAYBE_UNUSED(rb_num_t num),
    MAYBE_UNUSED(rb_num_t flag)
)
{
    return 3;
}

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

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

/* attr enum ruby_vminsn_type bin @ concatarray()(ary1, ary2)(ary) */
enum ruby_vminsn_type
attr_bin_concatarray(void)
{
    return 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_num_t width @ concatarray()(ary1, ary2)(ary) */
rb_num_t
attr_width_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 bool handles_frame @ concatarray()(ary1, ary2)(ary) */
bool
attr_handles_frame_concatarray(void)
{
    return false;
}

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

/* 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 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_num_t width @ splatarray(flag)(ary)(obj) */
rb_num_t
attr_width_splatarray(MAYBE_UNUSED(VALUE flag))
{
    return 2;
}

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

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

/* attr rb_snum_t sp_inc @ newhash(num)(...)(val) */
rb_snum_t
attr_sp_inc_newhash(MAYBE_UNUSED(rb_num_t num))
{
    return
#line 485 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns.def"
1 - num;
#line 3282 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/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 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 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_num_t width @ newhash(num)(...)(val) */
rb_num_t
attr_width_newhash(MAYBE_UNUSED(rb_num_t num))
{
    return 2;
}

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

/* 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 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 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_num_t width @ newrange(flag)(low, high)(val) */
rb_num_t
attr_width_newrange(MAYBE_UNUSED(rb_num_t flag))
{
    return 2;
}

/* 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 bool handles_frame @ newrange(flag)(low, high)(val) */
bool
attr_handles_frame_newrange(MAYBE_UNUSED(rb_num_t flag))
{
    return false;
}

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

/* attr enum ruby_vminsn_type bin @ pop()(val)() */
enum ruby_vminsn_type
attr_bin_pop(void)
{
    return 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_num_t width @ pop()(val)() */
rb_num_t
attr_width_pop(void)
{
    return 1;
}

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

/* attr bool handles_frame @ pop()(val)() */
bool
attr_handles_frame_pop(void)
{
    return false;
}

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

/* attr enum ruby_vminsn_type bin @ dup()(val)(val1, val2) */
enum ruby_vminsn_type
attr_bin_dup(void)
{
    return 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_num_t width @ dup()(val)(val1, val2) */
rb_num_t
attr_width_dup(void)
{
    return 1;
}

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

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

/* attr rb_snum_t sp_inc @ dupn(n)(...)(...) */
rb_snum_t
attr_sp_inc_dupn(MAYBE_UNUSED(rb_num_t n))
{
    return
#line 537 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns.def"
n;
#line 3509 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns_info.inc"
}

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

/* 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 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_num_t width @ dupn(n)(...)(...) */
rb_num_t
attr_width_dupn(MAYBE_UNUSED(rb_num_t n))
{
    return 2;
}

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

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

/* attr enum ruby_vminsn_type bin @ swap()(val, obj)(obj, val) */
enum ruby_vminsn_type
attr_bin_swap(void)
{
    return 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_num_t width @ swap()(val, obj)(obj, val) */
rb_num_t
attr_width_swap(void)
{
    return 1;
}

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

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

/* attr rb_snum_t sp_inc @ reverse(n)(...)(...) */
rb_snum_t
attr_sp_inc_reverse(MAYBE_UNUSED(rb_num_t n))
{
    return
#line 561 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns.def"
0;
#line 3624 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns_info.inc"
}

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

/* 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 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_num_t width @ reverse(n)(...)(...) */
rb_num_t
attr_width_reverse(MAYBE_UNUSED(rb_num_t n))
{
    return 2;
}

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

/* attr rb_snum_t sp_inc @ reput()(..., val)(val) */
rb_snum_t
attr_sp_inc_reput(void)
{
    return
#line 580 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns.def"
0;
#line 3683 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns_info.inc"
}

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

/* attr enum ruby_vminsn_type bin @ reput()(..., val)(val) */
enum ruby_vminsn_type
attr_bin_reput(void)
{
    return 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_num_t width @ reput()(..., val)(val) */
rb_num_t
attr_width_reput(void)
{
    return 1;
}

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

/* attr rb_snum_t sp_inc @ topn(n)(...)(val) */
rb_snum_t
attr_sp_inc_topn(MAYBE_UNUSED(rb_num_t n))
{
    return
#line 591 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns.def"
1;
#line 3742 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns_info.inc"
}

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

/* 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 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_num_t width @ topn(n)(...)(val) */
rb_num_t
attr_width_topn(MAYBE_UNUSED(rb_num_t n))
{
    return 2;
}

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

/* 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 602 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns.def"
0;
#line 3801 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns_info.inc"
}

/* 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 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 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_num_t width @ setn(n)(..., val)(val) */
rb_num_t
attr_width_setn(MAYBE_UNUSED(rb_num_t n))
{
    return 2;
}

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

/* attr rb_snum_t sp_inc @ adjuststack(n)(...)(...) */
rb_snum_t
attr_sp_inc_adjuststack(MAYBE_UNUSED(rb_num_t n))
{
    return
#line 613 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns.def"
-(rb_snum_t)n;
#line 3860 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns_info.inc"
}

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

/* 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 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_num_t width @ adjuststack(n)(...)(...) */
rb_num_t
attr_width_adjuststack(MAYBE_UNUSED(rb_num_t n))
{
    return 2;
}

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

/* 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 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 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_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 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 bool handles_frame @ defined(op_type, obj, needstr)(v)(val) */
bool
attr_handles_frame_defined(
    MAYBE_UNUSED(rb_num_t op_type),
    MAYBE_UNUSED(VALUE obj),
    MAYBE_UNUSED(VALUE needstr)
)
{
    return false;
}

/* 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 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 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_num_t width @ checkmatch(flag)(target, pattern)(result) */
rb_num_t
attr_width_checkmatch(MAYBE_UNUSED(rb_num_t flag))
{
    return 2;
}

/* 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 bool handles_frame @ checkmatch(flag)(target, pattern)(result) */
bool
attr_handles_frame_checkmatch(MAYBE_UNUSED(rb_num_t flag))
{
    return false;
}

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

/* 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 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 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_num_t width @ checktype(type)(val)(ret) */
rb_num_t
attr_width_checktype(MAYBE_UNUSED(rb_num_t type))
{
    return 2;
}

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

/* attr const char* name @ tracecoverage(nf, data)()() */
const char*
attr_name_tracecoverage(
    MAYBE_UNUSED(rb_num_t nf),
    MAYBE_UNUSED(VALUE data)
)
{
    return insn_name(BIN(tracecoverage));
}

/* attr enum ruby_vminsn_type bin @ tracecoverage(nf, data)()() */
enum ruby_vminsn_type
attr_bin_tracecoverage(
    MAYBE_UNUSED(rb_num_t nf),
    MAYBE_UNUSED(VALUE data)
)
{
    return BIN(tracecoverage);
}

/* attr rb_num_t open @ tracecoverage(nf, data)()() */
rb_num_t
attr_open_tracecoverage(
    MAYBE_UNUSED(rb_num_t nf),
    MAYBE_UNUSED(VALUE data)
)
{
    return 2;
}

/* attr rb_num_t popn @ tracecoverage(nf, data)()() */
rb_num_t
attr_popn_tracecoverage(
    MAYBE_UNUSED(rb_num_t nf),
    MAYBE_UNUSED(VALUE data)
)
{
    return 0;
}

/* attr rb_num_t retn @ tracecoverage(nf, data)()() */
rb_num_t
attr_retn_tracecoverage(
    MAYBE_UNUSED(rb_num_t nf),
    MAYBE_UNUSED(VALUE data)
)
{
    return 0;
}

/* attr rb_num_t width @ tracecoverage(nf, data)()() */
rb_num_t
attr_width_tracecoverage(
    MAYBE_UNUSED(rb_num_t nf),
    MAYBE_UNUSED(VALUE data)
)
{
    return 3;
}

/* attr rb_snum_t sp_inc @ tracecoverage(nf, data)()() */
rb_snum_t
attr_sp_inc_tracecoverage(
    MAYBE_UNUSED(rb_num_t nf),
    MAYBE_UNUSED(VALUE data)
)
{
    return 0;
}

/* attr bool handles_frame @ tracecoverage(nf, data)()() */
bool
attr_handles_frame_tracecoverage(
    MAYBE_UNUSED(rb_num_t nf),
    MAYBE_UNUSED(VALUE data)
)
{
    return false;
}

/* attr bool handles_frame @ defineclass(id, class_iseq, flags)(cbase, super)(val) */
bool
attr_handles_frame_defineclass(
    MAYBE_UNUSED(ID id),
    MAYBE_UNUSED(ISEQ class_iseq),
    MAYBE_UNUSED(rb_num_t flags)
)
{
    return
#line 693 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns.def"
true;
#line 4283 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns_info.inc"
}

/* 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 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 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_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 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 bool handles_frame @ send(ci, cc, blockiseq)(...)(val) */
bool
attr_handles_frame_send(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return
#line 720 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns.def"
true;
#line 4374 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns_info.inc"
}

/* 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 721 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns.def"
- (int)(ci->orig_argc + ((ci->flag & VM_CALL_ARGS_BLOCKARG) ? 1 : 0));
#line 4388 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns_info.inc"
}

/* 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 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 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_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 const char* name @ opt_str_freeze(str)()(val) */
const char*
attr_name_opt_str_freeze(MAYBE_UNUSED(VALUE str))
{
    return insn_name(BIN(opt_str_freeze));
}

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

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

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

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

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

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

/* attr bool handles_frame @ opt_str_freeze(str)()(val) */
bool
attr_handles_frame_opt_str_freeze(MAYBE_UNUSED(VALUE str))
{
    return false;
}

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

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

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

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

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

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

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

/* attr bool handles_frame @ opt_str_uminus(str)()(val) */
bool
attr_handles_frame_opt_str_uminus(MAYBE_UNUSED(VALUE str))
{
    return false;
}

/* 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 763 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns.def"
1 - num;
#line 4576 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/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 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 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_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 bool handles_frame @ opt_newarray_max(num)(...)(val) */
bool
attr_handles_frame_opt_newarray_max(MAYBE_UNUSED(rb_num_t num))
{
    return false;
}

/* 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 773 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns.def"
1 - num;
#line 4635 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/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 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 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_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 bool handles_frame @ opt_newarray_min(num)(...)(val) */
bool
attr_handles_frame_opt_newarray_min(MAYBE_UNUSED(rb_num_t num))
{
    return false;
}

/* attr bool handles_frame @ opt_send_without_block(ci, cc)(...)(val) */
bool
attr_handles_frame_opt_send_without_block(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return
#line 784 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns.def"
true;
#line 4697 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns_info.inc"
}

/* 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 785 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns.def"
-ci->orig_argc;
#line 4710 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns_info.inc"
}

/* 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 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 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_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 bool handles_frame @ invokesuper(ci, cc, blockiseq)(...)(val) */
bool
attr_handles_frame_invokesuper(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc),
    MAYBE_UNUSED(ISEQ blockiseq)
)
{
    return
#line 799 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns.def"
true;
#line 4784 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns_info.inc"
}

/* 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 800 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns.def"
- (int)(ci->orig_argc + ((ci->flag & VM_CALL_ARGS_BLOCKARG) ? 1 : 0));
#line 4798 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns_info.inc"
}

/* 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 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 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_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 bool handles_frame @ invokeblock(ci)(...)(val) */
bool
attr_handles_frame_invokeblock(MAYBE_UNUSED(CALL_INFO ci))
{
    return
#line 817 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns.def"
true;
#line 4874 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns_info.inc"
}

/* attr rb_snum_t sp_inc @ invokeblock(ci)(...)(val) */
rb_snum_t
attr_sp_inc_invokeblock(MAYBE_UNUSED(CALL_INFO ci))
{
    return
#line 818 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns.def"
1 - ci->orig_argc;
#line 4884 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns_info.inc"
}

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

/* 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 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_num_t width @ invokeblock(ci)(...)(val) */
rb_num_t
attr_width_invokeblock(MAYBE_UNUSED(CALL_INFO ci))
{
    return 2;
}

/* attr bool handles_frame @ leave()(val)(val) */
bool
attr_handles_frame_leave(void)
{
    return
#line 844 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns.def"
true;
#line 4936 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns_info.inc"
}

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

/* attr enum ruby_vminsn_type bin @ leave()(val)(val) */
enum ruby_vminsn_type
attr_bin_leave(void)
{
    return 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_num_t width @ leave()(val)(val) */
rb_num_t
attr_width_leave(void)
{
    return 1;
}

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

/* 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 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 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_num_t width @ throw(throw_state)(throwobj)(val) */
rb_num_t
attr_width_throw(MAYBE_UNUSED(rb_num_t throw_state))
{
    return 2;
}

/* 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 bool handles_frame @ throw(throw_state)(throwobj)(val) */
bool
attr_handles_frame_throw(MAYBE_UNUSED(rb_num_t throw_state))
{
    return false;
}

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

/* attr enum ruby_vminsn_type bin @ jump(dst)()() */
enum ruby_vminsn_type
attr_bin_jump(MAYBE_UNUSED(OFFSET dst))
{
    return 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_num_t width @ jump(dst)()() */
rb_num_t
attr_width_jump(MAYBE_UNUSED(OFFSET dst))
{
    return 2;
}

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

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

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

/* attr enum ruby_vminsn_type bin @ branchif(dst)(val)() */
enum ruby_vminsn_type
attr_bin_branchif(MAYBE_UNUSED(OFFSET dst))
{
    return 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_num_t width @ branchif(dst)(val)() */
rb_num_t
attr_width_branchif(MAYBE_UNUSED(OFFSET dst))
{
    return 2;
}

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

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

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

/* attr enum ruby_vminsn_type bin @ branchunless(dst)(val)() */
enum ruby_vminsn_type
attr_bin_branchunless(MAYBE_UNUSED(OFFSET dst))
{
    return 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_num_t width @ branchunless(dst)(val)() */
rb_num_t
attr_width_branchunless(MAYBE_UNUSED(OFFSET dst))
{
    return 2;
}

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

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

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

/* attr enum ruby_vminsn_type bin @ branchnil(dst)(val)() */
enum ruby_vminsn_type
attr_bin_branchnil(MAYBE_UNUSED(OFFSET dst))
{
    return 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_num_t width @ branchnil(dst)(val)() */
rb_num_t
attr_width_branchnil(MAYBE_UNUSED(OFFSET dst))
{
    return 2;
}

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

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

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

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

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

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

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

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

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

/* attr bool handles_frame @ getinlinecache(dst, ic)()(val) */
bool
attr_handles_frame_getinlinecache(
    MAYBE_UNUSED(OFFSET dst),
    MAYBE_UNUSED(IC ic)
)
{
    return false;
}

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

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

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

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

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

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

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

/* attr bool handles_frame @ setinlinecache(ic)(val)(val) */
bool
attr_handles_frame_setinlinecache(MAYBE_UNUSED(IC ic))
{
    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 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 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_num_t width @ once(iseq, ise)()(val) */
rb_num_t
attr_width_once(
    MAYBE_UNUSED(ISEQ iseq),
    MAYBE_UNUSED(ISE ise)
)
{
    return 3;
}

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

/* 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 985 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns.def"
-1;
#line 5494 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns_info.inc"
}

/* 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 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 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_num_t width @ opt_case_dispatch(hash, else_offset)(..., key)() */
rb_num_t
attr_width_opt_case_dispatch(
    MAYBE_UNUSED(CDHASH hash),
    MAYBE_UNUSED(OFFSET else_offset)
)
{
    return 3;
}

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

/* 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 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 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_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 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 bool handles_frame @ opt_plus(ci, cc)(recv, obj)(val) */
bool
attr_handles_frame_opt_plus(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* 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 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 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_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 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 bool handles_frame @ opt_minus(ci, cc)(recv, obj)(val) */
bool
attr_handles_frame_opt_minus(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* 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 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 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_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 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 bool handles_frame @ opt_mult(ci, cc)(recv, obj)(val) */
bool
attr_handles_frame_opt_mult(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* 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 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 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_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 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 bool handles_frame @ opt_div(ci, cc)(recv, obj)(val) */
bool
attr_handles_frame_opt_div(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* 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 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 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_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 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 bool handles_frame @ opt_mod(ci, cc)(recv, obj)(val) */
bool
attr_handles_frame_opt_mod(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* 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 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 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_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 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 bool handles_frame @ opt_eq(ci, cc)(recv, obj)(val) */
bool
attr_handles_frame_opt_eq(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* 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 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 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_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 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 bool handles_frame @ opt_neq(ci_eq, cc_eq, ci, cc)(recv, obj)(val) */
bool
attr_handles_frame_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 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 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 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_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 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 bool handles_frame @ opt_lt(ci, cc)(recv, obj)(val) */
bool
attr_handles_frame_opt_lt(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* 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 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 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_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 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 bool handles_frame @ opt_le(ci, cc)(recv, obj)(val) */
bool
attr_handles_frame_opt_le(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* 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 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 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_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 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 bool handles_frame @ opt_gt(ci, cc)(recv, obj)(val) */
bool
attr_handles_frame_opt_gt(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* 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 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 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_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 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 bool handles_frame @ opt_ge(ci, cc)(recv, obj)(val) */
bool
attr_handles_frame_opt_ge(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* 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 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 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_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 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 bool handles_frame @ opt_ltlt(ci, cc)(recv, obj)(val) */
bool
attr_handles_frame_opt_ltlt(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* 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 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 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_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 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 bool handles_frame @ opt_aref(ci, cc)(recv, obj)(val) */
bool
attr_handles_frame_opt_aref(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* 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 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 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_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 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 bool handles_frame @ opt_aset(ci, cc)(recv, obj, set)(val) */
bool
attr_handles_frame_opt_aset(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* 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 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 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_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 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 bool handles_frame @ opt_aset_with(key, ci, cc)(recv, val)(val) */
bool
attr_handles_frame_opt_aset_with(
    MAYBE_UNUSED(VALUE key),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* 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 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 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_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 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 bool handles_frame @ opt_aref_with(key, ci, cc)(recv)(val) */
bool
attr_handles_frame_opt_aref_with(
    MAYBE_UNUSED(VALUE key),
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* 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 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 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_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 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 bool handles_frame @ opt_length(ci, cc)(recv)(val) */
bool
attr_handles_frame_opt_length(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* 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 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 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_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 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 bool handles_frame @ opt_size(ci, cc)(recv)(val) */
bool
attr_handles_frame_opt_size(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* 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 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 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_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 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 bool handles_frame @ opt_empty_p(ci, cc)(recv)(val) */
bool
attr_handles_frame_opt_empty_p(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* 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 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 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_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 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 bool handles_frame @ opt_succ(ci, cc)(recv)(val) */
bool
attr_handles_frame_opt_succ(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* 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 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 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_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 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 bool handles_frame @ opt_not(ci, cc)(recv)(val) */
bool
attr_handles_frame_opt_not(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* 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 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 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_num_t width @ opt_regexpmatch1(recv)(obj)(val) */
rb_num_t
attr_width_opt_regexpmatch1(MAYBE_UNUSED(VALUE recv))
{
    return 2;
}

/* 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 bool handles_frame @ opt_regexpmatch1(recv)(obj)(val) */
bool
attr_handles_frame_opt_regexpmatch1(MAYBE_UNUSED(VALUE recv))
{
    return false;
}

/* 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 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 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_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 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 bool handles_frame @ opt_regexpmatch2(ci, cc)(obj2, obj1)(val) */
bool
attr_handles_frame_opt_regexpmatch2(
    MAYBE_UNUSED(CALL_INFO ci),
    MAYBE_UNUSED(CALL_CACHE cc)
)
{
    return false;
}

/* attr bool handles_frame @ opt_call_c_function(funcptr)()() */
bool
attr_handles_frame_opt_call_c_function(MAYBE_UNUSED(rb_insn_func_t funcptr))
{
    return
#line 1335 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/insns.def"
true;
#line 7422 "/tmp/ruby-snapshot20180531-14126-1g8hafs/ruby-2.6.0-preview2/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 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 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_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 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 const char* name @ bitblt()()(ret) */
const char*
attr_name_bitblt(void)
{
    return insn_name(BIN(bitblt));
}

/* attr enum ruby_vminsn_type bin @ bitblt()()(ret) */
enum ruby_vminsn_type
attr_bin_bitblt(void)
{
    return 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_num_t width @ bitblt()()(ret) */
rb_num_t
attr_width_bitblt(void)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ bitblt()()(ret) */
rb_snum_t
attr_sp_inc_bitblt(void)
{
    return 1;
}

/* attr bool handles_frame @ bitblt()()(ret) */
bool
attr_handles_frame_bitblt(void)
{
    return false;
}

/* attr const char* name @ answer()()(ret) */
const char*
attr_name_answer(void)
{
    return insn_name(BIN(answer));
}

/* attr enum ruby_vminsn_type bin @ answer()()(ret) */
enum ruby_vminsn_type
attr_bin_answer(void)
{
    return 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_num_t width @ answer()()(ret) */
rb_num_t
attr_width_answer(void)
{
    return 1;
}

/* attr rb_snum_t sp_inc @ answer()()(ret) */
rb_snum_t
attr_sp_inc_answer(void)
{
    return 1;
}

/* attr bool handles_frame @ answer()()(ret) */
bool
attr_handles_frame_answer(void)
{
    return false;
}

/* 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 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 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_num_t width @ getlocal_WC_0(idx)()(val) */
rb_num_t
attr_width_getlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
    return 2;
}

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

/* 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 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 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_num_t width @ getlocal_WC_1(idx)()(val) */
rb_num_t
attr_width_getlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
    return 2;
}

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

/* 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 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 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_num_t width @ setlocal_WC_0(idx)(val)() */
rb_num_t
attr_width_setlocal_WC_0(MAYBE_UNUSED(lindex_t idx))
{
    return 2;
}

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

/* 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 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 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_num_t width @ setlocal_WC_1(idx)(val)() */
rb_num_t
attr_width_setlocal_WC_1(MAYBE_UNUSED(lindex_t idx))
{
    return 2;
}

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

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

/* 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 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_num_t width @ putobject_INT2FIX_0_()()(val) */
rb_num_t
attr_width_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 bool handles_frame @ putobject_INT2FIX_0_()()(val) */
bool
attr_handles_frame_putobject_INT2FIX_0_(void)
{
    return false;
}

/* attr const char* name @ putobject_INT2FIX_1_()()(val) */
const char*
attr_name_putobject_INT2FIX_1_(void)
{
    return insn_name(BIN(putobject_INT2FIX_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 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_num_t width @ putobject_INT2FIX_1_()()(val) */
rb_num_t
attr_width_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 bool handles_frame @ putobject_INT2FIX_1_()()(val) */
bool
attr_handles_frame_putobject_INT2FIX_1_(void)
{
    return false;
}

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, -127,   -1,    0,
        -127,   -1,   -1,    1, -127,    0, -127, -127,
        -127, -127, -127,    0,   -1,    1,    0,    0,
          -1, -127,    1,    1, -127, -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,
          -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,
    };
    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_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(opt_send_without_block):
        return attr_sp_inc_opt_send_without_block((CALL_INFO)(opes[0]), (CALL_CACHE)(opes[1]));
    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);
}

