avalara_sdk 24.12.1 → 24.12.2

data/vendor/bundle/ruby/2.7.0/gems/debase-ruby_core_source-3.4.1/lib/debase/ruby_core_source/ruby-2.5.0-p0/vm.inc

@@ -0,0 +1,3667 @@
+/* -*-c-*- *********************************************************/
+/*******************************************************************/
+/*******************************************************************/
+/**
+  This file is VM main loop.
+
+  ----
+  This file is auto generated by insns2vm.rb
+  DO NOT TOUCH!
+
+  If you want to fix something, you must edit 'insns.def'
+ */
+
+
+INSN_ENTRY(nop){START_OF_ORIGINAL_INSN(nop);
+{
+
+
+  DEBUG_ENTER_INSN("nop");
+  ADD_PC(1+0);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_nop 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_nop_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(nop));
+{
+#line 40 "insns.def"
+    /* none */
+
+#line 32 "vm.inc"
+#undef CURRENT_INSN_nop
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(nop);}}}
+INSN_ENTRY(getlocal){START_OF_ORIGINAL_INSN(getlocal);
+{
+  VALUE val;
+  rb_num_t level = (rb_num_t)GET_OPERAND(2);
+  lindex_t idx = (lindex_t)GET_OPERAND(1);
+
+  DEBUG_ENTER_INSN("getlocal");
+  ADD_PC(1+2);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_getlocal 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_getlocal_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(getlocal));
+  COLLECT_USAGE_OPERAND(BIN(getlocal), 0, idx);
+  COLLECT_USAGE_OPERAND(BIN(getlocal), 1, level);
+{
+#line 60 "insns.def"
+    val = *(vm_get_ep(GET_EP(), level) - idx);
+    RB_DEBUG_COUNTER_INC(lvar_get);
+    (void)RB_DEBUG_COUNTER_INC_IF(lvar_get_dynamic, level > 0);
+
+#line 60 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_getlocal
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(getlocal);}}}
+INSN_ENTRY(setlocal){START_OF_ORIGINAL_INSN(setlocal);
+{
+  rb_num_t level = (rb_num_t)GET_OPERAND(2);
+  lindex_t idx = (lindex_t)GET_OPERAND(1);
+  VALUE val = TOPN(0);
+  DEBUG_ENTER_INSN("setlocal");
+  ADD_PC(1+2);
+  PREFETCH(GET_PC());
+  POPN(1);
+  #define CURRENT_INSN_setlocal 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_setlocal_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(setlocal));
+  COLLECT_USAGE_OPERAND(BIN(setlocal), 0, idx);
+  COLLECT_USAGE_OPERAND(BIN(setlocal), 1, level);
+{
+#line 78 "insns.def"
+    vm_env_write(vm_get_ep(GET_EP(), level), -(int)idx, val);
+    RB_DEBUG_COUNTER_INC(lvar_set);
+    (void)RB_DEBUG_COUNTER_INC_IF(lvar_set_dynamic, level > 0);
+
+#line 90 "vm.inc"
+#undef CURRENT_INSN_setlocal
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(setlocal);}}}
+INSN_ENTRY(getblockparam){START_OF_ORIGINAL_INSN(getblockparam);
+{
+  VALUE val;
+  rb_num_t level = (rb_num_t)GET_OPERAND(2);
+  lindex_t idx = (lindex_t)GET_OPERAND(1);
+
+  DEBUG_ENTER_INSN("getblockparam");
+  ADD_PC(1+2);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_getblockparam 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_getblockparam_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(getblockparam));
+  COLLECT_USAGE_OPERAND(BIN(getblockparam), 0, idx);
+  COLLECT_USAGE_OPERAND(BIN(getblockparam), 1, level);
+{
+#line 94 "insns.def"
+    const VALUE *ep = vm_get_ep(GET_EP(), level);
+    VM_ASSERT(VM_ENV_LOCAL_P(ep));
+
+    if (!VM_ENV_FLAGS(ep, VM_FRAME_FLAG_MODIFIED_BLOCK_PARAM)) {
+	val = rb_vm_bh_to_procval(ec, VM_ENV_BLOCK_HANDLER(ep));
+	vm_env_write(ep, -(int)idx, val);
+	VM_ENV_FLAGS_SET(ep, VM_FRAME_FLAG_MODIFIED_BLOCK_PARAM);
+    }
+    else {
+	val = *(ep - idx);
+	RB_DEBUG_COUNTER_INC(lvar_get);
+	(void)RB_DEBUG_COUNTER_INC_IF(lvar_get_dynamic, level > 0);
+    }
+
+#line 128 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_getblockparam
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(getblockparam);}}}
+INSN_ENTRY(setblockparam){START_OF_ORIGINAL_INSN(setblockparam);
+{
+  rb_num_t level = (rb_num_t)GET_OPERAND(2);
+  lindex_t idx = (lindex_t)GET_OPERAND(1);
+  VALUE val = TOPN(0);
+  DEBUG_ENTER_INSN("setblockparam");
+  ADD_PC(1+2);
+  PREFETCH(GET_PC());
+  POPN(1);
+  #define CURRENT_INSN_setblockparam 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_setblockparam_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(setblockparam));
+  COLLECT_USAGE_OPERAND(BIN(setblockparam), 0, idx);
+  COLLECT_USAGE_OPERAND(BIN(setblockparam), 1, level);
+{
+#line 120 "insns.def"
+    const VALUE *ep = vm_get_ep(GET_EP(), level);
+    VM_ASSERT(VM_ENV_LOCAL_P(ep));
+
+    vm_env_write(ep, -(int)idx, val);
+    RB_DEBUG_COUNTER_INC(lvar_set);
+    (void)RB_DEBUG_COUNTER_INC_IF(lvar_set_dynamic, level > 0);
+
+    VM_ENV_FLAGS_SET(ep, VM_FRAME_FLAG_MODIFIED_BLOCK_PARAM);
+
+#line 163 "vm.inc"
+#undef CURRENT_INSN_setblockparam
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(setblockparam);}}}
+INSN_ENTRY(getspecial){START_OF_ORIGINAL_INSN(getspecial);
+{
+  VALUE val;
+  rb_num_t type = (rb_num_t)GET_OPERAND(2);
+  rb_num_t key = (rb_num_t)GET_OPERAND(1);
+
+  DEBUG_ENTER_INSN("getspecial");
+  ADD_PC(1+2);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_getspecial 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_getspecial_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(getspecial));
+  COLLECT_USAGE_OPERAND(BIN(getspecial), 0, key);
+  COLLECT_USAGE_OPERAND(BIN(getspecial), 1, type);
+{
+#line 141 "insns.def"
+    val = vm_getspecial(ec, GET_LEP(), key, type);
+
+#line 189 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_getspecial
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(getspecial);}}}
+INSN_ENTRY(setspecial){START_OF_ORIGINAL_INSN(setspecial);
+{
+  rb_num_t key = (rb_num_t)GET_OPERAND(1);
+  VALUE obj = TOPN(0);
+  DEBUG_ENTER_INSN("setspecial");
+  ADD_PC(1+1);
+  PREFETCH(GET_PC());
+  POPN(1);
+  #define CURRENT_INSN_setspecial 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_setspecial_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(setspecial));
+  COLLECT_USAGE_OPERAND(BIN(setspecial), 0, key);
+{
+#line 155 "insns.def"
+    lep_svar_set(ec, GET_LEP(), key, obj);
+
+#line 215 "vm.inc"
+#undef CURRENT_INSN_setspecial
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(setspecial);}}}
+INSN_ENTRY(getinstancevariable){START_OF_ORIGINAL_INSN(getinstancevariable);
+{
+  VALUE val;
+  IC ic = (IC)GET_OPERAND(2);
+  ID id = (ID)GET_OPERAND(1);
+
+  DEBUG_ENTER_INSN("getinstancevariable");
+  ADD_PC(1+2);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_getinstancevariable 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_getinstancevariable_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(getinstancevariable));
+  COLLECT_USAGE_OPERAND(BIN(getinstancevariable), 0, id);
+  COLLECT_USAGE_OPERAND(BIN(getinstancevariable), 1, ic);
+{
+#line 169 "insns.def"
+    val = vm_getinstancevariable(GET_SELF(), id, ic);
+
+#line 241 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_getinstancevariable
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(getinstancevariable);}}}
+INSN_ENTRY(setinstancevariable){START_OF_ORIGINAL_INSN(setinstancevariable);
+{
+  IC ic = (IC)GET_OPERAND(2);
+  ID id = (ID)GET_OPERAND(1);
+  VALUE val = TOPN(0);
+  DEBUG_ENTER_INSN("setinstancevariable");
+  ADD_PC(1+2);
+  PREFETCH(GET_PC());
+  POPN(1);
+  #define CURRENT_INSN_setinstancevariable 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_setinstancevariable_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(setinstancevariable));
+  COLLECT_USAGE_OPERAND(BIN(setinstancevariable), 0, id);
+  COLLECT_USAGE_OPERAND(BIN(setinstancevariable), 1, ic);
+{
+#line 183 "insns.def"
+    vm_setinstancevariable(GET_SELF(), id, val, ic);
+
+#line 269 "vm.inc"
+#undef CURRENT_INSN_setinstancevariable
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(setinstancevariable);}}}
+INSN_ENTRY(getclassvariable){START_OF_ORIGINAL_INSN(getclassvariable);
+{
+  VALUE val;
+  ID id = (ID)GET_OPERAND(1);
+
+  DEBUG_ENTER_INSN("getclassvariable");
+  ADD_PC(1+1);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_getclassvariable 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_getclassvariable_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(getclassvariable));
+  COLLECT_USAGE_OPERAND(BIN(getclassvariable), 0, id);
+{
+#line 197 "insns.def"
+    val = rb_cvar_get(vm_get_cvar_base(rb_vm_get_cref(GET_EP()), GET_CFP()), id);
+
+#line 293 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_getclassvariable
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(getclassvariable);}}}
+INSN_ENTRY(setclassvariable){START_OF_ORIGINAL_INSN(setclassvariable);
+{
+  ID id = (ID)GET_OPERAND(1);
+  VALUE val = TOPN(0);
+  DEBUG_ENTER_INSN("setclassvariable");
+  ADD_PC(1+1);
+  PREFETCH(GET_PC());
+  POPN(1);
+  #define CURRENT_INSN_setclassvariable 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_setclassvariable_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(setclassvariable));
+  COLLECT_USAGE_OPERAND(BIN(setclassvariable), 0, id);
+{
+#line 211 "insns.def"
+    vm_ensure_not_refinement_module(GET_SELF());
+    rb_cvar_set(vm_get_cvar_base(rb_vm_get_cref(GET_EP()), GET_CFP()), id, val);
+
+#line 320 "vm.inc"
+#undef CURRENT_INSN_setclassvariable
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(setclassvariable);}}}
+INSN_ENTRY(getconstant){START_OF_ORIGINAL_INSN(getconstant);
+{
+  VALUE val;
+  ID id = (ID)GET_OPERAND(1);
+  VALUE klass = TOPN(0);
+  DEBUG_ENTER_INSN("getconstant");
+  ADD_PC(1+1);
+  PREFETCH(GET_PC());
+  POPN(1);
+  #define CURRENT_INSN_getconstant 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_getconstant_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(getconstant));
+  COLLECT_USAGE_OPERAND(BIN(getconstant), 0, id);
+{
+#line 233 "insns.def"
+    val = vm_get_ev_const(ec, klass, id, 0);
+
+#line 345 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_getconstant
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(getconstant);}}}
+INSN_ENTRY(setconstant){START_OF_ORIGINAL_INSN(setconstant);
+{
+  ID id = (ID)GET_OPERAND(1);
+  VALUE val = TOPN(1);
+  VALUE cbase = TOPN(0);
+  DEBUG_ENTER_INSN("setconstant");
+  ADD_PC(1+1);
+  PREFETCH(GET_PC());
+  POPN(2);
+  #define CURRENT_INSN_setconstant 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_setconstant_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(setconstant));
+  COLLECT_USAGE_OPERAND(BIN(setconstant), 0, id);
+{
+#line 255 "insns.def"
+    vm_check_if_namespace(cbase);
+    vm_ensure_not_refinement_module(GET_SELF());
+    rb_const_set(cbase, id, val);
+
+#line 374 "vm.inc"
+#undef CURRENT_INSN_setconstant
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(setconstant);}}}
+INSN_ENTRY(getglobal){START_OF_ORIGINAL_INSN(getglobal);
+{
+  VALUE val;
+  GENTRY entry = (GENTRY)GET_OPERAND(1);
+
+  DEBUG_ENTER_INSN("getglobal");
+  ADD_PC(1+1);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_getglobal 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_getglobal_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(getglobal));
+  COLLECT_USAGE_OPERAND(BIN(getglobal), 0, entry);
+{
+#line 271 "insns.def"
+    val = GET_GLOBAL((VALUE)entry);
+
+#line 398 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_getglobal
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(getglobal);}}}
+INSN_ENTRY(setglobal){START_OF_ORIGINAL_INSN(setglobal);
+{
+  GENTRY entry = (GENTRY)GET_OPERAND(1);
+  VALUE val = TOPN(0);
+  DEBUG_ENTER_INSN("setglobal");
+  ADD_PC(1+1);
+  PREFETCH(GET_PC());
+  POPN(1);
+  #define CURRENT_INSN_setglobal 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_setglobal_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(setglobal));
+  COLLECT_USAGE_OPERAND(BIN(setglobal), 0, entry);
+{
+#line 285 "insns.def"
+    SET_GLOBAL((VALUE)entry, val);
+
+#line 424 "vm.inc"
+#undef CURRENT_INSN_setglobal
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(setglobal);}}}
+INSN_ENTRY(putnil){START_OF_ORIGINAL_INSN(putnil);
+{
+  VALUE val;
+
+
+  DEBUG_ENTER_INSN("putnil");
+  ADD_PC(1+0);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_putnil 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_putnil_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(putnil));
+{
+#line 304 "insns.def"
+    val = Qnil;
+
+#line 447 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_putnil
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(putnil);}}}
+INSN_ENTRY(putself){START_OF_ORIGINAL_INSN(putself);
+{
+  VALUE val;
+
+
+  DEBUG_ENTER_INSN("putself");
+  ADD_PC(1+0);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_putself 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_putself_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(putself));
+{
+#line 318 "insns.def"
+    val = GET_SELF();
+
+#line 472 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_putself
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(putself);}}}
+INSN_ENTRY(putobject){START_OF_ORIGINAL_INSN(putobject);
+{
+  VALUE val = (VALUE)GET_OPERAND(1);
+
+  DEBUG_ENTER_INSN("putobject");
+  ADD_PC(1+1);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_putobject 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_putobject_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(putobject));
+  COLLECT_USAGE_OPERAND(BIN(putobject), 0, val);
+{
+#line 334 "insns.def"
+    /* */
+
+#line 497 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_putobject
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(putobject);}}}
+INSN_ENTRY(putspecialobject){START_OF_ORIGINAL_INSN(putspecialobject);
+{
+  VALUE val;
+  rb_num_t value_type = (rb_num_t)GET_OPERAND(1);
+
+  DEBUG_ENTER_INSN("putspecialobject");
+  ADD_PC(1+1);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_putspecialobject 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_putspecialobject_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(putspecialobject));
+  COLLECT_USAGE_OPERAND(BIN(putspecialobject), 0, value_type);
+{
+#line 349 "insns.def"
+    enum vm_special_object_type type;
+
+    type = (enum vm_special_object_type)value_type;
+    val = vm_get_special_object(GET_EP(), type);
+
+#line 526 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_putspecialobject
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(putspecialobject);}}}
+INSN_ENTRY(putiseq){START_OF_ORIGINAL_INSN(putiseq);
+{
+  VALUE ret;
+  ISEQ iseq = (ISEQ)GET_OPERAND(1);
+
+  DEBUG_ENTER_INSN("putiseq");
+  ADD_PC(1+1);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_putiseq 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_putiseq_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(putiseq));
+  COLLECT_USAGE_OPERAND(BIN(putiseq), 0, iseq);
+{
+#line 366 "insns.def"
+    ret = (VALUE)iseq;
+
+#line 552 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(ret);
+#undef CURRENT_INSN_putiseq
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(putiseq);}}}
+INSN_ENTRY(putstring){START_OF_ORIGINAL_INSN(putstring);
+{
+  VALUE val;
+  VALUE str = (VALUE)GET_OPERAND(1);
+
+  DEBUG_ENTER_INSN("putstring");
+  ADD_PC(1+1);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_putstring 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_putstring_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(putstring));
+  COLLECT_USAGE_OPERAND(BIN(putstring), 0, str);
+{
+#line 380 "insns.def"
+    val = rb_str_resurrect(str);
+
+#line 578 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_putstring
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(putstring);}}}
+INSN_ENTRY(concatstrings){START_OF_ORIGINAL_INSN(concatstrings);
+{
+  VALUE val;
+  rb_num_t num = (rb_num_t)GET_OPERAND(1);
+
+  DEBUG_ENTER_INSN("concatstrings");
+  ADD_PC(1+1);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_concatstrings 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_concatstrings_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(concatstrings));
+  COLLECT_USAGE_OPERAND(BIN(concatstrings), 0, num);
+{
+#line 394 "insns.def"
+    val = rb_str_concat_literals(num, STACK_ADDR_FROM_TOP(num));
+    POPN(num);
+
+#line 605 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_concatstrings
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(concatstrings);}}}
+INSN_ENTRY(tostring){START_OF_ORIGINAL_INSN(tostring);
+{
+
+  VALUE val = TOPN(1);
+  VALUE str = TOPN(0);
+  DEBUG_ENTER_INSN("tostring");
+  ADD_PC(1+0);
+  PREFETCH(GET_PC());
+  POPN(2);
+  #define CURRENT_INSN_tostring 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_tostring_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(tostring));
+{
+#line 409 "insns.def"
+    VALUE rb_obj_as_string_result(VALUE str, VALUE obj);
+    val = rb_obj_as_string_result(str, val);
+
+#line 632 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_tostring
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(tostring);}}}
+INSN_ENTRY(freezestring){START_OF_ORIGINAL_INSN(freezestring);
+{
+  VALUE debug_info = (VALUE)GET_OPERAND(1);
+  VALUE str = TOPN(0);
+  DEBUG_ENTER_INSN("freezestring");
+  ADD_PC(1+1);
+  PREFETCH(GET_PC());
+  POPN(1);
+  #define CURRENT_INSN_freezestring 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_freezestring_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(freezestring));
+  COLLECT_USAGE_OPERAND(BIN(freezestring), 0, debug_info);
+{
+#line 424 "insns.def"
+    vm_freezestring(str, debug_info);
+
+#line 658 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(str);
+#undef CURRENT_INSN_freezestring
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(freezestring);}}}
+INSN_ENTRY(toregexp){START_OF_ORIGINAL_INSN(toregexp);
+{
+  VALUE val;
+  rb_num_t cnt = (rb_num_t)GET_OPERAND(2);
+  rb_num_t opt = (rb_num_t)GET_OPERAND(1);
+
+  DEBUG_ENTER_INSN("toregexp");
+  ADD_PC(1+2);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_toregexp 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_toregexp_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(toregexp));
+  COLLECT_USAGE_OPERAND(BIN(toregexp), 0, opt);
+  COLLECT_USAGE_OPERAND(BIN(toregexp), 1, cnt);
+{
+#line 440 "insns.def"
+    VALUE rb_reg_new_ary(VALUE ary, int options);
+    VALUE rb_ary_tmp_new_from_values(VALUE, long, const VALUE *);
+    const VALUE ary = rb_ary_tmp_new_from_values(0, cnt, STACK_ADDR_FROM_TOP(cnt));
+    POPN(cnt);
+    val = rb_reg_new_ary(ary, (int)opt);
+    rb_ary_clear(ary);
+
+#line 691 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_toregexp
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(toregexp);}}}
+INSN_ENTRY(intern){START_OF_ORIGINAL_INSN(intern);
+{
+  VALUE sym;
+
+  VALUE str = TOPN(0);
+  DEBUG_ENTER_INSN("intern");
+  ADD_PC(1+0);
+  PREFETCH(GET_PC());
+  POPN(1);
+  #define CURRENT_INSN_intern 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_intern_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(intern));
+{
+#line 459 "insns.def"
+    sym = rb_str_intern(str);
+
+#line 717 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(sym);
+#undef CURRENT_INSN_intern
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(intern);}}}
+INSN_ENTRY(newarray){START_OF_ORIGINAL_INSN(newarray);
+{
+  VALUE val;
+  rb_num_t num = (rb_num_t)GET_OPERAND(1);
+
+  DEBUG_ENTER_INSN("newarray");
+  ADD_PC(1+1);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_newarray 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_newarray_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(newarray));
+  COLLECT_USAGE_OPERAND(BIN(newarray), 0, num);
+{
+#line 473 "insns.def"
+    val = rb_ary_new4(num, STACK_ADDR_FROM_TOP(num));
+    POPN(num);
+
+#line 744 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_newarray
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(newarray);}}}
+INSN_ENTRY(duparray){START_OF_ORIGINAL_INSN(duparray);
+{
+  VALUE val;
+  VALUE ary = (VALUE)GET_OPERAND(1);
+
+  DEBUG_ENTER_INSN("duparray");
+  ADD_PC(1+1);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_duparray 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_duparray_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(duparray));
+  COLLECT_USAGE_OPERAND(BIN(duparray), 0, ary);
+{
+#line 488 "insns.def"
+    val = rb_ary_resurrect(ary);
+
+#line 770 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_duparray
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(duparray);}}}
+INSN_ENTRY(expandarray){START_OF_ORIGINAL_INSN(expandarray);
+{
+  rb_num_t flag = (rb_num_t)GET_OPERAND(2);
+  rb_num_t num = (rb_num_t)GET_OPERAND(1);
+  VALUE ary = TOPN(0);
+  DEBUG_ENTER_INSN("expandarray");
+  ADD_PC(1+2);
+  PREFETCH(GET_PC());
+  POPN(1);
+  #define CURRENT_INSN_expandarray 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_expandarray_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(expandarray));
+  COLLECT_USAGE_OPERAND(BIN(expandarray), 0, num);
+  COLLECT_USAGE_OPERAND(BIN(expandarray), 1, flag);
+{
+#line 516 "insns.def"
+    vm_expandarray(GET_CFP(), ary, num, (int)flag);
+
+#line 798 "vm.inc"
+#undef CURRENT_INSN_expandarray
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(expandarray);}}}
+INSN_ENTRY(concatarray){START_OF_ORIGINAL_INSN(concatarray);
+{
+  VALUE ary;
+
+  VALUE ary1 = TOPN(1);
+  VALUE ary2 = TOPN(0);
+  DEBUG_ENTER_INSN("concatarray");
+  ADD_PC(1+0);
+  PREFETCH(GET_PC());
+  POPN(2);
+  #define CURRENT_INSN_concatarray 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_concatarray_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(concatarray));
+{
+#line 530 "insns.def"
+    ary = vm_concat_array(ary1, ary2);
+
+#line 823 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(ary);
+#undef CURRENT_INSN_concatarray
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(concatarray);}}}
+INSN_ENTRY(splatarray){START_OF_ORIGINAL_INSN(splatarray);
+{
+  VALUE obj;
+  VALUE flag = (VALUE)GET_OPERAND(1);
+  VALUE ary = TOPN(0);
+  DEBUG_ENTER_INSN("splatarray");
+  ADD_PC(1+1);
+  PREFETCH(GET_PC());
+  POPN(1);
+  #define CURRENT_INSN_splatarray 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_splatarray_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(splatarray));
+  COLLECT_USAGE_OPERAND(BIN(splatarray), 0, flag);
+{
+#line 544 "insns.def"
+    obj = vm_splat_array(flag, ary);
+
+#line 850 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(obj);
+#undef CURRENT_INSN_splatarray
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(splatarray);}}}
+INSN_ENTRY(newhash){START_OF_ORIGINAL_INSN(newhash);
+{
+  VALUE val;
+  rb_num_t num = (rb_num_t)GET_OPERAND(1);
+
+  DEBUG_ENTER_INSN("newhash");
+  ADD_PC(1+1);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_newhash 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_newhash_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(newhash));
+  COLLECT_USAGE_OPERAND(BIN(newhash), 0, num);
+{
+#line 559 "insns.def"
+    RUBY_DTRACE_CREATE_HOOK(HASH, num);
+
+    val = rb_hash_new_with_size(num / 2);
+
+    if (num) {
+        rb_hash_bulk_insert(num, STACK_ADDR_FROM_TOP(num), val);
+    }
+    POPN(num);
+
+#line 883 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_newhash
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(newhash);}}}
+INSN_ENTRY(newrange){START_OF_ORIGINAL_INSN(newrange);
+{
+  VALUE val;
+  rb_num_t flag = (rb_num_t)GET_OPERAND(1);
+  VALUE low = TOPN(1);
+  VALUE high = TOPN(0);
+  DEBUG_ENTER_INSN("newrange");
+  ADD_PC(1+1);
+  PREFETCH(GET_PC());
+  POPN(2);
+  #define CURRENT_INSN_newrange 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_newrange_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(newrange));
+  COLLECT_USAGE_OPERAND(BIN(newrange), 0, flag);
+{
+#line 580 "insns.def"
+    val = rb_range_new(low, high, (int)flag);
+
+#line 911 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_newrange
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(newrange);}}}
+INSN_ENTRY(pop){START_OF_ORIGINAL_INSN(pop);
+{
+
+  VALUE val = TOPN(0);
+  DEBUG_ENTER_INSN("pop");
+  ADD_PC(1+0);
+  PREFETCH(GET_PC());
+  POPN(1);
+  #define CURRENT_INSN_pop 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_pop_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(pop));
+{
+#line 598 "insns.def"
+    (void)val;
+    /* none */
+
+#line 937 "vm.inc"
+#undef CURRENT_INSN_pop
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(pop);}}}
+INSN_ENTRY(dup){START_OF_ORIGINAL_INSN(dup);
+{
+  VALUE val2;
+  VALUE val1;
+
+  VALUE val = TOPN(0);
+  DEBUG_ENTER_INSN("dup");
+  ADD_PC(1+0);
+  PREFETCH(GET_PC());
+  POPN(1);
+  #define CURRENT_INSN_dup 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_dup_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(dup));
+{
+#line 613 "insns.def"
+    val1 = val2 = val;
+
+#line 962 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 2);
+  PUSH(val1);
+  PUSH(val2);
+#undef CURRENT_INSN_dup
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(dup);}}}
+INSN_ENTRY(dupn){START_OF_ORIGINAL_INSN(dupn);
+{
+  rb_num_t n = (rb_num_t)GET_OPERAND(1);
+
+  DEBUG_ENTER_INSN("dupn");
+  ADD_PC(1+1);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_dupn 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_dupn_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(dupn));
+  COLLECT_USAGE_OPERAND(BIN(dupn), 0, n);
+{
+#line 627 "insns.def"
+    void *dst = GET_SP();
+    void *src = STACK_ADDR_FROM_TOP(n);
+
+    INC_SP(n); /* alloca */
+    MEMCPY(dst, src, VALUE, n);
+
+#line 992 "vm.inc"
+#undef CURRENT_INSN_dupn
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(dupn);}}}
+INSN_ENTRY(swap){START_OF_ORIGINAL_INSN(swap);
+{
+
+  VALUE val = TOPN(1);
+  VALUE obj = TOPN(0);
+  DEBUG_ENTER_INSN("swap");
+  ADD_PC(1+0);
+  PREFETCH(GET_PC());
+  POPN(2);
+  #define CURRENT_INSN_swap 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_swap_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(swap));
+{
+#line 646 "insns.def"
+    /* none */
+
+#line 1016 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 2);
+  PUSH(obj);
+  PUSH(val);
+#undef CURRENT_INSN_swap
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(swap);}}}
+INSN_ENTRY(reverse){START_OF_ORIGINAL_INSN(reverse);
+{
+  rb_num_t n = (rb_num_t)GET_OPERAND(1);
+
+  DEBUG_ENTER_INSN("reverse");
+  ADD_PC(1+1);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_reverse 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_reverse_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(reverse));
+  COLLECT_USAGE_OPERAND(BIN(reverse), 0, n);
+{
+#line 660 "insns.def"
+    rb_num_t i;
+    VALUE *sp = STACK_ADDR_FROM_TOP(n);
+
+    for (i=0; i<n/2; i++) {
+	VALUE v0 = sp[i];
+	VALUE v1 = TOPN(i);
+	sp[i] = v1;
+	TOPN(i) = v0;
+    }
+
+#line 1050 "vm.inc"
+#undef CURRENT_INSN_reverse
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(reverse);}}}
+INSN_ENTRY(reput){START_OF_ORIGINAL_INSN(reput);
+{
+
+  VALUE val = TOPN(0);
+  DEBUG_ENTER_INSN("reput");
+  ADD_PC(1+0);
+  PREFETCH(GET_PC());
+  POPN(1);
+  #define CURRENT_INSN_reput 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_reput_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(reput));
+{
+#line 682 "insns.def"
+    /* none */
+
+#line 1073 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_reput
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(reput);}}}
+INSN_ENTRY(topn){START_OF_ORIGINAL_INSN(topn);
+{
+  VALUE val;
+  rb_num_t n = (rb_num_t)GET_OPERAND(1);
+
+  DEBUG_ENTER_INSN("topn");
+  ADD_PC(1+1);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_topn 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_topn_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(topn));
+  COLLECT_USAGE_OPERAND(BIN(topn), 0, n);
+{
+#line 696 "insns.def"
+    val = TOPN(n);
+
+#line 1099 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_topn
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(topn);}}}
+INSN_ENTRY(setn){START_OF_ORIGINAL_INSN(setn);
+{
+  rb_num_t n = (rb_num_t)GET_OPERAND(1);
+  VALUE val = TOPN(0);
+  DEBUG_ENTER_INSN("setn");
+  ADD_PC(1+1);
+  PREFETCH(GET_PC());
+  POPN(1);
+  #define CURRENT_INSN_setn 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_setn_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(setn));
+  COLLECT_USAGE_OPERAND(BIN(setn), 0, n);
+{
+#line 710 "insns.def"
+    TOPN(n-1) = val;
+
+#line 1125 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_setn
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(setn);}}}
+INSN_ENTRY(adjuststack){START_OF_ORIGINAL_INSN(adjuststack);
+{
+  rb_num_t n = (rb_num_t)GET_OPERAND(1);
+
+  DEBUG_ENTER_INSN("adjuststack");
+  ADD_PC(1+1);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_adjuststack 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_adjuststack_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(adjuststack));
+  COLLECT_USAGE_OPERAND(BIN(adjuststack), 0, n);
+{
+#line 724 "insns.def"
+    DEC_SP(n);
+
+#line 1150 "vm.inc"
+#undef CURRENT_INSN_adjuststack
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(adjuststack);}}}
+INSN_ENTRY(defined){START_OF_ORIGINAL_INSN(defined);
+{
+  VALUE val;
+  VALUE needstr = (VALUE)GET_OPERAND(3);
+  VALUE obj = (VALUE)GET_OPERAND(2);
+  rb_num_t op_type = (rb_num_t)GET_OPERAND(1);
+  VALUE v = TOPN(0);
+  DEBUG_ENTER_INSN("defined");
+  ADD_PC(1+3);
+  PREFETCH(GET_PC());
+  POPN(1);
+  #define CURRENT_INSN_defined 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_defined_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(defined));
+  COLLECT_USAGE_OPERAND(BIN(defined), 0, op_type);
+  COLLECT_USAGE_OPERAND(BIN(defined), 1, obj);
+  COLLECT_USAGE_OPERAND(BIN(defined), 2, needstr);
+{
+#line 743 "insns.def"
+    val = vm_defined(ec, GET_CFP(), op_type, obj, needstr, v);
+
+#line 1179 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_defined
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(defined);}}}
+INSN_ENTRY(checkmatch){START_OF_ORIGINAL_INSN(checkmatch);
+{
+  VALUE result;
+  rb_num_t flag = (rb_num_t)GET_OPERAND(1);
+  VALUE target = TOPN(1);
+  VALUE pattern = TOPN(0);
+  DEBUG_ENTER_INSN("checkmatch");
+  ADD_PC(1+1);
+  PREFETCH(GET_PC());
+  POPN(2);
+  #define CURRENT_INSN_checkmatch 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_checkmatch_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(checkmatch));
+  COLLECT_USAGE_OPERAND(BIN(checkmatch), 0, flag);
+{
+#line 762 "insns.def"
+    result = vm_check_match(ec, target, pattern, flag);
+
+#line 1207 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(result);
+#undef CURRENT_INSN_checkmatch
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(checkmatch);}}}
+INSN_ENTRY(checkkeyword){START_OF_ORIGINAL_INSN(checkkeyword);
+{
+  VALUE ret;
+  lindex_t keyword_index = (lindex_t)GET_OPERAND(2);
+  lindex_t kw_bits_index = (lindex_t)GET_OPERAND(1);
+
+  DEBUG_ENTER_INSN("checkkeyword");
+  ADD_PC(1+2);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_checkkeyword 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_checkkeyword_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(checkkeyword));
+  COLLECT_USAGE_OPERAND(BIN(checkkeyword), 0, kw_bits_index);
+  COLLECT_USAGE_OPERAND(BIN(checkkeyword), 1, keyword_index);
+{
+#line 776 "insns.def"
+    ret = vm_check_keyword(kw_bits_index, keyword_index, GET_EP());
+
+#line 1235 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(ret);
+#undef CURRENT_INSN_checkkeyword
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(checkkeyword);}}}
+INSN_ENTRY(tracecoverage){START_OF_ORIGINAL_INSN(tracecoverage);
+{
+  VALUE data = (VALUE)GET_OPERAND(2);
+  rb_num_t nf = (rb_num_t)GET_OPERAND(1);
+
+  DEBUG_ENTER_INSN("tracecoverage");
+  ADD_PC(1+2);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_tracecoverage 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_tracecoverage_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(tracecoverage));
+  COLLECT_USAGE_OPERAND(BIN(tracecoverage), 0, nf);
+  COLLECT_USAGE_OPERAND(BIN(tracecoverage), 1, data);
+{
+#line 790 "insns.def"
+    rb_event_flag_t flag = (rb_event_flag_t)nf;
+
+    vm_dtrace(flag, ec);
+    EXEC_EVENT_HOOK(ec, flag, GET_SELF(), 0, 0, 0 /* id and klass are resolved at callee */, data);
+
+#line 1265 "vm.inc"
+#undef CURRENT_INSN_tracecoverage
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(tracecoverage);}}}
+INSN_ENTRY(defineclass){START_OF_ORIGINAL_INSN(defineclass);
+{
+  VALUE val;
+  rb_num_t flags = (rb_num_t)GET_OPERAND(3);
+  ISEQ class_iseq = (ISEQ)GET_OPERAND(2);
+  ID id = (ID)GET_OPERAND(1);
+  VALUE cbase = TOPN(1);
+  VALUE super = TOPN(0);
+  DEBUG_ENTER_INSN("defineclass");
+  ADD_PC(1+3);
+  PREFETCH(GET_PC());
+  POPN(2);
+  #define CURRENT_INSN_defineclass 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_defineclass_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(defineclass));
+  COLLECT_USAGE_OPERAND(BIN(defineclass), 0, id);
+  COLLECT_USAGE_OPERAND(BIN(defineclass), 1, class_iseq);
+  COLLECT_USAGE_OPERAND(BIN(defineclass), 2, flags);
+{
+#line 815 "insns.def"
+    VALUE klass = vm_find_or_create_class_by_id(id, flags, cbase, super);
+
+    rb_iseq_check(class_iseq);
+
+    /* enter scope */
+    vm_push_frame(ec, class_iseq, VM_FRAME_MAGIC_CLASS | VM_ENV_FLAG_LOCAL, klass,
+		  GET_BLOCK_HANDLER(),
+		  (VALUE)vm_cref_push(ec, klass, NULL, FALSE),
+		  class_iseq->body->iseq_encoded, GET_SP(),
+		  class_iseq->body->local_table_size,
+		  class_iseq->body->stack_max);
+    RESTORE_REGS();
+    NEXT_INSN();
+
+#line 1307 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_defineclass
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(defineclass);}}}
+INSN_ENTRY(send){START_OF_ORIGINAL_INSN(send);
+{
+  VALUE val;
+  ISEQ blockiseq = (ISEQ)GET_OPERAND(3);
+  CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
+  CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
+
+  DEBUG_ENTER_INSN("send");
+  ADD_PC(1+3);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_send 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_send_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(send));
+  COLLECT_USAGE_OPERAND(BIN(send), 0, ci);
+  COLLECT_USAGE_OPERAND(BIN(send), 1, cc);
+  COLLECT_USAGE_OPERAND(BIN(send), 2, blockiseq);
+{
+#line 846 "insns.def"
+    struct rb_calling_info calling;
+
+    vm_caller_setup_arg_block(ec, reg_cfp, &calling, ci, blockiseq, FALSE);
+    vm_search_method(ci, cc, calling.recv = TOPN(calling.argc = ci->orig_argc));
+    CALL_METHOD(&calling, ci, cc);
+
+#line 1341 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_send
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(send);}}}
+INSN_ENTRY(opt_str_freeze){START_OF_ORIGINAL_INSN(opt_str_freeze);
+{
+  VALUE val;
+  VALUE str = (VALUE)GET_OPERAND(1);
+
+  DEBUG_ENTER_INSN("opt_str_freeze");
+  ADD_PC(1+1);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_opt_str_freeze 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_opt_str_freeze_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(opt_str_freeze));
+  COLLECT_USAGE_OPERAND(BIN(opt_str_freeze), 0, str);
+{
+#line 859 "insns.def"
+    if (BASIC_OP_UNREDEFINED_P(BOP_FREEZE, STRING_REDEFINED_OP_FLAG)) {
+	val = str;
+    }
+    else {
+	val = rb_funcall(rb_str_resurrect(str), idFreeze, 0);
+    }
+
+#line 1372 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_opt_str_freeze
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(opt_str_freeze);}}}
+INSN_ENTRY(opt_str_uminus){START_OF_ORIGINAL_INSN(opt_str_uminus);
+{
+  VALUE val;
+  VALUE str = (VALUE)GET_OPERAND(1);
+
+  DEBUG_ENTER_INSN("opt_str_uminus");
+  ADD_PC(1+1);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_opt_str_uminus 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_opt_str_uminus_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(opt_str_uminus));
+  COLLECT_USAGE_OPERAND(BIN(opt_str_uminus), 0, str);
+{
+#line 873 "insns.def"
+    if (BASIC_OP_UNREDEFINED_P(BOP_UMINUS, STRING_REDEFINED_OP_FLAG)) {
+	val = str;
+    }
+    else {
+	val = rb_funcall(rb_str_resurrect(str), idUMinus, 0);
+    }
+
+#line 1403 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_opt_str_uminus
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(opt_str_uminus);}}}
+INSN_ENTRY(opt_newarray_max){START_OF_ORIGINAL_INSN(opt_newarray_max);
+{
+  VALUE val;
+  rb_num_t num = (rb_num_t)GET_OPERAND(1);
+
+  DEBUG_ENTER_INSN("opt_newarray_max");
+  ADD_PC(1+1);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_opt_newarray_max 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_opt_newarray_max_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(opt_newarray_max));
+  COLLECT_USAGE_OPERAND(BIN(opt_newarray_max), 0, num);
+{
+#line 887 "insns.def"
+    val = vm_opt_newarray_max(num, STACK_ADDR_FROM_TOP(num));
+    POPN(num);
+
+#line 1430 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_opt_newarray_max
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(opt_newarray_max);}}}
+INSN_ENTRY(opt_newarray_min){START_OF_ORIGINAL_INSN(opt_newarray_min);
+{
+  VALUE val;
+  rb_num_t num = (rb_num_t)GET_OPERAND(1);
+
+  DEBUG_ENTER_INSN("opt_newarray_min");
+  ADD_PC(1+1);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_opt_newarray_min 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_opt_newarray_min_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(opt_newarray_min));
+  COLLECT_USAGE_OPERAND(BIN(opt_newarray_min), 0, num);
+{
+#line 897 "insns.def"
+    val = vm_opt_newarray_min(num, STACK_ADDR_FROM_TOP(num));
+    POPN(num);
+
+#line 1457 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_opt_newarray_min
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(opt_newarray_min);}}}
+INSN_ENTRY(opt_send_without_block){START_OF_ORIGINAL_INSN(opt_send_without_block);
+{
+  VALUE val;
+  CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
+  CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
+
+  DEBUG_ENTER_INSN("opt_send_without_block");
+  ADD_PC(1+2);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_opt_send_without_block 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_opt_send_without_block_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(opt_send_without_block));
+  COLLECT_USAGE_OPERAND(BIN(opt_send_without_block), 0, ci);
+  COLLECT_USAGE_OPERAND(BIN(opt_send_without_block), 1, cc);
+{
+#line 912 "insns.def"
+    struct rb_calling_info calling;
+    calling.block_handler = VM_BLOCK_HANDLER_NONE;
+    vm_search_method(ci, cc, calling.recv = TOPN(calling.argc = ci->orig_argc));
+    CALL_METHOD(&calling, ci, cc);
+
+#line 1488 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_opt_send_without_block
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(opt_send_without_block);}}}
+INSN_ENTRY(invokesuper){START_OF_ORIGINAL_INSN(invokesuper);
+{
+  VALUE val;
+  ISEQ blockiseq = (ISEQ)GET_OPERAND(3);
+  CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
+  CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
+
+  DEBUG_ENTER_INSN("invokesuper");
+  ADD_PC(1+3);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_invokesuper 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_invokesuper_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(invokesuper));
+  COLLECT_USAGE_OPERAND(BIN(invokesuper), 0, ci);
+  COLLECT_USAGE_OPERAND(BIN(invokesuper), 1, cc);
+  COLLECT_USAGE_OPERAND(BIN(invokesuper), 2, blockiseq);
+{
+#line 929 "insns.def"
+    struct rb_calling_info calling;
+    calling.argc = ci->orig_argc;
+
+    vm_caller_setup_arg_block(ec, reg_cfp, &calling, ci, blockiseq, TRUE);
+    calling.recv = GET_SELF();
+    vm_search_super_method(ec, GET_CFP(), &calling, ci, cc);
+    CALL_METHOD(&calling, ci, cc);
+
+#line 1524 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_invokesuper
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(invokesuper);}}}
+INSN_ENTRY(invokeblock){START_OF_ORIGINAL_INSN(invokeblock);
+{
+  VALUE val;
+  CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
+
+  DEBUG_ENTER_INSN("invokeblock");
+  ADD_PC(1+1);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_invokeblock 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_invokeblock_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(invokeblock));
+  COLLECT_USAGE_OPERAND(BIN(invokeblock), 0, ci);
+{
+#line 949 "insns.def"
+    struct rb_calling_info calling;
+    calling.argc = ci->orig_argc;
+    calling.block_handler = VM_BLOCK_HANDLER_NONE;
+    calling.recv = GET_SELF();
+
+    val = vm_invoke_block(ec, GET_CFP(), &calling, ci);
+    if (val == Qundef) {
+	RESTORE_REGS();
+	NEXT_INSN();
+    }
+
+#line 1559 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_invokeblock
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(invokeblock);}}}
+INSN_ENTRY(leave){START_OF_ORIGINAL_INSN(leave);
+{
+
+  VALUE val = TOPN(0);
+  DEBUG_ENTER_INSN("leave");
+  ADD_PC(1+0);
+  PREFETCH(GET_PC());
+  POPN(1);
+  #define CURRENT_INSN_leave 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_leave_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(leave));
+{
+#line 972 "insns.def"
+    if (OPT_CHECKED_RUN) {
+	const VALUE *const bp = vm_base_ptr(reg_cfp);
+	if (reg_cfp->sp != bp) {
+	    vm_stack_consistency_error(ec, reg_cfp, bp);
+	}
+    }
+
+    RUBY_VM_CHECK_INTS(ec);
+
+    if (vm_pop_frame(ec, GET_CFP(), GET_EP())) {
+#if OPT_CALL_THREADED_CODE
+	rb_ec_thread_ptr(ec)->retval = val;
+	return 0;
+#else
+	return val;
+#endif
+    }
+    else {
+	RESTORE_REGS();
+    }
+
+#line 1603 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_leave
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(leave);}}}
+INSN_ENTRY(throw){START_OF_ORIGINAL_INSN(throw);
+{
+  VALUE val;
+  rb_num_t throw_state = (rb_num_t)GET_OPERAND(1);
+  VALUE throwobj = TOPN(0);
+  DEBUG_ENTER_INSN("throw");
+  ADD_PC(1+1);
+  PREFETCH(GET_PC());
+  POPN(1);
+  #define CURRENT_INSN_throw 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_throw_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(throw));
+  COLLECT_USAGE_OPERAND(BIN(throw), 0, throw_state);
+{
+#line 1009 "insns.def"
+    RUBY_VM_CHECK_INTS(ec);
+    val = vm_throw(ec, GET_CFP(), throw_state, throwobj);
+    THROW_EXCEPTION(val);
+    /* unreachable */
+
+#line 1633 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_throw
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(throw);}}}
+INSN_ENTRY(jump){START_OF_ORIGINAL_INSN(jump);
+{
+  OFFSET dst = (OFFSET)GET_OPERAND(1);
+
+  DEBUG_ENTER_INSN("jump");
+  ADD_PC(1+1);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_jump 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_jump_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(jump));
+  COLLECT_USAGE_OPERAND(BIN(jump), 0, dst);
+{
+#line 1030 "insns.def"
+    RUBY_VM_CHECK_INTS(ec);
+    JUMP(dst);
+
+#line 1659 "vm.inc"
+#undef CURRENT_INSN_jump
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(jump);}}}
+INSN_ENTRY(branchif){START_OF_ORIGINAL_INSN(branchif);
+{
+  OFFSET dst = (OFFSET)GET_OPERAND(1);
+  VALUE val = TOPN(0);
+  DEBUG_ENTER_INSN("branchif");
+  ADD_PC(1+1);
+  PREFETCH(GET_PC());
+  POPN(1);
+  #define CURRENT_INSN_branchif 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_branchif_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(branchif));
+  COLLECT_USAGE_OPERAND(BIN(branchif), 0, dst);
+{
+#line 1045 "insns.def"
+    if (RTEST(val)) {
+	RUBY_VM_CHECK_INTS(ec);
+	JUMP(dst);
+    }
+
+#line 1686 "vm.inc"
+#undef CURRENT_INSN_branchif
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(branchif);}}}
+INSN_ENTRY(branchunless){START_OF_ORIGINAL_INSN(branchunless);
+{
+  OFFSET dst = (OFFSET)GET_OPERAND(1);
+  VALUE val = TOPN(0);
+  DEBUG_ENTER_INSN("branchunless");
+  ADD_PC(1+1);
+  PREFETCH(GET_PC());
+  POPN(1);
+  #define CURRENT_INSN_branchunless 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_branchunless_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(branchunless));
+  COLLECT_USAGE_OPERAND(BIN(branchunless), 0, dst);
+{
+#line 1062 "insns.def"
+    if (!RTEST(val)) {
+	RUBY_VM_CHECK_INTS(ec);
+	JUMP(dst);
+    }
+
+#line 1713 "vm.inc"
+#undef CURRENT_INSN_branchunless
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(branchunless);}}}
+INSN_ENTRY(branchnil){START_OF_ORIGINAL_INSN(branchnil);
+{
+  OFFSET dst = (OFFSET)GET_OPERAND(1);
+  VALUE val = TOPN(0);
+  DEBUG_ENTER_INSN("branchnil");
+  ADD_PC(1+1);
+  PREFETCH(GET_PC());
+  POPN(1);
+  #define CURRENT_INSN_branchnil 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_branchnil_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(branchnil));
+  COLLECT_USAGE_OPERAND(BIN(branchnil), 0, dst);
+{
+#line 1079 "insns.def"
+    if (NIL_P(val)) {
+	RUBY_VM_CHECK_INTS(ec);
+	JUMP(dst);
+    }
+
+#line 1740 "vm.inc"
+#undef CURRENT_INSN_branchnil
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(branchnil);}}}
+INSN_ENTRY(branchiftype){START_OF_ORIGINAL_INSN(branchiftype);
+{
+  OFFSET dst = (OFFSET)GET_OPERAND(2);
+  rb_num_t type = (rb_num_t)GET_OPERAND(1);
+  VALUE val = TOPN(0);
+  DEBUG_ENTER_INSN("branchiftype");
+  ADD_PC(1+2);
+  PREFETCH(GET_PC());
+  POPN(1);
+  #define CURRENT_INSN_branchiftype 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_branchiftype_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(branchiftype));
+  COLLECT_USAGE_OPERAND(BIN(branchiftype), 0, type);
+  COLLECT_USAGE_OPERAND(BIN(branchiftype), 1, dst);
+{
+#line 1096 "insns.def"
+    if (TYPE(val) == (int)type) {
+	RUBY_VM_CHECK_INTS(ec);
+	JUMP(dst);
+    }
+
+#line 1769 "vm.inc"
+#undef CURRENT_INSN_branchiftype
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(branchiftype);}}}
+INSN_ENTRY(getinlinecache){START_OF_ORIGINAL_INSN(getinlinecache);
+{
+  VALUE val;
+  IC ic = (IC)GET_OPERAND(2);
+  OFFSET dst = (OFFSET)GET_OPERAND(1);
+
+  DEBUG_ENTER_INSN("getinlinecache");
+  ADD_PC(1+2);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_getinlinecache 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_getinlinecache_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(getinlinecache));
+  COLLECT_USAGE_OPERAND(BIN(getinlinecache), 0, dst);
+  COLLECT_USAGE_OPERAND(BIN(getinlinecache), 1, ic);
+{
+#line 1118 "insns.def"
+    val = vm_ic_hit_p(ic, GET_EP());
+    if (val != Qnil) {
+	JUMP(dst);
+    }
+
+#line 1798 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_getinlinecache
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(getinlinecache);}}}
+INSN_ENTRY(setinlinecache){START_OF_ORIGINAL_INSN(setinlinecache);
+{
+  IC ic = (IC)GET_OPERAND(1);
+  VALUE val = TOPN(0);
+  DEBUG_ENTER_INSN("setinlinecache");
+  ADD_PC(1+1);
+  PREFETCH(GET_PC());
+  POPN(1);
+  #define CURRENT_INSN_setinlinecache 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_setinlinecache_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(setinlinecache));
+  COLLECT_USAGE_OPERAND(BIN(setinlinecache), 0, ic);
+{
+#line 1135 "insns.def"
+    vm_ic_update(ic, val, GET_EP());
+
+#line 1824 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_setinlinecache
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(setinlinecache);}}}
+INSN_ENTRY(once){START_OF_ORIGINAL_INSN(once);
+{
+  VALUE val;
+  IC ic = (IC)GET_OPERAND(2);
+  ISEQ iseq = (ISEQ)GET_OPERAND(1);
+
+  DEBUG_ENTER_INSN("once");
+  ADD_PC(1+2);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_once 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_once_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(once));
+  COLLECT_USAGE_OPERAND(BIN(once), 0, iseq);
+  COLLECT_USAGE_OPERAND(BIN(once), 1, ic);
+{
+#line 1149 "insns.def"
+    val = vm_once_dispatch(ec, iseq, ic);
+
+#line 1852 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_once
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(once);}}}
+INSN_ENTRY(opt_case_dispatch){START_OF_ORIGINAL_INSN(opt_case_dispatch);
+{
+  OFFSET else_offset = (OFFSET)GET_OPERAND(2);
+  CDHASH hash = (CDHASH)GET_OPERAND(1);
+  VALUE key = TOPN(0);
+  DEBUG_ENTER_INSN("opt_case_dispatch");
+  ADD_PC(1+2);
+  PREFETCH(GET_PC());
+  POPN(1);
+  #define CURRENT_INSN_opt_case_dispatch 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_opt_case_dispatch_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(opt_case_dispatch));
+  COLLECT_USAGE_OPERAND(BIN(opt_case_dispatch), 0, hash);
+  COLLECT_USAGE_OPERAND(BIN(opt_case_dispatch), 1, else_offset);
+{
+#line 1163 "insns.def"
+    OFFSET dst = vm_case_dispatch(hash, else_offset, key);
+
+    if (dst) {
+	JUMP(dst);
+    }
+
+#line 1884 "vm.inc"
+#undef CURRENT_INSN_opt_case_dispatch
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(opt_case_dispatch);}}}
+INSN_ENTRY(opt_plus){START_OF_ORIGINAL_INSN(opt_plus);
+{
+  VALUE val;
+  CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
+  CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
+  VALUE recv = TOPN(1);
+  VALUE obj = TOPN(0);
+  DEBUG_ENTER_INSN("opt_plus");
+  ADD_PC(1+2);
+  PREFETCH(GET_PC());
+  POPN(2);
+  #define CURRENT_INSN_opt_plus 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_opt_plus_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(opt_plus));
+  COLLECT_USAGE_OPERAND(BIN(opt_plus), 0, ci);
+  COLLECT_USAGE_OPERAND(BIN(opt_plus), 1, cc);
+{
+#line 1183 "insns.def"
+    val = vm_opt_plus(recv, obj);
+
+    if (val == Qundef) {
+	/* other */
+	PUSH(recv);
+	PUSH(obj);
+	CALL_SIMPLE_METHOD(recv);
+    }
+
+#line 1919 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_opt_plus
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(opt_plus);}}}
+INSN_ENTRY(opt_minus){START_OF_ORIGINAL_INSN(opt_minus);
+{
+  VALUE val;
+  CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
+  CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
+  VALUE recv = TOPN(1);
+  VALUE obj = TOPN(0);
+  DEBUG_ENTER_INSN("opt_minus");
+  ADD_PC(1+2);
+  PREFETCH(GET_PC());
+  POPN(2);
+  #define CURRENT_INSN_opt_minus 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_opt_minus_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(opt_minus));
+  COLLECT_USAGE_OPERAND(BIN(opt_minus), 0, ci);
+  COLLECT_USAGE_OPERAND(BIN(opt_minus), 1, cc);
+{
+#line 1204 "insns.def"
+    val = vm_opt_minus(recv, obj);
+
+    if (val == Qundef) {
+	/* other */
+	PUSH(recv);
+	PUSH(obj);
+	CALL_SIMPLE_METHOD(recv);
+    }
+
+#line 1956 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_opt_minus
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(opt_minus);}}}
+INSN_ENTRY(opt_mult){START_OF_ORIGINAL_INSN(opt_mult);
+{
+  VALUE val;
+  CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
+  CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
+  VALUE recv = TOPN(1);
+  VALUE obj = TOPN(0);
+  DEBUG_ENTER_INSN("opt_mult");
+  ADD_PC(1+2);
+  PREFETCH(GET_PC());
+  POPN(2);
+  #define CURRENT_INSN_opt_mult 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_opt_mult_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(opt_mult));
+  COLLECT_USAGE_OPERAND(BIN(opt_mult), 0, ci);
+  COLLECT_USAGE_OPERAND(BIN(opt_mult), 1, cc);
+{
+#line 1225 "insns.def"
+    val = vm_opt_mult(recv, obj);
+
+    if (val == Qundef) {
+	/* other */
+	PUSH(recv);
+	PUSH(obj);
+	CALL_SIMPLE_METHOD(recv);
+    }
+
+#line 1993 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_opt_mult
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(opt_mult);}}}
+INSN_ENTRY(opt_div){START_OF_ORIGINAL_INSN(opt_div);
+{
+  VALUE val;
+  CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
+  CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
+  VALUE recv = TOPN(1);
+  VALUE obj = TOPN(0);
+  DEBUG_ENTER_INSN("opt_div");
+  ADD_PC(1+2);
+  PREFETCH(GET_PC());
+  POPN(2);
+  #define CURRENT_INSN_opt_div 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_opt_div_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(opt_div));
+  COLLECT_USAGE_OPERAND(BIN(opt_div), 0, ci);
+  COLLECT_USAGE_OPERAND(BIN(opt_div), 1, cc);
+{
+#line 1246 "insns.def"
+    val = vm_opt_div(recv, obj);
+
+    if (val == Qundef) {
+	/* other */
+	PUSH(recv);
+	PUSH(obj);
+	CALL_SIMPLE_METHOD(recv);
+    }
+
+#line 2030 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_opt_div
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(opt_div);}}}
+INSN_ENTRY(opt_mod){START_OF_ORIGINAL_INSN(opt_mod);
+{
+  VALUE val;
+  CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
+  CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
+  VALUE recv = TOPN(1);
+  VALUE obj = TOPN(0);
+  DEBUG_ENTER_INSN("opt_mod");
+  ADD_PC(1+2);
+  PREFETCH(GET_PC());
+  POPN(2);
+  #define CURRENT_INSN_opt_mod 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_opt_mod_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(opt_mod));
+  COLLECT_USAGE_OPERAND(BIN(opt_mod), 0, ci);
+  COLLECT_USAGE_OPERAND(BIN(opt_mod), 1, cc);
+{
+#line 1267 "insns.def"
+    val = vm_opt_mod(recv, obj);
+
+    if (val == Qundef) {
+	/* other */
+	PUSH(recv);
+	PUSH(obj);
+	CALL_SIMPLE_METHOD(recv);
+    }
+
+#line 2067 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_opt_mod
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(opt_mod);}}}
+INSN_ENTRY(opt_eq){START_OF_ORIGINAL_INSN(opt_eq);
+{
+  VALUE val;
+  CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
+  CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
+  VALUE recv = TOPN(1);
+  VALUE obj = TOPN(0);
+  DEBUG_ENTER_INSN("opt_eq");
+  ADD_PC(1+2);
+  PREFETCH(GET_PC());
+  POPN(2);
+  #define CURRENT_INSN_opt_eq 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_opt_eq_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(opt_eq));
+  COLLECT_USAGE_OPERAND(BIN(opt_eq), 0, ci);
+  COLLECT_USAGE_OPERAND(BIN(opt_eq), 1, cc);
+{
+#line 1288 "insns.def"
+    val = opt_eq_func(recv, obj, ci, cc);
+
+    if (val == Qundef) {
+	/* other */
+	PUSH(recv);
+	PUSH(obj);
+	CALL_SIMPLE_METHOD(recv);
+    }
+
+#line 2104 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_opt_eq
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(opt_eq);}}}
+INSN_ENTRY(opt_neq){START_OF_ORIGINAL_INSN(opt_neq);
+{
+  VALUE val;
+  CALL_CACHE cc_eq = (CALL_CACHE)GET_OPERAND(4);
+  CALL_INFO ci_eq = (CALL_INFO)GET_OPERAND(3);
+  CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
+  CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
+  VALUE recv = TOPN(1);
+  VALUE obj = TOPN(0);
+  DEBUG_ENTER_INSN("opt_neq");
+  ADD_PC(1+4);
+  PREFETCH(GET_PC());
+  POPN(2);
+  #define CURRENT_INSN_opt_neq 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_opt_neq_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(opt_neq));
+  COLLECT_USAGE_OPERAND(BIN(opt_neq), 0, ci);
+  COLLECT_USAGE_OPERAND(BIN(opt_neq), 1, cc);
+  COLLECT_USAGE_OPERAND(BIN(opt_neq), 2, ci_eq);
+  COLLECT_USAGE_OPERAND(BIN(opt_neq), 3, cc_eq);
+{
+#line 1309 "insns.def"
+    val = vm_opt_neq(ci, cc, ci_eq, cc_eq, recv, obj);
+
+    if (val == Qundef) {
+	/* other */
+	PUSH(recv);
+	PUSH(obj);
+	CALL_SIMPLE_METHOD(recv);
+    }
+
+#line 2145 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_opt_neq
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(opt_neq);}}}
+INSN_ENTRY(opt_lt){START_OF_ORIGINAL_INSN(opt_lt);
+{
+  VALUE val;
+  CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
+  CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
+  VALUE recv = TOPN(1);
+  VALUE obj = TOPN(0);
+  DEBUG_ENTER_INSN("opt_lt");
+  ADD_PC(1+2);
+  PREFETCH(GET_PC());
+  POPN(2);
+  #define CURRENT_INSN_opt_lt 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_opt_lt_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(opt_lt));
+  COLLECT_USAGE_OPERAND(BIN(opt_lt), 0, ci);
+  COLLECT_USAGE_OPERAND(BIN(opt_lt), 1, cc);
+{
+#line 1330 "insns.def"
+    val = vm_opt_lt(recv, obj);
+
+    if (val == Qundef) {
+	/* other */
+	PUSH(recv);
+	PUSH(obj);
+	CALL_SIMPLE_METHOD(recv);
+    }
+
+#line 2182 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_opt_lt
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(opt_lt);}}}
+INSN_ENTRY(opt_le){START_OF_ORIGINAL_INSN(opt_le);
+{
+  VALUE val;
+  CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
+  CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
+  VALUE recv = TOPN(1);
+  VALUE obj = TOPN(0);
+  DEBUG_ENTER_INSN("opt_le");
+  ADD_PC(1+2);
+  PREFETCH(GET_PC());
+  POPN(2);
+  #define CURRENT_INSN_opt_le 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_opt_le_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(opt_le));
+  COLLECT_USAGE_OPERAND(BIN(opt_le), 0, ci);
+  COLLECT_USAGE_OPERAND(BIN(opt_le), 1, cc);
+{
+#line 1351 "insns.def"
+    val = vm_opt_le(recv, obj);
+
+    if (val == Qundef) {
+	/* other */
+	PUSH(recv);
+	PUSH(obj);
+	CALL_SIMPLE_METHOD(recv);
+    }
+
+#line 2219 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_opt_le
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(opt_le);}}}
+INSN_ENTRY(opt_gt){START_OF_ORIGINAL_INSN(opt_gt);
+{
+  VALUE val;
+  CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
+  CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
+  VALUE recv = TOPN(1);
+  VALUE obj = TOPN(0);
+  DEBUG_ENTER_INSN("opt_gt");
+  ADD_PC(1+2);
+  PREFETCH(GET_PC());
+  POPN(2);
+  #define CURRENT_INSN_opt_gt 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_opt_gt_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(opt_gt));
+  COLLECT_USAGE_OPERAND(BIN(opt_gt), 0, ci);
+  COLLECT_USAGE_OPERAND(BIN(opt_gt), 1, cc);
+{
+#line 1372 "insns.def"
+    val = vm_opt_gt(recv, obj);
+
+    if (val == Qundef) {
+	/* other */
+	PUSH(recv);
+	PUSH(obj);
+	CALL_SIMPLE_METHOD(recv);
+    }
+
+#line 2256 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_opt_gt
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(opt_gt);}}}
+INSN_ENTRY(opt_ge){START_OF_ORIGINAL_INSN(opt_ge);
+{
+  VALUE val;
+  CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
+  CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
+  VALUE recv = TOPN(1);
+  VALUE obj = TOPN(0);
+  DEBUG_ENTER_INSN("opt_ge");
+  ADD_PC(1+2);
+  PREFETCH(GET_PC());
+  POPN(2);
+  #define CURRENT_INSN_opt_ge 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_opt_ge_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(opt_ge));
+  COLLECT_USAGE_OPERAND(BIN(opt_ge), 0, ci);
+  COLLECT_USAGE_OPERAND(BIN(opt_ge), 1, cc);
+{
+#line 1393 "insns.def"
+    val = vm_opt_ge(recv, obj);
+
+    if (val == Qundef) {
+	/* other */
+	PUSH(recv);
+	PUSH(obj);
+	CALL_SIMPLE_METHOD(recv);
+    }
+
+#line 2293 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_opt_ge
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(opt_ge);}}}
+INSN_ENTRY(opt_ltlt){START_OF_ORIGINAL_INSN(opt_ltlt);
+{
+  VALUE val;
+  CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
+  CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
+  VALUE recv = TOPN(1);
+  VALUE obj = TOPN(0);
+  DEBUG_ENTER_INSN("opt_ltlt");
+  ADD_PC(1+2);
+  PREFETCH(GET_PC());
+  POPN(2);
+  #define CURRENT_INSN_opt_ltlt 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_opt_ltlt_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(opt_ltlt));
+  COLLECT_USAGE_OPERAND(BIN(opt_ltlt), 0, ci);
+  COLLECT_USAGE_OPERAND(BIN(opt_ltlt), 1, cc);
+{
+#line 1414 "insns.def"
+    val = vm_opt_ltlt(recv, obj);
+
+    if (val == Qundef) {
+	/* other */
+	PUSH(recv);
+	PUSH(obj);
+	CALL_SIMPLE_METHOD(recv);
+    }
+
+#line 2330 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_opt_ltlt
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(opt_ltlt);}}}
+INSN_ENTRY(opt_aref){START_OF_ORIGINAL_INSN(opt_aref);
+{
+  VALUE val;
+  CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
+  CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
+  VALUE recv = TOPN(1);
+  VALUE obj = TOPN(0);
+  DEBUG_ENTER_INSN("opt_aref");
+  ADD_PC(1+2);
+  PREFETCH(GET_PC());
+  POPN(2);
+  #define CURRENT_INSN_opt_aref 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_opt_aref_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(opt_aref));
+  COLLECT_USAGE_OPERAND(BIN(opt_aref), 0, ci);
+  COLLECT_USAGE_OPERAND(BIN(opt_aref), 1, cc);
+{
+#line 1435 "insns.def"
+    val = vm_opt_aref(recv, obj);
+
+    if (val == Qundef) {
+	/* other */
+	PUSH(recv);
+	PUSH(obj);
+	CALL_SIMPLE_METHOD(recv);
+    }
+
+#line 2367 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_opt_aref
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(opt_aref);}}}
+INSN_ENTRY(opt_aset){START_OF_ORIGINAL_INSN(opt_aset);
+{
+  VALUE val;
+  CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
+  CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
+  VALUE recv = TOPN(2);
+  VALUE obj = TOPN(1);
+  VALUE set = TOPN(0);
+  DEBUG_ENTER_INSN("opt_aset");
+  ADD_PC(1+2);
+  PREFETCH(GET_PC());
+  POPN(3);
+  #define CURRENT_INSN_opt_aset 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_opt_aset_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(opt_aset));
+  COLLECT_USAGE_OPERAND(BIN(opt_aset), 0, ci);
+  COLLECT_USAGE_OPERAND(BIN(opt_aset), 1, cc);
+{
+#line 1456 "insns.def"
+    val = vm_opt_aset(recv, obj, set);
+
+    if (val == Qundef) {
+	/* other */
+	PUSH(recv);
+	PUSH(obj);
+	PUSH(set);
+	CALL_SIMPLE_METHOD(recv);
+    }
+
+#line 2406 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_opt_aset
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(opt_aset);}}}
+INSN_ENTRY(opt_aset_with){START_OF_ORIGINAL_INSN(opt_aset_with);
+{
+  VALUE key = (VALUE)GET_OPERAND(3);
+  CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
+  CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
+  VALUE recv = TOPN(1);
+  VALUE val = TOPN(0);
+  DEBUG_ENTER_INSN("opt_aset_with");
+  ADD_PC(1+3);
+  PREFETCH(GET_PC());
+  POPN(2);
+  #define CURRENT_INSN_opt_aset_with 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_opt_aset_with_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(opt_aset_with));
+  COLLECT_USAGE_OPERAND(BIN(opt_aset_with), 0, ci);
+  COLLECT_USAGE_OPERAND(BIN(opt_aset_with), 1, cc);
+  COLLECT_USAGE_OPERAND(BIN(opt_aset_with), 2, key);
+{
+#line 1478 "insns.def"
+    VALUE tmp = vm_opt_aset_with(recv, key, val);
+
+    if (tmp != Qundef) {
+	val = tmp;
+    }
+    else {
+	/* other */
+	PUSH(recv);
+	PUSH(rb_str_resurrect(key));
+	PUSH(val);
+	CALL_SIMPLE_METHOD(recv);
+    }
+
+#line 2448 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_opt_aset_with
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(opt_aset_with);}}}
+INSN_ENTRY(opt_aref_with){START_OF_ORIGINAL_INSN(opt_aref_with);
+{
+  VALUE val;
+  VALUE key = (VALUE)GET_OPERAND(3);
+  CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
+  CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
+  VALUE recv = TOPN(0);
+  DEBUG_ENTER_INSN("opt_aref_with");
+  ADD_PC(1+3);
+  PREFETCH(GET_PC());
+  POPN(1);
+  #define CURRENT_INSN_opt_aref_with 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_opt_aref_with_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(opt_aref_with));
+  COLLECT_USAGE_OPERAND(BIN(opt_aref_with), 0, ci);
+  COLLECT_USAGE_OPERAND(BIN(opt_aref_with), 1, cc);
+  COLLECT_USAGE_OPERAND(BIN(opt_aref_with), 2, key);
+{
+#line 1503 "insns.def"
+    val = vm_opt_aref_with(recv, key);
+
+    if (val == Qundef) {
+	/* other */
+	PUSH(recv);
+	PUSH(rb_str_resurrect(key));
+	CALL_SIMPLE_METHOD(recv);
+    }
+
+#line 2486 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_opt_aref_with
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(opt_aref_with);}}}
+INSN_ENTRY(opt_length){START_OF_ORIGINAL_INSN(opt_length);
+{
+  VALUE val;
+  CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
+  CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
+  VALUE recv = TOPN(0);
+  DEBUG_ENTER_INSN("opt_length");
+  ADD_PC(1+2);
+  PREFETCH(GET_PC());
+  POPN(1);
+  #define CURRENT_INSN_opt_length 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_opt_length_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(opt_length));
+  COLLECT_USAGE_OPERAND(BIN(opt_length), 0, ci);
+  COLLECT_USAGE_OPERAND(BIN(opt_length), 1, cc);
+{
+#line 1524 "insns.def"
+    val = vm_opt_length(recv, BOP_LENGTH);
+
+    if (val == Qundef) {
+	/* other */
+	PUSH(recv);
+	CALL_SIMPLE_METHOD(recv);
+    }
+
+#line 2521 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_opt_length
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(opt_length);}}}
+INSN_ENTRY(opt_size){START_OF_ORIGINAL_INSN(opt_size);
+{
+  VALUE val;
+  CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
+  CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
+  VALUE recv = TOPN(0);
+  DEBUG_ENTER_INSN("opt_size");
+  ADD_PC(1+2);
+  PREFETCH(GET_PC());
+  POPN(1);
+  #define CURRENT_INSN_opt_size 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_opt_size_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(opt_size));
+  COLLECT_USAGE_OPERAND(BIN(opt_size), 0, ci);
+  COLLECT_USAGE_OPERAND(BIN(opt_size), 1, cc);
+{
+#line 1544 "insns.def"
+    val = vm_opt_length(recv, BOP_SIZE);
+
+    if (val == Qundef) {
+	/* other */
+	PUSH(recv);
+	CALL_SIMPLE_METHOD(recv);
+    }
+
+#line 2556 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_opt_size
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(opt_size);}}}
+INSN_ENTRY(opt_empty_p){START_OF_ORIGINAL_INSN(opt_empty_p);
+{
+  VALUE val;
+  CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
+  CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
+  VALUE recv = TOPN(0);
+  DEBUG_ENTER_INSN("opt_empty_p");
+  ADD_PC(1+2);
+  PREFETCH(GET_PC());
+  POPN(1);
+  #define CURRENT_INSN_opt_empty_p 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_opt_empty_p_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(opt_empty_p));
+  COLLECT_USAGE_OPERAND(BIN(opt_empty_p), 0, ci);
+  COLLECT_USAGE_OPERAND(BIN(opt_empty_p), 1, cc);
+{
+#line 1564 "insns.def"
+    val = vm_opt_empty_p(recv);
+
+    if (val == Qundef) {
+	/* other */
+	PUSH(recv);
+	CALL_SIMPLE_METHOD(recv);
+    }
+
+#line 2591 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_opt_empty_p
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(opt_empty_p);}}}
+INSN_ENTRY(opt_succ){START_OF_ORIGINAL_INSN(opt_succ);
+{
+  VALUE val;
+  CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
+  CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
+  VALUE recv = TOPN(0);
+  DEBUG_ENTER_INSN("opt_succ");
+  ADD_PC(1+2);
+  PREFETCH(GET_PC());
+  POPN(1);
+  #define CURRENT_INSN_opt_succ 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_opt_succ_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(opt_succ));
+  COLLECT_USAGE_OPERAND(BIN(opt_succ), 0, ci);
+  COLLECT_USAGE_OPERAND(BIN(opt_succ), 1, cc);
+{
+#line 1584 "insns.def"
+    val = vm_opt_succ(recv);
+
+    if (val == Qundef) {
+	/* other */
+	PUSH(recv);
+	CALL_SIMPLE_METHOD(recv);
+    }
+
+#line 2626 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_opt_succ
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(opt_succ);}}}
+INSN_ENTRY(opt_not){START_OF_ORIGINAL_INSN(opt_not);
+{
+  VALUE val;
+  CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
+  CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
+  VALUE recv = TOPN(0);
+  DEBUG_ENTER_INSN("opt_not");
+  ADD_PC(1+2);
+  PREFETCH(GET_PC());
+  POPN(1);
+  #define CURRENT_INSN_opt_not 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_opt_not_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(opt_not));
+  COLLECT_USAGE_OPERAND(BIN(opt_not), 0, ci);
+  COLLECT_USAGE_OPERAND(BIN(opt_not), 1, cc);
+{
+#line 1604 "insns.def"
+    val = vm_opt_not(ci, cc, recv);
+
+    if (val == Qundef) {
+	/* other */
+	PUSH(recv);
+	CALL_SIMPLE_METHOD(recv);
+    }
+
+#line 2661 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_opt_not
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(opt_not);}}}
+INSN_ENTRY(opt_regexpmatch1){START_OF_ORIGINAL_INSN(opt_regexpmatch1);
+{
+  VALUE val;
+  VALUE recv = (VALUE)GET_OPERAND(1);
+  VALUE obj = TOPN(0);
+  DEBUG_ENTER_INSN("opt_regexpmatch1");
+  ADD_PC(1+1);
+  PREFETCH(GET_PC());
+  POPN(1);
+  #define CURRENT_INSN_opt_regexpmatch1 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_opt_regexpmatch1_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(opt_regexpmatch1));
+  COLLECT_USAGE_OPERAND(BIN(opt_regexpmatch1), 0, recv);
+{
+#line 1625 "insns.def"
+    val = vm_opt_regexpmatch1(recv, obj);
+
+#line 2688 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_opt_regexpmatch1
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(opt_regexpmatch1);}}}
+INSN_ENTRY(opt_regexpmatch2){START_OF_ORIGINAL_INSN(opt_regexpmatch2);
+{
+  VALUE val;
+  CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);
+  CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);
+  VALUE obj2 = TOPN(1);
+  VALUE obj1 = TOPN(0);
+  DEBUG_ENTER_INSN("opt_regexpmatch2");
+  ADD_PC(1+2);
+  PREFETCH(GET_PC());
+  POPN(2);
+  #define CURRENT_INSN_opt_regexpmatch2 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_opt_regexpmatch2_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(opt_regexpmatch2));
+  COLLECT_USAGE_OPERAND(BIN(opt_regexpmatch2), 0, ci);
+  COLLECT_USAGE_OPERAND(BIN(opt_regexpmatch2), 1, cc);
+{
+#line 1639 "insns.def"
+    val = vm_opt_regexpmatch2(obj2, obj1);
+
+    if (val == Qundef) {
+	/* other */
+	PUSH(obj2);
+	PUSH(obj1);
+	CALL_SIMPLE_METHOD(obj2);
+    }
+
+#line 2725 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef CURRENT_INSN_opt_regexpmatch2
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(opt_regexpmatch2);}}}
+INSN_ENTRY(opt_call_c_function){START_OF_ORIGINAL_INSN(opt_call_c_function);
+{
+  rb_insn_func_t funcptr = (rb_insn_func_t)GET_OPERAND(1);
+
+  DEBUG_ENTER_INSN("opt_call_c_function");
+  ADD_PC(1+1);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_opt_call_c_function 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_opt_call_c_function_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(opt_call_c_function));
+  COLLECT_USAGE_OPERAND(BIN(opt_call_c_function), 0, funcptr);
+{
+#line 1660 "insns.def"
+    reg_cfp = (funcptr)(ec, reg_cfp);
+
+    if (reg_cfp == 0) {
+	VALUE err = ec->errinfo;
+	ec->errinfo = Qnil;
+	THROW_EXCEPTION(err);
+    }
+
+    RESTORE_REGS();
+    NEXT_INSN();
+
+#line 2759 "vm.inc"
+#undef CURRENT_INSN_opt_call_c_function
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(opt_call_c_function);}}}
+INSN_ENTRY(bitblt){START_OF_ORIGINAL_INSN(bitblt);
+{
+  VALUE ret;
+
+
+  DEBUG_ENTER_INSN("bitblt");
+  ADD_PC(1+0);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_bitblt 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_bitblt_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(bitblt));
+{
+#line 1683 "insns.def"
+    ret = rb_str_new2("a bit of bacon, lettuce and tomato");
+
+#line 2782 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(ret);
+#undef CURRENT_INSN_bitblt
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(bitblt);}}}
+INSN_ENTRY(answer){START_OF_ORIGINAL_INSN(answer);
+{
+  VALUE ret;
+
+
+  DEBUG_ENTER_INSN("answer");
+  ADD_PC(1+0);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_answer 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_answer_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(answer));
+{
+#line 1697 "insns.def"
+    ret = INT2FIX(42);
+
+#line 2807 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(ret);
+#undef CURRENT_INSN_answer
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(answer);}}}
+INSN_ENTRY(getlocal_OP__WC__0){START_OF_ORIGINAL_INSN(getlocal_OP__WC__0);
+{
+  VALUE val;
+  #define level 0
+  lindex_t idx = (lindex_t)GET_OPERAND(1);
+
+  DEBUG_ENTER_INSN("getlocal_OP__WC__0");
+  ADD_PC(1+1);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_getlocal_OP__WC__0 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_getlocal_OP__WC__0_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(getlocal_OP__WC__0));
+  COLLECT_USAGE_OPERAND(BIN(getlocal_OP__WC__0), 0, idx);
+{
+#line 60 "insns.def"
+    val = *(vm_get_ep(GET_EP(), level) - idx);
+    RB_DEBUG_COUNTER_INC(lvar_get);
+    (void)RB_DEBUG_COUNTER_INC_IF(lvar_get_dynamic, level > 0);
+
+#line 2836 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef level
+#undef CURRENT_INSN_getlocal_OP__WC__0
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(getlocal_OP__WC__0);}}}
+INSN_ENTRY(getlocal_OP__WC__1){START_OF_ORIGINAL_INSN(getlocal_OP__WC__1);
+{
+  VALUE val;
+  #define level 1
+  lindex_t idx = (lindex_t)GET_OPERAND(1);
+
+  DEBUG_ENTER_INSN("getlocal_OP__WC__1");
+  ADD_PC(1+1);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_getlocal_OP__WC__1 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_getlocal_OP__WC__1_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(getlocal_OP__WC__1));
+  COLLECT_USAGE_OPERAND(BIN(getlocal_OP__WC__1), 0, idx);
+{
+#line 60 "insns.def"
+    val = *(vm_get_ep(GET_EP(), level) - idx);
+    RB_DEBUG_COUNTER_INC(lvar_get);
+    (void)RB_DEBUG_COUNTER_INC_IF(lvar_get_dynamic, level > 0);
+
+#line 2866 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef level
+#undef CURRENT_INSN_getlocal_OP__WC__1
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(getlocal_OP__WC__1);}}}
+INSN_ENTRY(setlocal_OP__WC__0){START_OF_ORIGINAL_INSN(setlocal_OP__WC__0);
+{
+  #define level 0
+  lindex_t idx = (lindex_t)GET_OPERAND(1);
+  VALUE val = TOPN(0);
+  DEBUG_ENTER_INSN("setlocal_OP__WC__0");
+  ADD_PC(1+1);
+  PREFETCH(GET_PC());
+  POPN(1);
+  #define CURRENT_INSN_setlocal_OP__WC__0 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_setlocal_OP__WC__0_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(setlocal_OP__WC__0));
+  COLLECT_USAGE_OPERAND(BIN(setlocal_OP__WC__0), 0, idx);
+{
+#line 78 "insns.def"
+    vm_env_write(vm_get_ep(GET_EP(), level), -(int)idx, val);
+    RB_DEBUG_COUNTER_INC(lvar_set);
+    (void)RB_DEBUG_COUNTER_INC_IF(lvar_set_dynamic, level > 0);
+
+#line 2896 "vm.inc"
+#undef level
+#undef CURRENT_INSN_setlocal_OP__WC__0
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(setlocal_OP__WC__0);}}}
+INSN_ENTRY(setlocal_OP__WC__1){START_OF_ORIGINAL_INSN(setlocal_OP__WC__1);
+{
+  #define level 1
+  lindex_t idx = (lindex_t)GET_OPERAND(1);
+  VALUE val = TOPN(0);
+  DEBUG_ENTER_INSN("setlocal_OP__WC__1");
+  ADD_PC(1+1);
+  PREFETCH(GET_PC());
+  POPN(1);
+  #define CURRENT_INSN_setlocal_OP__WC__1 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_setlocal_OP__WC__1_##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(setlocal_OP__WC__1));
+  COLLECT_USAGE_OPERAND(BIN(setlocal_OP__WC__1), 0, idx);
+{
+#line 78 "insns.def"
+    vm_env_write(vm_get_ep(GET_EP(), level), -(int)idx, val);
+    RB_DEBUG_COUNTER_INC(lvar_set);
+    (void)RB_DEBUG_COUNTER_INC_IF(lvar_set_dynamic, level > 0);
+
+#line 2924 "vm.inc"
+#undef level
+#undef CURRENT_INSN_setlocal_OP__WC__1
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(setlocal_OP__WC__1);}}}
+INSN_ENTRY(putobject_OP_INT2FIX_O_0_C_){START_OF_ORIGINAL_INSN(putobject_OP_INT2FIX_O_0_C_);
+{
+  #define val INT2FIX(0)
+
+
+  DEBUG_ENTER_INSN("putobject_OP_INT2FIX_O_0_C_");
+  ADD_PC(1+0);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_putobject_OP_INT2FIX_O_0_C_ 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_putobject_OP_INT2FIX_O_0_C__##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(putobject_OP_INT2FIX_O_0_C_));
+{
+#line 334 "insns.def"
+    /* */
+
+#line 2948 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef val
+#undef CURRENT_INSN_putobject_OP_INT2FIX_O_0_C_
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(putobject_OP_INT2FIX_O_0_C_);}}}
+INSN_ENTRY(putobject_OP_INT2FIX_O_1_C_){START_OF_ORIGINAL_INSN(putobject_OP_INT2FIX_O_1_C_);
+{
+  #define val INT2FIX(1)
+
+
+  DEBUG_ENTER_INSN("putobject_OP_INT2FIX_O_1_C_");
+  ADD_PC(1+0);
+  PREFETCH(GET_PC());
+  #define CURRENT_INSN_putobject_OP_INT2FIX_O_1_C_ 1
+  #define INSN_IS_SC()     0
+  #define INSN_LABEL(lab)  LABEL_putobject_OP_INT2FIX_O_1_C__##lab
+  #define LABEL_IS_SC(lab) LABEL_##lab##_##t
+  COLLECT_USAGE_INSN(BIN(putobject_OP_INT2FIX_O_1_C_));
+{
+#line 334 "insns.def"
+    /* */
+
+#line 2974 "vm.inc"
+  CHECK_VM_STACK_OVERFLOW_FOR_INSN(VM_REG_CFP, 1);
+  PUSH(val);
+#undef val
+#undef CURRENT_INSN_putobject_OP_INT2FIX_O_1_C_
+#undef INSN_IS_SC
+#undef INSN_LABEL
+#undef LABEL_IS_SC
+  END_INSN(putobject_OP_INT2FIX_O_1_C_);}}}
+INSN_ENTRY(trace_nop){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(nop);
+
+  END_INSN(trace_nop);}}}
+INSN_ENTRY(trace_getlocal){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(getlocal);
+
+  END_INSN(trace_getlocal);}}}
+INSN_ENTRY(trace_setlocal){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(setlocal);
+
+  END_INSN(trace_setlocal);}}}
+INSN_ENTRY(trace_getblockparam){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(getblockparam);
+
+  END_INSN(trace_getblockparam);}}}
+INSN_ENTRY(trace_setblockparam){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(setblockparam);
+
+  END_INSN(trace_setblockparam);}}}
+INSN_ENTRY(trace_getspecial){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(getspecial);
+
+  END_INSN(trace_getspecial);}}}
+INSN_ENTRY(trace_setspecial){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(setspecial);
+
+  END_INSN(trace_setspecial);}}}
+INSN_ENTRY(trace_getinstancevariable){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(getinstancevariable);
+
+  END_INSN(trace_getinstancevariable);}}}
+INSN_ENTRY(trace_setinstancevariable){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(setinstancevariable);
+
+  END_INSN(trace_setinstancevariable);}}}
+INSN_ENTRY(trace_getclassvariable){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(getclassvariable);
+
+  END_INSN(trace_getclassvariable);}}}
+INSN_ENTRY(trace_setclassvariable){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(setclassvariable);
+
+  END_INSN(trace_setclassvariable);}}}
+INSN_ENTRY(trace_getconstant){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(getconstant);
+
+  END_INSN(trace_getconstant);}}}
+INSN_ENTRY(trace_setconstant){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(setconstant);
+
+  END_INSN(trace_setconstant);}}}
+INSN_ENTRY(trace_getglobal){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(getglobal);
+
+  END_INSN(trace_getglobal);}}}
+INSN_ENTRY(trace_setglobal){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(setglobal);
+
+  END_INSN(trace_setglobal);}}}
+INSN_ENTRY(trace_putnil){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(putnil);
+
+  END_INSN(trace_putnil);}}}
+INSN_ENTRY(trace_putself){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(putself);
+
+  END_INSN(trace_putself);}}}
+INSN_ENTRY(trace_putobject){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(putobject);
+
+  END_INSN(trace_putobject);}}}
+INSN_ENTRY(trace_putspecialobject){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(putspecialobject);
+
+  END_INSN(trace_putspecialobject);}}}
+INSN_ENTRY(trace_putiseq){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(putiseq);
+
+  END_INSN(trace_putiseq);}}}
+INSN_ENTRY(trace_putstring){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(putstring);
+
+  END_INSN(trace_putstring);}}}
+INSN_ENTRY(trace_concatstrings){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(concatstrings);
+
+  END_INSN(trace_concatstrings);}}}
+INSN_ENTRY(trace_tostring){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(tostring);
+
+  END_INSN(trace_tostring);}}}
+INSN_ENTRY(trace_freezestring){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(freezestring);
+
+  END_INSN(trace_freezestring);}}}
+INSN_ENTRY(trace_toregexp){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(toregexp);
+
+  END_INSN(trace_toregexp);}}}
+INSN_ENTRY(trace_intern){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(intern);
+
+  END_INSN(trace_intern);}}}
+INSN_ENTRY(trace_newarray){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(newarray);
+
+  END_INSN(trace_newarray);}}}
+INSN_ENTRY(trace_duparray){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(duparray);
+
+  END_INSN(trace_duparray);}}}
+INSN_ENTRY(trace_expandarray){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(expandarray);
+
+  END_INSN(trace_expandarray);}}}
+INSN_ENTRY(trace_concatarray){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(concatarray);
+
+  END_INSN(trace_concatarray);}}}
+INSN_ENTRY(trace_splatarray){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(splatarray);
+
+  END_INSN(trace_splatarray);}}}
+INSN_ENTRY(trace_newhash){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(newhash);
+
+  END_INSN(trace_newhash);}}}
+INSN_ENTRY(trace_newrange){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(newrange);
+
+  END_INSN(trace_newrange);}}}
+INSN_ENTRY(trace_pop){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(pop);
+
+  END_INSN(trace_pop);}}}
+INSN_ENTRY(trace_dup){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(dup);
+
+  END_INSN(trace_dup);}}}
+INSN_ENTRY(trace_dupn){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(dupn);
+
+  END_INSN(trace_dupn);}}}
+INSN_ENTRY(trace_swap){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(swap);
+
+  END_INSN(trace_swap);}}}
+INSN_ENTRY(trace_reverse){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(reverse);
+
+  END_INSN(trace_reverse);}}}
+INSN_ENTRY(trace_reput){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(reput);
+
+  END_INSN(trace_reput);}}}
+INSN_ENTRY(trace_topn){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(topn);
+
+  END_INSN(trace_topn);}}}
+INSN_ENTRY(trace_setn){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(setn);
+
+  END_INSN(trace_setn);}}}
+INSN_ENTRY(trace_adjuststack){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(adjuststack);
+
+  END_INSN(trace_adjuststack);}}}
+INSN_ENTRY(trace_defined){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(defined);
+
+  END_INSN(trace_defined);}}}
+INSN_ENTRY(trace_checkmatch){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(checkmatch);
+
+  END_INSN(trace_checkmatch);}}}
+INSN_ENTRY(trace_checkkeyword){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(checkkeyword);
+
+  END_INSN(trace_checkkeyword);}}}
+INSN_ENTRY(trace_tracecoverage){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(tracecoverage);
+
+  END_INSN(trace_tracecoverage);}}}
+INSN_ENTRY(trace_defineclass){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(defineclass);
+
+  END_INSN(trace_defineclass);}}}
+INSN_ENTRY(trace_send){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(send);
+
+  END_INSN(trace_send);}}}
+INSN_ENTRY(trace_opt_str_freeze){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(opt_str_freeze);
+
+  END_INSN(trace_opt_str_freeze);}}}
+INSN_ENTRY(trace_opt_str_uminus){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(opt_str_uminus);
+
+  END_INSN(trace_opt_str_uminus);}}}
+INSN_ENTRY(trace_opt_newarray_max){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(opt_newarray_max);
+
+  END_INSN(trace_opt_newarray_max);}}}
+INSN_ENTRY(trace_opt_newarray_min){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(opt_newarray_min);
+
+  END_INSN(trace_opt_newarray_min);}}}
+INSN_ENTRY(trace_opt_send_without_block){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(opt_send_without_block);
+
+  END_INSN(trace_opt_send_without_block);}}}
+INSN_ENTRY(trace_invokesuper){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(invokesuper);
+
+  END_INSN(trace_invokesuper);}}}
+INSN_ENTRY(trace_invokeblock){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(invokeblock);
+
+  END_INSN(trace_invokeblock);}}}
+INSN_ENTRY(trace_leave){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(leave);
+
+  END_INSN(trace_leave);}}}
+INSN_ENTRY(trace_throw){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(throw);
+
+  END_INSN(trace_throw);}}}
+INSN_ENTRY(trace_jump){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(jump);
+
+  END_INSN(trace_jump);}}}
+INSN_ENTRY(trace_branchif){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(branchif);
+
+  END_INSN(trace_branchif);}}}
+INSN_ENTRY(trace_branchunless){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(branchunless);
+
+  END_INSN(trace_branchunless);}}}
+INSN_ENTRY(trace_branchnil){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(branchnil);
+
+  END_INSN(trace_branchnil);}}}
+INSN_ENTRY(trace_branchiftype){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(branchiftype);
+
+  END_INSN(trace_branchiftype);}}}
+INSN_ENTRY(trace_getinlinecache){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(getinlinecache);
+
+  END_INSN(trace_getinlinecache);}}}
+INSN_ENTRY(trace_setinlinecache){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(setinlinecache);
+
+  END_INSN(trace_setinlinecache);}}}
+INSN_ENTRY(trace_once){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(once);
+
+  END_INSN(trace_once);}}}
+INSN_ENTRY(trace_opt_case_dispatch){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(opt_case_dispatch);
+
+  END_INSN(trace_opt_case_dispatch);}}}
+INSN_ENTRY(trace_opt_plus){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(opt_plus);
+
+  END_INSN(trace_opt_plus);}}}
+INSN_ENTRY(trace_opt_minus){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(opt_minus);
+
+  END_INSN(trace_opt_minus);}}}
+INSN_ENTRY(trace_opt_mult){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(opt_mult);
+
+  END_INSN(trace_opt_mult);}}}
+INSN_ENTRY(trace_opt_div){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(opt_div);
+
+  END_INSN(trace_opt_div);}}}
+INSN_ENTRY(trace_opt_mod){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(opt_mod);
+
+  END_INSN(trace_opt_mod);}}}
+INSN_ENTRY(trace_opt_eq){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(opt_eq);
+
+  END_INSN(trace_opt_eq);}}}
+INSN_ENTRY(trace_opt_neq){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(opt_neq);
+
+  END_INSN(trace_opt_neq);}}}
+INSN_ENTRY(trace_opt_lt){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(opt_lt);
+
+  END_INSN(trace_opt_lt);}}}
+INSN_ENTRY(trace_opt_le){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(opt_le);
+
+  END_INSN(trace_opt_le);}}}
+INSN_ENTRY(trace_opt_gt){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(opt_gt);
+
+  END_INSN(trace_opt_gt);}}}
+INSN_ENTRY(trace_opt_ge){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(opt_ge);
+
+  END_INSN(trace_opt_ge);}}}
+INSN_ENTRY(trace_opt_ltlt){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(opt_ltlt);
+
+  END_INSN(trace_opt_ltlt);}}}
+INSN_ENTRY(trace_opt_aref){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(opt_aref);
+
+  END_INSN(trace_opt_aref);}}}
+INSN_ENTRY(trace_opt_aset){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(opt_aset);
+
+  END_INSN(trace_opt_aset);}}}
+INSN_ENTRY(trace_opt_aset_with){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(opt_aset_with);
+
+  END_INSN(trace_opt_aset_with);}}}
+INSN_ENTRY(trace_opt_aref_with){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(opt_aref_with);
+
+  END_INSN(trace_opt_aref_with);}}}
+INSN_ENTRY(trace_opt_length){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(opt_length);
+
+  END_INSN(trace_opt_length);}}}
+INSN_ENTRY(trace_opt_size){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(opt_size);
+
+  END_INSN(trace_opt_size);}}}
+INSN_ENTRY(trace_opt_empty_p){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(opt_empty_p);
+
+  END_INSN(trace_opt_empty_p);}}}
+INSN_ENTRY(trace_opt_succ){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(opt_succ);
+
+  END_INSN(trace_opt_succ);}}}
+INSN_ENTRY(trace_opt_not){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(opt_not);
+
+  END_INSN(trace_opt_not);}}}
+INSN_ENTRY(trace_opt_regexpmatch1){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(opt_regexpmatch1);
+
+  END_INSN(trace_opt_regexpmatch1);}}}
+INSN_ENTRY(trace_opt_regexpmatch2){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(opt_regexpmatch2);
+
+  END_INSN(trace_opt_regexpmatch2);}}}
+INSN_ENTRY(trace_opt_call_c_function){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(opt_call_c_function);
+
+  END_INSN(trace_opt_call_c_function);}}}
+INSN_ENTRY(trace_bitblt){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(bitblt);
+
+  END_INSN(trace_bitblt);}}}
+INSN_ENTRY(trace_answer){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(answer);
+
+  END_INSN(trace_answer);}}}
+INSN_ENTRY(trace_getlocal_OP__WC__0){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(getlocal_OP__WC__0);
+
+  END_INSN(trace_getlocal_OP__WC__0);}}}
+INSN_ENTRY(trace_getlocal_OP__WC__1){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(getlocal_OP__WC__1);
+
+  END_INSN(trace_getlocal_OP__WC__1);}}}
+INSN_ENTRY(trace_setlocal_OP__WC__0){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(setlocal_OP__WC__0);
+
+  END_INSN(trace_setlocal_OP__WC__0);}}}
+INSN_ENTRY(trace_setlocal_OP__WC__1){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(setlocal_OP__WC__1);
+
+  END_INSN(trace_setlocal_OP__WC__1);}}}
+INSN_ENTRY(trace_putobject_OP_INT2FIX_O_0_C_){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(putobject_OP_INT2FIX_O_0_C_);
+
+  END_INSN(trace_putobject_OP_INT2FIX_O_0_C_);}}}
+INSN_ENTRY(trace_putobject_OP_INT2FIX_O_1_C_){
+{
+{
+        vm_trace(ec, GET_CFP(), GET_PC());
+        DISPATCH_ORIGINAL_INSN(putobject_OP_INT2FIX_O_1_C_);
+
+  END_INSN(trace_putobject_OP_INT2FIX_O_1_C_);}}}