From b46ff4f55f116c2f2e558f84f31d2f4904ecd532 Mon Sep 17 00:00:00 2001
From: tannevaled <tannevaled@users.noreply.github.com>
Date: Thu, 24 Sep 2026 22:27:22 +0200
Subject: [PATCH 1/6] compiler,vm: decide keywords at the CALL SITE, and bind
 post params MRI's way

Two argument-binding facts rbgo decided in the callee, which MRI decides in
the caller and in a different order.

1. Keyword/positional separation (Ruby 3). bindKeywords peeled ANY trailing
   Hash into keywords, so `h = {key: 42}; foo(1, 2, 3, h)` silently became a
   keyword call. MRI never looks at the value: setup_parameters_complex
   (vm_args.c v3_4_0:591) assigns `keyword_hash` only under VM_CALL_KWARG or
   VM_CALL_KW_SPLAT, both set by the COMPILER from what was written, and with
   neither the hash is an ordinary positional argument - which is then counted
   by the arity check. New bytecode.FlagSendNoKW carries that verdict from
   every compiled send (OpSend/OpSendArray/OpSendBlockArg/OpSendArrayBlockArg,
   yield, super) to exec through VM.sendNoKW, set immediately before the
   dispatch and consumed at the top of exec. It is NEGATIVE on purpose: only
   sites the compiler can prove positional are flagged, so every path that
   cannot say (Object#send, Proc#call, a define_method body) keeps the older
   behaviour instead of losing keywords.

   An empty `**kw` is part of the same decision and could not stay in the
   compiler: ignore_keyword_hash_p (vm_args.c v3_4_0:506) drops it AND clears
   the keyword bit, so `f(x, **{})` passes one POSITIONAL x - even when x is a
   Hash. A call site that drops its own last argument can no longer say what
   the new last argument is, so the hash is now always appended
   (bytecode.FlagSendKWSplat) and applyKWSplat drops it where MRI does.

   Not reached: `foo(1, 2, 3, {key: 42})`. go-ruby-parser v0.3.0 parses the
   braced literal and `foo(1, 2, 3, key: 42)` into the SAME *ast.HashLit with
   no record of the braces, so the compiler cannot tell them apart; those sites
   are left on the older behaviour. It needs a `Braced` bit upstream.

2. Post parameters bind BEFORE optionals. setup_parameters_complex runs
   args_setup_lead_parameters, then args_setup_post_parameters - which MEMCPYs
   the last post_num arguments and SHRINKS the list - and only then
   args_setup_opt_parameters over what is left (vm_args.c v3_4_0:878-892). So
   `def m(a, b=9, *c, d)` called m(1, 2) gives b its DEFAULT. OpArgGiven
   compared against len(args), which made every optional before a post
   parameter look supplied and then left it nil, because the default-filling
   prologue was skipped. It now compares against the count that survives the
   post reservation.

internal/aot carries both: FreezeISeq already emitted Instr.Flags (the
regenerated prelude is 309 instructions richer, not byte-identical), and the
level-2 / codegen lowerings now state the same verdict through
vm.setSendNoKW so an AOT-built binary binds as the interpreter does.

Read for this change: vm_args.c v3_4_0 setup_parameters_complex,
ignore_keyword_hash_p, args_setup_{lead,post,opt,rest}_parameters,
args_setup_kw_parameters; vm_core.h VM_CALL_* flags.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 internal/aot/codegen.go           |   8 +-
 internal/aot/level2.go            |  11 +-
 internal/bytecode/bytecode.go     |  45 +++
 internal/compiler/compiler.go     | 147 +++++--
 internal/vm/aot_e2e_gen_test.go   |   2 +
 internal/vm/object_model.go       |   7 +
 internal/vm/prelude_frozen_gen.go | 622 +++++++++++++++---------------
 internal/vm/vm.go                 | 118 +++++-
 8 files changed, 612 insertions(+), 348 deletions(-)

diff --git a/internal/aot/codegen.go b/internal/aot/codegen.go
index b72cdb26..56e50164 100644
--- a/internal/aot/codegen.go
+++ b/internal/aot/codegen.go
@@ -158,12 +158,16 @@ func (g *gen) emit(pc int) (string, bool) {
 			argList[i] = fmt.Sprintf("s%d", recvSlot+1+i)
 		}
 		argsExpr := "[]object.Value{" + strings.Join(argList, ", ") + "}"
+		// State the call site's keyword/positional verdict, exactly as the
+		// interpreter's OpSend handler does, so a lowered call binds a trailing
+		// Hash the same way the interpreted one would. See bytecode.FlagSendNoKW.
+		noKW := fmt.Sprintf("\tvm.setSendNoKW(%t)\n", in.Flags&bytecode.FlagSendNoKW != 0)
 		if g.isSelf[recvSlot] && name == g.rubyName {
 			// Self-send to the method being compiled → direct recursive call (a
 			// plain send carries no block).
-			return line("s%d = vm.%s(self, %s, nil)", recvSlot, g.goName, argsExpr), true
+			return noKW + line("s%d = vm.%s(self, %s, nil)", recvSlot, g.goName, argsExpr), true
 		}
-		return line("s%d = vm.dispatchSend(s%d, %q, %s, nil)", recvSlot, recvSlot, name, argsExpr), true
+		return noKW + line("s%d = vm.dispatchSend(s%d, %q, %s, nil)", recvSlot, recvSlot, name, argsExpr), true
 	case bytecode.OpNewArray:
 		return line("s%d = &object.Array{Elems: []object.Value{%s}}", d-in.A, slotRange(d-in.A, in.A)), true
 	case bytecode.OpNewHash:
diff --git a/internal/aot/level2.go b/internal/aot/level2.go
index 2683792f..205c0058 100644
--- a/internal/aot/level2.go
+++ b/internal/aot/level2.go
@@ -234,17 +234,24 @@ func (s *mscope) emitSend(pc, d int) (string, bool) {
 		argList[i] = s.sv(recvSlot + 1 + i)
 	}
 	argsExpr := "[]object.Value{" + strings.Join(argList, ", ") + "}"
+	// The call site's keyword/positional verdict is part of the call, not of the
+	// callee, so lowered code has to state it exactly as the interpreter's OpSend
+	// handler does — otherwise an AOT-built binary would bind `f(1, 2, h)` as
+	// keywords where the interpreter binds it positionally. aotSend takes the raw
+	// flags for the visibility check only, so the verdict is set alongside it.
+	// See bytecode.FlagSendNoKW and VM.sendNoKW.
+	noKW := fmt.Sprintf("\tvm.setSendNoKW(%t)\n", in.Flags&bytecode.FlagSendNoKW != 0)
 	if in.C == 0 {
 		cache := s.g.nCaches
 		s.g.nCaches++
-		return fmt.Sprintf("\t%s = vm.aotSend(&aotic%d, %s, %q, %s, %d, self, nil)\n",
+		return noKW + fmt.Sprintf("\t%s = vm.aotSend(&aotic%d, %s, %q, %s, %d, self, nil)\n",
 			s.sv(recvSlot), cache, s.sv(recvSlot), name, argsExpr, in.Flags), true
 	}
 	closure, ok := s.g.emitClosure(s.iseq.Children[in.C-1], s)
 	if !ok {
 		return "", false
 	}
-	return fmt.Sprintf("\t%s = vm.dispatchSend(%s, %q, %s, &Proc{native: %s})\n",
+	return noKW + fmt.Sprintf("\t%s = vm.dispatchSend(%s, %q, %s, &Proc{native: %s})\n",
 		s.sv(recvSlot), s.sv(recvSlot), name, argsExpr, closure), true
 }
 
diff --git a/internal/bytecode/bytecode.go b/internal/bytecode/bytecode.go
index beed4217..df68385c 100644
--- a/internal/bytecode/bytecode.go
+++ b/internal/bytecode/bytecode.go
@@ -226,6 +226,51 @@ const (
 	// permits private calls through an explicit self), so the compiler does NOT
 	// set this flag when the receiver is `self`.
 	FlagSendExplicit = 1 << iota
+
+	// FlagSendNoKW marks a send whose LAST argument is syntactically a POSITIONAL
+	// value, so a Hash arriving there must NOT be turned into keyword arguments.
+	//
+	// MRI decides this at the call site, not in the callee: setup_parameters_complex
+	// (vm_args.c v3_4_0:591) only ever peels a trailing hash when the call info
+	// carries VM_CALL_KWARG (literal `k: v` arguments) or VM_CALL_KW_SPLAT (`**h`).
+	// With neither flag, `keyword_hash` stays Qnil and the hash counts as an
+	// ordinary positional argument — which is why, since Ruby 3.0,
+	//
+	//	def foo(a, b, c, **hsh); end
+	//	h = {key: 42}
+	//	foo(1, 2, 3, h)     # ArgumentError (given 4, expected 3)
+	//	foo(1, 2, 3, **h)   # hsh == {key: 42}
+	//
+	// rbgo materialises keyword arguments into a trailing Hash in the compiler, so
+	// by the time the VM binds parameters the two forms look identical. This flag
+	// carries the call site's answer through. It is NEGATIVE on purpose: it is set
+	// only where the compiler can PROVE the last argument is positional, so every
+	// path that cannot say (a native re-dispatch such as Object#send, Proc#call, or
+	// a call site whose last argument is a Hash LITERAL — see below) keeps the
+	// older "peel a trailing hash" behaviour rather than silently losing keywords.
+	//
+	// The one shape it cannot yet decide is a braced hash literal: go-ruby-parser
+	// v0.3.0 parses `foo(1, 2, 3, {key: 42})` and `foo(1, 2, 3, key: 42)` into the
+	// SAME *ast.HashLit, with no record of the braces, so the compiler cannot tell
+	// them apart. Those sites are left unflagged (keywords), which is what rbgo
+	// did before. Distinguishing them needs a `Braced` bit on ast.HashLit upstream.
+	FlagSendNoKW
+
+	// FlagSendKWSplat marks an array-dispatch send (OpSendArray, OpSendArrayBlockArg,
+	// OpInvokeBlockArray, OpInvokeSuperArray) whose LAST written argument is a
+	// keyword splat — `**h`, or a keyword list containing one — so the last element
+	// of the argument Array is that keyword Hash and nothing else is.
+	//
+	// It is MRI's VM_CALL_KW_SPLAT, and it exists because the hash may have to
+	// disappear: ignore_keyword_hash_p (vm_args.c v3_4_0:506) drops an EMPTY
+	// keyword splat from the argument list entirely, so `f(**{})` passes no
+	// argument at all and `f(x, **{})` passes exactly one — a POSITIONAL x, even
+	// when x is itself a Hash. rbgo used to make that decision in the compiler, by
+	// emitting an `empty?` test that skipped the concatenation; but a call site
+	// that drops its own last argument can no longer say whether what is now last
+	// was written as keywords, which is what FlagSendNoKW has to answer. So the
+	// hash is always appended and the VM drops it, exactly where MRI does.
+	FlagSendKWSplat
 )
 
 // LineEntry maps the first instruction of a run to the source line that run
diff --git a/internal/compiler/compiler.go b/internal/compiler/compiler.go
index a86f426d..5bca7161 100644
--- a/internal/compiler/compiler.go
+++ b/internal/compiler/compiler.go
@@ -807,15 +807,26 @@ func (c *Compiler) compileNode1(n ast.Node) {
 		// Bare anonymous `*` / `**` in `yield(*, **)` forward the enclosing method's
 		// anonymous parameters, exactly as in a call, so resolve them the same way.
 		yieldArgs := c.rewriteAnonArgs(v.Args)
+		// A yield carries the same call-site keyword verdict as any other call:
+		// MRI compiles `yield` through the ordinary argument path and the block is
+		// bound by setup_parameters_complex with arg_setup_block, reading the very
+		// same VM_CALL_KWARG / VM_CALL_KW_SPLAT flags (vm_args.c v3_4_0:591).
+		yieldNoKW := 0
+		if lastArgIsPositional(yieldArgs) {
+			yieldNoKW = bytecode.FlagSendNoKW
+		}
 		if hasSplat(yieldArgs) || hasTrailingKwSplat(yieldArgs) { // dynamic count: build an Array and yield it splatted
-			c.compileSplatItems(yieldArgs)
-			b.emit(bytecode.OpInvokeBlockArray, 0, 0)
+			c.compileSplatItemsMode(yieldArgs, true)
+			if hasTrailingKwSplat(yieldArgs) {
+				yieldNoKW |= bytecode.FlagSendKWSplat
+			}
+			b.insns[b.emit(bytecode.OpInvokeBlockArray, 0, 0)].Flags |= yieldNoKW
 			break
 		}
 		for _, a := range yieldArgs {
 			c.compileNode(a)
 		}
-		b.emit(bytecode.OpInvokeBlock, len(yieldArgs), 0)
+		b.insns[b.emit(bytecode.OpInvokeBlock, len(yieldArgs), 0)].Flags |= yieldNoKW
 	case *ast.If:
 		c.compileIf(v)
 	case *ast.While:
@@ -946,8 +957,9 @@ func forwardIndex(args []ast.Node) int {
 
 // compileForwardCall lowers a call carrying `...` (g(..., ...)): it splices the
 // enclosing `def f(...)` method's captured positionals (*...rest), keywords
-// (**...kw) and block (&...blk). The captured keywords are appended only when
-// non-empty, matching MRI — a `**{}` kwsplat passes no argument.
+// (**...kw) and block (&...blk). The captured keywords ride as a trailing hash
+// that the VM drops when empty, so a `**{}` kwsplat passes no argument and the
+// argument before it stays positional (bytecode.FlagSendKWSplat).
 func (c *Compiler) compileForwardCall(v *ast.Call, fwdAt int) {
 	b := c.cur()
 	if v.Recv != nil {
@@ -959,14 +971,16 @@ func (c *Compiler) compileForwardCall(v *ast.Call, fwdAt int) {
 	// Forward the block (&...blk; nil ⇒ no block) and send.
 	blkSlot, blkDepth := c.mustResolve(fwdBlockName)
 	b.emit(bytecode.OpGetLocal, blkSlot, blkDepth)
-	b.emit(bytecode.OpSendArrayBlockArg, b.addName(v.Name), 0)
+	at := b.emit(bytecode.OpSendArrayBlockArg, b.addName(v.Name), 0)
+	b.insns[at].Flags |= bytecode.FlagSendKWSplat
 }
 
 // emitForwardArgsArray builds, on top of the stack, the argument Array for a
 // `...` forwarding call: the leading explicit args, then the captured `*...rest`
 // positionals, then the trailing explicit args, then the captured `**...kw`
-// hash appended as a trailing element only when it has entries (matching MRI —
-// a `**{}` kwsplat passes no argument). It does not emit the block or the send.
+// hash as a trailing element — always, even when empty, because the send that
+// follows carries bytecode.FlagSendKWSplat and the VM drops an empty keyword
+// splat where MRI does. It does not emit the block or the send.
 func (c *Compiler) emitForwardArgsArray(leading, trailing []ast.Node) {
 	b := c.cur()
 	b.emit(bytecode.OpNewArray, 0, 0) // accumulator
@@ -985,18 +999,14 @@ func (c *Compiler) emitForwardArgsArray(leading, trailing []ast.Node) {
 	for _, a := range trailing {
 		appendOne(a)
 	}
-	// Append **...kw as a trailing hash, but only when it has entries.
+	// Append **...kw as a trailing hash. It is appended even when empty: the send
+	// that follows carries bytecode.FlagSendKWSplat, so the VM drops an empty one
+	// where MRI does (ignore_keyword_hash_p) and can then tell that whatever is
+	// left last was forwarded as a positional argument.
 	kwSlot, kwDepth := c.mustResolve(fwdKwName)
 	b.emit(bytecode.OpGetLocal, kwSlot, kwDepth)
-	b.emit(bytecode.OpDup, 0, 0)
-	b.emit(bytecode.OpSend, b.addName("empty?"), 0)
-	skip := b.emit(bytecode.OpBranchIf, 0, 0)
 	b.emit(bytecode.OpNewArray, 1, 0) // wrap the kw hash
 	b.emit(bytecode.OpConcatArray, 0, 0)
-	done := b.emit(bytecode.OpJump, 0, 0)
-	b.patch(skip, b.here())
-	b.emit(bytecode.OpPop, 0, 0) // drop the empty kw hash
-	b.patch(done, b.here())
 }
 
 // mustResolve resolves a (compiler-synthesised) local that is guaranteed to
@@ -1193,10 +1203,20 @@ func (c *Compiler) compileCall(v *ast.Call) {
 	} else {
 		b.emit(bytecode.OpPushSelf, 0, 0) // implicit receiver: self
 	}
+	// noKW is the call site's keyword/positional verdict for its last argument
+	// (see lastArgIsPositional): it travels on the send instruction so the VM
+	// binds a trailing Hash the way MRI's VM_CALL_KWARG / VM_CALL_KW_SPLAT flags
+	// make it. It is read from the whole written argument list, before the
+	// block-pass is pulled out below, because the pull-out is an implementation
+	// detail of how the value is stacked, not a change to what was written.
+	noKW := lastArgIsPositional(callArgs)
 	sendFlags := func(at int) int {
 		if explicit {
 			b.insns[at].Flags |= bytecode.FlagSendExplicit
 		}
+		if noKW {
+			b.insns[at].Flags |= bytecode.FlagSendNoKW
+		}
 		return at
 	}
 	// Safe navigation (recv&.m): if the receiver is nil, skip the send and leave
@@ -1223,7 +1243,17 @@ func (c *Compiler) compileCall(v *ast.Call) {
 	// hash (k: v) is never empty, and a braced positional hash carries no `**`
 	// entry, so neither is affected.
 	if hasSplat(args) || hasTrailingKwSplat(args) {
-		c.compileSplatItems(args)
+		c.compileSplatItemsMode(args, true)
+		if hasTrailingKwSplat(args) {
+			// The VM, not the compiler, drops an empty `**kw` — and it is then the
+			// VM that knows the new last argument is positional.
+			kwSplatFlag := func(at int) int {
+				b.insns[at].Flags |= bytecode.FlagSendKWSplat
+				return at
+			}
+			prev := sendFlags
+			sendFlags = func(at int) int { return kwSplatFlag(prev(at)) }
+		}
 		if blockPass != nil {
 			c.compileNode(blockPass)
 			sendFlags(b.emit(bytecode.OpSendArrayBlockArg, b.addName(v.Name), 0))
@@ -1535,6 +1565,18 @@ func hasSplat(items []ast.Node) bool {
 // runtime, so an empty `**kw` passes no argument — matching MRI's keyword
 // separation.
 func (c *Compiler) compileSplatItems(items []ast.Node) {
+	c.compileSplatItemsMode(items, false)
+}
+
+// compileSplatItemsMode is compileSplatItems with the argument-list rule made
+// explicit. keepEmptyKwSplat is set for a CALL's argument array (a call, a
+// yield, a super, a `...` forward): there the trailing `**kw` hash is appended
+// unconditionally and the VM drops it when it is empty, because only the VM can
+// then say what the new last argument is (see bytecode.FlagSendKWSplat). It is
+// clear for the non-call uses — an array literal, a masgn right-hand side, an
+// index-target argument list — which keep the older "an empty `**kw` contributes
+// nothing" lowering they were written for.
+func (c *Compiler) compileSplatItemsMode(items []ast.Node, keepEmptyKwSplat bool) {
 	b := c.cur()
 	b.emit(bytecode.OpNewArray, 0, 0) // accumulator
 	for i, it := range items {
@@ -1545,7 +1587,7 @@ func (c *Compiler) compileSplatItems(items []ast.Node) {
 			continue
 		}
 		if h, ok := it.(*ast.HashLit); ok && i == len(items)-1 && isKwSplatHash(h) {
-			c.appendKwSplatIfPresent(h)
+			c.appendKwSplat(h, keepEmptyKwSplat)
 			continue
 		}
 		c.compileNode(it)
@@ -1554,12 +1596,22 @@ func (c *Compiler) compileSplatItems(items []ast.Node) {
 	}
 }
 
-// appendKwSplatIfPresent builds the keyword hash h and concatenates it onto the
-// argument-array accumulator on top of the stack, but only when the hash is
-// non-empty — an empty keyword splat contributes no argument.
-func (c *Compiler) appendKwSplatIfPresent(h *ast.HashLit) {
+// appendKwSplat builds the keyword hash h and concatenates it onto the
+// argument-array accumulator on top of the stack.
+//
+// keepEmpty says who decides about an EMPTY keyword splat. In a call argument
+// list it is true and the hash is always appended, leaving the drop to the VM,
+// which is where MRI makes it (ignore_keyword_hash_p, vm_args.c v3_4_0:506) and
+// the only place that can also say whether what is left behind is positional.
+// Everywhere else it is false and an empty hash is skipped here, as before.
+func (c *Compiler) appendKwSplat(h *ast.HashLit, keepEmpty bool) {
 	b := c.cur()
 	c.compileNode(h)
+	if keepEmpty {
+		b.emit(bytecode.OpNewArray, 1, 0) // wrap the kw hash as a single element
+		b.emit(bytecode.OpConcatArray, 0, 0)
+		return
+	}
 	b.emit(bytecode.OpDup, 0, 0)
 	b.emit(bytecode.OpSend, b.addName("empty?"), 0)
 	skip := b.emit(bytecode.OpBranchIf, 0, 0)
@@ -1571,6 +1623,38 @@ func (c *Compiler) appendKwSplatIfPresent(h *ast.HashLit) {
 	b.patch(done, b.here())
 }
 
+// lastArgIsPositional reports whether the LAST argument of a call is
+// syntactically a positional value — so a Hash arriving there must stay a
+// positional argument and must not be re-read as keyword arguments.
+//
+// It is the compile-time half of MRI's call-site decision: setup_parameters_complex
+// (vm_args.c v3_4_0:591) peels a trailing hash into `keyword_hash` only when the
+// call info carries VM_CALL_KWARG or VM_CALL_KW_SPLAT, which the compiler sets
+// only for `k: v` arguments and for `**h` (compile.c v3_4_0, setup_args_core).
+// Every other last argument — a local, a method call, an index, a splat, a
+// literal of any other kind — leaves both flags clear, and the hash it may
+// evaluate to is positional.
+//
+// A `&block-pass` is not an argument for this purpose (the parser may park it
+// anywhere in the list), so it is skipped. An empty list has no last argument
+// and answers false: there is nothing to protect.
+//
+// It answers false for an *ast.HashLit because go-ruby-parser v0.3.0 gives
+// `f(k: 1)` and `f({k: 1})` the SAME node with no record of the braces. Both are
+// therefore left to the older behaviour — keywords — which is what `f(k: 1)`
+// needs and what `f({k: 1})` got before. Fixing that shape needs a `Braced` bit
+// on ast.HashLit upstream; see FlagSendNoKW.
+func lastArgIsPositional(args []ast.Node) bool {
+	for i := len(args) - 1; i >= 0; i-- {
+		if _, isBP := args[i].(*ast.BlockPass); isBP {
+			continue
+		}
+		_, isHash := args[i].(*ast.HashLit)
+		return !isHash
+	}
+	return false
+}
+
 // hasTrailingKwSplat reports whether the last argument is a keyword-splat hash
 // (a HashLit carrying at least one `**` entry, key == nil), which the call path
 // must build dynamically so an empty splat is dropped.
@@ -1855,6 +1939,7 @@ func (c *Compiler) compileSuper(v *ast.Super) {
 		blkSlot, blkDepth := c.mustResolve(fwdBlockName)
 		b.emit(bytecode.OpGetLocal, blkSlot, blkDepth)
 		at := b.emit(bytecode.OpInvokeSuperArray, 0, 0)
+		b.insns[at].Flags |= bytecode.FlagSendKWSplat
 		b.insns[at].C = 1
 		return
 	}
@@ -1862,18 +1947,29 @@ func (c *Compiler) compileSuper(v *ast.Super) {
 	// value (if any) lands on top of the args array. It may sit before a trailing
 	// keyword hash, so extractBlockPass scans anywhere; bare anonymous `&`/`*`/`**`
 	// are rewritten to reads of the enclosing method's anonymous params first.
-	args, blockPass := extractBlockPass(c.rewriteAnonArgs(v.Args))
+	rewritten := c.rewriteAnonArgs(v.Args)
+	// An explicit-argument `super(...)` is an ordinary call site, so it carries
+	// the same keyword/positional verdict for its last argument as one.
+	superNoKW := 0
+	if lastArgIsPositional(rewritten) {
+		superNoKW = bytecode.FlagSendNoKW
+	}
+	args, blockPass := extractBlockPass(rewritten)
 	// A splat (or a block-pass) means a dynamic argument count: build the args as
 	// an Array and dispatch super from it (kwargs ride along as the trailing hash,
 	// exactly as in a normal call).
-	if blockPass != nil || hasSplat(args) {
-		c.compileSplatItems(args)
+	if blockPass != nil || hasSplat(args) || hasTrailingKwSplat(args) {
+		c.compileSplatItemsMode(args, true)
+		if hasTrailingKwSplat(args) {
+			superNoKW |= bytecode.FlagSendKWSplat
+		}
 		cFlag := 0
 		if blockPass != nil {
 			c.compileNode(blockPass) // block-pass value sits above the args array
 			cFlag = 1
 		}
 		at := b.emit(bytecode.OpInvokeSuperArray, 0, 0)
+		b.insns[at].Flags |= superNoKW
 		switch {
 		case cFlag == 1:
 			b.insns[at].C = 1
@@ -1886,6 +1982,7 @@ func (c *Compiler) compileSuper(v *ast.Super) {
 		c.compileNode(a)
 	}
 	at := b.emit(bytecode.OpInvokeSuper, len(args), 0)
+	b.insns[at].Flags |= superNoKW
 	if v.Block != nil {
 		b.insns[at].C = c.compileBlock(v.Block) + 1
 	}
diff --git a/internal/vm/aot_e2e_gen_test.go b/internal/vm/aot_e2e_gen_test.go
index 9cdfc496..db707ea9 100644
--- a/internal/vm/aot_e2e_gen_test.go
+++ b/internal/vm/aot_e2e_gen_test.go
@@ -237,11 +237,13 @@ L6:
 	s1 = l0
 	s2 = object.IntValue(1)
 	s1 = vm.binaryOp(bytecode.OpSub, s1, s2)
+	vm.setSendNoKW(true)
 	s0 = vm.e2eFib_l1(self, []object.Value{s1}, nil)
 	s1 = self
 	s2 = l0
 	s3 = object.IntValue(2)
 	s2 = vm.binaryOp(bytecode.OpSub, s2, s3)
+	vm.setSendNoKW(true)
 	s1 = vm.e2eFib_l1(self, []object.Value{s2}, nil)
 	s0 = vm.binaryOp(bytecode.OpAdd, s0, s1)
 L17:
diff --git a/internal/vm/object_model.go b/internal/vm/object_model.go
index 7025c0d2..0e288141 100644
--- a/internal/vm/object_model.go
+++ b/internal/vm/object_model.go
@@ -1858,6 +1858,13 @@ func (vm *VM) callNative(m *Method, self object.Value, args []object.Value, blk
 			panic(r)
 		}
 	}()
+	// A native body never reads the call site's keyword/positional verdict (it
+	// takes Ruby's last-hash convention), so clear it here: otherwise a verdict
+	// set for THIS call would still be standing when the native yields to a block
+	// or dispatches a method of its own, and would be read by the wrong frame.
+	// Together with exec's consume-and-clear this bounds the field's lifetime to
+	// exactly one dispatch. See VM.sendNoKW.
+	vm.sendNoKW = false
 	return m.native(vm, self, args, blk)
 }
 
diff --git a/internal/vm/prelude_frozen_gen.go b/internal/vm/prelude_frozen_gen.go
index f8f79fb8..f3690fbf 100644
--- a/internal/vm/prelude_frozen_gen.go
+++ b/internal/vm/prelude_frozen_gen.go
@@ -23,7 +23,7 @@ func embeddedPrelude() *bytecode.ISeq {
 		Children: []*bytecode.ISeq{
 			&bytecode.ISeq{
 				Name:  "<module:Comparable>",
-				Insns: []bytecode.Instr{{Op: 44}, {Op: 9}, {Op: 5}, {Op: 1}, {Op: 30, A: 1, B: 1}, {Op: 9}, {Op: 44, A: 2, B: 1}, {Op: 9}, {Op: 44, A: 3, B: 2}, {Op: 9}, {Op: 44, A: 4, B: 3}, {Op: 9}, {Op: 44, A: 5, B: 4}, {Op: 9}, {Op: 44, A: 6, B: 5}, {Op: 9}, {Op: 44, A: 7, B: 6}, {Op: 9}, {Op: 44, A: 8, B: 7}, {Op: 53}},
+				Insns: []bytecode.Instr{{Op: 44}, {Op: 9}, {Op: 5}, {Op: 1}, {Op: 30, A: 1, B: 1, Flags: 2}, {Op: 9}, {Op: 44, A: 2, B: 1}, {Op: 9}, {Op: 44, A: 3, B: 2}, {Op: 9}, {Op: 44, A: 4, B: 3}, {Op: 9}, {Op: 44, A: 5, B: 4}, {Op: 9}, {Op: 44, A: 6, B: 5}, {Op: 9}, {Op: 44, A: 7, B: 6}, {Op: 9}, {Op: 44, A: 8, B: 7}, {Op: 53}},
 				Consts: []object.Value{
 					object.Symbol("__compare"),
 				},
@@ -38,7 +38,7 @@ func embeddedPrelude() *bytecode.ISeq {
 				Children: []*bytecode.ISeq{
 					&bytecode.ISeq{
 						Name:  "__compare",
-						Insns: []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 1, Flags: 1}, {Op: 28, A: 64}, {Op: 11}, {Op: 12, A: 2}, {Op: 9}, {Op: 33, A: 2}, {Op: 11, A: 2}, {Op: 30, A: 3, B: 1}, {Op: 27, A: 36}, {Op: 33, A: 4}, {Op: 11, A: 2}, {Op: 30, A: 3, B: 1}, {Op: 27, A: 36}, {Op: 33, A: 5}, {Op: 11, A: 2}, {Op: 30, A: 3, B: 1}, {Op: 27, A: 36}, {Op: 2}, {Op: 11, A: 2}, {Op: 30, A: 3, B: 1}, {Op: 27, A: 36}, {Op: 3}, {Op: 11, A: 2}, {Op: 30, A: 3, B: 1}, {Op: 27, A: 36}, {Op: 4}, {Op: 11, A: 2}, {Op: 30, A: 3, B: 1}, {Op: 27, A: 36}, {Op: 26, A: 39}, {Op: 11}, {Op: 30, A: 6, Flags: 1}, {Op: 26, A: 41}, {Op: 11}, {Op: 30, A: 7, Flags: 1}, {Op: 12, A: 3}, {Op: 9}, {Op: 5}, {Op: 33, A: 8}, {Op: 1}, {Op: 1, A: 1}, {Op: 30, A: 9}, {Op: 13}, {Op: 5}, {Op: 30, A: 7}, {Op: 30, A: 9}, {Op: 13}, {Op: 1, A: 2}, {Op: 30, A: 9}, {Op: 13}, {Op: 11, A: 3}, {Op: 30, A: 9}, {Op: 13}, {Op: 1, A: 3}, {Op: 30, A: 9}, {Op: 13}, {Op: 30, A: 10, B: 2}, {Op: 26, A: 65}, {Op: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 1, Flags: 1}, {Op: 28, A: 64}, {Op: 11}, {Op: 12, A: 2}, {Op: 9}, {Op: 33, A: 2}, {Op: 11, A: 2}, {Op: 30, A: 3, B: 1}, {Op: 27, A: 36}, {Op: 33, A: 4}, {Op: 11, A: 2}, {Op: 30, A: 3, B: 1}, {Op: 27, A: 36}, {Op: 33, A: 5}, {Op: 11, A: 2}, {Op: 30, A: 3, B: 1}, {Op: 27, A: 36}, {Op: 2}, {Op: 11, A: 2}, {Op: 30, A: 3, B: 1}, {Op: 27, A: 36}, {Op: 3}, {Op: 11, A: 2}, {Op: 30, A: 3, B: 1}, {Op: 27, A: 36}, {Op: 4}, {Op: 11, A: 2}, {Op: 30, A: 3, B: 1}, {Op: 27, A: 36}, {Op: 26, A: 39}, {Op: 11}, {Op: 30, A: 6, Flags: 1}, {Op: 26, A: 41}, {Op: 11}, {Op: 30, A: 7, Flags: 1}, {Op: 12, A: 3}, {Op: 9}, {Op: 5}, {Op: 33, A: 8}, {Op: 1}, {Op: 1, A: 1}, {Op: 30, A: 9}, {Op: 13}, {Op: 5}, {Op: 30, A: 7}, {Op: 30, A: 9}, {Op: 13}, {Op: 1, A: 2}, {Op: 30, A: 9}, {Op: 13}, {Op: 11, A: 3}, {Op: 30, A: 9}, {Op: 13}, {Op: 1, A: 3}, {Op: 30, A: 9}, {Op: 13}, {Op: 30, A: 10, B: 2, Flags: 2}, {Op: 26, A: 65}, {Op: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}},
 						Consts: []object.Value{
 							object.NewString(""),
 							object.NewString("comparison of "),
@@ -59,7 +59,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "<",
-						Insns: []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 1}, {Op: 18}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 1}, {Op: 18}, {Op: 53}},
 						Consts: []object.Value{
 							object.IntValue(0),
 						},
@@ -77,7 +77,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "<=",
-						Insns: []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 1}, {Op: 20}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 1}, {Op: 20}, {Op: 53}},
 						Consts: []object.Value{
 							object.IntValue(0),
 						},
@@ -95,7 +95,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  ">",
-						Insns: []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 1}, {Op: 19}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 1}, {Op: 19}, {Op: 53}},
 						Consts: []object.Value{
 							object.IntValue(0),
 						},
@@ -113,7 +113,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  ">=",
-						Insns: []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 1}, {Op: 21}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 1}, {Op: 21}, {Op: 53}},
 						Consts: []object.Value{
 							object.IntValue(0),
 						},
@@ -163,7 +163,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "clamp",
-						Insns: []bytecode.Instr{{Op: 11}, {Op: 30, Flags: 1}, {Op: 1}, {Op: 22}, {Op: 10}, {Op: 28, A: 12}, {Op: 9}, {Op: 11}, {Op: 1, A: 1}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 33, A: 2}, {Op: 30, A: 3, B: 1, Flags: 1}, {Op: 28, A: 43}, {Op: 11}, {Op: 1, A: 1}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 4, Flags: 1}, {Op: 10}, {Op: 28, A: 27}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 5, Flags: 1}, {Op: 30, A: 6, Flags: 1}, {Op: 25}, {Op: 28, A: 33}, {Op: 5}, {Op: 33, A: 7}, {Op: 1, A: 2}, {Op: 30, A: 8, B: 2}, {Op: 26, A: 34}, {Op: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 9, Flags: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 5, Flags: 1}, {Op: 12, A: 3}, {Op: 26, A: 92}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 1, A: 3}, {Op: 22}, {Op: 28, A: 56}, {Op: 11}, {Op: 10}, {Op: 59, A: 2}, {Op: 12, A: 2}, {Op: 9}, {Op: 12, A: 3}, {Op: 9}, {Op: 26, A: 92}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 1}, {Op: 22}, {Op: 28, A: 78}, {Op: 5}, {Op: 33, A: 10}, {Op: 1, A: 4}, {Op: 1, A: 5}, {Op: 30, A: 11}, {Op: 13}, {Op: 11}, {Op: 1, A: 1}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 30, A: 12, Flags: 1}, {Op: 30, A: 11}, {Op: 13}, {Op: 1, A: 6}, {Op: 30, A: 11}, {Op: 13}, {Op: 30, A: 8, B: 2}, {Op: 26, A: 92}, {Op: 5}, {Op: 33, A: 7}, {Op: 1, A: 7}, {Op: 1, A: 8}, {Op: 30, A: 11}, {Op: 13}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 30, A: 11}, {Op: 13}, {Op: 1, A: 9}, {Op: 30, A: 11}, {Op: 13}, {Op: 30, A: 8, B: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 30, A: 6, Flags: 1}, {Op: 25}, {Op: 10}, {Op: 28, A: 102}, {Op: 9}, {Op: 11, A: 3}, {Op: 30, A: 6, Flags: 1}, {Op: 25}, {Op: 28, A: 124}, {Op: 11, A: 2}, {Op: 11, A: 3}, {Op: 30, A: 13, B: 1}, {Op: 12, A: 4}, {Op: 9}, {Op: 11, A: 4}, {Op: 30, A: 6, Flags: 1}, {Op: 10}, {Op: 27, A: 116}, {Op: 9}, {Op: 11, A: 4}, {Op: 1, A: 1}, {Op: 19}, {Op: 28, A: 122}, {Op: 5}, {Op: 33, A: 7}, {Op: 1, A: 10}, {Op: 30, A: 8, B: 2}, {Op: 26, A: 123}, {Op: 2}, {Op: 26, A: 125}, {Op: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 30, A: 6, Flags: 1}, {Op: 25}, {Op: 28, A: 170}, {Op: 5}, {Op: 11, A: 2}, {Op: 30, A: 13, B: 1}, {Op: 12, A: 4}, {Op: 9}, {Op: 11, A: 4}, {Op: 30, A: 6, Flags: 1}, {Op: 28, A: 159}, {Op: 5}, {Op: 33, A: 7}, {Op: 1, A: 11}, {Op: 1, A: 12}, {Op: 30, A: 11}, {Op: 13}, {Op: 5}, {Op: 30, A: 12}, {Op: 30, A: 11}, {Op: 13}, {Op: 1, A: 13}, {Op: 30, A: 11}, {Op: 13}, {Op: 11, A: 2}, {Op: 30, A: 11}, {Op: 13}, {Op: 1, A: 14}, {Op: 30, A: 11}, {Op: 13}, {Op: 30, A: 8, B: 2}, {Op: 26, A: 160}, {Op: 2}, {Op: 9}, {Op: 11, A: 4}, {Op: 1, A: 1}, {Op: 18}, {Op: 28, A: 168}, {Op: 11, A: 2}, {Op: 53}, {Op: 26, A: 169}, {Op: 2}, {Op: 26, A: 171}, {Op: 2}, {Op: 9}, {Op: 11, A: 3}, {Op: 30, A: 6, Flags: 1}, {Op: 25}, {Op: 28, A: 216}, {Op: 5}, {Op: 11, A: 3}, {Op: 30, A: 13, B: 1}, {Op: 12, A: 4}, {Op: 9}, {Op: 11, A: 4}, {Op: 30, A: 6, Flags: 1}, {Op: 28, A: 205}, {Op: 5}, {Op: 33, A: 7}, {Op: 1, A: 15}, {Op: 1, A: 16}, {Op: 30, A: 11}, {Op: 13}, {Op: 5}, {Op: 30, A: 12}, {Op: 30, A: 11}, {Op: 13}, {Op: 1, A: 17}, {Op: 30, A: 11}, {Op: 13}, {Op: 11, A: 3}, {Op: 30, A: 11}, {Op: 13}, {Op: 1, A: 18}, {Op: 30, A: 11}, {Op: 13}, {Op: 30, A: 8, B: 2}, {Op: 26, A: 206}, {Op: 2}, {Op: 9}, {Op: 11, A: 4}, {Op: 1, A: 1}, {Op: 19}, {Op: 28, A: 214}, {Op: 11, A: 3}, {Op: 53}, {Op: 26, A: 215}, {Op: 2}, {Op: 26, A: 217}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 11}, {Op: 30, Flags: 1}, {Op: 1}, {Op: 22}, {Op: 10}, {Op: 28, A: 12}, {Op: 9}, {Op: 11}, {Op: 1, A: 1}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 33, A: 2}, {Op: 30, A: 3, B: 1, Flags: 3}, {Op: 28, A: 43}, {Op: 11}, {Op: 1, A: 1}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 4, Flags: 1}, {Op: 10}, {Op: 28, A: 27}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 5, Flags: 1}, {Op: 30, A: 6, Flags: 1}, {Op: 25}, {Op: 28, A: 33}, {Op: 5}, {Op: 33, A: 7}, {Op: 1, A: 2}, {Op: 30, A: 8, B: 2, Flags: 2}, {Op: 26, A: 34}, {Op: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 9, Flags: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 5, Flags: 1}, {Op: 12, A: 3}, {Op: 26, A: 92}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 1, A: 3}, {Op: 22}, {Op: 28, A: 56}, {Op: 11}, {Op: 10}, {Op: 59, A: 2}, {Op: 12, A: 2}, {Op: 9}, {Op: 12, A: 3}, {Op: 9}, {Op: 26, A: 92}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 1}, {Op: 22}, {Op: 28, A: 78}, {Op: 5}, {Op: 33, A: 10}, {Op: 1, A: 4}, {Op: 1, A: 5}, {Op: 30, A: 11}, {Op: 13}, {Op: 11}, {Op: 1, A: 1}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 30, A: 12, Flags: 1}, {Op: 30, A: 11}, {Op: 13}, {Op: 1, A: 6}, {Op: 30, A: 11}, {Op: 13}, {Op: 30, A: 8, B: 2, Flags: 2}, {Op: 26, A: 92}, {Op: 5}, {Op: 33, A: 7}, {Op: 1, A: 7}, {Op: 1, A: 8}, {Op: 30, A: 11}, {Op: 13}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 30, A: 11}, {Op: 13}, {Op: 1, A: 9}, {Op: 30, A: 11}, {Op: 13}, {Op: 30, A: 8, B: 2, Flags: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 30, A: 6, Flags: 1}, {Op: 25}, {Op: 10}, {Op: 28, A: 102}, {Op: 9}, {Op: 11, A: 3}, {Op: 30, A: 6, Flags: 1}, {Op: 25}, {Op: 28, A: 124}, {Op: 11, A: 2}, {Op: 11, A: 3}, {Op: 30, A: 13, B: 1}, {Op: 12, A: 4}, {Op: 9}, {Op: 11, A: 4}, {Op: 30, A: 6, Flags: 1}, {Op: 10}, {Op: 27, A: 116}, {Op: 9}, {Op: 11, A: 4}, {Op: 1, A: 1}, {Op: 19}, {Op: 28, A: 122}, {Op: 5}, {Op: 33, A: 7}, {Op: 1, A: 10}, {Op: 30, A: 8, B: 2, Flags: 2}, {Op: 26, A: 123}, {Op: 2}, {Op: 26, A: 125}, {Op: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 30, A: 6, Flags: 1}, {Op: 25}, {Op: 28, A: 170}, {Op: 5}, {Op: 11, A: 2}, {Op: 30, A: 13, B: 1}, {Op: 12, A: 4}, {Op: 9}, {Op: 11, A: 4}, {Op: 30, A: 6, Flags: 1}, {Op: 28, A: 159}, {Op: 5}, {Op: 33, A: 7}, {Op: 1, A: 11}, {Op: 1, A: 12}, {Op: 30, A: 11}, {Op: 13}, {Op: 5}, {Op: 30, A: 12}, {Op: 30, A: 11}, {Op: 13}, {Op: 1, A: 13}, {Op: 30, A: 11}, {Op: 13}, {Op: 11, A: 2}, {Op: 30, A: 11}, {Op: 13}, {Op: 1, A: 14}, {Op: 30, A: 11}, {Op: 13}, {Op: 30, A: 8, B: 2, Flags: 2}, {Op: 26, A: 160}, {Op: 2}, {Op: 9}, {Op: 11, A: 4}, {Op: 1, A: 1}, {Op: 18}, {Op: 28, A: 168}, {Op: 11, A: 2}, {Op: 53}, {Op: 26, A: 169}, {Op: 2}, {Op: 26, A: 171}, {Op: 2}, {Op: 9}, {Op: 11, A: 3}, {Op: 30, A: 6, Flags: 1}, {Op: 25}, {Op: 28, A: 216}, {Op: 5}, {Op: 11, A: 3}, {Op: 30, A: 13, B: 1}, {Op: 12, A: 4}, {Op: 9}, {Op: 11, A: 4}, {Op: 30, A: 6, Flags: 1}, {Op: 28, A: 205}, {Op: 5}, {Op: 33, A: 7}, {Op: 1, A: 15}, {Op: 1, A: 16}, {Op: 30, A: 11}, {Op: 13}, {Op: 5}, {Op: 30, A: 12}, {Op: 30, A: 11}, {Op: 13}, {Op: 1, A: 17}, {Op: 30, A: 11}, {Op: 13}, {Op: 11, A: 3}, {Op: 30, A: 11}, {Op: 13}, {Op: 1, A: 18}, {Op: 30, A: 11}, {Op: 13}, {Op: 30, A: 8, B: 2, Flags: 2}, {Op: 26, A: 206}, {Op: 2}, {Op: 9}, {Op: 11, A: 4}, {Op: 1, A: 1}, {Op: 19}, {Op: 28, A: 214}, {Op: 11, A: 3}, {Op: 53}, {Op: 26, A: 215}, {Op: 2}, {Op: 26, A: 217}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 53}},
 						Consts: []object.Value{
 							object.IntValue(1),
 							object.IntValue(0),
@@ -202,7 +202,7 @@ func embeddedPrelude() *bytecode.ISeq {
 			},
 			&bytecode.ISeq{
 				Name:  "<module:Enumerable>",
-				Insns: []bytecode.Instr{{Op: 44}, {Op: 9}, {Op: 44, A: 1, B: 1}, {Op: 9}, {Op: 44, A: 2, B: 2}, {Op: 9}, {Op: 5}, {Op: 1}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 30, A: 3, B: 3}, {Op: 9}, {Op: 44, A: 4, B: 3}, {Op: 9}, {Op: 78, A: 5, B: 4}, {Op: 9}, {Op: 44, A: 6, B: 4}, {Op: 9}, {Op: 44, A: 7, B: 5}, {Op: 9}, {Op: 44, A: 8, B: 6}, {Op: 9}, {Op: 78, A: 9, B: 8}, {Op: 9}, {Op: 44, A: 10, B: 7}, {Op: 9}, {Op: 44, A: 11, B: 8}, {Op: 9}, {Op: 44, A: 12, B: 9}, {Op: 9}, {Op: 44, A: 13, B: 10}, {Op: 9}, {Op: 44, A: 14, B: 11}, {Op: 9}, {Op: 44, A: 15, B: 12}, {Op: 9}, {Op: 78, A: 16, B: 15}, {Op: 9}, {Op: 44, A: 17, B: 13}, {Op: 9}, {Op: 44, A: 18, B: 14}, {Op: 9}, {Op: 78, A: 19, B: 18}, {Op: 9}, {Op: 44, A: 20, B: 15}, {Op: 9}, {Op: 78, A: 21, B: 20}, {Op: 9}, {Op: 44, A: 22, B: 16}, {Op: 9}, {Op: 44, A: 23, B: 17}, {Op: 9}, {Op: 44, A: 24, B: 18}, {Op: 9}, {Op: 44, A: 25, B: 19}, {Op: 9}, {Op: 44, A: 26, B: 20}, {Op: 9}, {Op: 78, A: 27, B: 26}, {Op: 9}, {Op: 44, A: 28, B: 21}, {Op: 9}, {Op: 44, A: 29, B: 22}, {Op: 9}, {Op: 44, A: 30, B: 23}, {Op: 9}, {Op: 44, A: 31, B: 24}, {Op: 9}, {Op: 44, A: 32, B: 25}, {Op: 9}, {Op: 44, A: 33, B: 26}, {Op: 9}, {Op: 44, A: 34, B: 27}, {Op: 9}, {Op: 44, A: 35, B: 28}, {Op: 9}, {Op: 44, A: 36, B: 29}, {Op: 9}, {Op: 78, A: 37, B: 36}, {Op: 9}, {Op: 44, A: 38, B: 30}, {Op: 9}, {Op: 44, A: 39, B: 31}, {Op: 9}, {Op: 44, A: 40, B: 32}, {Op: 9}, {Op: 44, A: 41, B: 33}, {Op: 9}, {Op: 44, A: 42, B: 34}, {Op: 9}, {Op: 44, A: 43, B: 35}, {Op: 9}, {Op: 44, A: 44, B: 36}, {Op: 9}, {Op: 44, A: 45, B: 37}, {Op: 9}, {Op: 78, A: 46, B: 15}, {Op: 9}, {Op: 44, A: 47, B: 38}, {Op: 9}, {Op: 44, A: 48, B: 39}, {Op: 9}, {Op: 44, A: 49, B: 40}, {Op: 9}, {Op: 44, A: 50, B: 41}, {Op: 9}, {Op: 44, A: 51, B: 42}, {Op: 9}, {Op: 44, A: 52, B: 43}, {Op: 9}, {Op: 44, A: 53, B: 44}, {Op: 9}, {Op: 44, A: 54, B: 45}, {Op: 9}, {Op: 44, A: 55, B: 46}, {Op: 9}, {Op: 44, A: 56, B: 47}, {Op: 9}, {Op: 44, A: 57, B: 48}, {Op: 9}, {Op: 44, A: 58, B: 49}, {Op: 9}, {Op: 44, A: 59, B: 50}, {Op: 9}, {Op: 44, A: 60, B: 51}, {Op: 9}, {Op: 44, A: 61, B: 52}, {Op: 9}, {Op: 44, A: 62, B: 53}, {Op: 53}},
+				Insns: []bytecode.Instr{{Op: 44}, {Op: 9}, {Op: 44, A: 1, B: 1}, {Op: 9}, {Op: 44, A: 2, B: 2}, {Op: 9}, {Op: 5}, {Op: 1}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 30, A: 3, B: 3, Flags: 2}, {Op: 9}, {Op: 44, A: 4, B: 3}, {Op: 9}, {Op: 78, A: 5, B: 4}, {Op: 9}, {Op: 44, A: 6, B: 4}, {Op: 9}, {Op: 44, A: 7, B: 5}, {Op: 9}, {Op: 44, A: 8, B: 6}, {Op: 9}, {Op: 78, A: 9, B: 8}, {Op: 9}, {Op: 44, A: 10, B: 7}, {Op: 9}, {Op: 44, A: 11, B: 8}, {Op: 9}, {Op: 44, A: 12, B: 9}, {Op: 9}, {Op: 44, A: 13, B: 10}, {Op: 9}, {Op: 44, A: 14, B: 11}, {Op: 9}, {Op: 44, A: 15, B: 12}, {Op: 9}, {Op: 78, A: 16, B: 15}, {Op: 9}, {Op: 44, A: 17, B: 13}, {Op: 9}, {Op: 44, A: 18, B: 14}, {Op: 9}, {Op: 78, A: 19, B: 18}, {Op: 9}, {Op: 44, A: 20, B: 15}, {Op: 9}, {Op: 78, A: 21, B: 20}, {Op: 9}, {Op: 44, A: 22, B: 16}, {Op: 9}, {Op: 44, A: 23, B: 17}, {Op: 9}, {Op: 44, A: 24, B: 18}, {Op: 9}, {Op: 44, A: 25, B: 19}, {Op: 9}, {Op: 44, A: 26, B: 20}, {Op: 9}, {Op: 78, A: 27, B: 26}, {Op: 9}, {Op: 44, A: 28, B: 21}, {Op: 9}, {Op: 44, A: 29, B: 22}, {Op: 9}, {Op: 44, A: 30, B: 23}, {Op: 9}, {Op: 44, A: 31, B: 24}, {Op: 9}, {Op: 44, A: 32, B: 25}, {Op: 9}, {Op: 44, A: 33, B: 26}, {Op: 9}, {Op: 44, A: 34, B: 27}, {Op: 9}, {Op: 44, A: 35, B: 28}, {Op: 9}, {Op: 44, A: 36, B: 29}, {Op: 9}, {Op: 78, A: 37, B: 36}, {Op: 9}, {Op: 44, A: 38, B: 30}, {Op: 9}, {Op: 44, A: 39, B: 31}, {Op: 9}, {Op: 44, A: 40, B: 32}, {Op: 9}, {Op: 44, A: 41, B: 33}, {Op: 9}, {Op: 44, A: 42, B: 34}, {Op: 9}, {Op: 44, A: 43, B: 35}, {Op: 9}, {Op: 44, A: 44, B: 36}, {Op: 9}, {Op: 44, A: 45, B: 37}, {Op: 9}, {Op: 78, A: 46, B: 15}, {Op: 9}, {Op: 44, A: 47, B: 38}, {Op: 9}, {Op: 44, A: 48, B: 39}, {Op: 9}, {Op: 44, A: 49, B: 40}, {Op: 9}, {Op: 44, A: 50, B: 41}, {Op: 9}, {Op: 44, A: 51, B: 42}, {Op: 9}, {Op: 44, A: 52, B: 43}, {Op: 9}, {Op: 44, A: 53, B: 44}, {Op: 9}, {Op: 44, A: 54, B: 45}, {Op: 9}, {Op: 44, A: 55, B: 46}, {Op: 9}, {Op: 44, A: 56, B: 47}, {Op: 9}, {Op: 44, A: 57, B: 48}, {Op: 9}, {Op: 44, A: 58, B: 49}, {Op: 9}, {Op: 44, A: 59, B: 50}, {Op: 9}, {Op: 44, A: 60, B: 51}, {Op: 9}, {Op: 44, A: 61, B: 52}, {Op: 9}, {Op: 44, A: 62, B: 53}, {Op: 53}},
 				Consts: []object.Value{
 					object.Symbol("__each_packed"),
 					object.Symbol("__pack"),
@@ -231,7 +231,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in __each_packed",
-								Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 48, A: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 48, A: 1, Flags: 2}, {Op: 53}},
 								Names:       []string{"__pack"},
 								Params:      []string{"a"},
 								NumRequired: 0,
@@ -249,7 +249,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "__pack",
-						Insns: []bytecode.Instr{{Op: 11}, {Op: 30, Flags: 1}, {Op: 28, A: 5}, {Op: 2}, {Op: 26, A: 15}, {Op: 11}, {Op: 30, A: 1, Flags: 1}, {Op: 1}, {Op: 22}, {Op: 28, A: 14}, {Op: 11}, {Op: 1, A: 1}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 26, A: 15}, {Op: 11}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 11}, {Op: 30, Flags: 1}, {Op: 28, A: 5}, {Op: 2}, {Op: 26, A: 15}, {Op: 11}, {Op: 30, A: 1, Flags: 1}, {Op: 1}, {Op: 22}, {Op: 28, A: 14}, {Op: 11}, {Op: 1, A: 1}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 26, A: 15}, {Op: 11}, {Op: 53}},
 						Consts: []object.Value{
 							object.IntValue(1),
 							object.IntValue(0),
@@ -268,7 +268,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "__enum_int_arg",
-						Insns: []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 28, A: 7}, {Op: 11}, {Op: 12, A: 1}, {Op: 26, A: 73}, {Op: 11}, {Op: 33, A: 2}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 28, A: 15}, {Op: 11}, {Op: 30, A: 3, Flags: 1}, {Op: 12, A: 1}, {Op: 26, A: 73}, {Op: 11}, {Op: 1}, {Op: 30, A: 4, B: 1, Flags: 1}, {Op: 28, A: 59}, {Op: 11}, {Op: 30, A: 3, Flags: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 25}, {Op: 28, A: 57}, {Op: 5}, {Op: 33, A: 5}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 30, A: 6}, {Op: 13}, {Op: 11}, {Op: 30, A: 7, Flags: 1}, {Op: 30, A: 6}, {Op: 13}, {Op: 1, A: 3}, {Op: 30, A: 6}, {Op: 13}, {Op: 11}, {Op: 30, A: 7, Flags: 1}, {Op: 30, A: 6}, {Op: 13}, {Op: 1, A: 4}, {Op: 30, A: 6}, {Op: 13}, {Op: 11, A: 1}, {Op: 30, A: 7, Flags: 1}, {Op: 30, A: 6}, {Op: 13}, {Op: 1, A: 5}, {Op: 30, A: 6}, {Op: 13}, {Op: 30, A: 8, B: 2}, {Op: 26, A: 58}, {Op: 2}, {Op: 26, A: 73}, {Op: 5}, {Op: 33, A: 5}, {Op: 1, A: 6}, {Op: 1, A: 7}, {Op: 30, A: 6}, {Op: 13}, {Op: 11}, {Op: 30, A: 7, Flags: 1}, {Op: 30, A: 6}, {Op: 13}, {Op: 1, A: 8}, {Op: 30, A: 6}, {Op: 13}, {Op: 30, A: 8, B: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 1, A: 9}, {Op: 19}, {Op: 10}, {Op: 27, A: 83}, {Op: 9}, {Op: 11, A: 1}, {Op: 1, A: 10}, {Op: 18}, {Op: 28, A: 89}, {Op: 5}, {Op: 33, A: 9}, {Op: 1, A: 11}, {Op: 30, A: 8, B: 2}, {Op: 26, A: 90}, {Op: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 28, A: 7}, {Op: 11}, {Op: 12, A: 1}, {Op: 26, A: 73}, {Op: 11}, {Op: 33, A: 2}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 28, A: 15}, {Op: 11}, {Op: 30, A: 3, Flags: 1}, {Op: 12, A: 1}, {Op: 26, A: 73}, {Op: 11}, {Op: 1}, {Op: 30, A: 4, B: 1, Flags: 3}, {Op: 28, A: 59}, {Op: 11}, {Op: 30, A: 3, Flags: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 25}, {Op: 28, A: 57}, {Op: 5}, {Op: 33, A: 5}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 30, A: 6}, {Op: 13}, {Op: 11}, {Op: 30, A: 7, Flags: 1}, {Op: 30, A: 6}, {Op: 13}, {Op: 1, A: 3}, {Op: 30, A: 6}, {Op: 13}, {Op: 11}, {Op: 30, A: 7, Flags: 1}, {Op: 30, A: 6}, {Op: 13}, {Op: 1, A: 4}, {Op: 30, A: 6}, {Op: 13}, {Op: 11, A: 1}, {Op: 30, A: 7, Flags: 1}, {Op: 30, A: 6}, {Op: 13}, {Op: 1, A: 5}, {Op: 30, A: 6}, {Op: 13}, {Op: 30, A: 8, B: 2, Flags: 2}, {Op: 26, A: 58}, {Op: 2}, {Op: 26, A: 73}, {Op: 5}, {Op: 33, A: 5}, {Op: 1, A: 6}, {Op: 1, A: 7}, {Op: 30, A: 6}, {Op: 13}, {Op: 11}, {Op: 30, A: 7, Flags: 1}, {Op: 30, A: 6}, {Op: 13}, {Op: 1, A: 8}, {Op: 30, A: 6}, {Op: 13}, {Op: 30, A: 8, B: 2, Flags: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 1, A: 9}, {Op: 19}, {Op: 10}, {Op: 27, A: 83}, {Op: 9}, {Op: 11, A: 1}, {Op: 1, A: 10}, {Op: 18}, {Op: 28, A: 89}, {Op: 5}, {Op: 33, A: 9}, {Op: 1, A: 11}, {Op: 30, A: 8, B: 2, Flags: 2}, {Op: 26, A: 90}, {Op: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("to_int"),
 							object.NewString(""),
@@ -297,7 +297,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "to_a",
-						Insns:       []bytecode.Instr{{Op: 6}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 62, C: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 6}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 62, C: 1, Flags: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}},
 						Names:       []string{"each"},
 						Params:      []string{"args"},
 						NumRequired: 0,
@@ -311,7 +311,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in to_a",
-								Insns:       []bytecode.Instr{{Op: 11, A: 1, B: 1}, {Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 30, A: 1, B: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 11, A: 1, B: 1}, {Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 30, A: 1, B: 1}, {Op: 53}},
 								Names:       []string{"__pack", "<<"},
 								Params:      []string{"a"},
 								NumRequired: 0,
@@ -329,7 +329,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "to_set",
-						Insns:       []bytecode.Instr{{Op: 54}, {Op: 27, A: 5}, {Op: 33}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 6}, {Op: 5}, {Op: 6, A: 1}, {Op: 61}, {Op: 11, A: 1}, {Op: 60}, {Op: 61}, {Op: 11, A: 2}, {Op: 67, A: 1, Flags: 1}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 54}, {Op: 27, A: 5}, {Op: 33}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 6}, {Op: 5}, {Op: 6, A: 1}, {Op: 61}, {Op: 11, A: 1}, {Op: 60}, {Op: 61}, {Op: 11, A: 2}, {Op: 67, A: 1, Flags: 3}, {Op: 53}},
 						Names:       []string{"Set", "new"},
 						Params:      []string{"klass", "args"},
 						NumRequired: 0,
@@ -344,7 +344,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "to_h",
-						Insns:       []bytecode.Instr{{Op: 7}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 62, C: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 7}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 62, C: 1, Flags: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}},
 						Names:       []string{"each"},
 						Params:      []string{"args"},
 						NumRequired: 0,
@@ -358,7 +358,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in to_h",
-								Insns: []bytecode.Instr{{Op: 52}, {Op: 28, A: 8}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 49}, {Op: 26, A: 11}, {Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 33, A: 1}, {Op: 11, A: 1}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 30, A: 3, Flags: 1}, {Op: 28, A: 36}, {Op: 5}, {Op: 33, A: 4}, {Op: 1}, {Op: 1, A: 1}, {Op: 30, A: 5}, {Op: 13}, {Op: 11, A: 1}, {Op: 30, A: 6, Flags: 1}, {Op: 30, A: 5}, {Op: 13}, {Op: 1, A: 2}, {Op: 30, A: 5}, {Op: 13}, {Op: 30, A: 7, B: 2}, {Op: 26, A: 37}, {Op: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 30, A: 8, Flags: 1}, {Op: 1, A: 3}, {Op: 22}, {Op: 25}, {Op: 28, A: 59}, {Op: 5}, {Op: 33, A: 9}, {Op: 1, A: 4}, {Op: 1, A: 5}, {Op: 30, A: 5}, {Op: 13}, {Op: 11, A: 2}, {Op: 30, A: 8, Flags: 1}, {Op: 30, A: 5}, {Op: 13}, {Op: 1, A: 6}, {Op: 30, A: 5}, {Op: 13}, {Op: 30, A: 7, B: 2}, {Op: 26, A: 60}, {Op: 2}, {Op: 9}, {Op: 11, A: 1, B: 1}, {Op: 11, A: 2}, {Op: 1, A: 7}, {Op: 30, A: 10, B: 1, Flags: 1}, {Op: 11, A: 2}, {Op: 1, A: 8}, {Op: 30, A: 10, B: 1, Flags: 1}, {Op: 12, A: 3}, {Op: 30, A: 11, B: 2, Flags: 1}, {Op: 9}, {Op: 11, A: 3}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 52}, {Op: 28, A: 8}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 49, Flags: 2}, {Op: 26, A: 11}, {Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 12, A: 1}, {Op: 9}, {Op: 33, A: 1}, {Op: 11, A: 1}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 30, A: 3, Flags: 1}, {Op: 28, A: 36}, {Op: 5}, {Op: 33, A: 4}, {Op: 1}, {Op: 1, A: 1}, {Op: 30, A: 5}, {Op: 13}, {Op: 11, A: 1}, {Op: 30, A: 6, Flags: 1}, {Op: 30, A: 5}, {Op: 13}, {Op: 1, A: 2}, {Op: 30, A: 5}, {Op: 13}, {Op: 30, A: 7, B: 2, Flags: 2}, {Op: 26, A: 37}, {Op: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 30, A: 8, Flags: 1}, {Op: 1, A: 3}, {Op: 22}, {Op: 25}, {Op: 28, A: 59}, {Op: 5}, {Op: 33, A: 9}, {Op: 1, A: 4}, {Op: 1, A: 5}, {Op: 30, A: 5}, {Op: 13}, {Op: 11, A: 2}, {Op: 30, A: 8, Flags: 1}, {Op: 30, A: 5}, {Op: 13}, {Op: 1, A: 6}, {Op: 30, A: 5}, {Op: 13}, {Op: 30, A: 7, B: 2, Flags: 2}, {Op: 26, A: 60}, {Op: 2}, {Op: 9}, {Op: 11, A: 1, B: 1}, {Op: 11, A: 2}, {Op: 1, A: 7}, {Op: 30, A: 10, B: 1, Flags: 3}, {Op: 11, A: 2}, {Op: 1, A: 8}, {Op: 30, A: 10, B: 1, Flags: 3}, {Op: 12, A: 3}, {Op: 30, A: 11, B: 2, Flags: 3}, {Op: 9}, {Op: 11, A: 3}, {Op: 53}},
 								Consts: []object.Value{
 									object.NewString(""),
 									object.NewString("wrong element type "),
@@ -387,7 +387,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "map",
-						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 2}, {Op: 9}, {Op: 11}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1, Flags: 2}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 2}, {Op: 9}, {Op: 11}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("map"),
 						},
@@ -403,7 +403,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in map",
-								Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1, Flags: 2}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}},
 								Consts: []object.Value{
 									object.Symbol("size"),
 								},
@@ -419,7 +419,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:        "block in map",
-								Insns:       []bytecode.Instr{{Op: 11, B: 1}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 49}, {Op: 30, B: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 11, B: 1}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 49, Flags: 2}, {Op: 30, B: 1}, {Op: 53}},
 								Names:       []string{"<<"},
 								Params:      []string{"a"},
 								NumRequired: 0,
@@ -437,7 +437,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "count",
-						Insns: []bytecode.Instr{{Op: 11}, {Op: 30, Flags: 1}, {Op: 1}, {Op: 19}, {Op: 28, A: 20}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 30, A: 2}, {Op: 13}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 30, A: 2}, {Op: 13}, {Op: 1, A: 3}, {Op: 30, A: 2}, {Op: 13}, {Op: 30, A: 3, B: 2}, {Op: 26, A: 21}, {Op: 2}, {Op: 9}, {Op: 1, A: 4}, {Op: 12, A: 1}, {Op: 9}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 25}, {Op: 28, A: 37}, {Op: 11}, {Op: 1, A: 4}, {Op: 30, A: 5, B: 1, Flags: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 6, C: 1}, {Op: 26, A: 44}, {Op: 52}, {Op: 28, A: 42}, {Op: 5}, {Op: 30, A: 6, C: 2}, {Op: 26, A: 44}, {Op: 5}, {Op: 30, A: 6, C: 3}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 11}, {Op: 30, Flags: 1}, {Op: 1}, {Op: 19}, {Op: 28, A: 20}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 30, A: 2}, {Op: 13}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 30, A: 2}, {Op: 13}, {Op: 1, A: 3}, {Op: 30, A: 2}, {Op: 13}, {Op: 30, A: 3, B: 2, Flags: 2}, {Op: 26, A: 21}, {Op: 2}, {Op: 9}, {Op: 1, A: 4}, {Op: 12, A: 1}, {Op: 9}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 25}, {Op: 28, A: 37}, {Op: 11}, {Op: 1, A: 4}, {Op: 30, A: 5, B: 1, Flags: 3}, {Op: 12, A: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 6, C: 1}, {Op: 26, A: 44}, {Op: 52}, {Op: 28, A: 42}, {Op: 5}, {Op: 30, A: 6, C: 2}, {Op: 26, A: 44}, {Op: 5}, {Op: 30, A: 6, C: 3}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}},
 						Consts: []object.Value{
 							object.IntValue(1),
 							object.NewString(""),
@@ -458,7 +458,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in count",
-								Insns: []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 11, A: 2, B: 1}, {Op: 22}, {Op: 28, A: 11}, {Op: 11, A: 1, B: 1}, {Op: 1}, {Op: 13}, {Op: 12, A: 1, B: 1}, {Op: 26, A: 12}, {Op: 2}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 11, A: 2, B: 1}, {Op: 22}, {Op: 28, A: 11}, {Op: 11, A: 1, B: 1}, {Op: 1}, {Op: 13}, {Op: 12, A: 1, B: 1}, {Op: 26, A: 12}, {Op: 2}, {Op: 53}},
 								Consts: []object.Value{
 									object.IntValue(1),
 								},
@@ -476,7 +476,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:  "block in count",
-								Insns: []bytecode.Instr{{Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 49}, {Op: 28, A: 11}, {Op: 11, A: 1, B: 1}, {Op: 1}, {Op: 13}, {Op: 12, A: 1, B: 1}, {Op: 26, A: 12}, {Op: 2}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 49, Flags: 2}, {Op: 28, A: 11}, {Op: 11, A: 1, B: 1}, {Op: 1}, {Op: 13}, {Op: 12, A: 1, B: 1}, {Op: 26, A: 12}, {Op: 2}, {Op: 53}},
 								Consts: []object.Value{
 									object.IntValue(1),
 								},
@@ -513,7 +513,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "min_by",
-						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 14}, {Op: 5}, {Op: 6}, {Op: 1}, {Op: 6, A: 1}, {Op: 61}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 62, C: 1}, {Op: 53}, {Op: 26, A: 15}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 62, A: 2, C: 2, Flags: 1}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 14}, {Op: 5}, {Op: 6}, {Op: 1}, {Op: 6, A: 1}, {Op: 61}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 62, C: 1, Flags: 2}, {Op: 53}, {Op: 26, A: 15}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 62, A: 2, C: 2, Flags: 3}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("min_by"),
 						},
@@ -530,7 +530,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in min_by",
-								Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1, Flags: 2}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}},
 								Consts: []object.Value{
 									object.Symbol("size"),
 								},
@@ -546,7 +546,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:        "block in min_by",
-								Insns:       []bytecode.Instr{{Op: 11}, {Op: 48, A: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 11}, {Op: 48, A: 1, Flags: 2}, {Op: 53}},
 								Params:      []string{"x"},
 								NumRequired: 1,
 								SplatIndex:  -1,
@@ -563,7 +563,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "max_by",
-						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 14}, {Op: 5}, {Op: 6}, {Op: 1}, {Op: 6, A: 1}, {Op: 61}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 62, C: 1}, {Op: 53}, {Op: 26, A: 15}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 62, A: 2, C: 2, Flags: 1}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 14}, {Op: 5}, {Op: 6}, {Op: 1}, {Op: 6, A: 1}, {Op: 61}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 62, C: 1, Flags: 2}, {Op: 53}, {Op: 26, A: 15}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 62, A: 2, C: 2, Flags: 3}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("max_by"),
 						},
@@ -580,7 +580,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in max_by",
-								Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1, Flags: 2}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}},
 								Consts: []object.Value{
 									object.Symbol("size"),
 								},
@@ -596,7 +596,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:        "block in max_by",
-								Insns:       []bytecode.Instr{{Op: 11}, {Op: 48, A: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 11}, {Op: 48, A: 1, Flags: 2}, {Op: 53}},
 								Params:      []string{"x"},
 								NumRequired: 1,
 								SplatIndex:  -1,
@@ -627,7 +627,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "sort_by",
-						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1}, {Op: 30, A: 2, C: 2, Flags: 1}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1, Flags: 2}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1}, {Op: 30, A: 2, C: 2, Flags: 1}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("sort_by"),
 						},
@@ -642,7 +642,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in sort_by",
-								Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1, Flags: 2}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}},
 								Consts: []object.Value{
 									object.Symbol("size"),
 								},
@@ -658,7 +658,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:        "block in sort_by",
-								Insns:       []bytecode.Instr{{Op: 11}, {Op: 48, A: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 11}, {Op: 48, A: 1, Flags: 2}, {Op: 53}},
 								Params:      []string{"x"},
 								NumRequired: 1,
 								SplatIndex:  -1,
@@ -675,7 +675,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "select",
-						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 2}, {Op: 9}, {Op: 11}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1, Flags: 2}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 2}, {Op: 9}, {Op: 11}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("select"),
 						},
@@ -691,7 +691,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in select",
-								Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1, Flags: 2}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}},
 								Consts: []object.Value{
 									object.Symbol("size"),
 								},
@@ -707,7 +707,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:        "block in select",
-								Insns:       []bytecode.Instr{{Op: 11}, {Op: 48, A: 1}, {Op: 28, A: 7}, {Op: 11, B: 1}, {Op: 11}, {Op: 30, B: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 11}, {Op: 48, A: 1, Flags: 2}, {Op: 28, A: 7}, {Op: 11, B: 1}, {Op: 11}, {Op: 30, B: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}},
 								Names:       []string{"<<"},
 								Params:      []string{"x"},
 								NumRequired: 1,
@@ -725,7 +725,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "reject",
-						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 2}, {Op: 9}, {Op: 11}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1, Flags: 2}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 2}, {Op: 9}, {Op: 11}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("reject"),
 						},
@@ -741,7 +741,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in reject",
-								Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1, Flags: 2}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}},
 								Consts: []object.Value{
 									object.Symbol("size"),
 								},
@@ -757,7 +757,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:        "block in reject",
-								Insns:       []bytecode.Instr{{Op: 11}, {Op: 48, A: 1}, {Op: 25}, {Op: 28, A: 8}, {Op: 11, B: 1}, {Op: 11}, {Op: 30, B: 1}, {Op: 26, A: 9}, {Op: 2}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 11}, {Op: 48, A: 1, Flags: 2}, {Op: 25}, {Op: 28, A: 8}, {Op: 11, B: 1}, {Op: 11}, {Op: 30, B: 1}, {Op: 26, A: 9}, {Op: 2}, {Op: 53}},
 								Names:       []string{"<<"},
 								Params:      []string{"x"},
 								NumRequired: 1,
@@ -775,7 +775,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "find",
-						Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 5}, {Op: 2}, {Op: 12}, {Op: 9}, {Op: 52}, {Op: 25}, {Op: 28, A: 14}, {Op: 5}, {Op: 1}, {Op: 11}, {Op: 30, B: 2, C: 1}, {Op: 53}, {Op: 26, A: 15}, {Op: 2}, {Op: 9}, {Op: 4}, {Op: 12, A: 1}, {Op: 9}, {Op: 2}, {Op: 12, A: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 28, A: 30}, {Op: 11, A: 2}, {Op: 53}, {Op: 26, A: 31}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 30, A: 2, Flags: 1}, {Op: 28, A: 37}, {Op: 2}, {Op: 26, A: 39}, {Op: 11}, {Op: 30, A: 3, Flags: 1}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 5}, {Op: 2}, {Op: 12}, {Op: 9}, {Op: 52}, {Op: 25}, {Op: 28, A: 14}, {Op: 5}, {Op: 1}, {Op: 11}, {Op: 30, B: 2, C: 1, Flags: 2}, {Op: 53}, {Op: 26, A: 15}, {Op: 2}, {Op: 9}, {Op: 4}, {Op: 12, A: 1}, {Op: 9}, {Op: 2}, {Op: 12, A: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 28, A: 30}, {Op: 11, A: 2}, {Op: 53}, {Op: 26, A: 31}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 30, A: 2, Flags: 1}, {Op: 28, A: 37}, {Op: 2}, {Op: 26, A: 39}, {Op: 11}, {Op: 30, A: 3, Flags: 1}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("find"),
 						},
@@ -804,7 +804,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:        "block in find",
-								Insns:       []bytecode.Instr{{Op: 11, A: 1, B: 1}, {Op: 25}, {Op: 28, A: 14}, {Op: 11}, {Op: 48, A: 1}, {Op: 28, A: 12}, {Op: 11}, {Op: 12, A: 2, B: 1}, {Op: 9}, {Op: 3}, {Op: 12, A: 1, B: 1}, {Op: 26, A: 13}, {Op: 2}, {Op: 26, A: 15}, {Op: 2}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 11, A: 1, B: 1}, {Op: 25}, {Op: 28, A: 14}, {Op: 11}, {Op: 48, A: 1, Flags: 2}, {Op: 28, A: 12}, {Op: 11}, {Op: 12, A: 2, B: 1}, {Op: 9}, {Op: 3}, {Op: 12, A: 1, B: 1}, {Op: 26, A: 13}, {Op: 2}, {Op: 26, A: 15}, {Op: 2}, {Op: 53}},
 								Params:      []string{"x"},
 								NumRequired: 1,
 								SplatIndex:  -1,
@@ -852,7 +852,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "sum",
-						Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 5}, {Op: 1}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 12, A: 1}, {Op: 9}, {Op: 1, A: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 12, A: 3}, {Op: 9}, {Op: 5}, {Op: 30, A: 2, C: 1}, {Op: 9}, {Op: 11, A: 3}, {Op: 28, A: 25}, {Op: 11, A: 1}, {Op: 11, A: 2}, {Op: 13}, {Op: 26, A: 26}, {Op: 11, A: 1}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 5}, {Op: 1}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 12, A: 1}, {Op: 9}, {Op: 1, A: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 12, A: 3}, {Op: 9}, {Op: 5}, {Op: 30, A: 2, C: 1}, {Op: 9}, {Op: 11, A: 3}, {Op: 28, A: 25}, {Op: 11, A: 1}, {Op: 11, A: 2}, {Op: 13}, {Op: 26, A: 26}, {Op: 11, A: 1}, {Op: 53}},
 						Consts: []object.Value{
 							object.IntValue(0),
 							frozenFloat(0x0),
@@ -870,7 +870,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in sum",
-								Insns:       []bytecode.Instr{{Op: 52}, {Op: 28, A: 5}, {Op: 11}, {Op: 48, A: 1}, {Op: 26, A: 6}, {Op: 11}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 3, B: 1}, {Op: 25}, {Op: 10}, {Op: 28, A: 16}, {Op: 9}, {Op: 11, A: 1}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 28, A: 24}, {Op: 11, A: 1, B: 1}, {Op: 30, A: 2, Flags: 1}, {Op: 12, A: 1, B: 1}, {Op: 9}, {Op: 3}, {Op: 12, A: 3, B: 1}, {Op: 26, A: 25}, {Op: 2}, {Op: 9}, {Op: 11, A: 3, B: 1}, {Op: 10}, {Op: 28, A: 33}, {Op: 9}, {Op: 11, A: 1}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 28, A: 63}, {Op: 11, A: 1, B: 1}, {Op: 11, A: 1}, {Op: 13}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 2, B: 1}, {Op: 11, A: 1, B: 1}, {Op: 30, A: 3, Flags: 1}, {Op: 11, A: 1}, {Op: 30, A: 3, Flags: 1}, {Op: 21}, {Op: 28, A: 52}, {Op: 11, A: 1, B: 1}, {Op: 11, A: 2}, {Op: 14}, {Op: 11, A: 1}, {Op: 13}, {Op: 26, A: 57}, {Op: 11, A: 1}, {Op: 11, A: 2}, {Op: 14}, {Op: 11, A: 1, B: 1}, {Op: 13}, {Op: 13}, {Op: 12, A: 2, B: 1}, {Op: 9}, {Op: 11, A: 2}, {Op: 12, A: 1, B: 1}, {Op: 26, A: 67}, {Op: 11, A: 1, B: 1}, {Op: 11, A: 1}, {Op: 13}, {Op: 12, A: 1, B: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 52}, {Op: 28, A: 5}, {Op: 11}, {Op: 48, A: 1, Flags: 2}, {Op: 26, A: 6}, {Op: 11}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 3, B: 1}, {Op: 25}, {Op: 10}, {Op: 28, A: 16}, {Op: 9}, {Op: 11, A: 1}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 28, A: 24}, {Op: 11, A: 1, B: 1}, {Op: 30, A: 2, Flags: 1}, {Op: 12, A: 1, B: 1}, {Op: 9}, {Op: 3}, {Op: 12, A: 3, B: 1}, {Op: 26, A: 25}, {Op: 2}, {Op: 9}, {Op: 11, A: 3, B: 1}, {Op: 10}, {Op: 28, A: 33}, {Op: 9}, {Op: 11, A: 1}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 28, A: 63}, {Op: 11, A: 1, B: 1}, {Op: 11, A: 1}, {Op: 13}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 2, B: 1}, {Op: 11, A: 1, B: 1}, {Op: 30, A: 3, Flags: 1}, {Op: 11, A: 1}, {Op: 30, A: 3, Flags: 1}, {Op: 21}, {Op: 28, A: 52}, {Op: 11, A: 1, B: 1}, {Op: 11, A: 2}, {Op: 14}, {Op: 11, A: 1}, {Op: 13}, {Op: 26, A: 57}, {Op: 11, A: 1}, {Op: 11, A: 2}, {Op: 14}, {Op: 11, A: 1, B: 1}, {Op: 13}, {Op: 13}, {Op: 12, A: 2, B: 1}, {Op: 9}, {Op: 11, A: 2}, {Op: 12, A: 1, B: 1}, {Op: 26, A: 67}, {Op: 11, A: 1, B: 1}, {Op: 11, A: 1}, {Op: 13}, {Op: 12, A: 1, B: 1}, {Op: 53}},
 								Names:       []string{"Float", "is_a?", "to_f", "abs"},
 								Params:      []string{"x"},
 								NumRequired: 1,
@@ -888,7 +888,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "min",
-						Insns:       []bytecode.Instr{{Op: 54}, {Op: 27, A: 5}, {Op: 2}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 25}, {Op: 28, A: 17}, {Op: 5}, {Op: 30, A: 1}, {Op: 11, A: 1}, {Op: 66, A: 2, Flags: 1}, {Op: 11}, {Op: 30, A: 3, B: 1, Flags: 1}, {Op: 53}, {Op: 26, A: 18}, {Op: 2}, {Op: 9}, {Op: 2}, {Op: 12, A: 2}, {Op: 9}, {Op: 3}, {Op: 12, A: 3}, {Op: 9}, {Op: 5}, {Op: 30, A: 4, C: 1}, {Op: 9}, {Op: 11, A: 2}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 54}, {Op: 27, A: 5}, {Op: 2}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 25}, {Op: 28, A: 17}, {Op: 5}, {Op: 30, A: 1}, {Op: 11, A: 1}, {Op: 66, A: 2, Flags: 1}, {Op: 11}, {Op: 30, A: 3, B: 1, Flags: 3}, {Op: 53}, {Op: 26, A: 18}, {Op: 2}, {Op: 9}, {Op: 2}, {Op: 12, A: 2}, {Op: 9}, {Op: 3}, {Op: 12, A: 3}, {Op: 9}, {Op: 5}, {Op: 30, A: 4, C: 1}, {Op: 9}, {Op: 11, A: 2}, {Op: 53}},
 						Names:       []string{"nil?", "to_a", "sort", "first", "__each_packed"},
 						Params:      []string{"n"},
 						NumRequired: 0,
@@ -902,7 +902,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in min",
-								Insns: []bytecode.Instr{{Op: 11, A: 3, B: 1}, {Op: 28, A: 8}, {Op: 11}, {Op: 12, A: 2, B: 1}, {Op: 9}, {Op: 4}, {Op: 12, A: 3, B: 1}, {Op: 26, A: 55}, {Op: 11, A: 1, B: 1}, {Op: 28, A: 15}, {Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 11, A: 2, B: 1}, {Op: 30, B: 2, Flags: 1}, {Op: 26, A: 18}, {Op: 11}, {Op: 11, A: 2, B: 1}, {Op: 30, A: 1, B: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 2, Flags: 1}, {Op: 28, A: 45}, {Op: 5}, {Op: 33, A: 3}, {Op: 1}, {Op: 1, A: 1}, {Op: 30, A: 4}, {Op: 13}, {Op: 11}, {Op: 30, A: 5, Flags: 1}, {Op: 30, A: 4}, {Op: 13}, {Op: 1, A: 2}, {Op: 30, A: 4}, {Op: 13}, {Op: 11, A: 2, B: 1}, {Op: 30, A: 5, Flags: 1}, {Op: 30, A: 4}, {Op: 13}, {Op: 1, A: 3}, {Op: 30, A: 4}, {Op: 13}, {Op: 30, A: 6, B: 2}, {Op: 26, A: 46}, {Op: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 1, A: 4}, {Op: 18}, {Op: 28, A: 54}, {Op: 11}, {Op: 12, A: 2, B: 1}, {Op: 26, A: 55}, {Op: 2}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 11, A: 3, B: 1}, {Op: 28, A: 8}, {Op: 11}, {Op: 12, A: 2, B: 1}, {Op: 9}, {Op: 4}, {Op: 12, A: 3, B: 1}, {Op: 26, A: 55}, {Op: 11, A: 1, B: 1}, {Op: 28, A: 15}, {Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 11, A: 2, B: 1}, {Op: 30, B: 2, Flags: 3}, {Op: 26, A: 18}, {Op: 11}, {Op: 11, A: 2, B: 1}, {Op: 30, A: 1, B: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 2, Flags: 1}, {Op: 28, A: 45}, {Op: 5}, {Op: 33, A: 3}, {Op: 1}, {Op: 1, A: 1}, {Op: 30, A: 4}, {Op: 13}, {Op: 11}, {Op: 30, A: 5, Flags: 1}, {Op: 30, A: 4}, {Op: 13}, {Op: 1, A: 2}, {Op: 30, A: 4}, {Op: 13}, {Op: 11, A: 2, B: 1}, {Op: 30, A: 5, Flags: 1}, {Op: 30, A: 4}, {Op: 13}, {Op: 1, A: 3}, {Op: 30, A: 4}, {Op: 13}, {Op: 30, A: 6, B: 2, Flags: 2}, {Op: 26, A: 46}, {Op: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 1, A: 4}, {Op: 18}, {Op: 28, A: 54}, {Op: 11}, {Op: 12, A: 2, B: 1}, {Op: 26, A: 55}, {Op: 2}, {Op: 53}},
 								Consts: []object.Value{
 									object.NewString(""),
 									object.NewString("comparison of "),
@@ -927,7 +927,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "max",
-						Insns:       []bytecode.Instr{{Op: 54}, {Op: 27, A: 5}, {Op: 2}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 25}, {Op: 28, A: 18}, {Op: 5}, {Op: 30, A: 1}, {Op: 11, A: 1}, {Op: 66, A: 2, Flags: 1}, {Op: 11}, {Op: 30, A: 3, B: 1, Flags: 1}, {Op: 30, A: 4, Flags: 1}, {Op: 53}, {Op: 26, A: 19}, {Op: 2}, {Op: 9}, {Op: 2}, {Op: 12, A: 2}, {Op: 9}, {Op: 3}, {Op: 12, A: 3}, {Op: 9}, {Op: 5}, {Op: 30, A: 5, C: 1}, {Op: 9}, {Op: 11, A: 2}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 54}, {Op: 27, A: 5}, {Op: 2}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 25}, {Op: 28, A: 18}, {Op: 5}, {Op: 30, A: 1}, {Op: 11, A: 1}, {Op: 66, A: 2, Flags: 1}, {Op: 11}, {Op: 30, A: 3, B: 1, Flags: 3}, {Op: 30, A: 4, Flags: 1}, {Op: 53}, {Op: 26, A: 19}, {Op: 2}, {Op: 9}, {Op: 2}, {Op: 12, A: 2}, {Op: 9}, {Op: 3}, {Op: 12, A: 3}, {Op: 9}, {Op: 5}, {Op: 30, A: 5, C: 1}, {Op: 9}, {Op: 11, A: 2}, {Op: 53}},
 						Names:       []string{"nil?", "to_a", "sort", "last", "reverse", "__each_packed"},
 						Params:      []string{"n"},
 						NumRequired: 0,
@@ -941,7 +941,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in max",
-								Insns: []bytecode.Instr{{Op: 11, A: 3, B: 1}, {Op: 28, A: 8}, {Op: 11}, {Op: 12, A: 2, B: 1}, {Op: 9}, {Op: 4}, {Op: 12, A: 3, B: 1}, {Op: 26, A: 55}, {Op: 11, A: 1, B: 1}, {Op: 28, A: 15}, {Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 11, A: 2, B: 1}, {Op: 30, B: 2, Flags: 1}, {Op: 26, A: 18}, {Op: 11}, {Op: 11, A: 2, B: 1}, {Op: 30, A: 1, B: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 2, Flags: 1}, {Op: 28, A: 45}, {Op: 5}, {Op: 33, A: 3}, {Op: 1}, {Op: 1, A: 1}, {Op: 30, A: 4}, {Op: 13}, {Op: 11}, {Op: 30, A: 5, Flags: 1}, {Op: 30, A: 4}, {Op: 13}, {Op: 1, A: 2}, {Op: 30, A: 4}, {Op: 13}, {Op: 11, A: 2, B: 1}, {Op: 30, A: 5, Flags: 1}, {Op: 30, A: 4}, {Op: 13}, {Op: 1, A: 3}, {Op: 30, A: 4}, {Op: 13}, {Op: 30, A: 6, B: 2}, {Op: 26, A: 46}, {Op: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 1, A: 4}, {Op: 19}, {Op: 28, A: 54}, {Op: 11}, {Op: 12, A: 2, B: 1}, {Op: 26, A: 55}, {Op: 2}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 11, A: 3, B: 1}, {Op: 28, A: 8}, {Op: 11}, {Op: 12, A: 2, B: 1}, {Op: 9}, {Op: 4}, {Op: 12, A: 3, B: 1}, {Op: 26, A: 55}, {Op: 11, A: 1, B: 1}, {Op: 28, A: 15}, {Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 11, A: 2, B: 1}, {Op: 30, B: 2, Flags: 3}, {Op: 26, A: 18}, {Op: 11}, {Op: 11, A: 2, B: 1}, {Op: 30, A: 1, B: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 2, Flags: 1}, {Op: 28, A: 45}, {Op: 5}, {Op: 33, A: 3}, {Op: 1}, {Op: 1, A: 1}, {Op: 30, A: 4}, {Op: 13}, {Op: 11}, {Op: 30, A: 5, Flags: 1}, {Op: 30, A: 4}, {Op: 13}, {Op: 1, A: 2}, {Op: 30, A: 4}, {Op: 13}, {Op: 11, A: 2, B: 1}, {Op: 30, A: 5, Flags: 1}, {Op: 30, A: 4}, {Op: 13}, {Op: 1, A: 3}, {Op: 30, A: 4}, {Op: 13}, {Op: 30, A: 6, B: 2, Flags: 2}, {Op: 26, A: 46}, {Op: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 1, A: 4}, {Op: 19}, {Op: 28, A: 54}, {Op: 11}, {Op: 12, A: 2, B: 1}, {Op: 26, A: 55}, {Op: 2}, {Op: 53}},
 								Consts: []object.Value{
 									object.NewString(""),
 									object.NewString("comparison of "),
@@ -980,7 +980,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "reduce",
-						Insns: []bytecode.Instr{{Op: 11}, {Op: 30, Flags: 1}, {Op: 1}, {Op: 19}, {Op: 28, A: 20}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 30, A: 2}, {Op: 13}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 30, A: 2}, {Op: 13}, {Op: 1, A: 3}, {Op: 30, A: 2}, {Op: 13}, {Op: 30, A: 3, B: 2}, {Op: 26, A: 21}, {Op: 2}, {Op: 9}, {Op: 2}, {Op: 12, A: 1}, {Op: 9}, {Op: 4}, {Op: 12, A: 2}, {Op: 9}, {Op: 2}, {Op: 12, A: 3}, {Op: 9}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 1}, {Op: 22}, {Op: 28, A: 49}, {Op: 11}, {Op: 1, A: 4}, {Op: 30, A: 4, B: 1, Flags: 1}, {Op: 12, A: 3}, {Op: 9}, {Op: 11}, {Op: 1, A: 5}, {Op: 30, A: 4, B: 1, Flags: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 3}, {Op: 12, A: 2}, {Op: 26, A: 78}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 1, A: 5}, {Op: 22}, {Op: 28, A: 69}, {Op: 52}, {Op: 28, A: 64}, {Op: 11}, {Op: 1, A: 4}, {Op: 30, A: 4, B: 1, Flags: 1}, {Op: 12, A: 3}, {Op: 9}, {Op: 3}, {Op: 12, A: 2}, {Op: 26, A: 68}, {Op: 11}, {Op: 1, A: 4}, {Op: 30, A: 4, B: 1, Flags: 1}, {Op: 12, A: 1}, {Op: 26, A: 78}, {Op: 52}, {Op: 25}, {Op: 28, A: 77}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 6}, {Op: 30, A: 3, B: 2}, {Op: 26, A: 78}, {Op: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 5, Flags: 1}, {Op: 10}, {Op: 27, A: 87}, {Op: 9}, {Op: 11, A: 1}, {Op: 33, A: 6}, {Op: 30, A: 7, B: 1, Flags: 1}, {Op: 10}, {Op: 27, A: 93}, {Op: 9}, {Op: 11, A: 1}, {Op: 33, A: 8}, {Op: 30, A: 7, B: 1, Flags: 1}, {Op: 25}, {Op: 28, A: 118}, {Op: 11, A: 1}, {Op: 1, A: 7}, {Op: 30, A: 9, B: 1, Flags: 1}, {Op: 28, A: 103}, {Op: 11, A: 1}, {Op: 30, A: 10, Flags: 1}, {Op: 12, A: 1}, {Op: 26, A: 117}, {Op: 5}, {Op: 33, A: 11}, {Op: 1, A: 8}, {Op: 1, A: 9}, {Op: 30, A: 2}, {Op: 13}, {Op: 11, A: 1}, {Op: 30, A: 12, Flags: 1}, {Op: 30, A: 2}, {Op: 13}, {Op: 1, A: 10}, {Op: 30, A: 2}, {Op: 13}, {Op: 30, A: 3, B: 2}, {Op: 26, A: 119}, {Op: 2}, {Op: 9}, {Op: 11, A: 3}, {Op: 12, A: 4}, {Op: 9}, {Op: 11, A: 2}, {Op: 12, A: 5}, {Op: 9}, {Op: 5}, {Op: 30, A: 13, C: 1}, {Op: 9}, {Op: 11, A: 4}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 11}, {Op: 30, Flags: 1}, {Op: 1}, {Op: 19}, {Op: 28, A: 20}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 30, A: 2}, {Op: 13}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 30, A: 2}, {Op: 13}, {Op: 1, A: 3}, {Op: 30, A: 2}, {Op: 13}, {Op: 30, A: 3, B: 2, Flags: 2}, {Op: 26, A: 21}, {Op: 2}, {Op: 9}, {Op: 2}, {Op: 12, A: 1}, {Op: 9}, {Op: 4}, {Op: 12, A: 2}, {Op: 9}, {Op: 2}, {Op: 12, A: 3}, {Op: 9}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 1}, {Op: 22}, {Op: 28, A: 49}, {Op: 11}, {Op: 1, A: 4}, {Op: 30, A: 4, B: 1, Flags: 3}, {Op: 12, A: 3}, {Op: 9}, {Op: 11}, {Op: 1, A: 5}, {Op: 30, A: 4, B: 1, Flags: 3}, {Op: 12, A: 1}, {Op: 9}, {Op: 3}, {Op: 12, A: 2}, {Op: 26, A: 78}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 1, A: 5}, {Op: 22}, {Op: 28, A: 69}, {Op: 52}, {Op: 28, A: 64}, {Op: 11}, {Op: 1, A: 4}, {Op: 30, A: 4, B: 1, Flags: 3}, {Op: 12, A: 3}, {Op: 9}, {Op: 3}, {Op: 12, A: 2}, {Op: 26, A: 68}, {Op: 11}, {Op: 1, A: 4}, {Op: 30, A: 4, B: 1, Flags: 3}, {Op: 12, A: 1}, {Op: 26, A: 78}, {Op: 52}, {Op: 25}, {Op: 28, A: 77}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 6}, {Op: 30, A: 3, B: 2, Flags: 2}, {Op: 26, A: 78}, {Op: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 5, Flags: 1}, {Op: 10}, {Op: 27, A: 87}, {Op: 9}, {Op: 11, A: 1}, {Op: 33, A: 6}, {Op: 30, A: 7, B: 1, Flags: 3}, {Op: 10}, {Op: 27, A: 93}, {Op: 9}, {Op: 11, A: 1}, {Op: 33, A: 8}, {Op: 30, A: 7, B: 1, Flags: 3}, {Op: 25}, {Op: 28, A: 118}, {Op: 11, A: 1}, {Op: 1, A: 7}, {Op: 30, A: 9, B: 1, Flags: 3}, {Op: 28, A: 103}, {Op: 11, A: 1}, {Op: 30, A: 10, Flags: 1}, {Op: 12, A: 1}, {Op: 26, A: 117}, {Op: 5}, {Op: 33, A: 11}, {Op: 1, A: 8}, {Op: 1, A: 9}, {Op: 30, A: 2}, {Op: 13}, {Op: 11, A: 1}, {Op: 30, A: 12, Flags: 1}, {Op: 30, A: 2}, {Op: 13}, {Op: 1, A: 10}, {Op: 30, A: 2}, {Op: 13}, {Op: 30, A: 3, B: 2, Flags: 2}, {Op: 26, A: 119}, {Op: 2}, {Op: 9}, {Op: 11, A: 3}, {Op: 12, A: 4}, {Op: 9}, {Op: 11, A: 2}, {Op: 12, A: 5}, {Op: 9}, {Op: 5}, {Op: 30, A: 13, C: 1}, {Op: 9}, {Op: 11, A: 4}, {Op: 53}},
 						Consts: []object.Value{
 							object.IntValue(2),
 							object.NewString(""),
@@ -1007,7 +1007,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in reduce",
-								Insns:       []bytecode.Instr{{Op: 11, A: 5, B: 1}, {Op: 25}, {Op: 28, A: 9}, {Op: 11}, {Op: 12, A: 4, B: 1}, {Op: 9}, {Op: 3}, {Op: 12, A: 5, B: 1}, {Op: 26, A: 21}, {Op: 11, A: 1, B: 1}, {Op: 28, A: 17}, {Op: 11, A: 4, B: 1}, {Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 30, B: 2, Flags: 1}, {Op: 12, A: 4, B: 1}, {Op: 26, A: 21}, {Op: 11, A: 4, B: 1}, {Op: 11}, {Op: 48, A: 2}, {Op: 12, A: 4, B: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 11, A: 5, B: 1}, {Op: 25}, {Op: 28, A: 9}, {Op: 11}, {Op: 12, A: 4, B: 1}, {Op: 9}, {Op: 3}, {Op: 12, A: 5, B: 1}, {Op: 26, A: 21}, {Op: 11, A: 1, B: 1}, {Op: 28, A: 17}, {Op: 11, A: 4, B: 1}, {Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 30, B: 2, Flags: 3}, {Op: 12, A: 4, B: 1}, {Op: 26, A: 21}, {Op: 11, A: 4, B: 1}, {Op: 11}, {Op: 48, A: 2, Flags: 2}, {Op: 12, A: 4, B: 1}, {Op: 53}},
 								Names:       []string{"send"},
 								Params:      []string{"x"},
 								NumRequired: 1,
@@ -1025,7 +1025,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "any?",
-						Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 8}, {Op: 3}, {Op: 12, A: 1}, {Op: 9}, {Op: 2}, {Op: 12}, {Op: 9}, {Op: 52}, {Op: 12, A: 2}, {Op: 9}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 8}, {Op: 3}, {Op: 12, A: 1}, {Op: 9}, {Op: 2}, {Op: 12}, {Op: 9}, {Op: 52}, {Op: 12, A: 2}, {Op: 9}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1, Flags: 2}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("__enum_any"),
 						},
@@ -1054,7 +1054,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:  "block (2 levels) in any?",
-										Insns: []bytecode.Instr{{Op: 11, A: 1, B: 2}, {Op: 28, A: 14}, {Op: 11, A: 2, B: 2}, {Op: 28, A: 10}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 49}, {Op: 26, A: 13}, {Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 26, A: 19}, {Op: 11, B: 2}, {Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 30, A: 1, B: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 28, A: 28}, {Op: 5}, {Op: 1}, {Op: 3}, {Op: 30, A: 2, B: 2}, {Op: 26, A: 29}, {Op: 2}, {Op: 53}},
+										Insns: []bytecode.Instr{{Op: 11, A: 1, B: 2}, {Op: 28, A: 14}, {Op: 11, A: 2, B: 2}, {Op: 28, A: 10}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 49, Flags: 2}, {Op: 26, A: 13}, {Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 26, A: 19}, {Op: 11, B: 2}, {Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 30, A: 1, B: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 28, A: 28}, {Op: 5}, {Op: 1}, {Op: 3}, {Op: 30, A: 2, B: 2, Flags: 2}, {Op: 26, A: 29}, {Op: 2}, {Op: 53}},
 										Consts: []object.Value{
 											object.Symbol("__enum_any"),
 										},
@@ -1078,7 +1078,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "all?",
-						Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 8}, {Op: 3}, {Op: 12, A: 1}, {Op: 9}, {Op: 2}, {Op: 12}, {Op: 9}, {Op: 52}, {Op: 12, A: 2}, {Op: 9}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 8}, {Op: 3}, {Op: 12, A: 1}, {Op: 9}, {Op: 2}, {Op: 12}, {Op: 9}, {Op: 52}, {Op: 12, A: 2}, {Op: 9}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1, Flags: 2}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("__enum_all"),
 						},
@@ -1107,7 +1107,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:  "block (2 levels) in all?",
-										Insns: []bytecode.Instr{{Op: 11, A: 1, B: 2}, {Op: 28, A: 14}, {Op: 11, A: 2, B: 2}, {Op: 28, A: 10}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 49}, {Op: 26, A: 13}, {Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 26, A: 19}, {Op: 11, B: 2}, {Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 30, A: 1, B: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 25}, {Op: 28, A: 29}, {Op: 5}, {Op: 1}, {Op: 4}, {Op: 30, A: 2, B: 2}, {Op: 26, A: 30}, {Op: 2}, {Op: 53}},
+										Insns: []bytecode.Instr{{Op: 11, A: 1, B: 2}, {Op: 28, A: 14}, {Op: 11, A: 2, B: 2}, {Op: 28, A: 10}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 49, Flags: 2}, {Op: 26, A: 13}, {Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 26, A: 19}, {Op: 11, B: 2}, {Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 30, A: 1, B: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 25}, {Op: 28, A: 29}, {Op: 5}, {Op: 1}, {Op: 4}, {Op: 30, A: 2, B: 2, Flags: 2}, {Op: 26, A: 30}, {Op: 2}, {Op: 53}},
 										Consts: []object.Value{
 											object.Symbol("__enum_all"),
 										},
@@ -1131,7 +1131,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "none?",
-						Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 8}, {Op: 3}, {Op: 12, A: 1}, {Op: 9}, {Op: 2}, {Op: 12}, {Op: 9}, {Op: 52}, {Op: 12, A: 2}, {Op: 9}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 8}, {Op: 3}, {Op: 12, A: 1}, {Op: 9}, {Op: 2}, {Op: 12}, {Op: 9}, {Op: 52}, {Op: 12, A: 2}, {Op: 9}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1, Flags: 2}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("__enum_none"),
 						},
@@ -1160,7 +1160,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:  "block (2 levels) in none?",
-										Insns: []bytecode.Instr{{Op: 11, A: 1, B: 2}, {Op: 28, A: 14}, {Op: 11, A: 2, B: 2}, {Op: 28, A: 10}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 49}, {Op: 26, A: 13}, {Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 26, A: 19}, {Op: 11, B: 2}, {Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 30, A: 1, B: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 28, A: 28}, {Op: 5}, {Op: 1}, {Op: 4}, {Op: 30, A: 2, B: 2}, {Op: 26, A: 29}, {Op: 2}, {Op: 53}},
+										Insns: []bytecode.Instr{{Op: 11, A: 1, B: 2}, {Op: 28, A: 14}, {Op: 11, A: 2, B: 2}, {Op: 28, A: 10}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 49, Flags: 2}, {Op: 26, A: 13}, {Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 26, A: 19}, {Op: 11, B: 2}, {Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 30, A: 1, B: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 28, A: 28}, {Op: 5}, {Op: 1}, {Op: 4}, {Op: 30, A: 2, B: 2, Flags: 2}, {Op: 26, A: 29}, {Op: 2}, {Op: 53}},
 										Consts: []object.Value{
 											object.Symbol("__enum_none"),
 										},
@@ -1184,7 +1184,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "one?",
-						Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 8}, {Op: 3}, {Op: 12, A: 1}, {Op: 9}, {Op: 2}, {Op: 12}, {Op: 9}, {Op: 52}, {Op: 12, A: 2}, {Op: 9}, {Op: 1}, {Op: 12, A: 3}, {Op: 9}, {Op: 5}, {Op: 1, A: 1}, {Op: 30, B: 1, C: 1}, {Op: 9}, {Op: 11, A: 3}, {Op: 1, A: 2}, {Op: 22}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 8}, {Op: 3}, {Op: 12, A: 1}, {Op: 9}, {Op: 2}, {Op: 12}, {Op: 9}, {Op: 52}, {Op: 12, A: 2}, {Op: 9}, {Op: 1}, {Op: 12, A: 3}, {Op: 9}, {Op: 5}, {Op: 1, A: 1}, {Op: 30, B: 1, C: 1, Flags: 2}, {Op: 9}, {Op: 11, A: 3}, {Op: 1, A: 2}, {Op: 22}, {Op: 53}},
 						Consts: []object.Value{
 							object.IntValue(0),
 							object.Symbol("__enum_one"),
@@ -1215,7 +1215,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:  "block (2 levels) in one?",
-										Insns: []bytecode.Instr{{Op: 11, A: 1, B: 2}, {Op: 28, A: 14}, {Op: 11, A: 2, B: 2}, {Op: 28, A: 10}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 49}, {Op: 26, A: 13}, {Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 26, A: 19}, {Op: 11, B: 2}, {Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 30, A: 1, B: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 28, A: 38}, {Op: 11, A: 3, B: 2}, {Op: 1}, {Op: 13}, {Op: 12, A: 3, B: 2}, {Op: 9}, {Op: 11, A: 3, B: 2}, {Op: 1}, {Op: 19}, {Op: 28, A: 36}, {Op: 5}, {Op: 1, A: 1}, {Op: 30, A: 2, B: 1}, {Op: 26, A: 37}, {Op: 2}, {Op: 26, A: 39}, {Op: 2}, {Op: 53}},
+										Insns: []bytecode.Instr{{Op: 11, A: 1, B: 2}, {Op: 28, A: 14}, {Op: 11, A: 2, B: 2}, {Op: 28, A: 10}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 49, Flags: 2}, {Op: 26, A: 13}, {Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 26, A: 19}, {Op: 11, B: 2}, {Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 30, A: 1, B: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 28, A: 38}, {Op: 11, A: 3, B: 2}, {Op: 1}, {Op: 13}, {Op: 12, A: 3, B: 2}, {Op: 9}, {Op: 11, A: 3, B: 2}, {Op: 1}, {Op: 19}, {Op: 28, A: 36}, {Op: 5}, {Op: 1, A: 1}, {Op: 30, A: 2, B: 1, Flags: 2}, {Op: 26, A: 37}, {Op: 2}, {Op: 26, A: 39}, {Op: 2}, {Op: 53}},
 										Consts: []object.Value{
 											object.IntValue(1),
 											object.Symbol("__enum_one"),
@@ -1253,7 +1253,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in uniq",
-								Insns: []bytecode.Instr{{Op: 52}, {Op: 28, A: 5}, {Op: 11}, {Op: 48, A: 1}, {Op: 26, A: 6}, {Op: 11}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, Flags: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 4}, {Op: 12, A: 3}, {Op: 9}, {Op: 1}, {Op: 12, A: 4}, {Op: 9}, {Op: 11, A: 4}, {Op: 11, A: 1, B: 1}, {Op: 30, A: 1, Flags: 1}, {Op: 18}, {Op: 28, A: 53}, {Op: 11, A: 2, B: 1}, {Op: 11, A: 4}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 11, A: 2}, {Op: 22}, {Op: 10}, {Op: 28, A: 36}, {Op: 9}, {Op: 11, A: 1, B: 1}, {Op: 11, A: 4}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 11, A: 1}, {Op: 30, A: 3, B: 1, Flags: 1}, {Op: 28, A: 45}, {Op: 3}, {Op: 12, A: 3}, {Op: 9}, {Op: 2}, {Op: 12, A: 5}, {Op: 9}, {Op: 26, A: 55}, {Op: 26, A: 46}, {Op: 2}, {Op: 9}, {Op: 11, A: 4}, {Op: 1, A: 1}, {Op: 13}, {Op: 12, A: 4}, {Op: 9}, {Op: 26, A: 18}, {Op: 2}, {Op: 26, A: 56}, {Op: 11, A: 5}, {Op: 9}, {Op: 11, A: 3}, {Op: 25}, {Op: 28, A: 72}, {Op: 11, A: 1, B: 1}, {Op: 11, A: 1}, {Op: 30, A: 4, B: 1}, {Op: 9}, {Op: 11, A: 2, B: 1}, {Op: 11, A: 2}, {Op: 30, A: 4, B: 1}, {Op: 9}, {Op: 11, B: 1}, {Op: 11}, {Op: 30, A: 4, B: 1}, {Op: 26, A: 73}, {Op: 2}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 52}, {Op: 28, A: 5}, {Op: 11}, {Op: 48, A: 1, Flags: 2}, {Op: 26, A: 6}, {Op: 11}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, Flags: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 4}, {Op: 12, A: 3}, {Op: 9}, {Op: 1}, {Op: 12, A: 4}, {Op: 9}, {Op: 11, A: 4}, {Op: 11, A: 1, B: 1}, {Op: 30, A: 1, Flags: 1}, {Op: 18}, {Op: 28, A: 53}, {Op: 11, A: 2, B: 1}, {Op: 11, A: 4}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 11, A: 2}, {Op: 22}, {Op: 10}, {Op: 28, A: 36}, {Op: 9}, {Op: 11, A: 1, B: 1}, {Op: 11, A: 4}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 11, A: 1}, {Op: 30, A: 3, B: 1, Flags: 3}, {Op: 28, A: 45}, {Op: 3}, {Op: 12, A: 3}, {Op: 9}, {Op: 2}, {Op: 12, A: 5}, {Op: 9}, {Op: 26, A: 55}, {Op: 26, A: 46}, {Op: 2}, {Op: 9}, {Op: 11, A: 4}, {Op: 1, A: 1}, {Op: 13}, {Op: 12, A: 4}, {Op: 9}, {Op: 26, A: 18}, {Op: 2}, {Op: 26, A: 56}, {Op: 11, A: 5}, {Op: 9}, {Op: 11, A: 3}, {Op: 25}, {Op: 28, A: 72}, {Op: 11, A: 1, B: 1}, {Op: 11, A: 1}, {Op: 30, A: 4, B: 1}, {Op: 9}, {Op: 11, A: 2, B: 1}, {Op: 11, A: 2}, {Op: 30, A: 4, B: 1}, {Op: 9}, {Op: 11, B: 1}, {Op: 11}, {Op: 30, A: 4, B: 1}, {Op: 26, A: 73}, {Op: 2}, {Op: 53}},
 								Consts: []object.Value{
 									object.IntValue(0),
 									object.IntValue(1),
@@ -1306,7 +1306,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "each_with_index",
-						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 14}, {Op: 5}, {Op: 6}, {Op: 1}, {Op: 6, A: 1}, {Op: 61}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 62, C: 1}, {Op: 53}, {Op: 26, A: 15}, {Op: 2}, {Op: 9}, {Op: 1, A: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 62, A: 1, C: 2}, {Op: 9}, {Op: 5}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 14}, {Op: 5}, {Op: 6}, {Op: 1}, {Op: 6, A: 1}, {Op: 61}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 62, C: 1, Flags: 2}, {Op: 53}, {Op: 26, A: 15}, {Op: 2}, {Op: 9}, {Op: 1, A: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 62, A: 1, C: 2, Flags: 2}, {Op: 9}, {Op: 5}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("each_with_index"),
 							object.IntValue(0),
@@ -1324,7 +1324,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in each_with_index",
-								Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1, Flags: 2}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}},
 								Consts: []object.Value{
 									object.Symbol("size"),
 								},
@@ -1340,7 +1340,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:  "block in each_with_index",
-								Insns: []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 11, A: 1, B: 1}, {Op: 48, A: 2}, {Op: 9}, {Op: 11, A: 1, B: 1}, {Op: 1}, {Op: 13}, {Op: 12, A: 1, B: 1}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 11, A: 1, B: 1}, {Op: 48, A: 2, Flags: 2}, {Op: 9}, {Op: 11, A: 1, B: 1}, {Op: 1}, {Op: 13}, {Op: 12, A: 1, B: 1}, {Op: 53}},
 								Consts: []object.Value{
 									object.IntValue(1),
 								},
@@ -1361,7 +1361,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "reverse_each",
-						Insns: []bytecode.Instr{{Op: 11}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1}, {Op: 11}, {Op: 66, A: 2, Flags: 1}, {Op: 9}, {Op: 5}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 11}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1, Flags: 2}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1}, {Op: 11}, {Op: 66, A: 2, Flags: 1}, {Op: 9}, {Op: 5}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("reverse_each"),
 						},
@@ -1377,7 +1377,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in reverse_each",
-								Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1, Flags: 2}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}},
 								Consts: []object.Value{
 									object.Symbol("size"),
 								},
@@ -1396,7 +1396,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "flat_map",
-						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 2}, {Op: 9}, {Op: 11}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1, Flags: 2}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 2}, {Op: 9}, {Op: 11}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("flat_map"),
 						},
@@ -1412,7 +1412,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in flat_map",
-								Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1, Flags: 2}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}},
 								Consts: []object.Value{
 									object.Symbol("size"),
 								},
@@ -1428,7 +1428,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:        "block in flat_map",
-								Insns:       []bytecode.Instr{{Op: 11}, {Op: 48, A: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 33}, {Op: 11, A: 1}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 30, A: 2, Flags: 1}, {Op: 28, A: 16}, {Op: 11, B: 1}, {Op: 11, A: 1}, {Op: 30, A: 3, B: 1}, {Op: 26, A: 18}, {Op: 11, A: 2}, {Op: 30, A: 4, C: 1, Flags: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 11}, {Op: 48, A: 1, Flags: 2}, {Op: 12, A: 1}, {Op: 9}, {Op: 33}, {Op: 11, A: 1}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 30, A: 2, Flags: 1}, {Op: 28, A: 16}, {Op: 11, B: 1}, {Op: 11, A: 1}, {Op: 30, A: 3, B: 1}, {Op: 26, A: 18}, {Op: 11, A: 2}, {Op: 30, A: 4, C: 1, Flags: 1}, {Op: 53}},
 								Names:       []string{"Array", "try_convert", "nil?", "<<", "each"},
 								Params:      []string{"x"},
 								NumRequired: 1,
@@ -1463,7 +1463,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "each_entry",
-						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 14}, {Op: 5}, {Op: 6}, {Op: 1}, {Op: 6, A: 1}, {Op: 61}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 62, C: 1}, {Op: 53}, {Op: 26, A: 15}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 62, A: 1, C: 2}, {Op: 9}, {Op: 5}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 14}, {Op: 5}, {Op: 6}, {Op: 1}, {Op: 6, A: 1}, {Op: 61}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 62, C: 1, Flags: 2}, {Op: 53}, {Op: 26, A: 15}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 62, A: 1, C: 2, Flags: 2}, {Op: 9}, {Op: 5}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("each_entry"),
 						},
@@ -1480,7 +1480,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in each_entry",
-								Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1, Flags: 2}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}},
 								Consts: []object.Value{
 									object.Symbol("size"),
 								},
@@ -1496,7 +1496,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:        "block in each_entry",
-								Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 48, A: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 48, A: 1, Flags: 2}, {Op: 53}},
 								Names:       []string{"__pack"},
 								Params:      []string{"a"},
 								NumRequired: 0,
@@ -1514,7 +1514,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "each_with_object",
-						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 9}, {Op: 5}, {Op: 1}, {Op: 11}, {Op: 30, B: 2, C: 1}, {Op: 53}, {Op: 26, A: 10}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 2}, {Op: 9}, {Op: 11}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 9}, {Op: 5}, {Op: 1}, {Op: 11}, {Op: 30, B: 2, C: 1, Flags: 2}, {Op: 53}, {Op: 26, A: 10}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 2}, {Op: 9}, {Op: 11}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("each_with_object"),
 						},
@@ -1531,7 +1531,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in each_with_object",
-								Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1, Flags: 2}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}},
 								Consts: []object.Value{
 									object.Symbol("size"),
 								},
@@ -1547,7 +1547,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:        "block in each_with_object",
-								Insns:       []bytecode.Instr{{Op: 11}, {Op: 11, B: 1}, {Op: 48, A: 2}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 11}, {Op: 11, B: 1}, {Op: 48, A: 2, Flags: 2}, {Op: 53}},
 								Params:      []string{"x"},
 								NumRequired: 1,
 								SplatIndex:  -1,
@@ -1564,7 +1564,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "filter_map",
-						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 2}, {Op: 9}, {Op: 11}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1, Flags: 2}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 2}, {Op: 9}, {Op: 11}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("filter_map"),
 						},
@@ -1580,7 +1580,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in filter_map",
-								Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1, Flags: 2}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}},
 								Consts: []object.Value{
 									object.Symbol("size"),
 								},
@@ -1596,7 +1596,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:        "block in filter_map",
-								Insns:       []bytecode.Instr{{Op: 11}, {Op: 48, A: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 28, A: 10}, {Op: 11, B: 1}, {Op: 11, A: 1}, {Op: 30, B: 1}, {Op: 26, A: 11}, {Op: 2}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 11}, {Op: 48, A: 1, Flags: 2}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 28, A: 10}, {Op: 11, B: 1}, {Op: 11, A: 1}, {Op: 30, B: 1}, {Op: 26, A: 11}, {Op: 2}, {Op: 53}},
 								Names:       []string{"<<"},
 								Params:      []string{"x"},
 								NumRequired: 1,
@@ -1614,7 +1614,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "partition",
-						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12}, {Op: 9}, {Op: 6}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 2}, {Op: 9}, {Op: 11}, {Op: 11, A: 1}, {Op: 6, A: 2}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1, Flags: 2}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12}, {Op: 9}, {Op: 6}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 2}, {Op: 9}, {Op: 11}, {Op: 11, A: 1}, {Op: 6, A: 2}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("partition"),
 						},
@@ -1630,7 +1630,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in partition",
-								Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1, Flags: 2}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}},
 								Consts: []object.Value{
 									object.Symbol("size"),
 								},
@@ -1646,7 +1646,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:        "block in partition",
-								Insns:       []bytecode.Instr{{Op: 11}, {Op: 48, A: 1}, {Op: 28, A: 7}, {Op: 11, B: 1}, {Op: 11}, {Op: 30, B: 1}, {Op: 26, A: 10}, {Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 30, B: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 11}, {Op: 48, A: 1, Flags: 2}, {Op: 28, A: 7}, {Op: 11, B: 1}, {Op: 11}, {Op: 30, B: 1}, {Op: 26, A: 10}, {Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 30, B: 1}, {Op: 53}},
 								Names:       []string{"<<"},
 								Params:      []string{"x"},
 								NumRequired: 1,
@@ -1664,7 +1664,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "group_by",
-						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 7}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 2}, {Op: 9}, {Op: 11}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1, Flags: 2}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 7}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 2}, {Op: 9}, {Op: 11}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("group_by"),
 						},
@@ -1680,7 +1680,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in group_by",
-								Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1, Flags: 2}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}},
 								Consts: []object.Value{
 									object.Symbol("size"),
 								},
@@ -1696,7 +1696,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:        "block in group_by",
-								Insns:       []bytecode.Instr{{Op: 11}, {Op: 48, A: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, B: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 12, A: 3}, {Op: 9}, {Op: 11, A: 2}, {Op: 11, A: 3}, {Op: 30, B: 1, Flags: 1}, {Op: 10}, {Op: 27, A: 26}, {Op: 9}, {Op: 6}, {Op: 12, A: 4}, {Op: 9}, {Op: 11, A: 2}, {Op: 11, A: 3}, {Op: 11, A: 4}, {Op: 30, A: 1, B: 2, Flags: 1}, {Op: 9}, {Op: 11, A: 4}, {Op: 26, A: 26}, {Op: 11}, {Op: 30, A: 2, B: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 11}, {Op: 48, A: 1, Flags: 2}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, B: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 12, A: 3}, {Op: 9}, {Op: 11, A: 2}, {Op: 11, A: 3}, {Op: 30, B: 1, Flags: 1}, {Op: 10}, {Op: 27, A: 26}, {Op: 9}, {Op: 6}, {Op: 12, A: 4}, {Op: 9}, {Op: 11, A: 2}, {Op: 11, A: 3}, {Op: 11, A: 4}, {Op: 30, A: 1, B: 2, Flags: 1}, {Op: 9}, {Op: 11, A: 4}, {Op: 26, A: 26}, {Op: 11}, {Op: 30, A: 2, B: 1}, {Op: 53}},
 								Names:       []string{"[]", "[]=", "<<"},
 								Params:      []string{"x"},
 								NumRequired: 1,
@@ -1714,7 +1714,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "tally",
-						Insns: []bytecode.Instr{{Op: 11}, {Op: 30, Flags: 1}, {Op: 1}, {Op: 19}, {Op: 28, A: 20}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 30, A: 2}, {Op: 13}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 30, A: 2}, {Op: 13}, {Op: 1, A: 3}, {Op: 30, A: 2}, {Op: 13}, {Op: 30, A: 3, B: 2}, {Op: 26, A: 21}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 28, A: 28}, {Op: 7}, {Op: 12, A: 1}, {Op: 26, A: 110}, {Op: 11}, {Op: 1, A: 4}, {Op: 30, A: 5, B: 1, Flags: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 33, A: 6}, {Op: 30, A: 7, B: 1, Flags: 1}, {Op: 25}, {Op: 28, A: 106}, {Op: 11, A: 2}, {Op: 1, A: 5}, {Op: 30, A: 8, B: 1, Flags: 1}, {Op: 28, A: 86}, {Op: 11, A: 2}, {Op: 30, A: 9, Flags: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 33, A: 6}, {Op: 30, A: 7, B: 1, Flags: 1}, {Op: 25}, {Op: 28, A: 84}, {Op: 5}, {Op: 33, A: 10}, {Op: 1, A: 6}, {Op: 1, A: 7}, {Op: 30, A: 2}, {Op: 13}, {Op: 11}, {Op: 1, A: 4}, {Op: 30, A: 5, B: 1, Flags: 1}, {Op: 30, A: 11, Flags: 1}, {Op: 30, A: 2}, {Op: 13}, {Op: 1, A: 8}, {Op: 30, A: 2}, {Op: 13}, {Op: 11}, {Op: 1, A: 4}, {Op: 30, A: 5, B: 1, Flags: 1}, {Op: 30, A: 11, Flags: 1}, {Op: 30, A: 2}, {Op: 13}, {Op: 1, A: 9}, {Op: 30, A: 2}, {Op: 13}, {Op: 11, A: 2}, {Op: 30, A: 11, Flags: 1}, {Op: 30, A: 2}, {Op: 13}, {Op: 1, A: 10}, {Op: 30, A: 2}, {Op: 13}, {Op: 30, A: 3, B: 2}, {Op: 26, A: 85}, {Op: 2}, {Op: 26, A: 105}, {Op: 5}, {Op: 33, A: 10}, {Op: 1, A: 11}, {Op: 1, A: 12}, {Op: 30, A: 2}, {Op: 13}, {Op: 11, A: 2}, {Op: 30, A: 12, Flags: 1}, {Op: 28, A: 97}, {Op: 1, A: 13}, {Op: 26, A: 99}, {Op: 11, A: 2}, {Op: 30, A: 11, Flags: 1}, {Op: 30, A: 2}, {Op: 13}, {Op: 1, A: 14}, {Op: 30, A: 2}, {Op: 13}, {Op: 30, A: 3, B: 2}, {Op: 26, A: 107}, {Op: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 30, A: 13, C: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 11}, {Op: 30, Flags: 1}, {Op: 1}, {Op: 19}, {Op: 28, A: 20}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 30, A: 2}, {Op: 13}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 30, A: 2}, {Op: 13}, {Op: 1, A: 3}, {Op: 30, A: 2}, {Op: 13}, {Op: 30, A: 3, B: 2, Flags: 2}, {Op: 26, A: 21}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 28, A: 28}, {Op: 7}, {Op: 12, A: 1}, {Op: 26, A: 110}, {Op: 11}, {Op: 1, A: 4}, {Op: 30, A: 5, B: 1, Flags: 3}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 33, A: 6}, {Op: 30, A: 7, B: 1, Flags: 3}, {Op: 25}, {Op: 28, A: 106}, {Op: 11, A: 2}, {Op: 1, A: 5}, {Op: 30, A: 8, B: 1, Flags: 3}, {Op: 28, A: 86}, {Op: 11, A: 2}, {Op: 30, A: 9, Flags: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 33, A: 6}, {Op: 30, A: 7, B: 1, Flags: 3}, {Op: 25}, {Op: 28, A: 84}, {Op: 5}, {Op: 33, A: 10}, {Op: 1, A: 6}, {Op: 1, A: 7}, {Op: 30, A: 2}, {Op: 13}, {Op: 11}, {Op: 1, A: 4}, {Op: 30, A: 5, B: 1, Flags: 3}, {Op: 30, A: 11, Flags: 1}, {Op: 30, A: 2}, {Op: 13}, {Op: 1, A: 8}, {Op: 30, A: 2}, {Op: 13}, {Op: 11}, {Op: 1, A: 4}, {Op: 30, A: 5, B: 1, Flags: 3}, {Op: 30, A: 11, Flags: 1}, {Op: 30, A: 2}, {Op: 13}, {Op: 1, A: 9}, {Op: 30, A: 2}, {Op: 13}, {Op: 11, A: 2}, {Op: 30, A: 11, Flags: 1}, {Op: 30, A: 2}, {Op: 13}, {Op: 1, A: 10}, {Op: 30, A: 2}, {Op: 13}, {Op: 30, A: 3, B: 2, Flags: 2}, {Op: 26, A: 85}, {Op: 2}, {Op: 26, A: 105}, {Op: 5}, {Op: 33, A: 10}, {Op: 1, A: 11}, {Op: 1, A: 12}, {Op: 30, A: 2}, {Op: 13}, {Op: 11, A: 2}, {Op: 30, A: 12, Flags: 1}, {Op: 28, A: 97}, {Op: 1, A: 13}, {Op: 26, A: 99}, {Op: 11, A: 2}, {Op: 30, A: 11, Flags: 1}, {Op: 30, A: 2}, {Op: 13}, {Op: 1, A: 14}, {Op: 30, A: 2}, {Op: 13}, {Op: 30, A: 3, B: 2, Flags: 2}, {Op: 26, A: 107}, {Op: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 30, A: 13, C: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}},
 						Consts: []object.Value{
 							object.IntValue(1),
 							object.NewString(""),
@@ -1745,7 +1745,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in tally",
-								Insns: []bytecode.Instr{{Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 30, B: 1, Flags: 1}, {Op: 28, A: 51}, {Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 33, A: 2}, {Op: 30, A: 3, B: 1, Flags: 1}, {Op: 25}, {Op: 28, A: 49}, {Op: 11, A: 1}, {Op: 30, A: 4, Flags: 1}, {Op: 28, A: 19}, {Op: 1}, {Op: 26, A: 33}, {Op: 11, A: 1}, {Op: 3}, {Op: 22}, {Op: 28, A: 25}, {Op: 1, A: 1}, {Op: 26, A: 33}, {Op: 11, A: 1}, {Op: 4}, {Op: 22}, {Op: 28, A: 31}, {Op: 1, A: 2}, {Op: 26, A: 33}, {Op: 11, A: 1}, {Op: 30, A: 5, Flags: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 5}, {Op: 33, A: 6}, {Op: 1, A: 3}, {Op: 1, A: 4}, {Op: 30, A: 7}, {Op: 13}, {Op: 11, A: 2}, {Op: 30, A: 7}, {Op: 13}, {Op: 1, A: 5}, {Op: 30, A: 7}, {Op: 13}, {Op: 30, A: 8, B: 2}, {Op: 26, A: 50}, {Op: 2}, {Op: 26, A: 53}, {Op: 1, A: 6}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 11, A: 1}, {Op: 1, A: 7}, {Op: 13}, {Op: 12, A: 3}, {Op: 30, A: 9, B: 2, Flags: 1}, {Op: 9}, {Op: 11, A: 3}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 30, B: 1, Flags: 3}, {Op: 28, A: 51}, {Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 33, A: 2}, {Op: 30, A: 3, B: 1, Flags: 3}, {Op: 25}, {Op: 28, A: 49}, {Op: 11, A: 1}, {Op: 30, A: 4, Flags: 1}, {Op: 28, A: 19}, {Op: 1}, {Op: 26, A: 33}, {Op: 11, A: 1}, {Op: 3}, {Op: 22}, {Op: 28, A: 25}, {Op: 1, A: 1}, {Op: 26, A: 33}, {Op: 11, A: 1}, {Op: 4}, {Op: 22}, {Op: 28, A: 31}, {Op: 1, A: 2}, {Op: 26, A: 33}, {Op: 11, A: 1}, {Op: 30, A: 5, Flags: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 5}, {Op: 33, A: 6}, {Op: 1, A: 3}, {Op: 1, A: 4}, {Op: 30, A: 7}, {Op: 13}, {Op: 11, A: 2}, {Op: 30, A: 7}, {Op: 13}, {Op: 1, A: 5}, {Op: 30, A: 7}, {Op: 13}, {Op: 30, A: 8, B: 2, Flags: 2}, {Op: 26, A: 50}, {Op: 2}, {Op: 26, A: 53}, {Op: 1, A: 6}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 11, A: 1}, {Op: 1, A: 7}, {Op: 13}, {Op: 12, A: 3}, {Op: 30, A: 9, B: 2, Flags: 3}, {Op: 9}, {Op: 11, A: 3}, {Op: 53}},
 								Consts: []object.Value{
 									object.NewString("nil"),
 									object.NewString("true"),
@@ -1790,7 +1790,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in zip",
-								Insns: []bytecode.Instr{{Op: 11}, {Op: 1}, {Op: 30, B: 1, Flags: 1}, {Op: 28, A: 7}, {Op: 11}, {Op: 30, A: 1, Flags: 1}, {Op: 26, A: 30}, {Op: 11}, {Op: 1, A: 1}, {Op: 30, B: 1, Flags: 1}, {Op: 28, A: 16}, {Op: 11}, {Op: 1, A: 1}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 30, A: 3, Flags: 1}, {Op: 26, A: 30}, {Op: 5}, {Op: 33, A: 4}, {Op: 1, A: 2}, {Op: 1, A: 3}, {Op: 30, A: 5}, {Op: 13}, {Op: 11}, {Op: 30, A: 6, Flags: 1}, {Op: 30, A: 5}, {Op: 13}, {Op: 1, A: 4}, {Op: 30, A: 5}, {Op: 13}, {Op: 30, A: 7, B: 2}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 11}, {Op: 1}, {Op: 30, B: 1, Flags: 3}, {Op: 28, A: 7}, {Op: 11}, {Op: 30, A: 1, Flags: 1}, {Op: 26, A: 30}, {Op: 11}, {Op: 1, A: 1}, {Op: 30, B: 1, Flags: 3}, {Op: 28, A: 16}, {Op: 11}, {Op: 1, A: 1}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 30, A: 3, Flags: 1}, {Op: 26, A: 30}, {Op: 5}, {Op: 33, A: 4}, {Op: 1, A: 2}, {Op: 1, A: 3}, {Op: 30, A: 5}, {Op: 13}, {Op: 11}, {Op: 30, A: 6, Flags: 1}, {Op: 30, A: 5}, {Op: 13}, {Op: 1, A: 4}, {Op: 30, A: 5}, {Op: 13}, {Op: 30, A: 7, B: 2, Flags: 2}, {Op: 53}},
 								Consts: []object.Value{
 									object.Symbol("to_ary"),
 									object.Symbol("each"),
@@ -1812,7 +1812,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:  "block in zip",
-								Insns: []bytecode.Instr{{Op: 11}, {Op: 6, A: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, B: 1}, {Op: 30, C: 1, Flags: 1}, {Op: 9}, {Op: 11, A: 1, B: 1}, {Op: 28, A: 12}, {Op: 11, A: 1}, {Op: 48, A: 1}, {Op: 26, A: 15}, {Op: 11, A: 2, B: 1}, {Op: 11, A: 1}, {Op: 30, A: 1, B: 1}, {Op: 9}, {Op: 11, A: 3, B: 1}, {Op: 1}, {Op: 13}, {Op: 12, A: 3, B: 1}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 11}, {Op: 6, A: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, B: 1}, {Op: 30, C: 1, Flags: 1}, {Op: 9}, {Op: 11, A: 1, B: 1}, {Op: 28, A: 12}, {Op: 11, A: 1}, {Op: 48, A: 1, Flags: 2}, {Op: 26, A: 15}, {Op: 11, A: 2, B: 1}, {Op: 11, A: 1}, {Op: 30, A: 1, B: 1}, {Op: 9}, {Op: 11, A: 3, B: 1}, {Op: 1}, {Op: 13}, {Op: 12, A: 3, B: 1}, {Op: 53}},
 								Consts: []object.Value{
 									object.IntValue(1),
 								},
@@ -1829,7 +1829,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:        "block (2 levels) in zip",
-										Insns:       []bytecode.Instr{{Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 11, A: 3, B: 2}, {Op: 30, B: 1, Flags: 1}, {Op: 30, A: 1, B: 1}, {Op: 53}},
+										Insns:       []bytecode.Instr{{Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 11, A: 3, B: 2}, {Op: 30, B: 1, Flags: 3}, {Op: 30, A: 1, B: 1}, {Op: 53}},
 										Names:       []string{"[]", "<<"},
 										Params:      []string{"o"},
 										NumRequired: 1,
@@ -1850,7 +1850,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "find_index",
-						Insns: []bytecode.Instr{{Op: 11}, {Op: 30, Flags: 1}, {Op: 1}, {Op: 19}, {Op: 28, A: 20}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 30, A: 2}, {Op: 13}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 30, A: 2}, {Op: 13}, {Op: 1, A: 3}, {Op: 30, A: 2}, {Op: 13}, {Op: 30, A: 3, B: 2}, {Op: 26, A: 21}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 10}, {Op: 28, A: 29}, {Op: 9}, {Op: 52}, {Op: 25}, {Op: 28, A: 35}, {Op: 5}, {Op: 1, A: 4}, {Op: 30, A: 5, B: 1, C: 1}, {Op: 53}, {Op: 26, A: 36}, {Op: 2}, {Op: 9}, {Op: 2}, {Op: 12, A: 1}, {Op: 9}, {Op: 1, A: 5}, {Op: 12, A: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 6, C: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 11}, {Op: 30, Flags: 1}, {Op: 1}, {Op: 19}, {Op: 28, A: 20}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 30, A: 2}, {Op: 13}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 30, A: 2}, {Op: 13}, {Op: 1, A: 3}, {Op: 30, A: 2}, {Op: 13}, {Op: 30, A: 3, B: 2, Flags: 2}, {Op: 26, A: 21}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 10}, {Op: 28, A: 29}, {Op: 9}, {Op: 52}, {Op: 25}, {Op: 28, A: 35}, {Op: 5}, {Op: 1, A: 4}, {Op: 30, A: 5, B: 1, C: 1, Flags: 2}, {Op: 53}, {Op: 26, A: 36}, {Op: 2}, {Op: 9}, {Op: 2}, {Op: 12, A: 1}, {Op: 9}, {Op: 1, A: 5}, {Op: 12, A: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 6, C: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}},
 						Consts: []object.Value{
 							object.IntValue(1),
 							object.NewString(""),
@@ -1884,7 +1884,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:  "block in find_index",
-								Insns: []bytecode.Instr{{Op: 11, A: 1, B: 1}, {Op: 30, Flags: 1}, {Op: 10}, {Op: 28, A: 21}, {Op: 9}, {Op: 11, B: 1}, {Op: 30, A: 1, Flags: 1}, {Op: 28, A: 14}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 49}, {Op: 26, A: 21}, {Op: 5}, {Op: 11}, {Op: 30, A: 2, B: 1}, {Op: 11, B: 1}, {Op: 1}, {Op: 30, A: 3, B: 1, Flags: 1}, {Op: 22}, {Op: 28, A: 25}, {Op: 11, A: 2, B: 1}, {Op: 12, A: 1, B: 1}, {Op: 26, A: 26}, {Op: 2}, {Op: 9}, {Op: 11, A: 2, B: 1}, {Op: 1, A: 1}, {Op: 13}, {Op: 12, A: 2, B: 1}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 11, A: 1, B: 1}, {Op: 30, Flags: 1}, {Op: 10}, {Op: 28, A: 21}, {Op: 9}, {Op: 11, B: 1}, {Op: 30, A: 1, Flags: 1}, {Op: 28, A: 14}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 49, Flags: 2}, {Op: 26, A: 21}, {Op: 5}, {Op: 11}, {Op: 30, A: 2, B: 1, Flags: 2}, {Op: 11, B: 1}, {Op: 1}, {Op: 30, A: 3, B: 1, Flags: 3}, {Op: 22}, {Op: 28, A: 25}, {Op: 11, A: 2, B: 1}, {Op: 12, A: 1, B: 1}, {Op: 26, A: 26}, {Op: 2}, {Op: 9}, {Op: 11, A: 2, B: 1}, {Op: 1, A: 1}, {Op: 13}, {Op: 12, A: 2, B: 1}, {Op: 53}},
 								Consts: []object.Value{
 									object.IntValue(0),
 									object.IntValue(1),
@@ -1920,7 +1920,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in grep",
-								Insns:       []bytecode.Instr{{Op: 11, B: 1}, {Op: 11}, {Op: 30, B: 1}, {Op: 28, A: 13}, {Op: 11, A: 1, B: 1}, {Op: 52}, {Op: 28, A: 10}, {Op: 11}, {Op: 48, A: 1}, {Op: 26, A: 11}, {Op: 11}, {Op: 30, A: 1, B: 1}, {Op: 26, A: 14}, {Op: 2}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 11, B: 1}, {Op: 11}, {Op: 30, B: 1}, {Op: 28, A: 13}, {Op: 11, A: 1, B: 1}, {Op: 52}, {Op: 28, A: 10}, {Op: 11}, {Op: 48, A: 1, Flags: 2}, {Op: 26, A: 11}, {Op: 11}, {Op: 30, A: 1, B: 1}, {Op: 26, A: 14}, {Op: 2}, {Op: 53}},
 								Names:       []string{"===", "<<"},
 								Params:      []string{"x"},
 								NumRequired: 1,
@@ -1952,7 +1952,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in grep_v",
-								Insns:       []bytecode.Instr{{Op: 11, B: 1}, {Op: 11}, {Op: 30, B: 1}, {Op: 25}, {Op: 28, A: 14}, {Op: 11, A: 1, B: 1}, {Op: 52}, {Op: 28, A: 11}, {Op: 11}, {Op: 48, A: 1}, {Op: 26, A: 12}, {Op: 11}, {Op: 30, A: 1, B: 1}, {Op: 26, A: 15}, {Op: 2}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 11, B: 1}, {Op: 11}, {Op: 30, B: 1}, {Op: 25}, {Op: 28, A: 14}, {Op: 11, A: 1, B: 1}, {Op: 52}, {Op: 28, A: 11}, {Op: 11}, {Op: 48, A: 1, Flags: 2}, {Op: 26, A: 12}, {Op: 11}, {Op: 30, A: 1, B: 1}, {Op: 26, A: 15}, {Op: 2}, {Op: 53}},
 								Names:       []string{"===", "<<"},
 								Params:      []string{"x"},
 								NumRequired: 1,
@@ -1970,7 +1970,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "take_while",
-						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12}, {Op: 9}, {Op: 3}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 2}, {Op: 9}, {Op: 11}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1, Flags: 2}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12}, {Op: 9}, {Op: 3}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 2}, {Op: 9}, {Op: 11}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("take_while"),
 						},
@@ -1998,7 +1998,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:        "block in take_while",
-								Insns:       []bytecode.Instr{{Op: 11, A: 1, B: 1}, {Op: 25}, {Op: 28, A: 6}, {Op: 2}, {Op: 53}, {Op: 26, A: 7}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 49}, {Op: 28, A: 20}, {Op: 11, B: 1}, {Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 30, A: 1, B: 1}, {Op: 26, A: 22}, {Op: 4}, {Op: 12, A: 1, B: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 11, A: 1, B: 1}, {Op: 25}, {Op: 28, A: 6}, {Op: 2}, {Op: 53}, {Op: 26, A: 7}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 49, Flags: 2}, {Op: 28, A: 20}, {Op: 11, B: 1}, {Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 30, A: 1, B: 1}, {Op: 26, A: 22}, {Op: 4}, {Op: 12, A: 1, B: 1}, {Op: 53}},
 								Names:       []string{"__pack", "<<"},
 								Params:      []string{"a"},
 								NumRequired: 0,
@@ -2016,7 +2016,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "drop_while",
-						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12}, {Op: 9}, {Op: 3}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 2}, {Op: 9}, {Op: 11}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1, Flags: 2}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12}, {Op: 9}, {Op: 3}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 2}, {Op: 9}, {Op: 11}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("drop_while"),
 						},
@@ -2044,7 +2044,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:        "block in drop_while",
-								Insns:       []bytecode.Instr{{Op: 11, A: 1, B: 1}, {Op: 10}, {Op: 28, A: 7}, {Op: 9}, {Op: 11}, {Op: 48, A: 1}, {Op: 25}, {Op: 28, A: 11}, {Op: 4}, {Op: 12, A: 1, B: 1}, {Op: 26, A: 12}, {Op: 2}, {Op: 9}, {Op: 11, A: 1, B: 1}, {Op: 25}, {Op: 28, A: 20}, {Op: 11, B: 1}, {Op: 11}, {Op: 30, B: 1}, {Op: 26, A: 21}, {Op: 2}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 11, A: 1, B: 1}, {Op: 10}, {Op: 28, A: 7}, {Op: 9}, {Op: 11}, {Op: 48, A: 1, Flags: 2}, {Op: 25}, {Op: 28, A: 11}, {Op: 4}, {Op: 12, A: 1, B: 1}, {Op: 26, A: 12}, {Op: 2}, {Op: 9}, {Op: 11, A: 1, B: 1}, {Op: 25}, {Op: 28, A: 20}, {Op: 11, B: 1}, {Op: 11}, {Op: 30, B: 1}, {Op: 26, A: 21}, {Op: 2}, {Op: 53}},
 								Names:       []string{"<<"},
 								Params:      []string{"x"},
 								NumRequired: 1,
@@ -2062,7 +2062,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "each_slice",
-						Insns: []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 1}, {Op: 20}, {Op: 28, A: 14}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 1}, {Op: 30, A: 2, B: 2}, {Op: 26, A: 15}, {Op: 2}, {Op: 9}, {Op: 52}, {Op: 25}, {Op: 28, A: 25}, {Op: 5}, {Op: 1, A: 2}, {Op: 11}, {Op: 30, A: 3, B: 2, C: 1}, {Op: 53}, {Op: 26, A: 26}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 30, A: 4, C: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 5, Flags: 1}, {Op: 25}, {Op: 28, A: 40}, {Op: 11, A: 1}, {Op: 48, A: 1}, {Op: 26, A: 41}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 1}, {Op: 20}, {Op: 28, A: 14}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 1}, {Op: 30, A: 2, B: 2, Flags: 2}, {Op: 26, A: 15}, {Op: 2}, {Op: 9}, {Op: 52}, {Op: 25}, {Op: 28, A: 25}, {Op: 5}, {Op: 1, A: 2}, {Op: 11}, {Op: 30, A: 3, B: 2, C: 1, Flags: 2}, {Op: 53}, {Op: 26, A: 26}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 30, A: 4, C: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 5, Flags: 1}, {Op: 25}, {Op: 28, A: 40}, {Op: 11, A: 1}, {Op: 48, A: 1, Flags: 2}, {Op: 26, A: 41}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 53}},
 						Consts: []object.Value{
 							object.IntValue(0),
 							object.NewString("invalid slice size"),
@@ -2081,7 +2081,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in each_slice",
-								Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 28, A: 8}, {Op: 5}, {Op: 30, A: 1}, {Op: 12}, {Op: 26, A: 9}, {Op: 2}, {Op: 28, A: 18}, {Op: 11}, {Op: 11, B: 1}, {Op: 13}, {Op: 1, A: 1}, {Op: 14}, {Op: 11, B: 1}, {Op: 16}, {Op: 26, A: 19}, {Op: 2}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1, Flags: 2}, {Op: 28, A: 8}, {Op: 5}, {Op: 30, A: 1}, {Op: 12}, {Op: 26, A: 9}, {Op: 2}, {Op: 28, A: 18}, {Op: 11}, {Op: 11, B: 1}, {Op: 13}, {Op: 1, A: 1}, {Op: 14}, {Op: 11, B: 1}, {Op: 16}, {Op: 26, A: 19}, {Op: 2}, {Op: 53}},
 								Consts: []object.Value{
 									object.Symbol("size"),
 									object.IntValue(1),
@@ -2099,7 +2099,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:        "block in each_slice",
-								Insns:       []bytecode.Instr{{Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 30, B: 1}, {Op: 9}, {Op: 11, A: 1, B: 1}, {Op: 30, A: 1, Flags: 1}, {Op: 11, B: 1}, {Op: 22}, {Op: 28, A: 15}, {Op: 11, A: 1, B: 1}, {Op: 48, A: 1}, {Op: 9}, {Op: 6}, {Op: 12, A: 1, B: 1}, {Op: 26, A: 16}, {Op: 2}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 30, B: 1}, {Op: 9}, {Op: 11, A: 1, B: 1}, {Op: 30, A: 1, Flags: 1}, {Op: 11, B: 1}, {Op: 22}, {Op: 28, A: 15}, {Op: 11, A: 1, B: 1}, {Op: 48, A: 1, Flags: 2}, {Op: 9}, {Op: 6}, {Op: 12, A: 1, B: 1}, {Op: 26, A: 16}, {Op: 2}, {Op: 53}},
 								Names:       []string{"<<", "length"},
 								Params:      []string{"x"},
 								NumRequired: 1,
@@ -2117,7 +2117,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "each_cons",
-						Insns: []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 1}, {Op: 20}, {Op: 28, A: 14}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 1}, {Op: 30, A: 2, B: 2}, {Op: 26, A: 15}, {Op: 2}, {Op: 9}, {Op: 52}, {Op: 25}, {Op: 28, A: 25}, {Op: 5}, {Op: 1, A: 2}, {Op: 11}, {Op: 30, A: 3, B: 2, C: 1}, {Op: 53}, {Op: 26, A: 26}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 30, A: 4, C: 2}, {Op: 9}, {Op: 5}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 1}, {Op: 20}, {Op: 28, A: 14}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 1}, {Op: 30, A: 2, B: 2, Flags: 2}, {Op: 26, A: 15}, {Op: 2}, {Op: 9}, {Op: 52}, {Op: 25}, {Op: 28, A: 25}, {Op: 5}, {Op: 1, A: 2}, {Op: 11}, {Op: 30, A: 3, B: 2, C: 1, Flags: 2}, {Op: 53}, {Op: 26, A: 26}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 30, A: 4, C: 2}, {Op: 9}, {Op: 5}, {Op: 53}},
 						Consts: []object.Value{
 							object.IntValue(0),
 							object.NewString("invalid size"),
@@ -2136,7 +2136,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in each_cons",
-								Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 12}, {Op: 28, A: 26}, {Op: 11}, {Op: 11, B: 1}, {Op: 14}, {Op: 1, A: 1}, {Op: 13}, {Op: 1, A: 2}, {Op: 18}, {Op: 28, A: 20}, {Op: 1, A: 2}, {Op: 26, A: 25}, {Op: 11}, {Op: 11, B: 1}, {Op: 14}, {Op: 1, A: 1}, {Op: 13}, {Op: 26, A: 27}, {Op: 2}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1, Flags: 2}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 12}, {Op: 28, A: 26}, {Op: 11}, {Op: 11, B: 1}, {Op: 14}, {Op: 1, A: 1}, {Op: 13}, {Op: 1, A: 2}, {Op: 18}, {Op: 28, A: 20}, {Op: 1, A: 2}, {Op: 26, A: 25}, {Op: 11}, {Op: 11, B: 1}, {Op: 14}, {Op: 1, A: 1}, {Op: 13}, {Op: 26, A: 27}, {Op: 2}, {Op: 53}},
 								Consts: []object.Value{
 									object.Symbol("size"),
 									object.IntValue(1),
@@ -2155,7 +2155,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:        "block in each_cons",
-								Insns:       []bytecode.Instr{{Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 30, B: 1}, {Op: 9}, {Op: 11, A: 1, B: 1}, {Op: 30, A: 1, Flags: 1}, {Op: 11, B: 1}, {Op: 19}, {Op: 28, A: 12}, {Op: 11, A: 1, B: 1}, {Op: 30, A: 2, Flags: 1}, {Op: 26, A: 13}, {Op: 2}, {Op: 9}, {Op: 11, A: 1, B: 1}, {Op: 30, A: 1, Flags: 1}, {Op: 11, B: 1}, {Op: 22}, {Op: 28, A: 23}, {Op: 11, A: 1, B: 1}, {Op: 30, A: 3, Flags: 1}, {Op: 48, A: 1}, {Op: 26, A: 24}, {Op: 2}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 30, B: 1}, {Op: 9}, {Op: 11, A: 1, B: 1}, {Op: 30, A: 1, Flags: 1}, {Op: 11, B: 1}, {Op: 19}, {Op: 28, A: 12}, {Op: 11, A: 1, B: 1}, {Op: 30, A: 2, Flags: 1}, {Op: 26, A: 13}, {Op: 2}, {Op: 9}, {Op: 11, A: 1, B: 1}, {Op: 30, A: 1, Flags: 1}, {Op: 11, B: 1}, {Op: 22}, {Op: 28, A: 23}, {Op: 11, A: 1, B: 1}, {Op: 30, A: 3, Flags: 1}, {Op: 48, A: 1, Flags: 2}, {Op: 26, A: 24}, {Op: 2}, {Op: 53}},
 								Names:       []string{"<<", "length", "shift", "dup"},
 								Params:      []string{"x"},
 								NumRequired: 1,
@@ -2173,7 +2173,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "first",
-						Insns: []bytecode.Instr{{Op: 11}, {Op: 30, Flags: 1}, {Op: 1}, {Op: 19}, {Op: 28, A: 20}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 30, A: 2}, {Op: 13}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 30, A: 2}, {Op: 13}, {Op: 1, A: 3}, {Op: 30, A: 2}, {Op: 13}, {Op: 30, A: 3, B: 2}, {Op: 26, A: 21}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 28, A: 35}, {Op: 2}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 1, A: 4}, {Op: 30, A: 5, B: 1, C: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}, {Op: 26, A: 36}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 11}, {Op: 1, A: 5}, {Op: 30, A: 6, B: 1, Flags: 1}, {Op: 30, A: 7, B: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 1, A: 5}, {Op: 18}, {Op: 28, A: 53}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 6}, {Op: 30, A: 3, B: 2}, {Op: 26, A: 54}, {Op: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 1, A: 5}, {Op: 22}, {Op: 28, A: 62}, {Op: 6}, {Op: 53}, {Op: 26, A: 63}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12, A: 3}, {Op: 9}, {Op: 5}, {Op: 1, A: 4}, {Op: 30, A: 5, B: 1, C: 2}, {Op: 9}, {Op: 11, A: 3}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 11}, {Op: 30, Flags: 1}, {Op: 1}, {Op: 19}, {Op: 28, A: 20}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 30, A: 2}, {Op: 13}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 30, A: 2}, {Op: 13}, {Op: 1, A: 3}, {Op: 30, A: 2}, {Op: 13}, {Op: 30, A: 3, B: 2, Flags: 2}, {Op: 26, A: 21}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 28, A: 35}, {Op: 2}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 1, A: 4}, {Op: 30, A: 5, B: 1, C: 1, Flags: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}, {Op: 26, A: 36}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 11}, {Op: 1, A: 5}, {Op: 30, A: 6, B: 1, Flags: 3}, {Op: 30, A: 7, B: 1, Flags: 2}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 1, A: 5}, {Op: 18}, {Op: 28, A: 53}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 6}, {Op: 30, A: 3, B: 2, Flags: 2}, {Op: 26, A: 54}, {Op: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 1, A: 5}, {Op: 22}, {Op: 28, A: 62}, {Op: 6}, {Op: 53}, {Op: 26, A: 63}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12, A: 3}, {Op: 9}, {Op: 5}, {Op: 1, A: 4}, {Op: 30, A: 5, B: 1, C: 2, Flags: 2}, {Op: 9}, {Op: 11, A: 3}, {Op: 53}},
 						Consts: []object.Value{
 							object.IntValue(1),
 							object.NewString(""),
@@ -2208,7 +2208,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:  "block (2 levels) in first",
-										Insns: []bytecode.Instr{{Op: 11}, {Op: 12, A: 1, B: 2}, {Op: 9}, {Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 53}},
+										Insns: []bytecode.Instr{{Op: 11}, {Op: 12, A: 1, B: 2}, {Op: 9}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, Flags: 2}, {Op: 53}},
 										Consts: []object.Value{
 											object.Symbol("__enum_first"),
 										},
@@ -2241,7 +2241,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:  "block (2 levels) in first",
-										Insns: []bytecode.Instr{{Op: 11, A: 3, B: 2}, {Op: 11}, {Op: 30, B: 1}, {Op: 9}, {Op: 11, A: 3, B: 2}, {Op: 30, A: 1, Flags: 1}, {Op: 11, A: 2, B: 2}, {Op: 21}, {Op: 28, A: 13}, {Op: 5}, {Op: 1}, {Op: 30, A: 2, B: 1}, {Op: 26, A: 14}, {Op: 2}, {Op: 53}},
+										Insns: []bytecode.Instr{{Op: 11, A: 3, B: 2}, {Op: 11}, {Op: 30, B: 1}, {Op: 9}, {Op: 11, A: 3, B: 2}, {Op: 30, A: 1, Flags: 1}, {Op: 11, A: 2, B: 2}, {Op: 21}, {Op: 28, A: 13}, {Op: 5}, {Op: 1}, {Op: 30, A: 2, B: 1, Flags: 2}, {Op: 26, A: 14}, {Op: 2}, {Op: 53}},
 										Consts: []object.Value{
 											object.Symbol("__enum_first"),
 										},
@@ -2265,7 +2265,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "take",
-						Insns: []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 1}, {Op: 18}, {Op: 28, A: 14}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 1}, {Op: 30, A: 2, B: 2}, {Op: 26, A: 15}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 1}, {Op: 22}, {Op: 28, A: 23}, {Op: 6}, {Op: 53}, {Op: 26, A: 24}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 1, A: 2}, {Op: 30, A: 3, B: 1, C: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 1}, {Op: 18}, {Op: 28, A: 14}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 1}, {Op: 30, A: 2, B: 2, Flags: 2}, {Op: 26, A: 15}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 1}, {Op: 22}, {Op: 28, A: 23}, {Op: 6}, {Op: 53}, {Op: 26, A: 24}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 1, A: 2}, {Op: 30, A: 3, B: 1, C: 1, Flags: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}},
 						Consts: []object.Value{
 							object.IntValue(0),
 							object.NewString("attempt to take negative size"),
@@ -2296,7 +2296,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:  "block (2 levels) in take",
-										Insns: []bytecode.Instr{{Op: 11, A: 1, B: 2}, {Op: 11}, {Op: 30, B: 1}, {Op: 9}, {Op: 11, A: 1, B: 2}, {Op: 30, A: 1, Flags: 1}, {Op: 11, B: 2}, {Op: 21}, {Op: 28, A: 13}, {Op: 5}, {Op: 1}, {Op: 30, A: 2, B: 1}, {Op: 26, A: 14}, {Op: 2}, {Op: 53}},
+										Insns: []bytecode.Instr{{Op: 11, A: 1, B: 2}, {Op: 11}, {Op: 30, B: 1}, {Op: 9}, {Op: 11, A: 1, B: 2}, {Op: 30, A: 1, Flags: 1}, {Op: 11, B: 2}, {Op: 21}, {Op: 28, A: 13}, {Op: 5}, {Op: 1}, {Op: 30, A: 2, B: 1, Flags: 2}, {Op: 26, A: 14}, {Op: 2}, {Op: 53}},
 										Consts: []object.Value{
 											object.Symbol("__enum_take"),
 										},
@@ -2320,7 +2320,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "drop",
-						Insns: []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 1}, {Op: 18}, {Op: 28, A: 14}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 1}, {Op: 30, A: 2, B: 2}, {Op: 26, A: 15}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12, A: 1}, {Op: 9}, {Op: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 3, C: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 1}, {Op: 18}, {Op: 28, A: 14}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 1}, {Op: 30, A: 2, B: 2, Flags: 2}, {Op: 26, A: 15}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12, A: 1}, {Op: 9}, {Op: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 3, C: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}},
 						Consts: []object.Value{
 							object.IntValue(0),
 							object.NewString("attempt to drop negative size"),
@@ -2359,7 +2359,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "chunk_while",
-						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 33}, {Op: 1}, {Op: 30, A: 1, B: 2}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 2}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 30, A: 3, Flags: 1}, {Op: 28, A: 22}, {Op: 6}, {Op: 1, A: 1}, {Op: 30, A: 4, B: 1, Flags: 1}, {Op: 53}, {Op: 26, A: 23}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12, A: 1}, {Op: 9}, {Op: 11}, {Op: 1, A: 2}, {Op: 30, A: 5, B: 1, Flags: 1}, {Op: 6, A: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 1, A: 3}, {Op: 12, A: 3}, {Op: 9}, {Op: 11, A: 3}, {Op: 11}, {Op: 30, A: 6, Flags: 1}, {Op: 18}, {Op: 28, A: 73}, {Op: 11}, {Op: 11, A: 3}, {Op: 1, A: 3}, {Op: 14}, {Op: 30, A: 5, B: 1, Flags: 1}, {Op: 11}, {Op: 11, A: 3}, {Op: 30, A: 5, B: 1, Flags: 1}, {Op: 48, A: 2}, {Op: 28, A: 57}, {Op: 11, A: 2}, {Op: 11}, {Op: 11, A: 3}, {Op: 30, A: 5, B: 1, Flags: 1}, {Op: 30, A: 7, B: 1}, {Op: 26, A: 66}, {Op: 11, A: 1}, {Op: 11, A: 2}, {Op: 30, A: 7, B: 1}, {Op: 9}, {Op: 11}, {Op: 11, A: 3}, {Op: 30, A: 5, B: 1, Flags: 1}, {Op: 6, A: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 3}, {Op: 1, A: 3}, {Op: 13}, {Op: 12, A: 3}, {Op: 9}, {Op: 26, A: 36}, {Op: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 11, A: 2}, {Op: 30, A: 7, B: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 1, A: 1}, {Op: 30, A: 4, B: 1, Flags: 1}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 33}, {Op: 1}, {Op: 30, A: 1, B: 2, Flags: 2}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 2}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 30, A: 3, Flags: 1}, {Op: 28, A: 22}, {Op: 6}, {Op: 1, A: 1}, {Op: 30, A: 4, B: 1, Flags: 3}, {Op: 53}, {Op: 26, A: 23}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12, A: 1}, {Op: 9}, {Op: 11}, {Op: 1, A: 2}, {Op: 30, A: 5, B: 1, Flags: 3}, {Op: 6, A: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 1, A: 3}, {Op: 12, A: 3}, {Op: 9}, {Op: 11, A: 3}, {Op: 11}, {Op: 30, A: 6, Flags: 1}, {Op: 18}, {Op: 28, A: 73}, {Op: 11}, {Op: 11, A: 3}, {Op: 1, A: 3}, {Op: 14}, {Op: 30, A: 5, B: 1, Flags: 3}, {Op: 11}, {Op: 11, A: 3}, {Op: 30, A: 5, B: 1, Flags: 3}, {Op: 48, A: 2, Flags: 2}, {Op: 28, A: 57}, {Op: 11, A: 2}, {Op: 11}, {Op: 11, A: 3}, {Op: 30, A: 5, B: 1, Flags: 3}, {Op: 30, A: 7, B: 1}, {Op: 26, A: 66}, {Op: 11, A: 1}, {Op: 11, A: 2}, {Op: 30, A: 7, B: 1}, {Op: 9}, {Op: 11}, {Op: 11, A: 3}, {Op: 30, A: 5, B: 1, Flags: 3}, {Op: 6, A: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 3}, {Op: 1, A: 3}, {Op: 13}, {Op: 12, A: 3}, {Op: 9}, {Op: 26, A: 36}, {Op: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 11, A: 2}, {Op: 30, A: 7, B: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 1, A: 1}, {Op: 30, A: 4, B: 1, Flags: 3}, {Op: 53}},
 						Consts: []object.Value{
 							object.NewString("tried to create Proc object without a block"),
 							object.Symbol("each"),
@@ -2379,7 +2379,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "slice_when",
-						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 33}, {Op: 1}, {Op: 30, A: 1, B: 2}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 2}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 30, A: 3, Flags: 1}, {Op: 28, A: 22}, {Op: 6}, {Op: 1, A: 1}, {Op: 30, A: 4, B: 1, Flags: 1}, {Op: 53}, {Op: 26, A: 23}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12, A: 1}, {Op: 9}, {Op: 11}, {Op: 1, A: 2}, {Op: 30, A: 5, B: 1, Flags: 1}, {Op: 6, A: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 1, A: 3}, {Op: 12, A: 3}, {Op: 9}, {Op: 11, A: 3}, {Op: 11}, {Op: 30, A: 6, Flags: 1}, {Op: 18}, {Op: 28, A: 73}, {Op: 11}, {Op: 11, A: 3}, {Op: 1, A: 3}, {Op: 14}, {Op: 30, A: 5, B: 1, Flags: 1}, {Op: 11}, {Op: 11, A: 3}, {Op: 30, A: 5, B: 1, Flags: 1}, {Op: 48, A: 2}, {Op: 28, A: 61}, {Op: 11, A: 1}, {Op: 11, A: 2}, {Op: 30, A: 7, B: 1}, {Op: 9}, {Op: 11}, {Op: 11, A: 3}, {Op: 30, A: 5, B: 1, Flags: 1}, {Op: 6, A: 1}, {Op: 12, A: 2}, {Op: 26, A: 66}, {Op: 11, A: 2}, {Op: 11}, {Op: 11, A: 3}, {Op: 30, A: 5, B: 1, Flags: 1}, {Op: 30, A: 7, B: 1}, {Op: 9}, {Op: 11, A: 3}, {Op: 1, A: 3}, {Op: 13}, {Op: 12, A: 3}, {Op: 9}, {Op: 26, A: 36}, {Op: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 11, A: 2}, {Op: 30, A: 7, B: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 1, A: 1}, {Op: 30, A: 4, B: 1, Flags: 1}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 33}, {Op: 1}, {Op: 30, A: 1, B: 2, Flags: 2}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 2}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 30, A: 3, Flags: 1}, {Op: 28, A: 22}, {Op: 6}, {Op: 1, A: 1}, {Op: 30, A: 4, B: 1, Flags: 3}, {Op: 53}, {Op: 26, A: 23}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12, A: 1}, {Op: 9}, {Op: 11}, {Op: 1, A: 2}, {Op: 30, A: 5, B: 1, Flags: 3}, {Op: 6, A: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 1, A: 3}, {Op: 12, A: 3}, {Op: 9}, {Op: 11, A: 3}, {Op: 11}, {Op: 30, A: 6, Flags: 1}, {Op: 18}, {Op: 28, A: 73}, {Op: 11}, {Op: 11, A: 3}, {Op: 1, A: 3}, {Op: 14}, {Op: 30, A: 5, B: 1, Flags: 3}, {Op: 11}, {Op: 11, A: 3}, {Op: 30, A: 5, B: 1, Flags: 3}, {Op: 48, A: 2, Flags: 2}, {Op: 28, A: 61}, {Op: 11, A: 1}, {Op: 11, A: 2}, {Op: 30, A: 7, B: 1}, {Op: 9}, {Op: 11}, {Op: 11, A: 3}, {Op: 30, A: 5, B: 1, Flags: 3}, {Op: 6, A: 1}, {Op: 12, A: 2}, {Op: 26, A: 66}, {Op: 11, A: 2}, {Op: 11}, {Op: 11, A: 3}, {Op: 30, A: 5, B: 1, Flags: 3}, {Op: 30, A: 7, B: 1}, {Op: 9}, {Op: 11, A: 3}, {Op: 1, A: 3}, {Op: 13}, {Op: 12, A: 3}, {Op: 9}, {Op: 26, A: 36}, {Op: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 11, A: 2}, {Op: 30, A: 7, B: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 1, A: 1}, {Op: 30, A: 4, B: 1, Flags: 3}, {Op: 53}},
 						Consts: []object.Value{
 							object.NewString("tried to create Proc object without a block"),
 							object.Symbol("each"),
@@ -2399,7 +2399,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "chunk",
-						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12}, {Op: 9}, {Op: 4}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 2}, {Op: 9}, {Op: 11}, {Op: 1, A: 1}, {Op: 30, A: 2, B: 1, C: 3, Flags: 1}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1, Flags: 2}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12}, {Op: 9}, {Op: 4}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 2}, {Op: 9}, {Op: 11}, {Op: 1, A: 1}, {Op: 30, A: 2, B: 1, C: 3, Flags: 3}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("chunk"),
 							object.Symbol("each"),
@@ -2428,7 +2428,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:  "block in chunk",
-								Insns: []bytecode.Instr{{Op: 11}, {Op: 48, A: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, Flags: 1}, {Op: 10}, {Op: 27, A: 12}, {Op: 9}, {Op: 11, A: 1}, {Op: 1}, {Op: 22}, {Op: 28, A: 16}, {Op: 4}, {Op: 12, A: 1, B: 1}, {Op: 26, A: 77}, {Op: 11, A: 1}, {Op: 1, A: 1}, {Op: 22}, {Op: 28, A: 30}, {Op: 11, B: 1}, {Op: 11, A: 1}, {Op: 11}, {Op: 6, A: 1}, {Op: 6, A: 2}, {Op: 30, A: 1, B: 1}, {Op: 9}, {Op: 4}, {Op: 12, A: 1, B: 1}, {Op: 26, A: 77}, {Op: 11, A: 1}, {Op: 33, A: 2}, {Op: 30, A: 3, B: 1, Flags: 1}, {Op: 10}, {Op: 28, A: 40}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 4, Flags: 1}, {Op: 1, A: 2}, {Op: 30, A: 5, B: 1, Flags: 1}, {Op: 28, A: 46}, {Op: 5}, {Op: 33, A: 6}, {Op: 1, A: 3}, {Op: 30, A: 7, B: 2}, {Op: 26, A: 47}, {Op: 2}, {Op: 9}, {Op: 11, A: 1, B: 1}, {Op: 10}, {Op: 28, A: 59}, {Op: 9}, {Op: 11, B: 1}, {Op: 1, A: 4}, {Op: 30, A: 8, B: 1, Flags: 1}, {Op: 1, A: 5}, {Op: 30, A: 8, B: 1, Flags: 1}, {Op: 11, A: 1}, {Op: 22}, {Op: 28, A: 68}, {Op: 11, B: 1}, {Op: 1, A: 4}, {Op: 30, A: 8, B: 1, Flags: 1}, {Op: 1, A: 6}, {Op: 30, A: 8, B: 1, Flags: 1}, {Op: 11}, {Op: 30, A: 1, B: 1}, {Op: 26, A: 77}, {Op: 11, B: 1}, {Op: 11, A: 1}, {Op: 11}, {Op: 6, A: 1}, {Op: 6, A: 2}, {Op: 30, A: 1, B: 1}, {Op: 9}, {Op: 3}, {Op: 12, A: 1, B: 1}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 11}, {Op: 48, A: 1, Flags: 2}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, Flags: 1}, {Op: 10}, {Op: 27, A: 12}, {Op: 9}, {Op: 11, A: 1}, {Op: 1}, {Op: 22}, {Op: 28, A: 16}, {Op: 4}, {Op: 12, A: 1, B: 1}, {Op: 26, A: 77}, {Op: 11, A: 1}, {Op: 1, A: 1}, {Op: 22}, {Op: 28, A: 30}, {Op: 11, B: 1}, {Op: 11, A: 1}, {Op: 11}, {Op: 6, A: 1}, {Op: 6, A: 2}, {Op: 30, A: 1, B: 1}, {Op: 9}, {Op: 4}, {Op: 12, A: 1, B: 1}, {Op: 26, A: 77}, {Op: 11, A: 1}, {Op: 33, A: 2}, {Op: 30, A: 3, B: 1, Flags: 3}, {Op: 10}, {Op: 28, A: 40}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 4, Flags: 1}, {Op: 1, A: 2}, {Op: 30, A: 5, B: 1, Flags: 3}, {Op: 28, A: 46}, {Op: 5}, {Op: 33, A: 6}, {Op: 1, A: 3}, {Op: 30, A: 7, B: 2, Flags: 2}, {Op: 26, A: 47}, {Op: 2}, {Op: 9}, {Op: 11, A: 1, B: 1}, {Op: 10}, {Op: 28, A: 59}, {Op: 9}, {Op: 11, B: 1}, {Op: 1, A: 4}, {Op: 30, A: 8, B: 1, Flags: 3}, {Op: 1, A: 5}, {Op: 30, A: 8, B: 1, Flags: 3}, {Op: 11, A: 1}, {Op: 22}, {Op: 28, A: 68}, {Op: 11, B: 1}, {Op: 1, A: 4}, {Op: 30, A: 8, B: 1, Flags: 3}, {Op: 1, A: 6}, {Op: 30, A: 8, B: 1, Flags: 3}, {Op: 11}, {Op: 30, A: 1, B: 1}, {Op: 26, A: 77}, {Op: 11, B: 1}, {Op: 11, A: 1}, {Op: 11}, {Op: 6, A: 1}, {Op: 6, A: 2}, {Op: 30, A: 1, B: 1}, {Op: 9}, {Op: 3}, {Op: 12, A: 1, B: 1}, {Op: 53}},
 								Consts: []object.Value{
 									object.Symbol("_separator"),
 									object.Symbol("_alone"),
@@ -2467,7 +2467,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "slice_before",
-						Insns: []bytecode.Instr{{Op: 11}, {Op: 30, Flags: 1}, {Op: 1}, {Op: 19}, {Op: 28, A: 20}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 30, A: 2}, {Op: 13}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 30, A: 2}, {Op: 13}, {Op: 1, A: 3}, {Op: 30, A: 2}, {Op: 13}, {Op: 30, A: 3, B: 2}, {Op: 26, A: 21}, {Op: 2}, {Op: 9}, {Op: 52}, {Op: 28, A: 35}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 25}, {Op: 28, A: 33}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 4}, {Op: 30, A: 3, B: 2}, {Op: 26, A: 34}, {Op: 2}, {Op: 26, A: 49}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 28, A: 43}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 5}, {Op: 30, A: 3, B: 2}, {Op: 26, A: 44}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 1, A: 6}, {Op: 30, A: 5, B: 1, Flags: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 6}, {Op: 12, A: 2}, {Op: 9}, {Op: 2}, {Op: 12, A: 3}, {Op: 9}, {Op: 5}, {Op: 30, A: 6, C: 1}, {Op: 9}, {Op: 11, A: 3}, {Op: 30, A: 7, Flags: 1}, {Op: 25}, {Op: 28, A: 67}, {Op: 11, A: 2}, {Op: 11, A: 3}, {Op: 30, A: 8, B: 1}, {Op: 26, A: 68}, {Op: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 1, A: 7}, {Op: 30, A: 9, B: 1, C: 2, Flags: 1}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 11}, {Op: 30, Flags: 1}, {Op: 1}, {Op: 19}, {Op: 28, A: 20}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 30, A: 2}, {Op: 13}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 30, A: 2}, {Op: 13}, {Op: 1, A: 3}, {Op: 30, A: 2}, {Op: 13}, {Op: 30, A: 3, B: 2, Flags: 2}, {Op: 26, A: 21}, {Op: 2}, {Op: 9}, {Op: 52}, {Op: 28, A: 35}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 25}, {Op: 28, A: 33}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 4}, {Op: 30, A: 3, B: 2, Flags: 2}, {Op: 26, A: 34}, {Op: 2}, {Op: 26, A: 49}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 28, A: 43}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 5}, {Op: 30, A: 3, B: 2, Flags: 2}, {Op: 26, A: 44}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 1, A: 6}, {Op: 30, A: 5, B: 1, Flags: 3}, {Op: 12, A: 1}, {Op: 9}, {Op: 6}, {Op: 12, A: 2}, {Op: 9}, {Op: 2}, {Op: 12, A: 3}, {Op: 9}, {Op: 5}, {Op: 30, A: 6, C: 1}, {Op: 9}, {Op: 11, A: 3}, {Op: 30, A: 7, Flags: 1}, {Op: 25}, {Op: 28, A: 67}, {Op: 11, A: 2}, {Op: 11, A: 3}, {Op: 30, A: 8, B: 1}, {Op: 26, A: 68}, {Op: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 1, A: 7}, {Op: 30, A: 9, B: 1, C: 2, Flags: 3}, {Op: 53}},
 						Consts: []object.Value{
 							object.IntValue(1),
 							object.NewString(""),
@@ -2491,7 +2491,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in slice_before",
-								Insns:       []bytecode.Instr{{Op: 52}, {Op: 28, A: 5}, {Op: 11}, {Op: 48, A: 1}, {Op: 26, A: 8}, {Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 30, B: 1}, {Op: 28, A: 23}, {Op: 11, A: 3, B: 1}, {Op: 30, A: 1, Flags: 1}, {Op: 25}, {Op: 28, A: 17}, {Op: 11, A: 2, B: 1}, {Op: 11, A: 3, B: 1}, {Op: 30, A: 2, B: 1}, {Op: 26, A: 18}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 6, A: 1}, {Op: 12, A: 3, B: 1}, {Op: 26, A: 34}, {Op: 11, A: 3, B: 1}, {Op: 30, A: 1, Flags: 1}, {Op: 28, A: 29}, {Op: 6}, {Op: 12, A: 3, B: 1}, {Op: 26, A: 30}, {Op: 2}, {Op: 9}, {Op: 11, A: 3, B: 1}, {Op: 11}, {Op: 30, A: 2, B: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 52}, {Op: 28, A: 5}, {Op: 11}, {Op: 48, A: 1, Flags: 2}, {Op: 26, A: 8}, {Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 30, B: 1}, {Op: 28, A: 23}, {Op: 11, A: 3, B: 1}, {Op: 30, A: 1, Flags: 1}, {Op: 25}, {Op: 28, A: 17}, {Op: 11, A: 2, B: 1}, {Op: 11, A: 3, B: 1}, {Op: 30, A: 2, B: 1}, {Op: 26, A: 18}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 6, A: 1}, {Op: 12, A: 3, B: 1}, {Op: 26, A: 34}, {Op: 11, A: 3, B: 1}, {Op: 30, A: 1, Flags: 1}, {Op: 28, A: 29}, {Op: 6}, {Op: 12, A: 3, B: 1}, {Op: 26, A: 30}, {Op: 2}, {Op: 9}, {Op: 11, A: 3, B: 1}, {Op: 11}, {Op: 30, A: 2, B: 1}, {Op: 53}},
 								Names:       []string{"===", "nil?", "<<"},
 								Params:      []string{"x"},
 								NumRequired: 1,
@@ -2521,7 +2521,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "slice_after",
-						Insns: []bytecode.Instr{{Op: 11}, {Op: 30, Flags: 1}, {Op: 1}, {Op: 19}, {Op: 28, A: 20}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 30, A: 2}, {Op: 13}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 30, A: 2}, {Op: 13}, {Op: 1, A: 3}, {Op: 30, A: 2}, {Op: 13}, {Op: 30, A: 3, B: 2}, {Op: 26, A: 21}, {Op: 2}, {Op: 9}, {Op: 52}, {Op: 28, A: 35}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 25}, {Op: 28, A: 33}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 4}, {Op: 30, A: 3, B: 2}, {Op: 26, A: 34}, {Op: 2}, {Op: 26, A: 49}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 28, A: 43}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 5}, {Op: 30, A: 3, B: 2}, {Op: 26, A: 44}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 1, A: 6}, {Op: 30, A: 5, B: 1, Flags: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 6}, {Op: 12, A: 2}, {Op: 9}, {Op: 6}, {Op: 12, A: 3}, {Op: 9}, {Op: 5}, {Op: 30, A: 6, C: 1}, {Op: 9}, {Op: 11, A: 3}, {Op: 30, A: 4, Flags: 1}, {Op: 25}, {Op: 28, A: 67}, {Op: 11, A: 2}, {Op: 11, A: 3}, {Op: 30, A: 7, B: 1}, {Op: 26, A: 68}, {Op: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 1, A: 7}, {Op: 30, A: 8, B: 1, C: 2, Flags: 1}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 11}, {Op: 30, Flags: 1}, {Op: 1}, {Op: 19}, {Op: 28, A: 20}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 30, A: 2}, {Op: 13}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 30, A: 2}, {Op: 13}, {Op: 1, A: 3}, {Op: 30, A: 2}, {Op: 13}, {Op: 30, A: 3, B: 2, Flags: 2}, {Op: 26, A: 21}, {Op: 2}, {Op: 9}, {Op: 52}, {Op: 28, A: 35}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 25}, {Op: 28, A: 33}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 4}, {Op: 30, A: 3, B: 2, Flags: 2}, {Op: 26, A: 34}, {Op: 2}, {Op: 26, A: 49}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 28, A: 43}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 5}, {Op: 30, A: 3, B: 2, Flags: 2}, {Op: 26, A: 44}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 1, A: 6}, {Op: 30, A: 5, B: 1, Flags: 3}, {Op: 12, A: 1}, {Op: 9}, {Op: 6}, {Op: 12, A: 2}, {Op: 9}, {Op: 6}, {Op: 12, A: 3}, {Op: 9}, {Op: 5}, {Op: 30, A: 6, C: 1}, {Op: 9}, {Op: 11, A: 3}, {Op: 30, A: 4, Flags: 1}, {Op: 25}, {Op: 28, A: 67}, {Op: 11, A: 2}, {Op: 11, A: 3}, {Op: 30, A: 7, B: 1}, {Op: 26, A: 68}, {Op: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 1, A: 7}, {Op: 30, A: 8, B: 1, C: 2, Flags: 3}, {Op: 53}},
 						Consts: []object.Value{
 							object.IntValue(1),
 							object.NewString(""),
@@ -2545,7 +2545,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in slice_after",
-								Insns:       []bytecode.Instr{{Op: 11, A: 3, B: 1}, {Op: 11}, {Op: 30, B: 1}, {Op: 9}, {Op: 52}, {Op: 28, A: 9}, {Op: 11}, {Op: 48, A: 1}, {Op: 26, A: 12}, {Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 30, A: 1, B: 1}, {Op: 28, A: 20}, {Op: 11, A: 2, B: 1}, {Op: 11, A: 3, B: 1}, {Op: 30, B: 1}, {Op: 9}, {Op: 6}, {Op: 12, A: 3, B: 1}, {Op: 26, A: 21}, {Op: 2}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 11, A: 3, B: 1}, {Op: 11}, {Op: 30, B: 1}, {Op: 9}, {Op: 52}, {Op: 28, A: 9}, {Op: 11}, {Op: 48, A: 1, Flags: 2}, {Op: 26, A: 12}, {Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 30, A: 1, B: 1}, {Op: 28, A: 20}, {Op: 11, A: 2, B: 1}, {Op: 11, A: 3, B: 1}, {Op: 30, B: 1}, {Op: 9}, {Op: 6}, {Op: 12, A: 3, B: 1}, {Op: 26, A: 21}, {Op: 2}, {Op: 53}},
 								Names:       []string{"<<", "==="},
 								Params:      []string{"x"},
 								NumRequired: 1,
@@ -2575,7 +2575,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "minmax_by",
-						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 2}, {Op: 5}, {Op: 30, A: 2, C: 3}, {Op: 6, A: 2}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1, Flags: 2}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 2}, {Op: 5}, {Op: 30, A: 2, C: 3}, {Op: 6, A: 2}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("minmax_by"),
 						},
@@ -2590,7 +2590,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in minmax_by",
-								Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1, Flags: 2}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}},
 								Consts: []object.Value{
 									object.Symbol("size"),
 								},
@@ -2606,7 +2606,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:        "block in minmax_by",
-								Insns:       []bytecode.Instr{{Op: 11}, {Op: 48, A: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 11}, {Op: 48, A: 1, Flags: 2}, {Op: 53}},
 								Params:      []string{"x"},
 								NumRequired: 1,
 								SplatIndex:  -1,
@@ -2620,7 +2620,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:        "block in minmax_by",
-								Insns:       []bytecode.Instr{{Op: 11}, {Op: 48, A: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 11}, {Op: 48, A: 1, Flags: 2}, {Op: 53}},
 								Params:      []string{"x"},
 								NumRequired: 1,
 								SplatIndex:  -1,
@@ -2637,7 +2637,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "cycle",
-						Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 5}, {Op: 2}, {Op: 12}, {Op: 9}, {Op: 52}, {Op: 25}, {Op: 28, A: 14}, {Op: 5}, {Op: 1}, {Op: 11}, {Op: 30, B: 2, C: 1}, {Op: 53}, {Op: 26, A: 15}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 30, A: 1, Flags: 1}, {Op: 25}, {Op: 28, A: 34}, {Op: 5}, {Op: 11}, {Op: 30, A: 2, B: 1}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 1, A: 1}, {Op: 20}, {Op: 28, A: 32}, {Op: 2}, {Op: 53}, {Op: 26, A: 33}, {Op: 2}, {Op: 26, A: 35}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 30, A: 3, C: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 4, Flags: 1}, {Op: 28, A: 48}, {Op: 2}, {Op: 53}, {Op: 26, A: 49}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 30, A: 1, Flags: 1}, {Op: 28, A: 56}, {Op: 5}, {Op: 30, A: 5, C: 3}, {Op: 26, A: 60}, {Op: 11}, {Op: 1, A: 2}, {Op: 14}, {Op: 30, A: 6, C: 4, Flags: 1}, {Op: 9}, {Op: 2}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 5}, {Op: 2}, {Op: 12}, {Op: 9}, {Op: 52}, {Op: 25}, {Op: 28, A: 14}, {Op: 5}, {Op: 1}, {Op: 11}, {Op: 30, B: 2, C: 1, Flags: 2}, {Op: 53}, {Op: 26, A: 15}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 30, A: 1, Flags: 1}, {Op: 25}, {Op: 28, A: 34}, {Op: 5}, {Op: 11}, {Op: 30, A: 2, B: 1, Flags: 2}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 1, A: 1}, {Op: 20}, {Op: 28, A: 32}, {Op: 2}, {Op: 53}, {Op: 26, A: 33}, {Op: 2}, {Op: 26, A: 35}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 30, A: 3, C: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 4, Flags: 1}, {Op: 28, A: 48}, {Op: 2}, {Op: 53}, {Op: 26, A: 49}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 30, A: 1, Flags: 1}, {Op: 28, A: 56}, {Op: 5}, {Op: 30, A: 5, C: 3}, {Op: 26, A: 60}, {Op: 11}, {Op: 1, A: 2}, {Op: 14}, {Op: 30, A: 6, C: 4, Flags: 1}, {Op: 9}, {Op: 2}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("cycle"),
 							object.IntValue(0),
@@ -2656,7 +2656,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in cycle",
-								Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 30, A: 2, Flags: 1}, {Op: 10}, {Op: 27, A: 18}, {Op: 9}, {Op: 11}, {Op: 1, A: 1}, {Op: 22}, {Op: 28, A: 21}, {Op: 11}, {Op: 26, A: 36}, {Op: 11, B: 1}, {Op: 30, A: 2, Flags: 1}, {Op: 28, A: 27}, {Op: 33, A: 3}, {Op: 34, A: 4}, {Op: 26, A: 36}, {Op: 11, B: 1}, {Op: 1, A: 1}, {Op: 20}, {Op: 28, A: 33}, {Op: 1, A: 1}, {Op: 26, A: 36}, {Op: 11}, {Op: 11, B: 1}, {Op: 15}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1, Flags: 2}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 30, A: 2, Flags: 1}, {Op: 10}, {Op: 27, A: 18}, {Op: 9}, {Op: 11}, {Op: 1, A: 1}, {Op: 22}, {Op: 28, A: 21}, {Op: 11}, {Op: 26, A: 36}, {Op: 11, B: 1}, {Op: 30, A: 2, Flags: 1}, {Op: 28, A: 27}, {Op: 33, A: 3}, {Op: 34, A: 4}, {Op: 26, A: 36}, {Op: 11, B: 1}, {Op: 1, A: 1}, {Op: 20}, {Op: 28, A: 33}, {Op: 1, A: 1}, {Op: 26, A: 36}, {Op: 11}, {Op: 11, B: 1}, {Op: 15}, {Op: 53}},
 								Consts: []object.Value{
 									object.Symbol("size"),
 									object.IntValue(0),
@@ -2674,7 +2674,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:        "block in cycle",
-								Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1, B: 1}, {Op: 11, A: 1}, {Op: 30, A: 1, B: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 48, A: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1, B: 1}, {Op: 11, A: 1}, {Op: 30, A: 1, B: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 48, A: 1, Flags: 2}, {Op: 53}},
 								Names:       []string{"__pack", "<<"},
 								Params:      []string{"a"},
 								NumRequired: 0,
@@ -2701,7 +2701,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:        "block (2 levels) in cycle",
-										Insns:       []bytecode.Instr{{Op: 11}, {Op: 48, A: 1}, {Op: 53}},
+										Insns:       []bytecode.Instr{{Op: 11}, {Op: 48, A: 1, Flags: 2}, {Op: 53}},
 										Params:      []string{"x"},
 										NumRequired: 1,
 										SplatIndex:  -1,
@@ -2730,7 +2730,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:        "block (2 levels) in cycle",
-										Insns:       []bytecode.Instr{{Op: 11}, {Op: 48, A: 1}, {Op: 53}},
+										Insns:       []bytecode.Instr{{Op: 11}, {Op: 48, A: 1, Flags: 2}, {Op: 53}},
 										Params:      []string{"x"},
 										NumRequired: 1,
 										SplatIndex:  -1,
@@ -2753,7 +2753,7 @@ func embeddedPrelude() *bytecode.ISeq {
 			},
 			&bytecode.ISeq{
 				Name:        "<class:Numeric>",
-				Insns:       []bytecode.Instr{{Op: 5}, {Op: 33}, {Op: 30, A: 1, B: 1}, {Op: 9}, {Op: 44, A: 2}, {Op: 9}, {Op: 44, A: 3, B: 1}, {Op: 53}},
+				Insns:       []bytecode.Instr{{Op: 5}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 2}, {Op: 9}, {Op: 44, A: 2}, {Op: 9}, {Op: 44, A: 3, B: 1}, {Op: 53}},
 				Names:       []string{"Comparable", "include", "numerator", "denominator"},
 				NumRequired: 0,
 				SplatIndex:  -1,
@@ -2880,7 +2880,7 @@ func embeddedPrelude() *bytecode.ISeq {
 			},
 			&bytecode.ISeq{
 				Name:        "<class:String>",
-				Insns:       []bytecode.Instr{{Op: 5}, {Op: 33}, {Op: 30, A: 1, B: 1}, {Op: 53}},
+				Insns:       []bytecode.Instr{{Op: 5}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 2}, {Op: 53}},
 				Names:       []string{"Comparable", "include"},
 				NumRequired: 0,
 				SplatIndex:  -1,
@@ -2893,7 +2893,7 @@ func embeddedPrelude() *bytecode.ISeq {
 			},
 			&bytecode.ISeq{
 				Name:        "<class:Symbol>",
-				Insns:       []bytecode.Instr{{Op: 5}, {Op: 33}, {Op: 30, A: 1, B: 1}, {Op: 53}},
+				Insns:       []bytecode.Instr{{Op: 5}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 2}, {Op: 53}},
 				Names:       []string{"Comparable", "include"},
 				NumRequired: 0,
 				SplatIndex:  -1,
@@ -2906,7 +2906,7 @@ func embeddedPrelude() *bytecode.ISeq {
 			},
 			&bytecode.ISeq{
 				Name:        "<class:Array>",
-				Insns:       []bytecode.Instr{{Op: 5}, {Op: 33}, {Op: 30, A: 1, B: 1}, {Op: 9}, {Op: 44, A: 2}, {Op: 53}},
+				Insns:       []bytecode.Instr{{Op: 5}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 2}, {Op: 9}, {Op: 44, A: 2}, {Op: 53}},
 				Names:       []string{"Enumerable", "include", "deconstruct"},
 				NumRequired: 0,
 				SplatIndex:  -1,
@@ -2933,7 +2933,7 @@ func embeddedPrelude() *bytecode.ISeq {
 			},
 			&bytecode.ISeq{
 				Name:        "<class:Range>",
-				Insns:       []bytecode.Instr{{Op: 5}, {Op: 33}, {Op: 30, A: 1, B: 1}, {Op: 9}, {Op: 44, A: 2}, {Op: 9}, {Op: 44, A: 3, B: 1}, {Op: 9}, {Op: 44, A: 4, B: 2}, {Op: 53}},
+				Insns:       []bytecode.Instr{{Op: 5}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 2}, {Op: 9}, {Op: 44, A: 2}, {Op: 9}, {Op: 44, A: 3, B: 1}, {Op: 9}, {Op: 44, A: 4, B: 2}, {Op: 53}},
 				Names:       []string{"Enumerable", "include", "==", "eql?", "hash"},
 				NumRequired: 0,
 				SplatIndex:  -1,
@@ -2945,7 +2945,7 @@ func embeddedPrelude() *bytecode.ISeq {
 				Children: []*bytecode.ISeq{
 					&bytecode.ISeq{
 						Name:        "==",
-						Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 28, A: 7}, {Op: 3}, {Op: 53}, {Op: 26, A: 8}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 33, A: 1}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 25}, {Op: 28, A: 17}, {Op: 4}, {Op: 53}, {Op: 26, A: 18}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 3}, {Op: 11}, {Op: 30, A: 3, Flags: 1}, {Op: 22}, {Op: 10}, {Op: 28, A: 32}, {Op: 9}, {Op: 5}, {Op: 30, A: 4}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 22}, {Op: 10}, {Op: 28, A: 40}, {Op: 9}, {Op: 5}, {Op: 30, A: 5}, {Op: 11}, {Op: 30, A: 5, Flags: 1}, {Op: 22}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 28, A: 7}, {Op: 3}, {Op: 53}, {Op: 26, A: 8}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 33, A: 1}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 25}, {Op: 28, A: 17}, {Op: 4}, {Op: 53}, {Op: 26, A: 18}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 3}, {Op: 11}, {Op: 30, A: 3, Flags: 1}, {Op: 22}, {Op: 10}, {Op: 28, A: 32}, {Op: 9}, {Op: 5}, {Op: 30, A: 4}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 22}, {Op: 10}, {Op: 28, A: 40}, {Op: 9}, {Op: 5}, {Op: 30, A: 5}, {Op: 11}, {Op: 30, A: 5, Flags: 1}, {Op: 22}, {Op: 53}},
 						Names:       []string{"equal?", "Range", "is_a?", "begin", "end", "exclude_end?"},
 						Params:      []string{"other"},
 						NumRequired: 1,
@@ -2960,7 +2960,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "eql?",
-						Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 28, A: 7}, {Op: 3}, {Op: 53}, {Op: 26, A: 8}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 33, A: 1}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 25}, {Op: 28, A: 17}, {Op: 4}, {Op: 53}, {Op: 26, A: 18}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 3}, {Op: 11}, {Op: 30, A: 3, Flags: 1}, {Op: 30, A: 4, B: 1, Flags: 1}, {Op: 10}, {Op: 28, A: 32}, {Op: 9}, {Op: 5}, {Op: 30, A: 5}, {Op: 11}, {Op: 30, A: 5, Flags: 1}, {Op: 30, A: 4, B: 1, Flags: 1}, {Op: 10}, {Op: 28, A: 40}, {Op: 9}, {Op: 5}, {Op: 30, A: 6}, {Op: 11}, {Op: 30, A: 6, Flags: 1}, {Op: 22}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 28, A: 7}, {Op: 3}, {Op: 53}, {Op: 26, A: 8}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 33, A: 1}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 25}, {Op: 28, A: 17}, {Op: 4}, {Op: 53}, {Op: 26, A: 18}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 3}, {Op: 11}, {Op: 30, A: 3, Flags: 1}, {Op: 30, A: 4, B: 1, Flags: 3}, {Op: 10}, {Op: 28, A: 32}, {Op: 9}, {Op: 5}, {Op: 30, A: 5}, {Op: 11}, {Op: 30, A: 5, Flags: 1}, {Op: 30, A: 4, B: 1, Flags: 3}, {Op: 10}, {Op: 28, A: 40}, {Op: 9}, {Op: 5}, {Op: 30, A: 6}, {Op: 11}, {Op: 30, A: 6, Flags: 1}, {Op: 22}, {Op: 53}},
 						Names:       []string{"equal?", "Range", "is_a?", "begin", "eql?", "end", "exclude_end?"},
 						Params:      []string{"other"},
 						NumRequired: 1,
@@ -2991,7 +2991,7 @@ func embeddedPrelude() *bytecode.ISeq {
 			},
 			&bytecode.ISeq{
 				Name:        "<class:Hash>",
-				Insns:       []bytecode.Instr{{Op: 5}, {Op: 33}, {Op: 30, A: 1, B: 1}, {Op: 9}, {Op: 44, A: 2}, {Op: 53}},
+				Insns:       []bytecode.Instr{{Op: 5}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 2}, {Op: 9}, {Op: 44, A: 2}, {Op: 53}},
 				Names:       []string{"Enumerable", "include", "deconstruct_keys"},
 				NumRequired: 0,
 				SplatIndex:  -1,
@@ -3020,7 +3020,7 @@ func embeddedPrelude() *bytecode.ISeq {
 			},
 			&bytecode.ISeq{
 				Name:  "<class:Set>",
-				Insns: []bytecode.Instr{{Op: 5}, {Op: 33}, {Op: 30, A: 1, B: 1}, {Op: 9}, {Op: 44, A: 2}, {Op: 9}, {Op: 5}, {Op: 1}, {Op: 30, A: 3, B: 1}, {Op: 9}, {Op: 44, A: 4, B: 1}, {Op: 9}, {Op: 5}, {Op: 1, A: 1}, {Op: 30, A: 3, B: 1}, {Op: 9}, {Op: 44, A: 5, B: 2}, {Op: 9}, {Op: 44, A: 6, B: 3}, {Op: 9}, {Op: 44, A: 7, B: 4}, {Op: 9}, {Op: 44, A: 8, B: 5}, {Op: 9}, {Op: 44, A: 9, B: 6}, {Op: 9}, {Op: 78, A: 10, B: 9}, {Op: 9}, {Op: 78, A: 11, B: 9}, {Op: 9}, {Op: 44, A: 12, B: 7}, {Op: 9}, {Op: 78, A: 13, B: 12}, {Op: 9}, {Op: 44, A: 14, B: 8}, {Op: 9}, {Op: 78, A: 15, B: 14}, {Op: 9}, {Op: 44, A: 16, B: 9}, {Op: 9}, {Op: 44, A: 17, B: 10}, {Op: 9}, {Op: 44, A: 18, B: 11}, {Op: 9}, {Op: 44, A: 19, B: 12}, {Op: 9}, {Op: 44, A: 20, B: 13}, {Op: 9}, {Op: 44, A: 21, B: 14}, {Op: 9}, {Op: 78, A: 22, B: 21}, {Op: 9}, {Op: 44, A: 23, B: 15}, {Op: 9}, {Op: 78, A: 24, B: 23}, {Op: 9}, {Op: 44, A: 25, B: 16}, {Op: 9}, {Op: 78, A: 26, B: 25}, {Op: 9}, {Op: 44, A: 27, B: 17}, {Op: 9}, {Op: 78, A: 28, B: 27}, {Op: 9}, {Op: 44, A: 29, B: 18}, {Op: 9}, {Op: 44, A: 30, B: 19}, {Op: 9}, {Op: 78, A: 31, B: 30}, {Op: 9}, {Op: 44, A: 32, B: 20}, {Op: 9}, {Op: 44, A: 33, B: 21}, {Op: 9}, {Op: 44, A: 34, B: 22}, {Op: 9}, {Op: 44, A: 35, B: 23}, {Op: 9}, {Op: 44, A: 36, B: 24}, {Op: 9}, {Op: 44, A: 37, B: 25}, {Op: 9}, {Op: 78, A: 38, B: 37}, {Op: 9}, {Op: 44, A: 39, B: 26}, {Op: 9}, {Op: 44, A: 40, B: 27}, {Op: 9}, {Op: 78, A: 41, B: 40}, {Op: 9}, {Op: 44, A: 42, B: 28}, {Op: 9}, {Op: 44, A: 43, B: 29}, {Op: 9}, {Op: 44, A: 44, B: 30}, {Op: 9}, {Op: 5}, {Op: 1, A: 2}, {Op: 30, A: 3, B: 1}, {Op: 9}, {Op: 44, A: 45, B: 31}, {Op: 9}, {Op: 44, A: 46, B: 32}, {Op: 9}, {Op: 44, A: 47, B: 33}, {Op: 9}, {Op: 5}, {Op: 1, A: 3}, {Op: 30, A: 48, B: 1}, {Op: 9}, {Op: 44, A: 49, B: 34}, {Op: 9}, {Op: 44, A: 50, B: 35}, {Op: 53}},
+				Insns: []bytecode.Instr{{Op: 5}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 2}, {Op: 9}, {Op: 44, A: 2}, {Op: 9}, {Op: 5}, {Op: 1}, {Op: 30, A: 3, B: 1, Flags: 2}, {Op: 9}, {Op: 44, A: 4, B: 1}, {Op: 9}, {Op: 5}, {Op: 1, A: 1}, {Op: 30, A: 3, B: 1, Flags: 2}, {Op: 9}, {Op: 44, A: 5, B: 2}, {Op: 9}, {Op: 44, A: 6, B: 3}, {Op: 9}, {Op: 44, A: 7, B: 4}, {Op: 9}, {Op: 44, A: 8, B: 5}, {Op: 9}, {Op: 44, A: 9, B: 6}, {Op: 9}, {Op: 78, A: 10, B: 9}, {Op: 9}, {Op: 78, A: 11, B: 9}, {Op: 9}, {Op: 44, A: 12, B: 7}, {Op: 9}, {Op: 78, A: 13, B: 12}, {Op: 9}, {Op: 44, A: 14, B: 8}, {Op: 9}, {Op: 78, A: 15, B: 14}, {Op: 9}, {Op: 44, A: 16, B: 9}, {Op: 9}, {Op: 44, A: 17, B: 10}, {Op: 9}, {Op: 44, A: 18, B: 11}, {Op: 9}, {Op: 44, A: 19, B: 12}, {Op: 9}, {Op: 44, A: 20, B: 13}, {Op: 9}, {Op: 44, A: 21, B: 14}, {Op: 9}, {Op: 78, A: 22, B: 21}, {Op: 9}, {Op: 44, A: 23, B: 15}, {Op: 9}, {Op: 78, A: 24, B: 23}, {Op: 9}, {Op: 44, A: 25, B: 16}, {Op: 9}, {Op: 78, A: 26, B: 25}, {Op: 9}, {Op: 44, A: 27, B: 17}, {Op: 9}, {Op: 78, A: 28, B: 27}, {Op: 9}, {Op: 44, A: 29, B: 18}, {Op: 9}, {Op: 44, A: 30, B: 19}, {Op: 9}, {Op: 78, A: 31, B: 30}, {Op: 9}, {Op: 44, A: 32, B: 20}, {Op: 9}, {Op: 44, A: 33, B: 21}, {Op: 9}, {Op: 44, A: 34, B: 22}, {Op: 9}, {Op: 44, A: 35, B: 23}, {Op: 9}, {Op: 44, A: 36, B: 24}, {Op: 9}, {Op: 44, A: 37, B: 25}, {Op: 9}, {Op: 78, A: 38, B: 37}, {Op: 9}, {Op: 44, A: 39, B: 26}, {Op: 9}, {Op: 44, A: 40, B: 27}, {Op: 9}, {Op: 78, A: 41, B: 40}, {Op: 9}, {Op: 44, A: 42, B: 28}, {Op: 9}, {Op: 44, A: 43, B: 29}, {Op: 9}, {Op: 44, A: 44, B: 30}, {Op: 9}, {Op: 5}, {Op: 1, A: 2}, {Op: 30, A: 3, B: 1, Flags: 2}, {Op: 9}, {Op: 44, A: 45, B: 31}, {Op: 9}, {Op: 44, A: 46, B: 32}, {Op: 9}, {Op: 44, A: 47, B: 33}, {Op: 9}, {Op: 5}, {Op: 1, A: 3}, {Op: 30, A: 48, B: 1, Flags: 2}, {Op: 9}, {Op: 44, A: 49, B: 34}, {Op: 9}, {Op: 44, A: 50, B: 35}, {Op: 53}},
 				Consts: []object.Value{
 					object.Symbol("__do_with_enum"),
 					object.Symbol("initialize"),
@@ -3038,7 +3038,7 @@ func embeddedPrelude() *bytecode.ISeq {
 				Children: []*bytecode.ISeq{
 					&bytecode.ISeq{
 						Name:  "__do_with_enum",
-						Insns: []bytecode.Instr{{Op: 11}, {Op: 1}, {Op: 30, B: 1, Flags: 1}, {Op: 28, A: 8}, {Op: 11}, {Op: 11, A: 1}, {Op: 66, A: 1, Flags: 1}, {Op: 26, A: 20}, {Op: 11}, {Op: 1, A: 1}, {Op: 30, B: 1, Flags: 1}, {Op: 28, A: 16}, {Op: 11}, {Op: 11, A: 1}, {Op: 66, A: 2, Flags: 1}, {Op: 26, A: 20}, {Op: 5}, {Op: 33, A: 3}, {Op: 1, A: 2}, {Op: 30, A: 4, B: 2}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 11}, {Op: 1}, {Op: 30, B: 1, Flags: 3}, {Op: 28, A: 8}, {Op: 11}, {Op: 11, A: 1}, {Op: 66, A: 1, Flags: 1}, {Op: 26, A: 20}, {Op: 11}, {Op: 1, A: 1}, {Op: 30, B: 1, Flags: 3}, {Op: 28, A: 16}, {Op: 11}, {Op: 11, A: 1}, {Op: 66, A: 2, Flags: 1}, {Op: 26, A: 20}, {Op: 5}, {Op: 33, A: 3}, {Op: 1, A: 2}, {Op: 30, A: 4, B: 2, Flags: 2}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("each_entry"),
 							object.Symbol("each"),
@@ -3058,7 +3058,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "initialize",
-						Insns:       []bytecode.Instr{{Op: 54}, {Op: 27, A: 5}, {Op: 2}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 28, A: 11}, {Op: 2}, {Op: 53}, {Op: 26, A: 12}, {Op: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 28, A: 19}, {Op: 5}, {Op: 11}, {Op: 30, A: 1, B: 1, C: 1}, {Op: 26, A: 22}, {Op: 5}, {Op: 11}, {Op: 30, A: 1, B: 1, C: 2}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 54}, {Op: 27, A: 5}, {Op: 2}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 28, A: 11}, {Op: 2}, {Op: 53}, {Op: 26, A: 12}, {Op: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 28, A: 19}, {Op: 5}, {Op: 11}, {Op: 30, A: 1, B: 1, C: 1, Flags: 2}, {Op: 26, A: 22}, {Op: 5}, {Op: 11}, {Op: 30, A: 1, B: 1, C: 2, Flags: 2}, {Op: 53}},
 						Names:       []string{"nil?", "__do_with_enum"},
 						Params:      []string{"enum"},
 						NumRequired: 0,
@@ -3072,7 +3072,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in initialize",
-								Insns:       []bytecode.Instr{{Op: 5}, {Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 30, B: 1, Flags: 1}, {Op: 30, A: 1, B: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 5}, {Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 30, B: 1, Flags: 3}, {Op: 30, A: 1, B: 1, Flags: 2}, {Op: 53}},
 								Names:       []string{"call", "add"},
 								Params:      []string{"o"},
 								NumRequired: 1,
@@ -3087,7 +3087,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:        "block in initialize",
-								Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 53}},
 								Names:       []string{"add"},
 								Params:      []string{"o"},
 								NumRequired: 1,
@@ -3105,7 +3105,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "each",
-						Insns: []bytecode.Instr{{Op: 11}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 11}, {Op: 66, A: 1}, {Op: 9}, {Op: 5}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 11}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1, Flags: 2}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 11}, {Op: 66, A: 1}, {Op: 9}, {Op: 5}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("each"),
 						},
@@ -3153,7 +3153,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "add?",
-						Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 28, A: 6}, {Op: 2}, {Op: 26, A: 9}, {Op: 5}, {Op: 11}, {Op: 30, A: 1, B: 1}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 28, A: 6}, {Op: 2}, {Op: 26, A: 9}, {Op: 5}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 2}, {Op: 53}},
 						Names:       []string{"include?", "add"},
 						Params:      []string{"o"},
 						NumRequired: 1,
@@ -3168,7 +3168,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "delete?",
-						Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 28, A: 8}, {Op: 5}, {Op: 11}, {Op: 30, A: 1, B: 1}, {Op: 26, A: 9}, {Op: 2}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 28, A: 8}, {Op: 5}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 2}, {Op: 26, A: 9}, {Op: 2}, {Op: 53}},
 						Names:       []string{"include?", "delete"},
 						Params:      []string{"o"},
 						NumRequired: 1,
@@ -3183,7 +3183,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "|",
-						Insns:       []bytecode.Instr{{Op: 5}, {Op: 30}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 11}, {Op: 30, A: 1, B: 1, C: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 5}, {Op: 30}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 11}, {Op: 30, A: 1, B: 1, C: 1, Flags: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}},
 						Names:       []string{"dup", "__do_with_enum"},
 						Params:      []string{"other"},
 						NumRequired: 1,
@@ -3197,7 +3197,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in |",
-								Insns:       []bytecode.Instr{{Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 30, B: 1, Flags: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 30, B: 1, Flags: 3}, {Op: 53}},
 								Names:       []string{"add"},
 								Params:      []string{"o"},
 								NumRequired: 1,
@@ -3215,7 +3215,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "&",
-						Insns:       []bytecode.Instr{{Op: 5}, {Op: 30}, {Op: 30, A: 1, Flags: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 11}, {Op: 30, A: 2, B: 1, C: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 5}, {Op: 30}, {Op: 30, A: 1, Flags: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 11}, {Op: 30, A: 2, B: 1, C: 1, Flags: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}},
 						Names:       []string{"class", "new", "__do_with_enum"},
 						Params:      []string{"other"},
 						NumRequired: 1,
@@ -3229,7 +3229,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in &",
-								Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 28, A: 8}, {Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 26, A: 9}, {Op: 2}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 28, A: 8}, {Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 26, A: 9}, {Op: 2}, {Op: 53}},
 								Names:       []string{"include?", "add"},
 								Params:      []string{"o"},
 								NumRequired: 1,
@@ -3247,7 +3247,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "-",
-						Insns:       []bytecode.Instr{{Op: 5}, {Op: 30}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 11}, {Op: 30, A: 1, B: 1, C: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 5}, {Op: 30}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 11}, {Op: 30, A: 1, B: 1, C: 1, Flags: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}},
 						Names:       []string{"dup", "__do_with_enum"},
 						Params:      []string{"other"},
 						NumRequired: 1,
@@ -3261,7 +3261,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in -",
-								Insns:       []bytecode.Instr{{Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 30, B: 1, Flags: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 30, B: 1, Flags: 3}, {Op: 53}},
 								Names:       []string{"delete"},
 								Params:      []string{"o"},
 								NumRequired: 1,
@@ -3279,7 +3279,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "^",
-						Insns:       []bytecode.Instr{{Op: 5}, {Op: 30}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 30, A: 2, C: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 5}, {Op: 30}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 30, A: 2, C: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}},
 						Names:       []string{"class", "new", "each"},
 						Params:      []string{"other"},
 						NumRequired: 1,
@@ -3293,7 +3293,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in ^",
-								Insns:       []bytecode.Instr{{Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 30, B: 1, Flags: 1}, {Op: 28, A: 8}, {Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 26, A: 11}, {Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 30, B: 1, Flags: 3}, {Op: 28, A: 8}, {Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 26, A: 11}, {Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 53}},
 								Names:       []string{"include?", "delete", "add"},
 								Params:      []string{"o"},
 								NumRequired: 1,
@@ -3325,7 +3325,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in merge",
-								Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1, C: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1, C: 1, Flags: 2}, {Op: 53}},
 								Names:       []string{"__do_with_enum"},
 								Params:      []string{"enum"},
 								NumRequired: 1,
@@ -3339,7 +3339,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:        "block (2 levels) in merge",
-										Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 53}},
+										Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 53}},
 										Names:       []string{"add"},
 										Params:      []string{"o"},
 										NumRequired: 1,
@@ -3360,7 +3360,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "subtract",
-						Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1, C: 1}, {Op: 9}, {Op: 5}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1, C: 1, Flags: 2}, {Op: 9}, {Op: 5}, {Op: 53}},
 						Names:       []string{"__do_with_enum"},
 						Params:      []string{"other"},
 						NumRequired: 1,
@@ -3374,7 +3374,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in subtract",
-								Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 53}},
 								Names:       []string{"delete"},
 								Params:      []string{"o"},
 								NumRequired: 1,
@@ -3392,7 +3392,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "replace",
-						Insns: []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 28, A: 12}, {Op: 5}, {Op: 11}, {Op: 30, A: 2, Flags: 1}, {Op: 30, A: 3, B: 1}, {Op: 9}, {Op: 11}, {Op: 30, A: 4, C: 1, Flags: 1}, {Op: 26, A: 38}, {Op: 11}, {Op: 1}, {Op: 30, A: 5, B: 1, Flags: 1}, {Op: 10}, {Op: 27, A: 21}, {Op: 9}, {Op: 11}, {Op: 1, A: 1}, {Op: 30, A: 5, B: 1, Flags: 1}, {Op: 25}, {Op: 28, A: 28}, {Op: 5}, {Op: 33, A: 6}, {Op: 1, A: 2}, {Op: 30, A: 7, B: 2}, {Op: 26, A: 29}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 5}, {Op: 30, A: 2}, {Op: 30, A: 3, B: 1}, {Op: 9}, {Op: 5}, {Op: 11}, {Op: 30, A: 8, B: 1, C: 2}, {Op: 9}, {Op: 5}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 28, A: 12}, {Op: 5}, {Op: 11}, {Op: 30, A: 2, Flags: 1}, {Op: 30, A: 3, B: 1, Flags: 2}, {Op: 9}, {Op: 11}, {Op: 30, A: 4, C: 1, Flags: 1}, {Op: 26, A: 38}, {Op: 11}, {Op: 1}, {Op: 30, A: 5, B: 1, Flags: 3}, {Op: 10}, {Op: 27, A: 21}, {Op: 9}, {Op: 11}, {Op: 1, A: 1}, {Op: 30, A: 5, B: 1, Flags: 3}, {Op: 25}, {Op: 28, A: 28}, {Op: 5}, {Op: 33, A: 6}, {Op: 1, A: 2}, {Op: 30, A: 7, B: 2, Flags: 2}, {Op: 26, A: 29}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 5}, {Op: 30, A: 2}, {Op: 30, A: 3, B: 1, Flags: 2}, {Op: 9}, {Op: 5}, {Op: 11}, {Op: 30, A: 8, B: 1, C: 2, Flags: 2}, {Op: 9}, {Op: 5}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("each_entry"),
 							object.Symbol("each"),
@@ -3411,7 +3411,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in replace",
-								Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 53}},
 								Names:       []string{"add"},
 								Params:      []string{"o"},
 								NumRequired: 1,
@@ -3426,7 +3426,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:        "block in replace",
-								Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 53}},
 								Names:       []string{"add"},
 								Params:      []string{"o"},
 								NumRequired: 1,
@@ -3444,7 +3444,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "reset",
-						Insns:       []bytecode.Instr{{Op: 5}, {Op: 30}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 5}, {Op: 30, A: 1}, {Op: 30, A: 2, B: 1}, {Op: 9}, {Op: 11}, {Op: 30, A: 3, C: 1, Flags: 1}, {Op: 9}, {Op: 5}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 5}, {Op: 30}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 5}, {Op: 30, A: 1}, {Op: 30, A: 2, B: 1, Flags: 2}, {Op: 9}, {Op: 11}, {Op: 30, A: 3, C: 1, Flags: 1}, {Op: 9}, {Op: 5}, {Op: 53}},
 						Names:       []string{"to_a", "compare_by_identity?", "__replace_cbi", "each"},
 						NumRequired: 0,
 						SplatIndex:  -1,
@@ -3457,7 +3457,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in reset",
-								Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 53}},
 								Names:       []string{"add"},
 								Params:      []string{"o"},
 								NumRequired: 1,
@@ -3475,7 +3475,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "subset?",
-						Insns: []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 25}, {Op: 28, A: 10}, {Op: 5}, {Op: 33, A: 2}, {Op: 1}, {Op: 30, A: 3, B: 2}, {Op: 26, A: 11}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 4}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 19}, {Op: 28, A: 21}, {Op: 4}, {Op: 53}, {Op: 26, A: 22}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 5, C: 1}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 25}, {Op: 28, A: 10}, {Op: 5}, {Op: 33, A: 2}, {Op: 1}, {Op: 30, A: 3, B: 2, Flags: 2}, {Op: 26, A: 11}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 4}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 19}, {Op: 28, A: 21}, {Op: 4}, {Op: 53}, {Op: 26, A: 22}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 5, C: 1}, {Op: 53}},
 						Consts: []object.Value{
 							object.NewString("value must be a set"),
 						},
@@ -3492,7 +3492,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in subset?",
-								Insns:       []bytecode.Instr{{Op: 11, B: 1}, {Op: 11}, {Op: 30, B: 1, Flags: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 11, B: 1}, {Op: 11}, {Op: 30, B: 1, Flags: 3}, {Op: 53}},
 								Names:       []string{"include?"},
 								Params:      []string{"o"},
 								NumRequired: 1,
@@ -3510,7 +3510,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "proper_subset?",
-						Insns: []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 25}, {Op: 28, A: 10}, {Op: 5}, {Op: 33, A: 2}, {Op: 1}, {Op: 30, A: 3, B: 2}, {Op: 26, A: 11}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 4}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 21}, {Op: 28, A: 21}, {Op: 4}, {Op: 53}, {Op: 26, A: 22}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 5, C: 1}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 25}, {Op: 28, A: 10}, {Op: 5}, {Op: 33, A: 2}, {Op: 1}, {Op: 30, A: 3, B: 2, Flags: 2}, {Op: 26, A: 11}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 4}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 21}, {Op: 28, A: 21}, {Op: 4}, {Op: 53}, {Op: 26, A: 22}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 5, C: 1}, {Op: 53}},
 						Consts: []object.Value{
 							object.NewString("value must be a set"),
 						},
@@ -3527,7 +3527,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in proper_subset?",
-								Insns:       []bytecode.Instr{{Op: 11, B: 1}, {Op: 11}, {Op: 30, B: 1, Flags: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 11, B: 1}, {Op: 11}, {Op: 30, B: 1, Flags: 3}, {Op: 53}},
 								Names:       []string{"include?"},
 								Params:      []string{"o"},
 								NumRequired: 1,
@@ -3545,7 +3545,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "superset?",
-						Insns: []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 25}, {Op: 28, A: 10}, {Op: 5}, {Op: 33, A: 2}, {Op: 1}, {Op: 30, A: 3, B: 2}, {Op: 26, A: 11}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 4}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 18}, {Op: 28, A: 21}, {Op: 4}, {Op: 53}, {Op: 26, A: 22}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 30, A: 5, C: 1, Flags: 1}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 25}, {Op: 28, A: 10}, {Op: 5}, {Op: 33, A: 2}, {Op: 1}, {Op: 30, A: 3, B: 2, Flags: 2}, {Op: 26, A: 11}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 4}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 18}, {Op: 28, A: 21}, {Op: 4}, {Op: 53}, {Op: 26, A: 22}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 30, A: 5, C: 1, Flags: 1}, {Op: 53}},
 						Consts: []object.Value{
 							object.NewString("value must be a set"),
 						},
@@ -3562,7 +3562,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in superset?",
-								Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 53}},
 								Names:       []string{"include?"},
 								Params:      []string{"o"},
 								NumRequired: 1,
@@ -3580,7 +3580,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "proper_superset?",
-						Insns: []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 25}, {Op: 28, A: 10}, {Op: 5}, {Op: 33, A: 2}, {Op: 1}, {Op: 30, A: 3, B: 2}, {Op: 26, A: 11}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 4}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 20}, {Op: 28, A: 21}, {Op: 4}, {Op: 53}, {Op: 26, A: 22}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 30, A: 5, C: 1, Flags: 1}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 25}, {Op: 28, A: 10}, {Op: 5}, {Op: 33, A: 2}, {Op: 1}, {Op: 30, A: 3, B: 2, Flags: 2}, {Op: 26, A: 11}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 4}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 20}, {Op: 28, A: 21}, {Op: 4}, {Op: 53}, {Op: 26, A: 22}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 30, A: 5, C: 1, Flags: 1}, {Op: 53}},
 						Consts: []object.Value{
 							object.NewString("value must be a set"),
 						},
@@ -3597,7 +3597,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in proper_superset?",
-								Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 53}},
 								Names:       []string{"include?"},
 								Params:      []string{"o"},
 								NumRequired: 1,
@@ -3615,7 +3615,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "<=>",
-						Insns: []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 25}, {Op: 28, A: 8}, {Op: 2}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 2}, {Op: 11}, {Op: 30, A: 2, Flags: 1}, {Op: 30, A: 3, B: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 1}, {Op: 11, A: 1}, {Op: 30, A: 4, B: 1}, {Op: 27, A: 22}, {Op: 26, A: 30}, {Op: 5}, {Op: 11}, {Op: 30, A: 5, B: 1}, {Op: 28, A: 28}, {Op: 1}, {Op: 26, A: 29}, {Op: 2}, {Op: 26, A: 50}, {Op: 1, A: 1}, {Op: 11, A: 1}, {Op: 30, A: 4, B: 1}, {Op: 27, A: 35}, {Op: 26, A: 43}, {Op: 5}, {Op: 11}, {Op: 30, A: 6, B: 1}, {Op: 28, A: 41}, {Op: 1, A: 1}, {Op: 26, A: 42}, {Op: 2}, {Op: 26, A: 50}, {Op: 5}, {Op: 11}, {Op: 22}, {Op: 28, A: 49}, {Op: 1, A: 2}, {Op: 26, A: 50}, {Op: 2}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 25}, {Op: 28, A: 8}, {Op: 2}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 2}, {Op: 11}, {Op: 30, A: 2, Flags: 1}, {Op: 30, A: 3, B: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 1}, {Op: 11, A: 1}, {Op: 30, A: 4, B: 1}, {Op: 27, A: 22}, {Op: 26, A: 30}, {Op: 5}, {Op: 11}, {Op: 30, A: 5, B: 1, Flags: 2}, {Op: 28, A: 28}, {Op: 1}, {Op: 26, A: 29}, {Op: 2}, {Op: 26, A: 50}, {Op: 1, A: 1}, {Op: 11, A: 1}, {Op: 30, A: 4, B: 1}, {Op: 27, A: 35}, {Op: 26, A: 43}, {Op: 5}, {Op: 11}, {Op: 30, A: 6, B: 1, Flags: 2}, {Op: 28, A: 41}, {Op: 1, A: 1}, {Op: 26, A: 42}, {Op: 2}, {Op: 26, A: 50}, {Op: 5}, {Op: 11}, {Op: 22}, {Op: 28, A: 49}, {Op: 1, A: 2}, {Op: 26, A: 50}, {Op: 2}, {Op: 53}},
 						Consts: []object.Value{
 							object.IntValue(-1),
 							object.IntValue(1),
@@ -3635,7 +3635,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "==",
-						Insns: []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 28, A: 7}, {Op: 3}, {Op: 53}, {Op: 26, A: 8}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 33, A: 1}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 25}, {Op: 28, A: 17}, {Op: 4}, {Op: 53}, {Op: 26, A: 18}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 1}, {Op: 30, A: 3, B: 1, Flags: 1}, {Op: 10}, {Op: 28, A: 30}, {Op: 9}, {Op: 5}, {Op: 30, A: 4}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 23}, {Op: 28, A: 34}, {Op: 4}, {Op: 53}, {Op: 26, A: 35}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 5}, {Op: 11}, {Op: 30, A: 5, Flags: 1}, {Op: 22}, {Op: 25}, {Op: 28, A: 46}, {Op: 4}, {Op: 53}, {Op: 26, A: 47}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 6, C: 1}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 28, A: 7}, {Op: 3}, {Op: 53}, {Op: 26, A: 8}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 33, A: 1}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 25}, {Op: 28, A: 17}, {Op: 4}, {Op: 53}, {Op: 26, A: 18}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 1}, {Op: 30, A: 3, B: 1, Flags: 3}, {Op: 10}, {Op: 28, A: 30}, {Op: 9}, {Op: 5}, {Op: 30, A: 4}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 23}, {Op: 28, A: 34}, {Op: 4}, {Op: 53}, {Op: 26, A: 35}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 5}, {Op: 11}, {Op: 30, A: 5, Flags: 1}, {Op: 22}, {Op: 25}, {Op: 28, A: 46}, {Op: 4}, {Op: 53}, {Op: 26, A: 47}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 6, C: 1}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("compare_by_identity?"),
 						},
@@ -3652,7 +3652,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in ==",
-								Insns:       []bytecode.Instr{{Op: 11, B: 1}, {Op: 11}, {Op: 30, B: 1, Flags: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 11, B: 1}, {Op: 11}, {Op: 30, B: 1, Flags: 3}, {Op: 53}},
 								Names:       []string{"include?"},
 								Params:      []string{"o"},
 								NumRequired: 1,
@@ -3700,7 +3700,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in disjoint?",
-								Insns:       []bytecode.Instr{{Op: 11, B: 1}, {Op: 11}, {Op: 30, B: 1, Flags: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 11, B: 1}, {Op: 11}, {Op: 30, B: 1, Flags: 3}, {Op: 53}},
 								Names:       []string{"include?"},
 								Params:      []string{"o"},
 								NumRequired: 1,
@@ -3715,7 +3715,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:        "block in disjoint?",
-								Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 53}},
 								Names:       []string{"include?"},
 								Params:      []string{"o"},
 								NumRequired: 1,
@@ -3733,7 +3733,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "intersect?",
-						Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 25}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 25}, {Op: 53}},
 						Names:       []string{"disjoint?"},
 						Params:      []string{"other"},
 						NumRequired: 1,
@@ -3748,7 +3748,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "delete_if",
-						Insns: []bytecode.Instr{{Op: 11}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1}, {Op: 30, A: 2, C: 2, Flags: 1}, {Op: 9}, {Op: 5}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 11}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1, Flags: 2}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1}, {Op: 30, A: 2, C: 2, Flags: 1}, {Op: 9}, {Op: 5}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("delete_if"),
 						},
@@ -3777,7 +3777,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:        "block in delete_if",
-								Insns:       []bytecode.Instr{{Op: 11, B: 1}, {Op: 11}, {Op: 30, B: 1, Flags: 1}, {Op: 28, A: 8}, {Op: 5}, {Op: 11}, {Op: 30, A: 1, B: 1}, {Op: 26, A: 9}, {Op: 2}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 11, B: 1}, {Op: 11}, {Op: 30, B: 1, Flags: 3}, {Op: 28, A: 8}, {Op: 5}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 2}, {Op: 26, A: 9}, {Op: 2}, {Op: 53}},
 								Names:       []string{"call", "delete"},
 								Params:      []string{"o"},
 								NumRequired: 1,
@@ -3795,7 +3795,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "keep_if",
-						Insns: []bytecode.Instr{{Op: 11}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1}, {Op: 30, A: 2, C: 2, Flags: 1}, {Op: 9}, {Op: 5}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 11}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1, Flags: 2}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1}, {Op: 30, A: 2, C: 2, Flags: 1}, {Op: 9}, {Op: 5}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("keep_if"),
 						},
@@ -3824,7 +3824,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:        "block in keep_if",
-								Insns:       []bytecode.Instr{{Op: 11, B: 1}, {Op: 11}, {Op: 30, B: 1, Flags: 1}, {Op: 25}, {Op: 28, A: 9}, {Op: 5}, {Op: 11}, {Op: 30, A: 1, B: 1}, {Op: 26, A: 10}, {Op: 2}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 11, B: 1}, {Op: 11}, {Op: 30, B: 1, Flags: 3}, {Op: 25}, {Op: 28, A: 9}, {Op: 5}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 2}, {Op: 26, A: 10}, {Op: 2}, {Op: 53}},
 								Names:       []string{"call", "delete"},
 								Params:      []string{"o"},
 								NumRequired: 1,
@@ -3842,7 +3842,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "select!",
-						Insns: []bytecode.Instr{{Op: 11}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 11}, {Op: 66, A: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1}, {Op: 11, A: 1}, {Op: 22}, {Op: 28, A: 25}, {Op: 2}, {Op: 26, A: 26}, {Op: 5}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 11}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1, Flags: 2}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 11}, {Op: 66, A: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1}, {Op: 11, A: 1}, {Op: 22}, {Op: 28, A: 25}, {Op: 2}, {Op: 26, A: 26}, {Op: 5}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("select!"),
 						},
@@ -3874,7 +3874,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "reject!",
-						Insns: []bytecode.Instr{{Op: 11}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 11}, {Op: 66, A: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1}, {Op: 11, A: 1}, {Op: 22}, {Op: 28, A: 25}, {Op: 2}, {Op: 26, A: 26}, {Op: 5}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 11}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1, Flags: 2}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 11}, {Op: 66, A: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1}, {Op: 11, A: 1}, {Op: 22}, {Op: 28, A: 25}, {Op: 2}, {Op: 26, A: 26}, {Op: 5}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("reject!"),
 						},
@@ -3906,7 +3906,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "map!",
-						Insns: []bytecode.Instr{{Op: 11}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1}, {Op: 11}, {Op: 66, A: 2, Flags: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 4}, {Op: 30, A: 3, B: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 4, C: 2, Flags: 1}, {Op: 9}, {Op: 5}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 11}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1, Flags: 2}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1}, {Op: 11}, {Op: 66, A: 2, Flags: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 4}, {Op: 30, A: 3, B: 1, Flags: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 4, C: 2, Flags: 1}, {Op: 9}, {Op: 5}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("map!"),
 						},
@@ -3935,7 +3935,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:        "block in map!",
-								Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 53}},
 								Names:       []string{"add"},
 								Params:      []string{"o"},
 								NumRequired: 1,
@@ -3953,7 +3953,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "classify",
-						Insns: []bytecode.Instr{{Op: 11}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 7}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 11}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1, Flags: 2}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 7}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("classify"),
 						},
@@ -3982,7 +3982,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:        "block in classify",
-								Insns:       []bytecode.Instr{{Op: 11, B: 1}, {Op: 11}, {Op: 30, B: 1, Flags: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1, B: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 12, A: 3}, {Op: 9}, {Op: 11, A: 2}, {Op: 11, A: 3}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 10}, {Op: 27, A: 29}, {Op: 9}, {Op: 5}, {Op: 30, A: 2}, {Op: 30, A: 3, Flags: 1}, {Op: 12, A: 4}, {Op: 9}, {Op: 11, A: 2}, {Op: 11, A: 3}, {Op: 11, A: 4}, {Op: 30, A: 4, B: 2, Flags: 1}, {Op: 9}, {Op: 11, A: 4}, {Op: 26, A: 29}, {Op: 11}, {Op: 30, A: 5, B: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 11, B: 1}, {Op: 11}, {Op: 30, B: 1, Flags: 3}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1, B: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 12, A: 3}, {Op: 9}, {Op: 11, A: 2}, {Op: 11, A: 3}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 10}, {Op: 27, A: 29}, {Op: 9}, {Op: 5}, {Op: 30, A: 2}, {Op: 30, A: 3, Flags: 1}, {Op: 12, A: 4}, {Op: 9}, {Op: 11, A: 2}, {Op: 11, A: 3}, {Op: 11, A: 4}, {Op: 30, A: 4, B: 2, Flags: 1}, {Op: 9}, {Op: 11, A: 4}, {Op: 26, A: 29}, {Op: 11}, {Op: 30, A: 5, B: 1}, {Op: 53}},
 								Names:       []string{"call", "[]", "class", "new", "[]=", "<<"},
 								Params:      []string{"o"},
 								NumRequired: 1,
@@ -4000,7 +4000,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "divide",
-						Insns: []bytecode.Instr{{Op: 11}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 30, A: 1, Flags: 1}, {Op: 1, A: 1}, {Op: 22}, {Op: 28, A: 19}, {Op: 5}, {Op: 11}, {Op: 66, A: 2}, {Op: 26, A: 26}, {Op: 5}, {Op: 30, A: 3}, {Op: 5}, {Op: 11}, {Op: 66, A: 4}, {Op: 30, A: 5, Flags: 1}, {Op: 30, A: 6, B: 1, Flags: 1}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 11}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1, Flags: 2}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 30, A: 1, Flags: 1}, {Op: 1, A: 1}, {Op: 22}, {Op: 28, A: 19}, {Op: 5}, {Op: 11}, {Op: 66, A: 2}, {Op: 26, A: 26}, {Op: 5}, {Op: 30, A: 3}, {Op: 5}, {Op: 11}, {Op: 66, A: 4}, {Op: 30, A: 5, Flags: 1}, {Op: 30, A: 6, B: 1, Flags: 3}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("divide"),
 							object.IntValue(2),
@@ -4033,7 +4033,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "__divide_graph",
-						Insns: []bytecode.Instr{{Op: 5}, {Op: 30}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 1, Flags: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 33, A: 2}, {Op: 11, A: 2}, {Op: 30, A: 3, B: 1, C: 1, Flags: 1}, {Op: 12, A: 3}, {Op: 9}, {Op: 11, A: 2}, {Op: 30, A: 4, C: 2, Flags: 1}, {Op: 9}, {Op: 1}, {Op: 12, A: 4}, {Op: 9}, {Op: 33, A: 2}, {Op: 11, A: 2}, {Op: 30, A: 3, B: 1, Flags: 1}, {Op: 12, A: 5}, {Op: 9}, {Op: 33, A: 2}, {Op: 11, A: 2}, {Op: 1}, {Op: 30, A: 3, B: 2, Flags: 1}, {Op: 12, A: 6}, {Op: 9}, {Op: 33, A: 2}, {Op: 11, A: 2}, {Op: 4}, {Op: 30, A: 3, B: 2, Flags: 1}, {Op: 12, A: 7}, {Op: 9}, {Op: 6}, {Op: 12, A: 8}, {Op: 9}, {Op: 6}, {Op: 12, A: 9}, {Op: 9}, {Op: 2}, {Op: 12, A: 10}, {Op: 9}, {Op: 5}, {Op: 30, A: 5, C: 3}, {Op: 12, A: 10}, {Op: 9}, {Op: 11, A: 2}, {Op: 30, A: 4, C: 4, Flags: 1}, {Op: 9}, {Op: 5}, {Op: 30, A: 6}, {Op: 11, A: 9}, {Op: 30, A: 7, C: 5, Flags: 1}, {Op: 30, A: 3, B: 1, Flags: 1}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 5}, {Op: 30}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 1, Flags: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 33, A: 2}, {Op: 11, A: 2}, {Op: 30, A: 3, B: 1, C: 1, Flags: 3}, {Op: 12, A: 3}, {Op: 9}, {Op: 11, A: 2}, {Op: 30, A: 4, C: 2, Flags: 1}, {Op: 9}, {Op: 1}, {Op: 12, A: 4}, {Op: 9}, {Op: 33, A: 2}, {Op: 11, A: 2}, {Op: 30, A: 3, B: 1, Flags: 3}, {Op: 12, A: 5}, {Op: 9}, {Op: 33, A: 2}, {Op: 11, A: 2}, {Op: 1}, {Op: 30, A: 3, B: 2, Flags: 3}, {Op: 12, A: 6}, {Op: 9}, {Op: 33, A: 2}, {Op: 11, A: 2}, {Op: 4}, {Op: 30, A: 3, B: 2, Flags: 3}, {Op: 12, A: 7}, {Op: 9}, {Op: 6}, {Op: 12, A: 8}, {Op: 9}, {Op: 6}, {Op: 12, A: 9}, {Op: 9}, {Op: 2}, {Op: 12, A: 10}, {Op: 9}, {Op: 5}, {Op: 30, A: 5, C: 3}, {Op: 12, A: 10}, {Op: 9}, {Op: 11, A: 2}, {Op: 30, A: 4, C: 4, Flags: 1}, {Op: 9}, {Op: 5}, {Op: 30, A: 6}, {Op: 11, A: 9}, {Op: 30, A: 7, C: 5, Flags: 1}, {Op: 30, A: 3, B: 1, Flags: 3}, {Op: 53}},
 						Consts: []object.Value{
 							object.IntValue(0),
 						},
@@ -4075,7 +4075,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:        "block (2 levels) in __divide_graph",
-										Insns:       []bytecode.Instr{{Op: 11, B: 2}, {Op: 11, A: 1, B: 2}, {Op: 11, B: 1}, {Op: 30, B: 1, Flags: 1}, {Op: 11, A: 1, B: 2}, {Op: 11}, {Op: 30, B: 1, Flags: 1}, {Op: 30, A: 1, B: 2, Flags: 1}, {Op: 28, A: 15}, {Op: 11, A: 3, B: 2}, {Op: 11, B: 1}, {Op: 30, B: 1, Flags: 1}, {Op: 11}, {Op: 30, A: 2, B: 1}, {Op: 26, A: 16}, {Op: 2}, {Op: 53}},
+										Insns:       []bytecode.Instr{{Op: 11, B: 2}, {Op: 11, A: 1, B: 2}, {Op: 11, B: 1}, {Op: 30, B: 1, Flags: 3}, {Op: 11, A: 1, B: 2}, {Op: 11}, {Op: 30, B: 1, Flags: 3}, {Op: 30, A: 1, B: 2, Flags: 3}, {Op: 28, A: 15}, {Op: 11, A: 3, B: 2}, {Op: 11, B: 1}, {Op: 30, B: 1, Flags: 3}, {Op: 11}, {Op: 30, A: 2, B: 1}, {Op: 26, A: 16}, {Op: 2}, {Op: 53}},
 										Names:       []string{"[]", "call", "<<"},
 										Params:      []string{"j"},
 										NumRequired: 1,
@@ -4093,7 +4093,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:  "block in __divide_graph",
-								Insns: []bytecode.Instr{{Op: 11, A: 5, B: 1}, {Op: 11}, {Op: 11, A: 4, B: 1}, {Op: 12, A: 1}, {Op: 30, B: 2, Flags: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 9}, {Op: 11, A: 6, B: 1}, {Op: 11}, {Op: 11, A: 4, B: 1}, {Op: 12, A: 2}, {Op: 30, B: 2, Flags: 1}, {Op: 9}, {Op: 11, A: 2}, {Op: 9}, {Op: 11, A: 4, B: 1}, {Op: 1}, {Op: 13}, {Op: 12, A: 4, B: 1}, {Op: 9}, {Op: 11, A: 8, B: 1}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 9}, {Op: 11, A: 7, B: 1}, {Op: 11}, {Op: 3}, {Op: 12, A: 3}, {Op: 30, B: 2, Flags: 1}, {Op: 9}, {Op: 11, A: 3}, {Op: 9}, {Op: 11, A: 3, B: 1}, {Op: 11}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 30, A: 3, C: 1, Flags: 1}, {Op: 9}, {Op: 11, A: 6, B: 1}, {Op: 11}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 11, A: 5, B: 1}, {Op: 11}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 22}, {Op: 28, A: 56}, {Op: 6}, {Op: 12, A: 4}, {Op: 9}, {Op: 5}, {Op: 30, A: 4, C: 2}, {Op: 9}, {Op: 11, A: 9, B: 1}, {Op: 11, A: 4}, {Op: 30, A: 5, B: 1}, {Op: 26, A: 57}, {Op: 2}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 11, A: 5, B: 1}, {Op: 11}, {Op: 11, A: 4, B: 1}, {Op: 12, A: 1}, {Op: 30, B: 2, Flags: 3}, {Op: 9}, {Op: 11, A: 1}, {Op: 9}, {Op: 11, A: 6, B: 1}, {Op: 11}, {Op: 11, A: 4, B: 1}, {Op: 12, A: 2}, {Op: 30, B: 2, Flags: 3}, {Op: 9}, {Op: 11, A: 2}, {Op: 9}, {Op: 11, A: 4, B: 1}, {Op: 1}, {Op: 13}, {Op: 12, A: 4, B: 1}, {Op: 9}, {Op: 11, A: 8, B: 1}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 9}, {Op: 11, A: 7, B: 1}, {Op: 11}, {Op: 3}, {Op: 12, A: 3}, {Op: 30, B: 2, Flags: 3}, {Op: 9}, {Op: 11, A: 3}, {Op: 9}, {Op: 11, A: 3, B: 1}, {Op: 11}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 30, A: 3, C: 1, Flags: 1}, {Op: 9}, {Op: 11, A: 6, B: 1}, {Op: 11}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 11, A: 5, B: 1}, {Op: 11}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 22}, {Op: 28, A: 56}, {Op: 6}, {Op: 12, A: 4}, {Op: 9}, {Op: 5}, {Op: 30, A: 4, C: 2}, {Op: 9}, {Op: 11, A: 9, B: 1}, {Op: 11, A: 4}, {Op: 30, A: 5, B: 1}, {Op: 26, A: 57}, {Op: 2}, {Op: 53}},
 								Consts: []object.Value{
 									object.IntValue(1),
 								},
@@ -4110,7 +4110,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:        "block (2 levels) in __divide_graph",
-										Insns:       []bytecode.Instr{{Op: 11, A: 5, B: 2}, {Op: 11}, {Op: 30, B: 1, Flags: 1}, {Op: 30, A: 1, Flags: 1}, {Op: 28, A: 29}, {Op: 11, A: 10, B: 2}, {Op: 11}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 9}, {Op: 11, A: 6, B: 2}, {Op: 11}, {Op: 30, B: 1, Flags: 1}, {Op: 11, A: 6, B: 2}, {Op: 11, B: 1}, {Op: 30, B: 1, Flags: 1}, {Op: 18}, {Op: 28, A: 27}, {Op: 11, A: 6, B: 2}, {Op: 11, B: 1}, {Op: 11, A: 6, B: 2}, {Op: 11}, {Op: 30, B: 1, Flags: 1}, {Op: 12, A: 1}, {Op: 30, A: 3, B: 2, Flags: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 26, A: 28}, {Op: 2}, {Op: 26, A: 54}, {Op: 11, A: 7, B: 2}, {Op: 11}, {Op: 30, B: 1, Flags: 1}, {Op: 28, A: 53}, {Op: 11, A: 5, B: 2}, {Op: 11}, {Op: 30, B: 1, Flags: 1}, {Op: 11, A: 6, B: 2}, {Op: 11, B: 1}, {Op: 30, B: 1, Flags: 1}, {Op: 18}, {Op: 28, A: 51}, {Op: 11, A: 6, B: 2}, {Op: 11, B: 1}, {Op: 11, A: 5, B: 2}, {Op: 11}, {Op: 30, B: 1, Flags: 1}, {Op: 12, A: 2}, {Op: 30, A: 3, B: 2, Flags: 1}, {Op: 9}, {Op: 11, A: 2}, {Op: 26, A: 52}, {Op: 2}, {Op: 26, A: 54}, {Op: 2}, {Op: 53}},
+										Insns:       []bytecode.Instr{{Op: 11, A: 5, B: 2}, {Op: 11}, {Op: 30, B: 1, Flags: 3}, {Op: 30, A: 1, Flags: 1}, {Op: 28, A: 29}, {Op: 11, A: 10, B: 2}, {Op: 11}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 9}, {Op: 11, A: 6, B: 2}, {Op: 11}, {Op: 30, B: 1, Flags: 3}, {Op: 11, A: 6, B: 2}, {Op: 11, B: 1}, {Op: 30, B: 1, Flags: 3}, {Op: 18}, {Op: 28, A: 27}, {Op: 11, A: 6, B: 2}, {Op: 11, B: 1}, {Op: 11, A: 6, B: 2}, {Op: 11}, {Op: 30, B: 1, Flags: 3}, {Op: 12, A: 1}, {Op: 30, A: 3, B: 2, Flags: 3}, {Op: 9}, {Op: 11, A: 1}, {Op: 26, A: 28}, {Op: 2}, {Op: 26, A: 54}, {Op: 11, A: 7, B: 2}, {Op: 11}, {Op: 30, B: 1, Flags: 3}, {Op: 28, A: 53}, {Op: 11, A: 5, B: 2}, {Op: 11}, {Op: 30, B: 1, Flags: 3}, {Op: 11, A: 6, B: 2}, {Op: 11, B: 1}, {Op: 30, B: 1, Flags: 3}, {Op: 18}, {Op: 28, A: 51}, {Op: 11, A: 6, B: 2}, {Op: 11, B: 1}, {Op: 11, A: 5, B: 2}, {Op: 11}, {Op: 30, B: 1, Flags: 3}, {Op: 12, A: 2}, {Op: 30, A: 3, B: 2, Flags: 3}, {Op: 9}, {Op: 11, A: 2}, {Op: 26, A: 52}, {Op: 2}, {Op: 26, A: 54}, {Op: 2}, {Op: 53}},
 										Names:       []string{"[]", "nil?", "call", "[]="},
 										Params:      []string{"w"},
 										NumRequired: 1,
@@ -4125,7 +4125,7 @@ func embeddedPrelude() *bytecode.ISeq {
 									},
 									&bytecode.ISeq{
 										Name:        "block (2 levels) in __divide_graph",
-										Insns:       []bytecode.Instr{{Op: 11, A: 8, B: 2}, {Op: 30, Flags: 1}, {Op: 12}, {Op: 9}, {Op: 11, A: 7, B: 2}, {Op: 11}, {Op: 4}, {Op: 12, A: 1}, {Op: 30, A: 1, B: 2, Flags: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 9}, {Op: 11, A: 4, B: 1}, {Op: 11, A: 1, B: 2}, {Op: 11}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 30, A: 3, B: 1}, {Op: 9}, {Op: 11}, {Op: 11, B: 1}, {Op: 22}, {Op: 28, A: 25}, {Op: 2}, {Op: 55}, {Op: 26, A: 26}, {Op: 2}, {Op: 53}},
+										Insns:       []bytecode.Instr{{Op: 11, A: 8, B: 2}, {Op: 30, Flags: 1}, {Op: 12}, {Op: 9}, {Op: 11, A: 7, B: 2}, {Op: 11}, {Op: 4}, {Op: 12, A: 1}, {Op: 30, A: 1, B: 2, Flags: 3}, {Op: 9}, {Op: 11, A: 1}, {Op: 9}, {Op: 11, A: 4, B: 1}, {Op: 11, A: 1, B: 2}, {Op: 11}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 30, A: 3, B: 1}, {Op: 9}, {Op: 11}, {Op: 11, B: 1}, {Op: 22}, {Op: 28, A: 25}, {Op: 2}, {Op: 55}, {Op: 26, A: 26}, {Op: 2}, {Op: 53}},
 										Names:       []string{"pop", "[]=", "[]", "<<"},
 										NumRequired: 0,
 										SplatIndex:  -1,
@@ -4142,7 +4142,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:        "block in __divide_graph",
-								Insns:       []bytecode.Instr{{Op: 11, A: 5, B: 1}, {Op: 11}, {Op: 30, B: 1, Flags: 1}, {Op: 30, A: 1, Flags: 1}, {Op: 28, A: 9}, {Op: 11, A: 10, B: 1}, {Op: 11}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 26, A: 10}, {Op: 2}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 11, A: 5, B: 1}, {Op: 11}, {Op: 30, B: 1, Flags: 3}, {Op: 30, A: 1, Flags: 1}, {Op: 28, A: 9}, {Op: 11, A: 10, B: 1}, {Op: 11}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 26, A: 10}, {Op: 2}, {Op: 53}},
 								Names:       []string{"[]", "nil?", "call"},
 								Params:      []string{"v"},
 								NumRequired: 1,
@@ -4157,7 +4157,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:        "block in __divide_graph",
-								Insns:       []bytecode.Instr{{Op: 5}, {Op: 30}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 5}, {Op: 30}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 53}},
 								Names:       []string{"class", "new"},
 								Params:      []string{"c"},
 								NumRequired: 1,
@@ -4188,7 +4188,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "flatten!",
-						Insns:       []bytecode.Instr{{Op: 5}, {Op: 30, C: 1}, {Op: 28, A: 10}, {Op: 5}, {Op: 5}, {Op: 30, A: 1}, {Op: 30, A: 2, B: 1}, {Op: 9}, {Op: 5}, {Op: 26, A: 11}, {Op: 2}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 5}, {Op: 30, C: 1}, {Op: 28, A: 10}, {Op: 5}, {Op: 5}, {Op: 30, A: 1}, {Op: 30, A: 2, B: 1, Flags: 2}, {Op: 9}, {Op: 5}, {Op: 26, A: 11}, {Op: 2}, {Op: 53}},
 						Names:       []string{"any?", "flatten", "replace"},
 						NumRequired: 0,
 						SplatIndex:  -1,
@@ -4200,7 +4200,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in flatten!",
-								Insns:       []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 53}},
 								Names:       []string{"Set", "is_a?"},
 								Params:      []string{"o"},
 								NumRequired: 1,
@@ -4232,7 +4232,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in flatten_merge",
-								Insns: []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 28, A: 35}, {Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 30, A: 2, Flags: 1}, {Op: 30, A: 3, B: 1, Flags: 1}, {Op: 28, A: 14}, {Op: 5}, {Op: 33, A: 4}, {Op: 1}, {Op: 30, A: 5, B: 2}, {Op: 26, A: 15}, {Op: 2}, {Op: 9}, {Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 30, A: 2, Flags: 1}, {Op: 3}, {Op: 12, A: 1}, {Op: 30, A: 6, B: 2, Flags: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 9}, {Op: 5}, {Op: 11}, {Op: 11, A: 1, B: 1}, {Op: 30, A: 7, B: 2}, {Op: 9}, {Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 30, A: 2, Flags: 1}, {Op: 30, A: 8, B: 1, Flags: 1}, {Op: 26, A: 38}, {Op: 5}, {Op: 11}, {Op: 30, A: 9, B: 1}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 28, A: 35}, {Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 30, A: 2, Flags: 1}, {Op: 30, A: 3, B: 1, Flags: 3}, {Op: 28, A: 14}, {Op: 5}, {Op: 33, A: 4}, {Op: 1}, {Op: 30, A: 5, B: 2, Flags: 2}, {Op: 26, A: 15}, {Op: 2}, {Op: 9}, {Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 30, A: 2, Flags: 1}, {Op: 3}, {Op: 12, A: 1}, {Op: 30, A: 6, B: 2, Flags: 3}, {Op: 9}, {Op: 11, A: 1}, {Op: 9}, {Op: 5}, {Op: 11}, {Op: 11, A: 1, B: 1}, {Op: 30, A: 7, B: 2, Flags: 2}, {Op: 9}, {Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 30, A: 2, Flags: 1}, {Op: 30, A: 8, B: 1, Flags: 3}, {Op: 26, A: 38}, {Op: 5}, {Op: 11}, {Op: 30, A: 9, B: 1, Flags: 2}, {Op: 53}},
 								Consts: []object.Value{
 									object.NewString("tried to flatten recursive Set"),
 								},
@@ -4253,7 +4253,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "join",
-						Insns:       []bytecode.Instr{{Op: 54}, {Op: 27, A: 5}, {Op: 2}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 30}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 54}, {Op: 27, A: 5}, {Op: 2}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 30}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 53}},
 						Names:       []string{"to_a", "join"},
 						Params:      []string{"sep"},
 						NumRequired: 0,
@@ -4295,7 +4295,7 @@ func embeddedPrelude() *bytecode.ISeq {
 				Children: []*bytecode.ISeq{
 					&bytecode.ISeq{
 						Name:  "<class:Version>",
-						Insns: []bytecode.Instr{{Op: 5}, {Op: 33}, {Op: 30, A: 1, B: 1}, {Op: 9}, {Op: 1}, {Op: 41, A: 2}, {Op: 9}, {Op: 33, A: 3}, {Op: 1, A: 1}, {Op: 33, A: 2}, {Op: 13}, {Op: 1, A: 2}, {Op: 13}, {Op: 30, A: 4, B: 1, Flags: 1}, {Op: 41, A: 5}, {Op: 9}, {Op: 45, A: 6}, {Op: 9}, {Op: 45, A: 7, B: 1}, {Op: 9}, {Op: 5}, {Op: 1, A: 3}, {Op: 30, A: 8, B: 1}, {Op: 9}, {Op: 44, A: 9, B: 2}, {Op: 9}, {Op: 44, A: 10, B: 3}, {Op: 9}, {Op: 44, A: 11, B: 4}, {Op: 9}, {Op: 44, A: 12, B: 5}, {Op: 9}, {Op: 44, A: 13, B: 6}, {Op: 9}, {Op: 44, A: 14, B: 7}, {Op: 9}, {Op: 44, A: 15, B: 8}, {Op: 9}, {Op: 44, A: 16, B: 9}, {Op: 9}, {Op: 44, A: 17, B: 10}, {Op: 9}, {Op: 44, A: 18, B: 11}, {Op: 9}, {Op: 44, A: 19, B: 12}, {Op: 9}, {Op: 5}, {Op: 30, A: 20}, {Op: 9}, {Op: 44, A: 21, B: 13}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 5}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 2}, {Op: 9}, {Op: 1}, {Op: 41, A: 2}, {Op: 9}, {Op: 33, A: 3}, {Op: 1, A: 1}, {Op: 33, A: 2}, {Op: 13}, {Op: 1, A: 2}, {Op: 13}, {Op: 30, A: 4, B: 1, Flags: 3}, {Op: 41, A: 5}, {Op: 9}, {Op: 45, A: 6}, {Op: 9}, {Op: 45, A: 7, B: 1}, {Op: 9}, {Op: 5}, {Op: 1, A: 3}, {Op: 30, A: 8, B: 1, Flags: 2}, {Op: 9}, {Op: 44, A: 9, B: 2}, {Op: 9}, {Op: 44, A: 10, B: 3}, {Op: 9}, {Op: 44, A: 11, B: 4}, {Op: 9}, {Op: 44, A: 12, B: 5}, {Op: 9}, {Op: 44, A: 13, B: 6}, {Op: 9}, {Op: 44, A: 14, B: 7}, {Op: 9}, {Op: 44, A: 15, B: 8}, {Op: 9}, {Op: 44, A: 16, B: 9}, {Op: 9}, {Op: 44, A: 17, B: 10}, {Op: 9}, {Op: 44, A: 18, B: 11}, {Op: 9}, {Op: 44, A: 19, B: 12}, {Op: 9}, {Op: 5}, {Op: 30, A: 20}, {Op: 9}, {Op: 44, A: 21, B: 13}, {Op: 53}},
 						Consts: []object.Value{
 							object.NewString("[0-9]+(\\.[0-9a-zA-Z]+)*(-[0-9A-Za-z.-]+)?"),
 							object.NewString("\\A\\s*("),
@@ -4328,7 +4328,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:        "create",
-								Insns:       []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 28, A: 6}, {Op: 11}, {Op: 26, A: 14}, {Op: 11}, {Op: 30, A: 2, Flags: 1}, {Op: 28, A: 11}, {Op: 2}, {Op: 26, A: 14}, {Op: 5}, {Op: 11}, {Op: 30, A: 3, B: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 28, A: 6}, {Op: 11}, {Op: 26, A: 14}, {Op: 11}, {Op: 30, A: 2, Flags: 1}, {Op: 28, A: 11}, {Op: 2}, {Op: 26, A: 14}, {Op: 5}, {Op: 11}, {Op: 30, A: 3, B: 1, Flags: 2}, {Op: 53}},
 								Names:       []string{"Version", "is_a?", "nil?", "new"},
 								Params:      []string{"input"},
 								NumRequired: 1,
@@ -4343,7 +4343,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:  "initialize",
-								Insns: []bytecode.Instr{{Op: 5}, {Op: 30}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 25}, {Op: 28, A: 20}, {Op: 5}, {Op: 33, A: 2}, {Op: 1}, {Op: 1, A: 1}, {Op: 30, A: 3}, {Op: 13}, {Op: 11}, {Op: 30, A: 3}, {Op: 13}, {Op: 1, A: 2}, {Op: 30, A: 3}, {Op: 13}, {Op: 30, A: 4, B: 2}, {Op: 26, A: 21}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 30, A: 3, Flags: 1}, {Op: 30, A: 5, Flags: 1}, {Op: 1, A: 3}, {Op: 1, A: 4}, {Op: 30, A: 6, B: 2, Flags: 1}, {Op: 32, A: 7}, {Op: 9}, {Op: 31, A: 7}, {Op: 30, A: 8, Flags: 1}, {Op: 28, A: 36}, {Op: 1, A: 5}, {Op: 32, A: 7}, {Op: 26, A: 37}, {Op: 2}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 5}, {Op: 30}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 25}, {Op: 28, A: 20}, {Op: 5}, {Op: 33, A: 2}, {Op: 1}, {Op: 1, A: 1}, {Op: 30, A: 3}, {Op: 13}, {Op: 11}, {Op: 30, A: 3}, {Op: 13}, {Op: 1, A: 2}, {Op: 30, A: 3}, {Op: 13}, {Op: 30, A: 4, B: 2, Flags: 2}, {Op: 26, A: 21}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 30, A: 3, Flags: 1}, {Op: 30, A: 5, Flags: 1}, {Op: 1, A: 3}, {Op: 1, A: 4}, {Op: 30, A: 6, B: 2, Flags: 3}, {Op: 32, A: 7}, {Op: 9}, {Op: 31, A: 7}, {Op: 30, A: 8, Flags: 1}, {Op: 28, A: 36}, {Op: 1, A: 5}, {Op: 32, A: 7}, {Op: 26, A: 37}, {Op: 2}, {Op: 53}},
 								Consts: []object.Value{
 									object.NewString(""),
 									object.NewString("Malformed version number string "),
@@ -4398,7 +4398,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:        "segments",
-								Insns:       []bytecode.Instr{{Op: 31}, {Op: 10}, {Op: 27, A: 8}, {Op: 9}, {Op: 31, A: 1}, {Op: 68, A: 2, B: 3}, {Op: 30, A: 4, B: 1, Flags: 1}, {Op: 30, A: 5, C: 1, Flags: 1}, {Op: 32}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 31}, {Op: 10}, {Op: 27, A: 8}, {Op: 9}, {Op: 31, A: 1}, {Op: 68, A: 2, B: 3}, {Op: 30, A: 4, B: 1, Flags: 3}, {Op: 30, A: 5, C: 1, Flags: 1}, {Op: 32}, {Op: 53}},
 								Names:       []string{"@segments", "@version", "[0-9]+|[a-zA-Z]+", "", "scan", "map"},
 								NumRequired: 0,
 								SplatIndex:  -1,
@@ -4441,7 +4441,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:  "release",
-								Insns: []bytecode.Instr{{Op: 5}, {Op: 30}, {Op: 25}, {Op: 28, A: 7}, {Op: 5}, {Op: 53}, {Op: 26, A: 8}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 30, A: 2, Flags: 1}, {Op: 25}, {Op: 10}, {Op: 28, A: 24}, {Op: 9}, {Op: 11}, {Op: 30, A: 3, Flags: 1}, {Op: 33, A: 4}, {Op: 30, A: 5, B: 1, Flags: 1}, {Op: 25}, {Op: 28, A: 29}, {Op: 11}, {Op: 30, A: 6, Flags: 1}, {Op: 9}, {Op: 26, A: 13}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 7}, {Op: 11}, {Op: 1}, {Op: 30, A: 8, B: 1, Flags: 1}, {Op: 30, A: 9, B: 1, Flags: 1}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 5}, {Op: 30}, {Op: 25}, {Op: 28, A: 7}, {Op: 5}, {Op: 53}, {Op: 26, A: 8}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 30, A: 2, Flags: 1}, {Op: 25}, {Op: 10}, {Op: 28, A: 24}, {Op: 9}, {Op: 11}, {Op: 30, A: 3, Flags: 1}, {Op: 33, A: 4}, {Op: 30, A: 5, B: 1, Flags: 3}, {Op: 25}, {Op: 28, A: 29}, {Op: 11}, {Op: 30, A: 6, Flags: 1}, {Op: 9}, {Op: 26, A: 13}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 7}, {Op: 11}, {Op: 1}, {Op: 30, A: 8, B: 1, Flags: 3}, {Op: 30, A: 9, B: 1, Flags: 3}, {Op: 53}},
 								Consts: []object.Value{
 									object.NewString("."),
 								},
@@ -4458,7 +4458,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:  "bump",
-								Insns: []bytecode.Instr{{Op: 5}, {Op: 30}, {Op: 30, A: 1, Flags: 1}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 30, A: 2, Flags: 1}, {Op: 25}, {Op: 10}, {Op: 28, A: 16}, {Op: 9}, {Op: 11}, {Op: 30, A: 3, Flags: 1}, {Op: 33, A: 4}, {Op: 30, A: 5, B: 1, Flags: 1}, {Op: 25}, {Op: 28, A: 21}, {Op: 11}, {Op: 30, A: 6, Flags: 1}, {Op: 9}, {Op: 26, A: 5}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 30, A: 7, Flags: 1}, {Op: 1}, {Op: 19}, {Op: 28, A: 31}, {Op: 11}, {Op: 30, A: 6, Flags: 1}, {Op: 26, A: 32}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 1, A: 1}, {Op: 11}, {Op: 1, A: 1}, {Op: 30, A: 8, B: 1, Flags: 1}, {Op: 1}, {Op: 13}, {Op: 12, A: 1}, {Op: 30, A: 9, B: 2, Flags: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 9}, {Op: 5}, {Op: 30, A: 10}, {Op: 11}, {Op: 1, A: 2}, {Op: 30, A: 11, B: 1, Flags: 1}, {Op: 30, A: 12, B: 1, Flags: 1}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 5}, {Op: 30}, {Op: 30, A: 1, Flags: 1}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 30, A: 2, Flags: 1}, {Op: 25}, {Op: 10}, {Op: 28, A: 16}, {Op: 9}, {Op: 11}, {Op: 30, A: 3, Flags: 1}, {Op: 33, A: 4}, {Op: 30, A: 5, B: 1, Flags: 3}, {Op: 25}, {Op: 28, A: 21}, {Op: 11}, {Op: 30, A: 6, Flags: 1}, {Op: 9}, {Op: 26, A: 5}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 30, A: 7, Flags: 1}, {Op: 1}, {Op: 19}, {Op: 28, A: 31}, {Op: 11}, {Op: 30, A: 6, Flags: 1}, {Op: 26, A: 32}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 1, A: 1}, {Op: 11}, {Op: 1, A: 1}, {Op: 30, A: 8, B: 1, Flags: 3}, {Op: 1}, {Op: 13}, {Op: 12, A: 1}, {Op: 30, A: 9, B: 2, Flags: 3}, {Op: 9}, {Op: 11, A: 1}, {Op: 9}, {Op: 5}, {Op: 30, A: 10}, {Op: 11}, {Op: 1, A: 2}, {Op: 30, A: 11, B: 1, Flags: 3}, {Op: 30, A: 12, B: 1, Flags: 3}, {Op: 53}},
 								Consts: []object.Value{
 									object.IntValue(1),
 									object.IntValue(-1),
@@ -4477,7 +4477,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:  "<=>",
-								Insns: []bytecode.Instr{{Op: 5}, {Op: 30}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 30, A: 2, Flags: 1}, {Op: 28, A: 12}, {Op: 2}, {Op: 53}, {Op: 26, A: 13}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 3}, {Op: 12, A: 1}, {Op: 9}, {Op: 11}, {Op: 30, A: 3, Flags: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 4, Flags: 1}, {Op: 11, A: 2}, {Op: 30, A: 4, Flags: 1}, {Op: 19}, {Op: 28, A: 31}, {Op: 11, A: 1}, {Op: 30, A: 4, Flags: 1}, {Op: 26, A: 33}, {Op: 11, A: 2}, {Op: 30, A: 4, Flags: 1}, {Op: 12, A: 3}, {Op: 9}, {Op: 1}, {Op: 12, A: 4}, {Op: 9}, {Op: 11, A: 4}, {Op: 11, A: 3}, {Op: 18}, {Op: 28, A: 90}, {Op: 11, A: 1}, {Op: 11, A: 4}, {Op: 30, A: 5, B: 1, Flags: 1}, {Op: 12, A: 5}, {Op: 9}, {Op: 11, A: 2}, {Op: 11, A: 4}, {Op: 30, A: 5, B: 1, Flags: 1}, {Op: 12, A: 6}, {Op: 9}, {Op: 11, A: 5}, {Op: 30, A: 2, Flags: 1}, {Op: 28, A: 58}, {Op: 1}, {Op: 12, A: 5}, {Op: 26, A: 59}, {Op: 2}, {Op: 9}, {Op: 11, A: 6}, {Op: 30, A: 2, Flags: 1}, {Op: 28, A: 66}, {Op: 1}, {Op: 12, A: 6}, {Op: 26, A: 67}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 11, A: 5}, {Op: 11, A: 6}, {Op: 30, A: 6, B: 2}, {Op: 12, A: 7}, {Op: 9}, {Op: 11, A: 7}, {Op: 1}, {Op: 22}, {Op: 25}, {Op: 28, A: 82}, {Op: 11, A: 7}, {Op: 53}, {Op: 26, A: 83}, {Op: 2}, {Op: 9}, {Op: 11, A: 4}, {Op: 1, A: 1}, {Op: 13}, {Op: 12, A: 4}, {Op: 9}, {Op: 26, A: 38}, {Op: 2}, {Op: 9}, {Op: 1}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 5}, {Op: 30}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 30, A: 2, Flags: 1}, {Op: 28, A: 12}, {Op: 2}, {Op: 53}, {Op: 26, A: 13}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 3}, {Op: 12, A: 1}, {Op: 9}, {Op: 11}, {Op: 30, A: 3, Flags: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 4, Flags: 1}, {Op: 11, A: 2}, {Op: 30, A: 4, Flags: 1}, {Op: 19}, {Op: 28, A: 31}, {Op: 11, A: 1}, {Op: 30, A: 4, Flags: 1}, {Op: 26, A: 33}, {Op: 11, A: 2}, {Op: 30, A: 4, Flags: 1}, {Op: 12, A: 3}, {Op: 9}, {Op: 1}, {Op: 12, A: 4}, {Op: 9}, {Op: 11, A: 4}, {Op: 11, A: 3}, {Op: 18}, {Op: 28, A: 90}, {Op: 11, A: 1}, {Op: 11, A: 4}, {Op: 30, A: 5, B: 1, Flags: 3}, {Op: 12, A: 5}, {Op: 9}, {Op: 11, A: 2}, {Op: 11, A: 4}, {Op: 30, A: 5, B: 1, Flags: 3}, {Op: 12, A: 6}, {Op: 9}, {Op: 11, A: 5}, {Op: 30, A: 2, Flags: 1}, {Op: 28, A: 58}, {Op: 1}, {Op: 12, A: 5}, {Op: 26, A: 59}, {Op: 2}, {Op: 9}, {Op: 11, A: 6}, {Op: 30, A: 2, Flags: 1}, {Op: 28, A: 66}, {Op: 1}, {Op: 12, A: 6}, {Op: 26, A: 67}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 11, A: 5}, {Op: 11, A: 6}, {Op: 30, A: 6, B: 2, Flags: 2}, {Op: 12, A: 7}, {Op: 9}, {Op: 11, A: 7}, {Op: 1}, {Op: 22}, {Op: 25}, {Op: 28, A: 82}, {Op: 11, A: 7}, {Op: 53}, {Op: 26, A: 83}, {Op: 2}, {Op: 9}, {Op: 11, A: 4}, {Op: 1, A: 1}, {Op: 13}, {Op: 12, A: 4}, {Op: 9}, {Op: 26, A: 38}, {Op: 2}, {Op: 9}, {Op: 1}, {Op: 53}},
 								Consts: []object.Value{
 									object.IntValue(0),
 									object.IntValue(1),
@@ -4496,7 +4496,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:  "==",
-								Insns: []bytecode.Instr{{Op: 5}, {Op: 30}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 30, A: 2, Flags: 1}, {Op: 28, A: 12}, {Op: 4}, {Op: 53}, {Op: 26, A: 13}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 11}, {Op: 30, A: 3, B: 1}, {Op: 1}, {Op: 22}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 5}, {Op: 30}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 30, A: 2, Flags: 1}, {Op: 28, A: 12}, {Op: 4}, {Op: 53}, {Op: 26, A: 13}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 11}, {Op: 30, A: 3, B: 1}, {Op: 1}, {Op: 22}, {Op: 53}},
 								Consts: []object.Value{
 									object.IntValue(0),
 								},
@@ -4514,7 +4514,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:        "eql?",
-								Insns:       []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 10}, {Op: 28, A: 11}, {Op: 9}, {Op: 5}, {Op: 30, A: 2}, {Op: 11}, {Op: 30, A: 2, Flags: 1}, {Op: 22}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 10}, {Op: 28, A: 11}, {Op: 9}, {Op: 5}, {Op: 30, A: 2}, {Op: 11}, {Op: 30, A: 2, Flags: 1}, {Op: 22}, {Op: 53}},
 								Names:       []string{"Version", "is_a?", "segments"},
 								Params:      []string{"other"},
 								NumRequired: 1,
@@ -4542,7 +4542,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:  "compare_segment",
-								Insns: []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 10}, {Op: 28, A: 9}, {Op: 9}, {Op: 11, A: 1}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 28, A: 14}, {Op: 11}, {Op: 11, A: 1}, {Op: 30, A: 2, B: 1}, {Op: 26, A: 35}, {Op: 11}, {Op: 33, A: 3}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 10}, {Op: 28, A: 23}, {Op: 9}, {Op: 11, A: 1}, {Op: 33, A: 3}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 28, A: 28}, {Op: 11}, {Op: 11, A: 1}, {Op: 30, A: 2, B: 1}, {Op: 26, A: 35}, {Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 28, A: 34}, {Op: 1}, {Op: 26, A: 35}, {Op: 1, A: 1}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 10}, {Op: 28, A: 9}, {Op: 9}, {Op: 11, A: 1}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 28, A: 14}, {Op: 11}, {Op: 11, A: 1}, {Op: 30, A: 2, B: 1}, {Op: 26, A: 35}, {Op: 11}, {Op: 33, A: 3}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 10}, {Op: 28, A: 23}, {Op: 9}, {Op: 11, A: 1}, {Op: 33, A: 3}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 28, A: 28}, {Op: 11}, {Op: 11, A: 1}, {Op: 30, A: 2, B: 1}, {Op: 26, A: 35}, {Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 28, A: 34}, {Op: 1}, {Op: 26, A: 35}, {Op: 1, A: 1}, {Op: 53}},
 								Consts: []object.Value{
 									object.IntValue(1),
 									object.IntValue(-1),
@@ -4564,7 +4564,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "<class:Requirement>",
-						Insns: []bytecode.Instr{{Op: 1}, {Op: 5}, {Op: 30, C: 1}, {Op: 1, A: 1}, {Op: 5}, {Op: 30, C: 2}, {Op: 1, A: 2}, {Op: 5}, {Op: 30, C: 3}, {Op: 1, A: 3}, {Op: 5}, {Op: 30, C: 4}, {Op: 1, A: 4}, {Op: 5}, {Op: 30, C: 5}, {Op: 1, A: 5}, {Op: 5}, {Op: 30, C: 6}, {Op: 1, A: 6}, {Op: 5}, {Op: 30, C: 7}, {Op: 7, A: 7}, {Op: 41, A: 1}, {Op: 9}, {Op: 33, A: 2}, {Op: 1, A: 7}, {Op: 33, A: 3}, {Op: 34, A: 4}, {Op: 13}, {Op: 1, A: 8}, {Op: 13}, {Op: 30, A: 5, B: 1, Flags: 1}, {Op: 41, A: 6}, {Op: 9}, {Op: 45, A: 7, B: 7}, {Op: 9}, {Op: 45, A: 8, B: 8}, {Op: 9}, {Op: 5}, {Op: 1, A: 9}, {Op: 30, A: 9, B: 1}, {Op: 9}, {Op: 44, A: 10, B: 9}, {Op: 9}, {Op: 45, A: 11, B: 10}, {Op: 9}, {Op: 44, A: 12, B: 11}, {Op: 9}, {Op: 78, A: 13, B: 12}, {Op: 9}, {Op: 78, A: 14, B: 12}, {Op: 9}, {Op: 44, A: 15, B: 12}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 1}, {Op: 5}, {Op: 30, C: 1}, {Op: 1, A: 1}, {Op: 5}, {Op: 30, C: 2}, {Op: 1, A: 2}, {Op: 5}, {Op: 30, C: 3}, {Op: 1, A: 3}, {Op: 5}, {Op: 30, C: 4}, {Op: 1, A: 4}, {Op: 5}, {Op: 30, C: 5}, {Op: 1, A: 5}, {Op: 5}, {Op: 30, C: 6}, {Op: 1, A: 6}, {Op: 5}, {Op: 30, C: 7}, {Op: 7, A: 7}, {Op: 41, A: 1}, {Op: 9}, {Op: 33, A: 2}, {Op: 1, A: 7}, {Op: 33, A: 3}, {Op: 34, A: 4}, {Op: 13}, {Op: 1, A: 8}, {Op: 13}, {Op: 30, A: 5, B: 1, Flags: 3}, {Op: 41, A: 6}, {Op: 9}, {Op: 45, A: 7, B: 7}, {Op: 9}, {Op: 45, A: 8, B: 8}, {Op: 9}, {Op: 5}, {Op: 1, A: 9}, {Op: 30, A: 9, B: 1, Flags: 2}, {Op: 9}, {Op: 44, A: 10, B: 9}, {Op: 9}, {Op: 45, A: 11, B: 10}, {Op: 9}, {Op: 44, A: 12, B: 11}, {Op: 9}, {Op: 78, A: 13, B: 12}, {Op: 9}, {Op: 78, A: 14, B: 12}, {Op: 9}, {Op: 44, A: 15, B: 12}, {Op: 53}},
 						Consts: []object.Value{
 							object.NewString("="),
 							object.NewString("!="),
@@ -4687,7 +4687,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:        "create",
-								Insns:       []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 28, A: 6}, {Op: 11}, {Op: 26, A: 9}, {Op: 5}, {Op: 11}, {Op: 30, A: 2, B: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 28, A: 6}, {Op: 11}, {Op: 26, A: 9}, {Op: 5}, {Op: 11}, {Op: 30, A: 2, B: 1, Flags: 2}, {Op: 53}},
 								Names:       []string{"Requirement", "is_a?", "new"},
 								Params:      []string{"input"},
 								NumRequired: 1,
@@ -4702,7 +4702,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:  "default",
-								Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1, Flags: 2}, {Op: 53}},
 								Consts: []object.Value{
 									object.NewString(">= 0"),
 								},
@@ -4735,7 +4735,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:        "block in initialize",
-										Insns:       []bytecode.Instr{{Op: 5}, {Op: 30}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 53}},
+										Insns:       []bytecode.Instr{{Op: 5}, {Op: 30}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 53}},
 										Names:       []string{"class", "parse"},
 										Params:      []string{"r"},
 										NumRequired: 1,
@@ -4753,7 +4753,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:  "parse",
-								Insns: []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 28, A: 9}, {Op: 1}, {Op: 11}, {Op: 6, A: 2}, {Op: 53}, {Op: 26, A: 10}, {Op: 2}, {Op: 9}, {Op: 33, A: 2}, {Op: 11}, {Op: 30, A: 3, Flags: 1}, {Op: 30, A: 4, B: 1, Flags: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 25}, {Op: 28, A: 35}, {Op: 5}, {Op: 33, A: 5}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 30, A: 3}, {Op: 13}, {Op: 11}, {Op: 30, A: 6, Flags: 1}, {Op: 30, A: 3}, {Op: 13}, {Op: 1, A: 3}, {Op: 30, A: 3}, {Op: 13}, {Op: 30, A: 7, B: 2}, {Op: 26, A: 36}, {Op: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 1, A: 4}, {Op: 30, A: 8, B: 1, Flags: 1}, {Op: 10}, {Op: 27, A: 44}, {Op: 9}, {Op: 1, A: 5}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 33}, {Op: 11, A: 1}, {Op: 1, A: 6}, {Op: 30, A: 8, B: 1, Flags: 1}, {Op: 30, A: 9, B: 1, Flags: 1}, {Op: 6, A: 2}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 28, A: 9}, {Op: 1}, {Op: 11}, {Op: 6, A: 2}, {Op: 53}, {Op: 26, A: 10}, {Op: 2}, {Op: 9}, {Op: 33, A: 2}, {Op: 11}, {Op: 30, A: 3, Flags: 1}, {Op: 30, A: 4, B: 1, Flags: 3}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 25}, {Op: 28, A: 35}, {Op: 5}, {Op: 33, A: 5}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 30, A: 3}, {Op: 13}, {Op: 11}, {Op: 30, A: 6, Flags: 1}, {Op: 30, A: 3}, {Op: 13}, {Op: 1, A: 3}, {Op: 30, A: 3}, {Op: 13}, {Op: 30, A: 7, B: 2, Flags: 2}, {Op: 26, A: 36}, {Op: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 1, A: 4}, {Op: 30, A: 8, B: 1, Flags: 3}, {Op: 10}, {Op: 27, A: 44}, {Op: 9}, {Op: 1, A: 5}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 33}, {Op: 11, A: 1}, {Op: 1, A: 6}, {Op: 30, A: 8, B: 1, Flags: 3}, {Op: 30, A: 9, B: 1, Flags: 3}, {Op: 6, A: 2}, {Op: 53}},
 								Consts: []object.Value{
 									object.NewString("="),
 									object.NewString(""),
@@ -4777,7 +4777,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:        "satisfied_by?",
-								Insns:       []bytecode.Instr{{Op: 33}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 12}, {Op: 9}, {Op: 31, A: 2}, {Op: 30, A: 3, C: 1, Flags: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 33}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 12}, {Op: 9}, {Op: 31, A: 2}, {Op: 30, A: 3, C: 1, Flags: 1}, {Op: 53}},
 								Names:       []string{"Version", "create", "@requirements", "all?"},
 								Params:      []string{"version"},
 								NumRequired: 1,
@@ -4791,7 +4791,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:        "block in satisfied_by?",
-										Insns:       []bytecode.Instr{{Op: 33}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 11, B: 1}, {Op: 11, A: 1}, {Op: 30, A: 2, B: 2, Flags: 1}, {Op: 53}},
+										Insns:       []bytecode.Instr{{Op: 33}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 11, B: 1}, {Op: 11, A: 1}, {Op: 30, A: 2, B: 2, Flags: 3}, {Op: 53}},
 										Names:       []string{"OPS", "[]", "call"},
 										Params:      []string{"op", "req"},
 										NumRequired: 2,
@@ -4809,7 +4809,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:  "to_s",
-								Insns: []bytecode.Instr{{Op: 31}, {Op: 30, A: 1, C: 1, Flags: 1}, {Op: 1}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 31}, {Op: 30, A: 1, C: 1, Flags: 1}, {Op: 1}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 53}},
 								Consts: []object.Value{
 									object.NewString(", "),
 								},
@@ -4851,7 +4851,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "ruby_version",
-						Insns:       []bytecode.Instr{{Op: 33}, {Op: 33, A: 1}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 33}, {Op: 33, A: 1}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 53}},
 						Names:       []string{"Version", "RUBY_VERSION", "new"},
 						NumRequired: 0,
 						SplatIndex:  -1,
@@ -4944,7 +4944,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in initialize",
-								Insns:       []bytecode.Instr{{Op: 31}, {Op: 11}, {Op: 30, A: 1, Flags: 1}, {Op: 11, A: 1}, {Op: 12, A: 2}, {Op: 30, A: 2, B: 2, Flags: 1}, {Op: 9}, {Op: 11, A: 2}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 31}, {Op: 11}, {Op: 30, A: 1, Flags: 1}, {Op: 11, A: 1}, {Op: 12, A: 2}, {Op: 30, A: 2, B: 2, Flags: 3}, {Op: 9}, {Op: 11, A: 2}, {Op: 53}},
 								Names:       []string{"@table", "to_sym", "[]="},
 								Params:      []string{"k", "v"},
 								NumRequired: 2,
@@ -4962,7 +4962,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "[]",
-						Insns:       []bytecode.Instr{{Op: 31}, {Op: 11}, {Op: 30, A: 1, Flags: 1}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 31}, {Op: 11}, {Op: 30, A: 1, Flags: 1}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 53}},
 						Names:       []string{"@table", "to_sym", "[]"},
 						Params:      []string{"name"},
 						NumRequired: 1,
@@ -4977,7 +4977,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "[]=",
-						Insns:       []bytecode.Instr{{Op: 31}, {Op: 11}, {Op: 30, A: 1, Flags: 1}, {Op: 11, A: 1}, {Op: 12, A: 2}, {Op: 30, A: 2, B: 2, Flags: 1}, {Op: 9}, {Op: 11, A: 2}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 31}, {Op: 11}, {Op: 30, A: 1, Flags: 1}, {Op: 11, A: 1}, {Op: 12, A: 2}, {Op: 30, A: 2, B: 2, Flags: 3}, {Op: 9}, {Op: 11, A: 2}, {Op: 53}},
 						Names:       []string{"@table", "to_sym", "[]="},
 						Params:      []string{"name", "value"},
 						NumRequired: 2,
@@ -4992,7 +4992,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "to_h",
-						Insns:       []bytecode.Instr{{Op: 33}, {Op: 31, A: 1}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 33}, {Op: 31, A: 1}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 53}},
 						Names:       []string{"OpenStruct", "@table", "__data_to_h"},
 						NumRequired: 0,
 						SplatIndex:  -1,
@@ -5005,7 +5005,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "each_pair",
-						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 31, A: 1}, {Op: 30, A: 2, C: 1, Flags: 1}, {Op: 9}, {Op: 5}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, Flags: 2}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 31, A: 1}, {Op: 30, A: 2, C: 1, Flags: 1}, {Op: 9}, {Op: 5}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("each_pair"),
 						},
@@ -5020,7 +5020,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in each_pair",
-								Insns:       []bytecode.Instr{{Op: 11}, {Op: 11, A: 1}, {Op: 48, A: 2}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 11}, {Op: 11, A: 1}, {Op: 48, A: 2, Flags: 2}, {Op: 53}},
 								Params:      []string{"k", "v"},
 								NumRequired: 2,
 								SplatIndex:  -1,
@@ -5050,7 +5050,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "dig",
-						Insns:       []bytecode.Instr{{Op: 33}, {Op: 6}, {Op: 31, A: 1}, {Op: 6, A: 1}, {Op: 61}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 62, A: 2, Flags: 1}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 33}, {Op: 6}, {Op: 31, A: 1}, {Op: 6, A: 1}, {Op: 61}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 62, A: 2, Flags: 3}, {Op: 53}},
 						Names:       []string{"OpenStruct", "@table", "__data_dig"},
 						Params:      []string{"names"},
 						NumRequired: 0,
@@ -5065,7 +5065,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "delete_field",
-						Insns:       []bytecode.Instr{{Op: 33}, {Op: 31, A: 1}, {Op: 11}, {Op: 30, A: 2, Flags: 1}, {Op: 30, A: 3, B: 2, Flags: 1}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 33}, {Op: 31, A: 1}, {Op: 11}, {Op: 30, A: 2, Flags: 1}, {Op: 30, A: 3, B: 2, Flags: 3}, {Op: 53}},
 						Names:       []string{"OpenStruct", "@table", "to_sym", "__data_delete_field"},
 						Params:      []string{"name"},
 						NumRequired: 1,
@@ -5080,7 +5080,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "respond_to_missing?",
-						Insns: []bytecode.Instr{{Op: 54, A: 1}, {Op: 27, A: 5}, {Op: 4}, {Op: 12, A: 1}, {Op: 9}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 31, A: 1}, {Op: 11}, {Op: 30, A: 2, Flags: 1}, {Op: 30, A: 3, B: 1, Flags: 1}, {Op: 10}, {Op: 27, A: 19}, {Op: 9}, {Op: 11, A: 2}, {Op: 1}, {Op: 30, A: 4, B: 1, Flags: 1}, {Op: 10}, {Op: 27, A: 23}, {Op: 9}, {Op: 47, B: 1}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 54, A: 1}, {Op: 27, A: 5}, {Op: 4}, {Op: 12, A: 1}, {Op: 9}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 31, A: 1}, {Op: 11}, {Op: 30, A: 2, Flags: 1}, {Op: 30, A: 3, B: 1, Flags: 3}, {Op: 10}, {Op: 27, A: 19}, {Op: 9}, {Op: 11, A: 2}, {Op: 1}, {Op: 30, A: 4, B: 1, Flags: 3}, {Op: 10}, {Op: 27, A: 23}, {Op: 9}, {Op: 47, B: 1}, {Op: 53}},
 						Consts: []object.Value{
 							object.NewString("="),
 						},
@@ -5098,7 +5098,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "method_missing",
-						Insns: []bytecode.Instr{{Op: 11}, {Op: 30, Flags: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 1}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 28, A: 46}, {Op: 11, A: 1}, {Op: 30, A: 2, Flags: 1}, {Op: 1, A: 1}, {Op: 22}, {Op: 25}, {Op: 28, A: 29}, {Op: 5}, {Op: 33, A: 3}, {Op: 1, A: 2}, {Op: 1, A: 3}, {Op: 30}, {Op: 13}, {Op: 11, A: 1}, {Op: 30, A: 2, Flags: 1}, {Op: 30}, {Op: 13}, {Op: 1, A: 4}, {Op: 30}, {Op: 13}, {Op: 30, A: 4, B: 2}, {Op: 26, A: 30}, {Op: 2}, {Op: 9}, {Op: 31, A: 5}, {Op: 11, A: 2}, {Op: 1, A: 5}, {Op: 1, A: 6}, {Op: 8}, {Op: 30, A: 6, B: 1, Flags: 1}, {Op: 30, A: 7, Flags: 1}, {Op: 11, A: 1}, {Op: 1, A: 5}, {Op: 30, A: 6, B: 1, Flags: 1}, {Op: 12, A: 3}, {Op: 30, A: 8, B: 2, Flags: 1}, {Op: 9}, {Op: 11, A: 3}, {Op: 26, A: 54}, {Op: 11, A: 1}, {Op: 30, A: 9, Flags: 1}, {Op: 28, A: 53}, {Op: 31, A: 5}, {Op: 11}, {Op: 30, A: 6, B: 1, Flags: 1}, {Op: 26, A: 54}, {Op: 47, B: 1}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 11}, {Op: 30, Flags: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 1}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 28, A: 46}, {Op: 11, A: 1}, {Op: 30, A: 2, Flags: 1}, {Op: 1, A: 1}, {Op: 22}, {Op: 25}, {Op: 28, A: 29}, {Op: 5}, {Op: 33, A: 3}, {Op: 1, A: 2}, {Op: 1, A: 3}, {Op: 30}, {Op: 13}, {Op: 11, A: 1}, {Op: 30, A: 2, Flags: 1}, {Op: 30}, {Op: 13}, {Op: 1, A: 4}, {Op: 30}, {Op: 13}, {Op: 30, A: 4, B: 2, Flags: 2}, {Op: 26, A: 30}, {Op: 2}, {Op: 9}, {Op: 31, A: 5}, {Op: 11, A: 2}, {Op: 1, A: 5}, {Op: 1, A: 6}, {Op: 8}, {Op: 30, A: 6, B: 1, Flags: 3}, {Op: 30, A: 7, Flags: 1}, {Op: 11, A: 1}, {Op: 1, A: 5}, {Op: 30, A: 6, B: 1, Flags: 3}, {Op: 12, A: 3}, {Op: 30, A: 8, B: 2, Flags: 3}, {Op: 9}, {Op: 11, A: 3}, {Op: 26, A: 54}, {Op: 11, A: 1}, {Op: 30, A: 9, Flags: 1}, {Op: 28, A: 53}, {Op: 31, A: 5}, {Op: 11}, {Op: 30, A: 6, B: 1, Flags: 3}, {Op: 26, A: 54}, {Op: 47, B: 1}, {Op: 53}},
 						Consts: []object.Value{
 							object.NewString("="),
 							object.IntValue(1),
@@ -5122,7 +5122,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "==",
-						Insns:       []bytecode.Instr{{Op: 33}, {Op: 31, A: 1}, {Op: 11}, {Op: 33}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 28, A: 9}, {Op: 11}, {Op: 30, A: 3, Flags: 1}, {Op: 26, A: 10}, {Op: 2}, {Op: 30, A: 4, B: 2, Flags: 1}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 33}, {Op: 31, A: 1}, {Op: 11}, {Op: 33}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 28, A: 9}, {Op: 11}, {Op: 30, A: 3, Flags: 1}, {Op: 26, A: 10}, {Op: 2}, {Op: 30, A: 4, B: 2, Flags: 3}, {Op: 53}},
 						Names:       []string{"OpenStruct", "@table", "is_a?", "to_h", "__data_eq"},
 						Params:      []string{"other"},
 						NumRequired: 1,
@@ -5137,7 +5137,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "respond_to?",
-						Insns:       []bytecode.Instr{{Op: 54, A: 1}, {Op: 27, A: 5}, {Op: 4}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 11}, {Op: 11, A: 1}, {Op: 30, B: 2}, {Op: 10}, {Op: 27, A: 13}, {Op: 9}, {Op: 47, B: 1}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 54, A: 1}, {Op: 27, A: 5}, {Op: 4}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 11}, {Op: 11, A: 1}, {Op: 30, B: 2, Flags: 2}, {Op: 10}, {Op: 27, A: 13}, {Op: 9}, {Op: 47, B: 1}, {Op: 53}},
 						Names:       []string{"respond_to_missing?"},
 						Params:      []string{"name", "include_private"},
 						NumRequired: 1,
@@ -5152,7 +5152,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "inspect",
-						Insns:       []bytecode.Instr{{Op: 33}, {Op: 31, A: 1}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 33}, {Op: 31, A: 1}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 53}},
 						Names:       []string{"OpenStruct", "@table", "__data_inspect"},
 						NumRequired: 0,
 						SplatIndex:  -1,
@@ -5180,7 +5180,7 @@ func embeddedPrelude() *bytecode.ISeq {
 				Children: []*bytecode.ISeq{
 					&bytecode.ISeq{
 						Name:        "def_delegator",
-						Insns:       []bytecode.Instr{{Op: 54, A: 2}, {Op: 27, A: 5}, {Op: 11, A: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 11, A: 2}, {Op: 30, A: 1, B: 1, C: 1}, {Op: 9}, {Op: 11, A: 2}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 54, A: 2}, {Op: 27, A: 5}, {Op: 11, A: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 11, A: 2}, {Op: 30, A: 1, B: 1, C: 1, Flags: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 53}},
 						Names:       []string{"to_s", "define_method"},
 						Params:      []string{"accessor", "method", "ali"},
 						NumRequired: 2,
@@ -5194,7 +5194,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in def_delegator",
-								Insns:       []bytecode.Instr{{Op: 33}, {Op: 5}, {Op: 11, B: 1}, {Op: 30, A: 1, B: 2, Flags: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 6}, {Op: 11, A: 1, B: 1}, {Op: 6, A: 1}, {Op: 61}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 11, A: 1}, {Op: 67, A: 2, Flags: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 33}, {Op: 5}, {Op: 11, B: 1}, {Op: 30, A: 1, B: 2, Flags: 3}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 6}, {Op: 11, A: 1, B: 1}, {Op: 6, A: 1}, {Op: 61}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 11, A: 1}, {Op: 67, A: 2, Flags: 3}, {Op: 53}},
 								Names:       []string{"Forwardable", "__resolve_accessor", "__send__"},
 								Params:      []string{"args"},
 								NumRequired: 0,
@@ -5226,7 +5226,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in def_delegators",
-								Insns:       []bytecode.Instr{{Op: 5}, {Op: 11, B: 1}, {Op: 11}, {Op: 30, B: 2}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 5}, {Op: 11, B: 1}, {Op: 11}, {Op: 30, B: 2, Flags: 2}, {Op: 53}},
 								Names:       []string{"def_delegator"},
 								Params:      []string{"m"},
 								NumRequired: 1,
@@ -5244,7 +5244,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "__resolve_accessor",
-						Insns: []bytecode.Instr{{Op: 11, A: 1}, {Op: 1}, {Op: 30, B: 1, Flags: 1}, {Op: 28, A: 9}, {Op: 11}, {Op: 11, A: 1}, {Op: 30, A: 1, Flags: 1}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 26, A: 12}, {Op: 11}, {Op: 11, A: 1}, {Op: 30, A: 3, B: 1, Flags: 1}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 11, A: 1}, {Op: 1}, {Op: 30, B: 1, Flags: 3}, {Op: 28, A: 9}, {Op: 11}, {Op: 11, A: 1}, {Op: 30, A: 1, Flags: 1}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 26, A: 12}, {Op: 11}, {Op: 11, A: 1}, {Op: 30, A: 3, B: 1, Flags: 3}, {Op: 53}},
 						Consts: []object.Value{
 							object.NewString("@"),
 						},
@@ -5277,7 +5277,7 @@ func embeddedPrelude() *bytecode.ISeq {
 				Children: []*bytecode.ISeq{
 					&bytecode.ISeq{
 						Name:        "def_single_delegator",
-						Insns:       []bytecode.Instr{{Op: 54, A: 2}, {Op: 27, A: 5}, {Op: 11, A: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 11, A: 2}, {Op: 30, A: 1, B: 1, C: 1}, {Op: 9}, {Op: 11, A: 2}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 54, A: 2}, {Op: 27, A: 5}, {Op: 11, A: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 11, A: 2}, {Op: 30, A: 1, B: 1, C: 1, Flags: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 53}},
 						Names:       []string{"to_s", "define_singleton_method"},
 						Params:      []string{"accessor", "method", "ali"},
 						NumRequired: 2,
@@ -5291,7 +5291,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in def_single_delegator",
-								Insns:       []bytecode.Instr{{Op: 33}, {Op: 5}, {Op: 11, B: 1}, {Op: 30, A: 1, B: 2, Flags: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 6}, {Op: 11, A: 1, B: 1}, {Op: 6, A: 1}, {Op: 61}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 11, A: 1}, {Op: 67, A: 2, Flags: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 33}, {Op: 5}, {Op: 11, B: 1}, {Op: 30, A: 1, B: 2, Flags: 3}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 6}, {Op: 11, A: 1, B: 1}, {Op: 6, A: 1}, {Op: 61}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 11, A: 1}, {Op: 67, A: 2, Flags: 3}, {Op: 53}},
 								Names:       []string{"Forwardable", "__resolve_accessor", "__send__"},
 								Params:      []string{"args"},
 								NumRequired: 0,
@@ -5323,7 +5323,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in def_single_delegators",
-								Insns:       []bytecode.Instr{{Op: 5}, {Op: 11, B: 1}, {Op: 11}, {Op: 30, B: 2}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 5}, {Op: 11, B: 1}, {Op: 11}, {Op: 30, B: 2, Flags: 2}, {Op: 53}},
 								Names:       []string{"def_single_delegator"},
 								Params:      []string{"m"},
 								NumRequired: 1,
@@ -5356,7 +5356,7 @@ func embeddedPrelude() *bytecode.ISeq {
 				Children: []*bytecode.ISeq{
 					&bytecode.ISeq{
 						Name:        "initialize",
-						Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 53}},
 						Names:       []string{"__setobj__"},
 						Params:      []string{"obj"},
 						NumRequired: 1,
@@ -5371,7 +5371,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "method_missing",
-						Insns:       []bytecode.Instr{{Op: 5}, {Op: 30}, {Op: 12, A: 3}, {Op: 9}, {Op: 11, A: 3}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 28, A: 19}, {Op: 11, A: 3}, {Op: 6}, {Op: 11}, {Op: 6, A: 1}, {Op: 61}, {Op: 11, A: 1}, {Op: 60}, {Op: 61}, {Op: 11, A: 2}, {Op: 67, A: 2, Flags: 1}, {Op: 26, A: 20}, {Op: 47, B: 1}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 5}, {Op: 30}, {Op: 12, A: 3}, {Op: 9}, {Op: 11, A: 3}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 28, A: 19}, {Op: 11, A: 3}, {Op: 6}, {Op: 11}, {Op: 6, A: 1}, {Op: 61}, {Op: 11, A: 1}, {Op: 60}, {Op: 61}, {Op: 11, A: 2}, {Op: 67, A: 2, Flags: 3}, {Op: 26, A: 20}, {Op: 47, B: 1}, {Op: 53}},
 						Names:       []string{"__getobj__", "respond_to?", "__send__"},
 						Params:      []string{"name", "args"},
 						NumRequired: 1,
@@ -5386,7 +5386,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "respond_to_missing?",
-						Insns:       []bytecode.Instr{{Op: 54, A: 1}, {Op: 27, A: 5}, {Op: 4}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 30}, {Op: 11}, {Op: 11, A: 1}, {Op: 30, A: 1, B: 2, Flags: 1}, {Op: 10}, {Op: 27, A: 14}, {Op: 9}, {Op: 47, B: 1}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 54, A: 1}, {Op: 27, A: 5}, {Op: 4}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 30}, {Op: 11}, {Op: 11, A: 1}, {Op: 30, A: 1, B: 2, Flags: 3}, {Op: 10}, {Op: 27, A: 14}, {Op: 9}, {Op: 47, B: 1}, {Op: 53}},
 						Names:       []string{"__getobj__", "respond_to?"},
 						Params:      []string{"name", "include_private"},
 						NumRequired: 1,
@@ -5401,7 +5401,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "respond_to?",
-						Insns:       []bytecode.Instr{{Op: 54, A: 1}, {Op: 27, A: 5}, {Op: 4}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 11}, {Op: 11, A: 1}, {Op: 30, B: 2}, {Op: 10}, {Op: 27, A: 13}, {Op: 9}, {Op: 47, B: 1}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 54, A: 1}, {Op: 27, A: 5}, {Op: 4}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 11}, {Op: 11, A: 1}, {Op: 30, B: 2, Flags: 2}, {Op: 10}, {Op: 27, A: 13}, {Op: 9}, {Op: 47, B: 1}, {Op: 53}},
 						Names:       []string{"respond_to_missing?"},
 						Params:      []string{"name", "include_private"},
 						NumRequired: 1,
@@ -5416,7 +5416,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "==",
-						Insns:       []bytecode.Instr{{Op: 11}, {Op: 5}, {Op: 30, B: 1, Flags: 1}, {Op: 28, A: 7}, {Op: 3}, {Op: 53}, {Op: 26, A: 8}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1}, {Op: 11}, {Op: 22}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 11}, {Op: 5}, {Op: 30, B: 1, Flags: 3}, {Op: 28, A: 7}, {Op: 3}, {Op: 53}, {Op: 26, A: 8}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1}, {Op: 11}, {Op: 22}, {Op: 53}},
 						Names:       []string{"equal?", "__getobj__"},
 						Params:      []string{"other"},
 						NumRequired: 1,
@@ -5431,7 +5431,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "__getobj__",
-						Insns: []bytecode.Instr{{Op: 5}, {Op: 33}, {Op: 1}, {Op: 1, A: 1}, {Op: 30, A: 1}, {Op: 13}, {Op: 5}, {Op: 30, A: 2}, {Op: 30, A: 1}, {Op: 13}, {Op: 1, A: 2}, {Op: 30, A: 1}, {Op: 13}, {Op: 30, A: 3, B: 2}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 5}, {Op: 33}, {Op: 1}, {Op: 1, A: 1}, {Op: 30, A: 1}, {Op: 13}, {Op: 5}, {Op: 30, A: 2}, {Op: 30, A: 1}, {Op: 13}, {Op: 1, A: 2}, {Op: 30, A: 1}, {Op: 13}, {Op: 30, A: 3, B: 2, Flags: 2}, {Op: 53}},
 						Consts: []object.Value{
 							object.NewString(""),
 							object.NewString(""),
@@ -5449,7 +5449,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "__setobj__",
-						Insns: []bytecode.Instr{{Op: 5}, {Op: 33}, {Op: 1}, {Op: 1, A: 1}, {Op: 30, A: 1}, {Op: 13}, {Op: 5}, {Op: 30, A: 2}, {Op: 30, A: 1}, {Op: 13}, {Op: 1, A: 2}, {Op: 30, A: 1}, {Op: 13}, {Op: 30, A: 3, B: 2}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 5}, {Op: 33}, {Op: 1}, {Op: 1, A: 1}, {Op: 30, A: 1}, {Op: 13}, {Op: 5}, {Op: 30, A: 2}, {Op: 30, A: 1}, {Op: 13}, {Op: 1, A: 2}, {Op: 30, A: 1}, {Op: 13}, {Op: 30, A: 3, B: 2, Flags: 2}, {Op: 53}},
 						Consts: []object.Value{
 							object.NewString(""),
 							object.NewString(""),
@@ -5515,7 +5515,7 @@ func embeddedPrelude() *bytecode.ISeq {
 			},
 			&bytecode.ISeq{
 				Name:  "DelegateClass",
-				Insns: []bytecode.Instr{{Op: 33}, {Op: 33, A: 1}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 3, C: 1, Flags: 1}, {Op: 9}, {Op: 1}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 1, A: 3}, {Op: 1, A: 4}, {Op: 1, A: 5}, {Op: 1, A: 6}, {Op: 1, A: 7}, {Op: 1, A: 8}, {Op: 1, A: 9}, {Op: 1, A: 10}, {Op: 1, A: 11}, {Op: 1, A: 12}, {Op: 1, A: 13}, {Op: 1, A: 14}, {Op: 1, A: 15}, {Op: 1, A: 16}, {Op: 1, A: 17}, {Op: 1, A: 18}, {Op: 1, A: 19}, {Op: 1, A: 20}, {Op: 1, A: 21}, {Op: 1, A: 22}, {Op: 6, A: 23}, {Op: 12, A: 2}, {Op: 9}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 30, A: 5, C: 2, Flags: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}},
+				Insns: []bytecode.Instr{{Op: 33}, {Op: 33, A: 1}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 3, C: 1, Flags: 1}, {Op: 9}, {Op: 1}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 1, A: 3}, {Op: 1, A: 4}, {Op: 1, A: 5}, {Op: 1, A: 6}, {Op: 1, A: 7}, {Op: 1, A: 8}, {Op: 1, A: 9}, {Op: 1, A: 10}, {Op: 1, A: 11}, {Op: 1, A: 12}, {Op: 1, A: 13}, {Op: 1, A: 14}, {Op: 1, A: 15}, {Op: 1, A: 16}, {Op: 1, A: 17}, {Op: 1, A: 18}, {Op: 1, A: 19}, {Op: 1, A: 20}, {Op: 1, A: 21}, {Op: 1, A: 22}, {Op: 6, A: 23}, {Op: 12, A: 2}, {Op: 9}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 30, A: 5, C: 2, Flags: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}},
 				Consts: []object.Value{
 					object.Symbol("__getobj__"),
 					object.Symbol("__setobj__"),
@@ -5597,7 +5597,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "block in DelegateClass",
-						Insns: []bytecode.Instr{{Op: 11, A: 2, B: 1}, {Op: 11}, {Op: 30, B: 1, Flags: 1}, {Op: 28, A: 7}, {Op: 2}, {Op: 53}, {Op: 26, A: 8}, {Op: 2}, {Op: 9}, {Op: 11, A: 1, B: 1}, {Op: 1}, {Op: 11}, {Op: 30, A: 1, B: 2, C: 1, Flags: 1}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 11, A: 2, B: 1}, {Op: 11}, {Op: 30, B: 1, Flags: 3}, {Op: 28, A: 7}, {Op: 2}, {Op: 53}, {Op: 26, A: 8}, {Op: 2}, {Op: 9}, {Op: 11, A: 1, B: 1}, {Op: 1}, {Op: 11}, {Op: 30, A: 1, B: 2, C: 1, Flags: 3}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("define_method"),
 						},
@@ -5614,7 +5614,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block (2 levels) in DelegateClass",
-								Insns:       []bytecode.Instr{{Op: 5}, {Op: 30}, {Op: 6}, {Op: 11, B: 1}, {Op: 6, A: 1}, {Op: 61}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 11, A: 1}, {Op: 67, A: 1, Flags: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 5}, {Op: 30}, {Op: 6}, {Op: 11, B: 1}, {Op: 6, A: 1}, {Op: 61}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 11, A: 1}, {Op: 67, A: 1, Flags: 3}, {Op: 53}},
 								Names:       []string{"__getobj__", "__send__"},
 								Params:      []string{"args"},
 								NumRequired: 0,
@@ -5635,7 +5635,7 @@ func embeddedPrelude() *bytecode.ISeq {
 			},
 			&bytecode.ISeq{
 				Name:  "<class:Pathname>",
-				Insns: []bytecode.Instr{{Op: 5}, {Op: 33}, {Op: 30, A: 1, B: 1}, {Op: 9}, {Op: 1}, {Op: 41, A: 2}, {Op: 9}, {Op: 44, A: 3}, {Op: 9}, {Op: 44, A: 4, B: 1}, {Op: 9}, {Op: 78, A: 5, B: 4}, {Op: 9}, {Op: 44, A: 6, B: 2}, {Op: 9}, {Op: 44, A: 7, B: 3}, {Op: 9}, {Op: 44, A: 8, B: 4}, {Op: 9}, {Op: 44, A: 9, B: 5}, {Op: 9}, {Op: 78, A: 10, B: 9}, {Op: 9}, {Op: 44, A: 11, B: 6}, {Op: 9}, {Op: 44, A: 12, B: 7}, {Op: 9}, {Op: 44, A: 13, B: 8}, {Op: 9}, {Op: 44, A: 14, B: 9}, {Op: 9}, {Op: 44, A: 15, B: 10}, {Op: 9}, {Op: 44, A: 16, B: 11}, {Op: 9}, {Op: 44, A: 17, B: 12}, {Op: 9}, {Op: 44, A: 18, B: 13}, {Op: 9}, {Op: 44, A: 19, B: 14}, {Op: 9}, {Op: 44, A: 20, B: 15}, {Op: 9}, {Op: 78, A: 21, B: 20}, {Op: 9}, {Op: 44, A: 22, B: 16}, {Op: 9}, {Op: 44, A: 23, B: 17}, {Op: 9}, {Op: 44, A: 24, B: 18}, {Op: 9}, {Op: 44, A: 25, B: 19}, {Op: 9}, {Op: 44, A: 26, B: 20}, {Op: 9}, {Op: 44, A: 27, B: 21}, {Op: 9}, {Op: 44, A: 28, B: 22}, {Op: 9}, {Op: 44, A: 29, B: 23}, {Op: 9}, {Op: 44, A: 30, B: 24}, {Op: 9}, {Op: 44, A: 31, B: 25}, {Op: 9}, {Op: 44, A: 32, B: 26}, {Op: 9}, {Op: 44, A: 33, B: 27}, {Op: 9}, {Op: 44, A: 34, B: 28}, {Op: 9}, {Op: 44, A: 35, B: 29}, {Op: 9}, {Op: 44, A: 36, B: 30}, {Op: 53}},
+				Insns: []bytecode.Instr{{Op: 5}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 2}, {Op: 9}, {Op: 1}, {Op: 41, A: 2}, {Op: 9}, {Op: 44, A: 3}, {Op: 9}, {Op: 44, A: 4, B: 1}, {Op: 9}, {Op: 78, A: 5, B: 4}, {Op: 9}, {Op: 44, A: 6, B: 2}, {Op: 9}, {Op: 44, A: 7, B: 3}, {Op: 9}, {Op: 44, A: 8, B: 4}, {Op: 9}, {Op: 44, A: 9, B: 5}, {Op: 9}, {Op: 78, A: 10, B: 9}, {Op: 9}, {Op: 44, A: 11, B: 6}, {Op: 9}, {Op: 44, A: 12, B: 7}, {Op: 9}, {Op: 44, A: 13, B: 8}, {Op: 9}, {Op: 44, A: 14, B: 9}, {Op: 9}, {Op: 44, A: 15, B: 10}, {Op: 9}, {Op: 44, A: 16, B: 11}, {Op: 9}, {Op: 44, A: 17, B: 12}, {Op: 9}, {Op: 44, A: 18, B: 13}, {Op: 9}, {Op: 44, A: 19, B: 14}, {Op: 9}, {Op: 44, A: 20, B: 15}, {Op: 9}, {Op: 78, A: 21, B: 20}, {Op: 9}, {Op: 44, A: 22, B: 16}, {Op: 9}, {Op: 44, A: 23, B: 17}, {Op: 9}, {Op: 44, A: 24, B: 18}, {Op: 9}, {Op: 44, A: 25, B: 19}, {Op: 9}, {Op: 44, A: 26, B: 20}, {Op: 9}, {Op: 44, A: 27, B: 21}, {Op: 9}, {Op: 44, A: 28, B: 22}, {Op: 9}, {Op: 44, A: 29, B: 23}, {Op: 9}, {Op: 44, A: 30, B: 24}, {Op: 9}, {Op: 44, A: 31, B: 25}, {Op: 9}, {Op: 44, A: 32, B: 26}, {Op: 9}, {Op: 44, A: 33, B: 27}, {Op: 9}, {Op: 44, A: 34, B: 28}, {Op: 9}, {Op: 44, A: 35, B: 29}, {Op: 9}, {Op: 44, A: 36, B: 30}, {Op: 53}},
 				Consts: []object.Value{
 					object.NewString("/"),
 				},
@@ -5650,7 +5650,7 @@ func embeddedPrelude() *bytecode.ISeq {
 				Children: []*bytecode.ISeq{
 					&bytecode.ISeq{
 						Name:  "initialize",
-						Insns: []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 28, A: 8}, {Op: 11}, {Op: 30, A: 2, Flags: 1}, {Op: 12}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 33, A: 3}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 25}, {Op: 28, A: 20}, {Op: 5}, {Op: 33, A: 4}, {Op: 1}, {Op: 30, A: 5, B: 2}, {Op: 26, A: 21}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 32, A: 6}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 28, A: 8}, {Op: 11}, {Op: 30, A: 2, Flags: 1}, {Op: 12}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 33, A: 3}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 25}, {Op: 28, A: 20}, {Op: 5}, {Op: 33, A: 4}, {Op: 1}, {Op: 30, A: 5, B: 2, Flags: 2}, {Op: 26, A: 21}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 32, A: 6}, {Op: 53}},
 						Consts: []object.Value{
 							object.NewString("no implicit conversion into String"),
 						},
@@ -5725,7 +5725,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "==",
-						Insns:       []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 10}, {Op: 28, A: 10}, {Op: 9}, {Op: 11}, {Op: 30, A: 2, Flags: 1}, {Op: 31, A: 3}, {Op: 22}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 10}, {Op: 28, A: 10}, {Op: 9}, {Op: 11}, {Op: 30, A: 2, Flags: 1}, {Op: 31, A: 3}, {Op: 22}, {Op: 53}},
 						Names:       []string{"Pathname", "is_a?", "to_s", "@path"},
 						Params:      []string{"other"},
 						NumRequired: 1,
@@ -5740,7 +5740,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "<=>",
-						Insns:       []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 25}, {Op: 28, A: 8}, {Op: 2}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 31, A: 2}, {Op: 11}, {Op: 30, A: 3, Flags: 1}, {Op: 30, A: 4, B: 1}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 25}, {Op: 28, A: 8}, {Op: 2}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 31, A: 2}, {Op: 11}, {Op: 30, A: 3, Flags: 1}, {Op: 30, A: 4, B: 1}, {Op: 53}},
 						Names:       []string{"Pathname", "is_a?", "@path", "to_s", "<=>"},
 						Params:      []string{"other"},
 						NumRequired: 1,
@@ -5768,7 +5768,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "absolute?",
-						Insns:       []bytecode.Instr{{Op: 33}, {Op: 31, A: 1}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 33}, {Op: 31, A: 1}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 53}},
 						Names:       []string{"Pathname", "@path", "__lex_absolute?"},
 						NumRequired: 0,
 						SplatIndex:  -1,
@@ -5807,7 +5807,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "+",
-						Insns:       []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 25}, {Op: 28, A: 10}, {Op: 33}, {Op: 11}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 12}, {Op: 26, A: 11}, {Op: 2}, {Op: 9}, {Op: 33}, {Op: 33}, {Op: 31, A: 3}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 30, A: 5, B: 2, Flags: 1}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 25}, {Op: 28, A: 10}, {Op: 33}, {Op: 11}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 12}, {Op: 26, A: 11}, {Op: 2}, {Op: 9}, {Op: 33}, {Op: 33}, {Op: 31, A: 3}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 30, A: 5, B: 2, Flags: 3}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 53}},
 						Names:       []string{"Pathname", "is_a?", "new", "@path", "to_s", "__lex_plus"},
 						Params:      []string{"other"},
 						NumRequired: 1,
@@ -5867,7 +5867,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "basename",
-						Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 5}, {Op: 1}, {Op: 12}, {Op: 9}, {Op: 33}, {Op: 33}, {Op: 31, A: 1}, {Op: 11}, {Op: 30, A: 2, B: 2, Flags: 1}, {Op: 30, A: 3, B: 1, Flags: 1}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 5}, {Op: 1}, {Op: 12}, {Op: 9}, {Op: 33}, {Op: 33}, {Op: 31, A: 1}, {Op: 11}, {Op: 30, A: 2, B: 2, Flags: 3}, {Op: 30, A: 3, B: 1, Flags: 3}, {Op: 53}},
 						Consts: []object.Value{
 							object.NewString(""),
 						},
@@ -5885,7 +5885,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "dirname",
-						Insns:       []bytecode.Instr{{Op: 33}, {Op: 33}, {Op: 31, A: 1}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 30, A: 3, B: 1, Flags: 1}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 33}, {Op: 33}, {Op: 31, A: 1}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 30, A: 3, B: 1, Flags: 3}, {Op: 53}},
 						Names:       []string{"Pathname", "@path", "__lex_dirname", "new"},
 						NumRequired: 0,
 						SplatIndex:  -1,
@@ -5898,7 +5898,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "extname",
-						Insns:       []bytecode.Instr{{Op: 33}, {Op: 31, A: 1}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 33}, {Op: 31, A: 1}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 53}},
 						Names:       []string{"Pathname", "@path", "__lex_extname"},
 						NumRequired: 0,
 						SplatIndex:  -1,
@@ -5924,7 +5924,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "each_filename",
-						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 33, A: 1}, {Op: 31, A: 2}, {Op: 30, A: 3, B: 1, Flags: 1}, {Op: 30, A: 4, C: 1, Flags: 1}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, Flags: 2}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 33, A: 1}, {Op: 31, A: 2}, {Op: 30, A: 3, B: 1, Flags: 3}, {Op: 30, A: 4, C: 1, Flags: 1}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("each_filename"),
 						},
@@ -5939,7 +5939,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in each_filename",
-								Insns:       []bytecode.Instr{{Op: 11}, {Op: 48, A: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 11}, {Op: 48, A: 1, Flags: 2}, {Op: 53}},
 								Params:      []string{"f"},
 								NumRequired: 1,
 								SplatIndex:  -1,
@@ -5956,7 +5956,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "ascend",
-						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 33, A: 1}, {Op: 31, A: 2}, {Op: 30, A: 3, B: 1, Flags: 1}, {Op: 30, A: 4, C: 1, Flags: 1}, {Op: 9}, {Op: 5}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, Flags: 2}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 33, A: 1}, {Op: 31, A: 2}, {Op: 30, A: 3, B: 1, Flags: 3}, {Op: 30, A: 4, C: 1, Flags: 1}, {Op: 9}, {Op: 5}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("ascend"),
 						},
@@ -5971,7 +5971,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in ascend",
-								Insns:       []bytecode.Instr{{Op: 33}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 48, A: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 33}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 48, A: 1, Flags: 2}, {Op: 53}},
 								Names:       []string{"Pathname", "new"},
 								Params:      []string{"p"},
 								NumRequired: 1,
@@ -5989,7 +5989,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "descend",
-						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 33, A: 1}, {Op: 31, A: 2}, {Op: 30, A: 3, B: 1, Flags: 1}, {Op: 30, A: 4, C: 1, Flags: 1}, {Op: 9}, {Op: 5}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, Flags: 2}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 33, A: 1}, {Op: 31, A: 2}, {Op: 30, A: 3, B: 1, Flags: 3}, {Op: 30, A: 4, C: 1, Flags: 1}, {Op: 9}, {Op: 5}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("descend"),
 						},
@@ -6004,7 +6004,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in descend",
-								Insns:       []bytecode.Instr{{Op: 33}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 48, A: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 33}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 48, A: 1, Flags: 2}, {Op: 53}},
 								Names:       []string{"Pathname", "new"},
 								Params:      []string{"p"},
 								NumRequired: 1,
@@ -6022,7 +6022,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "cleanpath",
-						Insns:       []bytecode.Instr{{Op: 33}, {Op: 33}, {Op: 31, A: 1}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 30, A: 3, B: 1, Flags: 1}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 33}, {Op: 33}, {Op: 31, A: 1}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 30, A: 3, B: 1, Flags: 3}, {Op: 53}},
 						Names:       []string{"Pathname", "@path", "__lex_cleanpath", "new"},
 						NumRequired: 0,
 						SplatIndex:  -1,
@@ -6035,7 +6035,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "sub_ext",
-						Insns:       []bytecode.Instr{{Op: 33}, {Op: 33}, {Op: 31, A: 1}, {Op: 11}, {Op: 30, A: 2, B: 2, Flags: 1}, {Op: 30, A: 3, B: 1, Flags: 1}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 33}, {Op: 33}, {Op: 31, A: 1}, {Op: 11}, {Op: 30, A: 2, B: 2, Flags: 3}, {Op: 30, A: 3, B: 1, Flags: 3}, {Op: 53}},
 						Names:       []string{"Pathname", "@path", "__lex_sub_ext", "new"},
 						Params:      []string{"repl"},
 						NumRequired: 1,
@@ -6050,7 +6050,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "relative_path_from",
-						Insns:       []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 25}, {Op: 28, A: 10}, {Op: 33}, {Op: 11}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 12}, {Op: 26, A: 11}, {Op: 2}, {Op: 9}, {Op: 33}, {Op: 33}, {Op: 31, A: 3}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 30, A: 5, B: 2, Flags: 1}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 25}, {Op: 28, A: 10}, {Op: 33}, {Op: 11}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 12}, {Op: 26, A: 11}, {Op: 2}, {Op: 9}, {Op: 33}, {Op: 33}, {Op: 31, A: 3}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 30, A: 5, B: 2, Flags: 3}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 53}},
 						Names:       []string{"Pathname", "is_a?", "new", "@path", "to_s", "__lex_relative_path_from"},
 						Params:      []string{"base_directory"},
 						NumRequired: 1,
@@ -6065,7 +6065,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "read",
-						Insns:       []bytecode.Instr{{Op: 33}, {Op: 6}, {Op: 31, A: 1}, {Op: 6, A: 1}, {Op: 61}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 62, A: 2, Flags: 1}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 33}, {Op: 6}, {Op: 31, A: 1}, {Op: 6, A: 1}, {Op: 61}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 62, A: 2, Flags: 3}, {Op: 53}},
 						Names:       []string{"File", "@path", "read"},
 						Params:      []string{"args"},
 						NumRequired: 0,
@@ -6080,7 +6080,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "write",
-						Insns:       []bytecode.Instr{{Op: 33}, {Op: 6}, {Op: 31, A: 1}, {Op: 6, A: 1}, {Op: 61}, {Op: 11}, {Op: 6, A: 1}, {Op: 61}, {Op: 11, A: 1}, {Op: 60}, {Op: 61}, {Op: 62, A: 2, Flags: 1}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 33}, {Op: 6}, {Op: 31, A: 1}, {Op: 6, A: 1}, {Op: 61}, {Op: 11}, {Op: 6, A: 1}, {Op: 61}, {Op: 11, A: 1}, {Op: 60}, {Op: 61}, {Op: 62, A: 2, Flags: 3}, {Op: 53}},
 						Names:       []string{"File", "@path", "write"},
 						Params:      []string{"content", "args"},
 						NumRequired: 1,
@@ -6095,7 +6095,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "each_line",
-						Insns:       []bytecode.Instr{{Op: 33}, {Op: 6}, {Op: 31, A: 1}, {Op: 6, A: 1}, {Op: 61}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 11, A: 1}, {Op: 67, A: 2, Flags: 1}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 33}, {Op: 6}, {Op: 31, A: 1}, {Op: 6, A: 1}, {Op: 61}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 11, A: 1}, {Op: 67, A: 2, Flags: 3}, {Op: 53}},
 						Names:       []string{"File", "@path", "foreach"},
 						Params:      []string{"args"},
 						NumRequired: 0,
@@ -6110,7 +6110,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "exist?",
-						Insns:       []bytecode.Instr{{Op: 33}, {Op: 31, A: 1}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 33}, {Op: 31, A: 1}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 53}},
 						Names:       []string{"File", "@path", "exist?"},
 						NumRequired: 0,
 						SplatIndex:  -1,
@@ -6123,7 +6123,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "file?",
-						Insns:       []bytecode.Instr{{Op: 33}, {Op: 31, A: 1}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 33}, {Op: 31, A: 1}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 53}},
 						Names:       []string{"File", "@path", "file?"},
 						NumRequired: 0,
 						SplatIndex:  -1,
@@ -6136,7 +6136,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "directory?",
-						Insns:       []bytecode.Instr{{Op: 33}, {Op: 31, A: 1}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 33}, {Op: 31, A: 1}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 53}},
 						Names:       []string{"File", "@path", "directory?"},
 						NumRequired: 0,
 						SplatIndex:  -1,
@@ -6149,7 +6149,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "open",
-						Insns:       []bytecode.Instr{{Op: 33}, {Op: 6}, {Op: 31, A: 1}, {Op: 6, A: 1}, {Op: 61}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 11, A: 1}, {Op: 67, A: 2, Flags: 1}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 33}, {Op: 6}, {Op: 31, A: 1}, {Op: 6, A: 1}, {Op: 61}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 11, A: 1}, {Op: 67, A: 2, Flags: 3}, {Op: 53}},
 						Names:       []string{"File", "@path", "open"},
 						Params:      []string{"args"},
 						NumRequired: 0,
@@ -6207,7 +6207,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "included",
-						Insns: []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 9}, {Op: 11}, {Op: 1}, {Op: 1, A: 1}, {Op: 30, A: 2, B: 2, Flags: 1}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 9}, {Op: 11}, {Op: 1}, {Op: 1, A: 1}, {Op: 30, A: 2, B: 2, Flags: 3}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("new"),
 							object.Symbol("allocate"),
@@ -6229,7 +6229,7 @@ func embeddedPrelude() *bytecode.ISeq {
 			},
 			&bytecode.ISeq{
 				Name:  "<class:ERB>",
-				Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 1, A: 1}, {Op: 30, B: 2}, {Op: 9}, {Op: 5}, {Op: 1, A: 2}, {Op: 1, A: 3}, {Op: 30, A: 1, B: 2}, {Op: 9}, {Op: 44, A: 2}, {Op: 9}, {Op: 44, A: 3, B: 1}, {Op: 9}, {Op: 44, A: 4, B: 2}, {Op: 9}, {Op: 44, A: 5, B: 3}, {Op: 9}, {Op: 5}, {Op: 30, A: 6}, {Op: 9}, {Op: 44, A: 7, B: 4}, {Op: 53}},
+				Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 1, A: 1}, {Op: 30, B: 2, Flags: 2}, {Op: 9}, {Op: 5}, {Op: 1, A: 2}, {Op: 1, A: 3}, {Op: 30, A: 1, B: 2, Flags: 2}, {Op: 9}, {Op: 44, A: 2}, {Op: 9}, {Op: 44, A: 3, B: 1}, {Op: 9}, {Op: 44, A: 4, B: 2}, {Op: 9}, {Op: 44, A: 5, B: 3}, {Op: 9}, {Op: 5}, {Op: 30, A: 6}, {Op: 9}, {Op: 44, A: 7, B: 4}, {Op: 53}},
 				Consts: []object.Value{
 					object.Symbol("src"),
 					object.Symbol("encoding"),
@@ -6247,7 +6247,7 @@ func embeddedPrelude() *bytecode.ISeq {
 				Children: []*bytecode.ISeq{
 					&bytecode.ISeq{
 						Name:  "initialize",
-						Insns: []bytecode.Instr{{Op: 63}, {Op: 27, A: 5}, {Op: 2}, {Op: 12, A: 1}, {Op: 9}, {Op: 63, A: 1}, {Op: 27, A: 10}, {Op: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 2}, {Op: 32}, {Op: 9}, {Op: 1, A: 1}, {Op: 32, A: 1}, {Op: 9}, {Op: 1, A: 2}, {Op: 32, A: 2}, {Op: 9}, {Op: 5}, {Op: 11}, {Op: 11, A: 1}, {Op: 11, A: 2}, {Op: 30, A: 3, B: 3}, {Op: 32, A: 4}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 63}, {Op: 27, A: 5}, {Op: 2}, {Op: 12, A: 1}, {Op: 9}, {Op: 63, A: 1}, {Op: 27, A: 10}, {Op: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 2}, {Op: 32}, {Op: 9}, {Op: 1, A: 1}, {Op: 32, A: 1}, {Op: 9}, {Op: 1, A: 2}, {Op: 32, A: 2}, {Op: 9}, {Op: 5}, {Op: 11}, {Op: 11, A: 1}, {Op: 11, A: 2}, {Op: 30, A: 3, B: 3, Flags: 2}, {Op: 32, A: 4}, {Op: 53}},
 						Consts: []object.Value{
 							object.NewString("_erbout"),
 							object.IntValue(0),
@@ -6269,7 +6269,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "result",
-						Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 6}, {Op: 5}, {Op: 30}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 31, A: 1}, {Op: 11}, {Op: 31, A: 2}, {Op: 10}, {Op: 27, A: 14}, {Op: 9}, {Op: 1}, {Op: 31, A: 3}, {Op: 30, A: 4, B: 4}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 6}, {Op: 5}, {Op: 30}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 31, A: 1}, {Op: 11}, {Op: 31, A: 2}, {Op: 10}, {Op: 27, A: 14}, {Op: 9}, {Op: 1}, {Op: 31, A: 3}, {Op: 30, A: 4, B: 4, Flags: 2}, {Op: 53}},
 						Consts: []object.Value{
 							object.NewString("(erb)"),
 						},
@@ -6287,7 +6287,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "result_with_hash",
-						Insns:       []bytecode.Instr{{Op: 5}, {Op: 30}, {Op: 12, A: 1}, {Op: 9}, {Op: 11}, {Op: 30, A: 1, C: 1, Flags: 1}, {Op: 9}, {Op: 5}, {Op: 11, A: 1}, {Op: 30, A: 2, B: 1}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 5}, {Op: 30}, {Op: 12, A: 1}, {Op: 9}, {Op: 11}, {Op: 30, A: 1, C: 1, Flags: 1}, {Op: 9}, {Op: 5}, {Op: 11, A: 1}, {Op: 30, A: 2, B: 1, Flags: 2}, {Op: 53}},
 						Names:       []string{"new_toplevel", "each", "result"},
 						Params:      []string{"hash"},
 						NumRequired: 1,
@@ -6301,7 +6301,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in result_with_hash",
-								Insns:       []bytecode.Instr{{Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 11, A: 1}, {Op: 30, B: 2, Flags: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 11, A: 1}, {Op: 30, B: 2, Flags: 3}, {Op: 53}},
 								Names:       []string{"local_variable_set"},
 								Params:      []string{"key", "value"},
 								NumRequired: 2,
@@ -6319,7 +6319,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "run",
-						Insns:       []bytecode.Instr{{Op: 54}, {Op: 27, A: 6}, {Op: 5}, {Op: 30}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 5}, {Op: 11}, {Op: 30, A: 1, B: 1}, {Op: 30, A: 2, B: 1}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 54}, {Op: 27, A: 6}, {Op: 5}, {Op: 30}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 5}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 2}, {Op: 30, A: 2, B: 1, Flags: 2}, {Op: 53}},
 						Names:       []string{"new_toplevel", "result", "print"},
 						Params:      []string{"b"},
 						NumRequired: 0,
@@ -6373,7 +6373,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "<class:Safe>",
-								Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 9}, {Op: 44, A: 1}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1, Flags: 2}, {Op: 9}, {Op: 44, A: 1}, {Op: 53}},
 								Consts: []object.Value{
 									object.Symbol("value"),
 								},
@@ -6406,7 +6406,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:        "safe",
-								Insns:       []bytecode.Instr{{Op: 33}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 33}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 53}},
 								Names:       []string{"Safe", "new"},
 								Params:      []string{"v"},
 								NumRequired: 1,
@@ -6448,7 +6448,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:  "render_attribute",
-								Insns: []bytecode.Instr{{Op: 11, A: 1}, {Op: 30, Flags: 1}, {Op: 10}, {Op: 27, A: 8}, {Op: 9}, {Op: 11, A: 1}, {Op: 4}, {Op: 22}, {Op: 28, A: 12}, {Op: 1}, {Op: 53}, {Op: 26, A: 13}, {Op: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 3}, {Op: 22}, {Op: 28, A: 30}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 30, A: 1}, {Op: 13}, {Op: 11}, {Op: 30, A: 1}, {Op: 13}, {Op: 1, A: 3}, {Op: 30, A: 1}, {Op: 13}, {Op: 53}, {Op: 26, A: 31}, {Op: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 33, A: 2}, {Op: 30, A: 3, B: 1, Flags: 1}, {Op: 28, A: 55}, {Op: 1, A: 4}, {Op: 1, A: 5}, {Op: 30, A: 1}, {Op: 13}, {Op: 11}, {Op: 30, A: 1}, {Op: 13}, {Op: 1, A: 6}, {Op: 30, A: 1}, {Op: 13}, {Op: 11, A: 1}, {Op: 30, A: 4, Flags: 1}, {Op: 30, A: 1}, {Op: 13}, {Op: 1, A: 7}, {Op: 30, A: 1}, {Op: 13}, {Op: 53}, {Op: 26, A: 56}, {Op: 2}, {Op: 9}, {Op: 1, A: 8}, {Op: 1, A: 9}, {Op: 30, A: 1}, {Op: 13}, {Op: 11}, {Op: 30, A: 1}, {Op: 13}, {Op: 1, A: 10}, {Op: 30, A: 1}, {Op: 13}, {Op: 5}, {Op: 11, A: 1}, {Op: 30, A: 5, B: 1}, {Op: 30, A: 1}, {Op: 13}, {Op: 1, A: 11}, {Op: 30, A: 1}, {Op: 13}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 11, A: 1}, {Op: 30, Flags: 1}, {Op: 10}, {Op: 27, A: 8}, {Op: 9}, {Op: 11, A: 1}, {Op: 4}, {Op: 22}, {Op: 28, A: 12}, {Op: 1}, {Op: 53}, {Op: 26, A: 13}, {Op: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 3}, {Op: 22}, {Op: 28, A: 30}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 30, A: 1}, {Op: 13}, {Op: 11}, {Op: 30, A: 1}, {Op: 13}, {Op: 1, A: 3}, {Op: 30, A: 1}, {Op: 13}, {Op: 53}, {Op: 26, A: 31}, {Op: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 33, A: 2}, {Op: 30, A: 3, B: 1, Flags: 3}, {Op: 28, A: 55}, {Op: 1, A: 4}, {Op: 1, A: 5}, {Op: 30, A: 1}, {Op: 13}, {Op: 11}, {Op: 30, A: 1}, {Op: 13}, {Op: 1, A: 6}, {Op: 30, A: 1}, {Op: 13}, {Op: 11, A: 1}, {Op: 30, A: 4, Flags: 1}, {Op: 30, A: 1}, {Op: 13}, {Op: 1, A: 7}, {Op: 30, A: 1}, {Op: 13}, {Op: 53}, {Op: 26, A: 56}, {Op: 2}, {Op: 9}, {Op: 1, A: 8}, {Op: 1, A: 9}, {Op: 30, A: 1}, {Op: 13}, {Op: 11}, {Op: 30, A: 1}, {Op: 13}, {Op: 1, A: 10}, {Op: 30, A: 1}, {Op: 13}, {Op: 5}, {Op: 11, A: 1}, {Op: 30, A: 5, B: 1, Flags: 2}, {Op: 30, A: 1}, {Op: 13}, {Op: 1, A: 11}, {Op: 30, A: 1}, {Op: 13}, {Op: 53}},
 								Consts: []object.Value{
 									object.NewString(""),
 									object.NewString(""),
@@ -6494,7 +6494,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:  "block in render_attributes",
-										Insns: []bytecode.Instr{{Op: 11}, {Op: 30, Flags: 1}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 1}, {Op: 22}, {Op: 28, A: 38}, {Op: 11, A: 2, B: 1}, {Op: 1, A: 1}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 33, A: 2}, {Op: 30, A: 3, B: 1, Flags: 1}, {Op: 28, A: 21}, {Op: 11, A: 1}, {Op: 1, A: 2}, {Op: 30, A: 4, B: 1, Flags: 1}, {Op: 26, A: 22}, {Op: 11, A: 1}, {Op: 12, A: 3}, {Op: 9}, {Op: 11, A: 2, B: 1}, {Op: 1, A: 3}, {Op: 11, A: 2}, {Op: 11, A: 3}, {Op: 6, A: 2}, {Op: 30, A: 5, Flags: 1}, {Op: 30, A: 6, C: 1, Flags: 1}, {Op: 1, A: 4}, {Op: 30, A: 4, B: 1, Flags: 1}, {Op: 12, A: 4}, {Op: 30, A: 7, B: 2, Flags: 1}, {Op: 9}, {Op: 11, A: 4}, {Op: 26, A: 57}, {Op: 11}, {Op: 1, A: 5}, {Op: 22}, {Op: 28, A: 50}, {Op: 11, A: 2, B: 1}, {Op: 1, A: 6}, {Op: 11, A: 1}, {Op: 12, A: 5}, {Op: 30, A: 7, B: 2, Flags: 1}, {Op: 9}, {Op: 11, A: 5}, {Op: 26, A: 57}, {Op: 11, A: 2, B: 1}, {Op: 11}, {Op: 11, A: 1}, {Op: 12, A: 6}, {Op: 30, A: 7, B: 2, Flags: 1}, {Op: 9}, {Op: 11, A: 6}, {Op: 53}},
+										Insns: []bytecode.Instr{{Op: 11}, {Op: 30, Flags: 1}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 1}, {Op: 22}, {Op: 28, A: 38}, {Op: 11, A: 2, B: 1}, {Op: 1, A: 1}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 33, A: 2}, {Op: 30, A: 3, B: 1, Flags: 3}, {Op: 28, A: 21}, {Op: 11, A: 1}, {Op: 1, A: 2}, {Op: 30, A: 4, B: 1, Flags: 3}, {Op: 26, A: 22}, {Op: 11, A: 1}, {Op: 12, A: 3}, {Op: 9}, {Op: 11, A: 2, B: 1}, {Op: 1, A: 3}, {Op: 11, A: 2}, {Op: 11, A: 3}, {Op: 6, A: 2}, {Op: 30, A: 5, Flags: 1}, {Op: 30, A: 6, C: 1, Flags: 1}, {Op: 1, A: 4}, {Op: 30, A: 4, B: 1, Flags: 3}, {Op: 12, A: 4}, {Op: 30, A: 7, B: 2, Flags: 3}, {Op: 9}, {Op: 11, A: 4}, {Op: 26, A: 57}, {Op: 11}, {Op: 1, A: 5}, {Op: 22}, {Op: 28, A: 50}, {Op: 11, A: 2, B: 1}, {Op: 1, A: 6}, {Op: 11, A: 1}, {Op: 12, A: 5}, {Op: 30, A: 7, B: 2, Flags: 3}, {Op: 9}, {Op: 11, A: 5}, {Op: 26, A: 57}, {Op: 11, A: 2, B: 1}, {Op: 11}, {Op: 11, A: 1}, {Op: 12, A: 6}, {Op: 30, A: 7, B: 2, Flags: 3}, {Op: 9}, {Op: 11, A: 6}, {Op: 53}},
 										Consts: []object.Value{
 											object.NewString("class"),
 											object.NewString("class"),
@@ -6537,7 +6537,7 @@ func embeddedPrelude() *bytecode.ISeq {
 									},
 									&bytecode.ISeq{
 										Name:        "block in render_attributes",
-										Insns:       []bytecode.Instr{{Op: 11, A: 3, B: 1}, {Op: 11}, {Op: 11, A: 1}, {Op: 30, B: 2, Flags: 1}, {Op: 53}},
+										Insns:       []bytecode.Instr{{Op: 11, A: 3, B: 1}, {Op: 11}, {Op: 11, A: 1}, {Op: 30, B: 2, Flags: 3}, {Op: 53}},
 										Names:       []string{"call"},
 										Params:      []string{"k", "v"},
 										NumRequired: 2,
@@ -6566,7 +6566,7 @@ func embeddedPrelude() *bytecode.ISeq {
 										Children: []*bytecode.ISeq{
 											&bytecode.ISeq{
 												Name:        "block (2 levels) in render_attributes",
-												Insns:       []bytecode.Instr{{Op: 11, A: 3, B: 2}, {Op: 11}, {Op: 11, A: 1}, {Op: 30, B: 2, Flags: 1}, {Op: 53}},
+												Insns:       []bytecode.Instr{{Op: 11, A: 3, B: 2}, {Op: 11}, {Op: 11, A: 1}, {Op: 30, B: 2, Flags: 3}, {Op: 53}},
 												Names:       []string{"call"},
 												Params:      []string{"k", "v"},
 												NumRequired: 2,
@@ -6584,7 +6584,7 @@ func embeddedPrelude() *bytecode.ISeq {
 									},
 									&bytecode.ISeq{
 										Name:        "block in render_attributes",
-										Insns:       []bytecode.Instr{{Op: 11, A: 4, B: 1}, {Op: 5}, {Op: 11}, {Op: 11, A: 2, B: 1}, {Op: 11}, {Op: 30, B: 1, Flags: 1}, {Op: 30, A: 1, B: 2}, {Op: 30, A: 2, B: 1}, {Op: 53}},
+										Insns:       []bytecode.Instr{{Op: 11, A: 4, B: 1}, {Op: 5}, {Op: 11}, {Op: 11, A: 2, B: 1}, {Op: 11}, {Op: 30, B: 1, Flags: 3}, {Op: 30, A: 1, B: 2, Flags: 2}, {Op: 30, A: 2, B: 1}, {Op: 53}},
 										Names:       []string{"[]", "render_attribute", "<<"},
 										Params:      []string{"k"},
 										NumRequired: 1,
@@ -6605,7 +6605,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "<class:Template>",
-						Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 9}, {Op: 44, A: 1}, {Op: 9}, {Op: 44, A: 2, B: 1}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1, Flags: 2}, {Op: 9}, {Op: 44, A: 1}, {Op: 9}, {Op: 44, A: 2, B: 1}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("src"),
 						},
@@ -6620,7 +6620,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "initialize",
-								Insns:       []bytecode.Instr{{Op: 54}, {Op: 27, A: 5}, {Op: 2}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 10}, {Op: 28, A: 11}, {Op: 9}, {Op: 11, A: 1}, {Op: 28, A: 16}, {Op: 11, A: 1}, {Op: 30, A: 1, Flags: 1}, {Op: 12}, {Op: 26, A: 17}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 11}, {Op: 30, A: 2, Flags: 1}, {Op: 30, A: 3, B: 1}, {Op: 32, A: 4}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 54}, {Op: 27, A: 5}, {Op: 2}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 10}, {Op: 28, A: 11}, {Op: 9}, {Op: 11, A: 1}, {Op: 28, A: 16}, {Op: 11, A: 1}, {Op: 30, A: 1, Flags: 1}, {Op: 12}, {Op: 26, A: 17}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 11}, {Op: 30, A: 2, Flags: 1}, {Op: 30, A: 3, B: 1, Flags: 2}, {Op: 32, A: 4}, {Op: 53}},
 								Names:       []string{"nil?", "call", "to_s", "__compile", "@src"},
 								Params:      []string{"template"},
 								NumRequired: 0,
@@ -6635,7 +6635,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:  "render",
-								Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 6}, {Op: 33}, {Op: 30, A: 1, Flags: 1}, {Op: 12}, {Op: 9}, {Op: 54, A: 1}, {Op: 27, A: 11}, {Op: 7}, {Op: 12, A: 1}, {Op: 9}, {Op: 72}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 2, C: 1, Flags: 1}, {Op: 9}, {Op: 5}, {Op: 31, A: 3}, {Op: 11, A: 2}, {Op: 1}, {Op: 1, A: 1}, {Op: 30, A: 4, B: 4}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 6}, {Op: 33}, {Op: 30, A: 1, Flags: 1}, {Op: 12}, {Op: 9}, {Op: 54, A: 1}, {Op: 27, A: 11}, {Op: 7}, {Op: 12, A: 1}, {Op: 9}, {Op: 72}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 2, C: 1, Flags: 1}, {Op: 9}, {Op: 5}, {Op: 31, A: 3}, {Op: 11, A: 2}, {Op: 1}, {Op: 1, A: 1}, {Op: 30, A: 4, B: 4, Flags: 2}, {Op: 53}},
 								Consts: []object.Value{
 									object.NewString("(slim)"),
 									object.IntValue(0),
@@ -6653,7 +6653,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:        "block in render",
-										Insns:       []bytecode.Instr{{Op: 11, A: 2, B: 1}, {Op: 11}, {Op: 11, A: 1}, {Op: 30, B: 2, Flags: 1}, {Op: 53}},
+										Insns:       []bytecode.Instr{{Op: 11, A: 2, B: 1}, {Op: 11}, {Op: 11, A: 1}, {Op: 30, B: 2, Flags: 3}, {Op: 53}},
 										Names:       []string{"local_variable_set"},
 										Params:      []string{"k", "v"},
 										NumRequired: 2,
@@ -6780,7 +6780,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:  "block in render",
-										Insns: []bytecode.Instr{{Op: 11}, {Op: 30, Flags: 1}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 1}, {Op: 22}, {Op: 10}, {Op: 28, A: 13}, {Op: 9}, {Op: 11, A: 1}, {Op: 33, A: 1}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 28, A: 17}, {Op: 11, A: 1}, {Op: 30, A: 3, C: 1, Flags: 1}, {Op: 26, A: 79}, {Op: 11}, {Op: 1, A: 1}, {Op: 22}, {Op: 28, A: 50}, {Op: 11, A: 1, B: 1}, {Op: 1, A: 2}, {Op: 30, A: 4, B: 1, Flags: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 11, A: 1}, {Op: 33, A: 5}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 28, A: 35}, {Op: 11, A: 1}, {Op: 1, A: 3}, {Op: 30, A: 6, B: 1, Flags: 1}, {Op: 26, A: 36}, {Op: 11, A: 1}, {Op: 6, A: 2}, {Op: 30, A: 7, Flags: 1}, {Op: 1, A: 4}, {Op: 30, A: 6, B: 1, Flags: 1}, {Op: 12, A: 3}, {Op: 9}, {Op: 11, A: 1, B: 1}, {Op: 1, A: 5}, {Op: 11, A: 3}, {Op: 12, A: 4}, {Op: 30, A: 8, B: 2, Flags: 1}, {Op: 9}, {Op: 11, A: 4}, {Op: 26, A: 79}, {Op: 11}, {Op: 1, A: 6}, {Op: 22}, {Op: 28, A: 72}, {Op: 11, A: 1, B: 1}, {Op: 1, A: 7}, {Op: 30, A: 4, B: 1, Flags: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 1, B: 1}, {Op: 1, A: 8}, {Op: 11, A: 2}, {Op: 11, A: 1}, {Op: 6, A: 2}, {Op: 30, A: 7, Flags: 1}, {Op: 1, A: 9}, {Op: 30, A: 6, B: 1, Flags: 1}, {Op: 12, A: 5}, {Op: 30, A: 8, B: 2, Flags: 1}, {Op: 9}, {Op: 11, A: 5}, {Op: 26, A: 79}, {Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 11, A: 1}, {Op: 12, A: 6}, {Op: 30, A: 8, B: 2, Flags: 1}, {Op: 9}, {Op: 11, A: 6}, {Op: 53}},
+										Insns: []bytecode.Instr{{Op: 11}, {Op: 30, Flags: 1}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 1}, {Op: 22}, {Op: 10}, {Op: 28, A: 13}, {Op: 9}, {Op: 11, A: 1}, {Op: 33, A: 1}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 28, A: 17}, {Op: 11, A: 1}, {Op: 30, A: 3, C: 1, Flags: 1}, {Op: 26, A: 79}, {Op: 11}, {Op: 1, A: 1}, {Op: 22}, {Op: 28, A: 50}, {Op: 11, A: 1, B: 1}, {Op: 1, A: 2}, {Op: 30, A: 4, B: 1, Flags: 3}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 11, A: 1}, {Op: 33, A: 5}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 28, A: 35}, {Op: 11, A: 1}, {Op: 1, A: 3}, {Op: 30, A: 6, B: 1, Flags: 3}, {Op: 26, A: 36}, {Op: 11, A: 1}, {Op: 6, A: 2}, {Op: 30, A: 7, Flags: 1}, {Op: 1, A: 4}, {Op: 30, A: 6, B: 1, Flags: 3}, {Op: 12, A: 3}, {Op: 9}, {Op: 11, A: 1, B: 1}, {Op: 1, A: 5}, {Op: 11, A: 3}, {Op: 12, A: 4}, {Op: 30, A: 8, B: 2, Flags: 3}, {Op: 9}, {Op: 11, A: 4}, {Op: 26, A: 79}, {Op: 11}, {Op: 1, A: 6}, {Op: 22}, {Op: 28, A: 72}, {Op: 11, A: 1, B: 1}, {Op: 1, A: 7}, {Op: 30, A: 4, B: 1, Flags: 3}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 1, B: 1}, {Op: 1, A: 8}, {Op: 11, A: 2}, {Op: 11, A: 1}, {Op: 6, A: 2}, {Op: 30, A: 7, Flags: 1}, {Op: 1, A: 9}, {Op: 30, A: 6, B: 1, Flags: 3}, {Op: 12, A: 5}, {Op: 30, A: 8, B: 2, Flags: 3}, {Op: 9}, {Op: 11, A: 5}, {Op: 26, A: 79}, {Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 11, A: 1}, {Op: 12, A: 6}, {Op: 30, A: 8, B: 2, Flags: 3}, {Op: 9}, {Op: 11, A: 6}, {Op: 53}},
 										Consts: []object.Value{
 											object.NewString("data"),
 											object.NewString("class"),
@@ -6806,7 +6806,7 @@ func embeddedPrelude() *bytecode.ISeq {
 										Children: []*bytecode.ISeq{
 											&bytecode.ISeq{
 												Name:  "block (2 levels) in render",
-												Insns: []bytecode.Instr{{Op: 11, A: 1, B: 2}, {Op: 1}, {Op: 1, A: 1}, {Op: 30}, {Op: 13}, {Op: 11}, {Op: 30}, {Op: 13}, {Op: 1, A: 2}, {Op: 30}, {Op: 13}, {Op: 11, A: 1}, {Op: 12, A: 2}, {Op: 30, A: 1, B: 2, Flags: 1}, {Op: 9}, {Op: 11, A: 2}, {Op: 53}},
+												Insns: []bytecode.Instr{{Op: 11, A: 1, B: 2}, {Op: 1}, {Op: 1, A: 1}, {Op: 30}, {Op: 13}, {Op: 11}, {Op: 30}, {Op: 13}, {Op: 1, A: 2}, {Op: 30}, {Op: 13}, {Op: 11, A: 1}, {Op: 12, A: 2}, {Op: 30, A: 1, B: 2, Flags: 3}, {Op: 9}, {Op: 11, A: 2}, {Op: 53}},
 												Consts: []object.Value{
 													object.NewString(""),
 													object.NewString("data-"),
@@ -6829,7 +6829,7 @@ func embeddedPrelude() *bytecode.ISeq {
 									},
 									&bytecode.ISeq{
 										Name:  "block in render",
-										Insns: []bytecode.Instr{{Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 30, B: 1, Flags: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 33, A: 1}, {Op: 11}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 28, A: 32}, {Op: 11, A: 1}, {Op: 10}, {Op: 28, A: 16}, {Op: 9}, {Op: 11, A: 1}, {Op: 4}, {Op: 23}, {Op: 28, A: 30}, {Op: 11, A: 2, B: 1}, {Op: 1}, {Op: 1, A: 1}, {Op: 30, A: 3}, {Op: 13}, {Op: 11}, {Op: 30, A: 3}, {Op: 13}, {Op: 1, A: 2}, {Op: 30, A: 3}, {Op: 13}, {Op: 30, A: 4, B: 1}, {Op: 26, A: 31}, {Op: 2}, {Op: 26, A: 62}, {Op: 11, A: 1}, {Op: 30, A: 5, Flags: 1}, {Op: 28, A: 38}, {Op: 2}, {Op: 53}, {Op: 26, A: 39}, {Op: 2}, {Op: 9}, {Op: 11, A: 2, B: 1}, {Op: 1, A: 3}, {Op: 1, A: 4}, {Op: 30, A: 3}, {Op: 13}, {Op: 11}, {Op: 30, A: 3}, {Op: 13}, {Op: 1, A: 5}, {Op: 30, A: 3}, {Op: 13}, {Op: 33, A: 6}, {Op: 34, A: 7}, {Op: 11, A: 1}, {Op: 30, A: 3, Flags: 1}, {Op: 30, A: 8, B: 1, Flags: 1}, {Op: 30, A: 3}, {Op: 13}, {Op: 1, A: 6}, {Op: 30, A: 3}, {Op: 13}, {Op: 30, A: 4, B: 1}, {Op: 53}},
+										Insns: []bytecode.Instr{{Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 30, B: 1, Flags: 3}, {Op: 12, A: 1}, {Op: 9}, {Op: 33, A: 1}, {Op: 11}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 28, A: 32}, {Op: 11, A: 1}, {Op: 10}, {Op: 28, A: 16}, {Op: 9}, {Op: 11, A: 1}, {Op: 4}, {Op: 23}, {Op: 28, A: 30}, {Op: 11, A: 2, B: 1}, {Op: 1}, {Op: 1, A: 1}, {Op: 30, A: 3}, {Op: 13}, {Op: 11}, {Op: 30, A: 3}, {Op: 13}, {Op: 1, A: 2}, {Op: 30, A: 3}, {Op: 13}, {Op: 30, A: 4, B: 1}, {Op: 26, A: 31}, {Op: 2}, {Op: 26, A: 62}, {Op: 11, A: 1}, {Op: 30, A: 5, Flags: 1}, {Op: 28, A: 38}, {Op: 2}, {Op: 53}, {Op: 26, A: 39}, {Op: 2}, {Op: 9}, {Op: 11, A: 2, B: 1}, {Op: 1, A: 3}, {Op: 1, A: 4}, {Op: 30, A: 3}, {Op: 13}, {Op: 11}, {Op: 30, A: 3}, {Op: 13}, {Op: 1, A: 5}, {Op: 30, A: 3}, {Op: 13}, {Op: 33, A: 6}, {Op: 34, A: 7}, {Op: 11, A: 1}, {Op: 30, A: 3, Flags: 1}, {Op: 30, A: 8, B: 1, Flags: 3}, {Op: 30, A: 3}, {Op: 13}, {Op: 1, A: 6}, {Op: 30, A: 3}, {Op: 13}, {Op: 30, A: 4, B: 1}, {Op: 53}},
 										Consts: []object.Value{
 											object.NewString(""),
 											object.NewString(" "),
@@ -6859,7 +6859,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "<class:Template>",
-						Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 9}, {Op: 44, A: 1}, {Op: 9}, {Op: 44, A: 2, B: 1}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1, Flags: 2}, {Op: 9}, {Op: 44, A: 1}, {Op: 9}, {Op: 44, A: 2, B: 1}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("src"),
 						},
@@ -6874,7 +6874,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "initialize",
-								Insns:       []bytecode.Instr{{Op: 54}, {Op: 27, A: 5}, {Op: 2}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 10}, {Op: 28, A: 11}, {Op: 9}, {Op: 11, A: 1}, {Op: 28, A: 16}, {Op: 11, A: 1}, {Op: 30, A: 1, Flags: 1}, {Op: 12}, {Op: 26, A: 17}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 11}, {Op: 30, A: 2, Flags: 1}, {Op: 30, A: 3, B: 1}, {Op: 32, A: 4}, {Op: 53}},
+								Insns:       []bytecode.Instr{{Op: 54}, {Op: 27, A: 5}, {Op: 2}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 10}, {Op: 28, A: 11}, {Op: 9}, {Op: 11, A: 1}, {Op: 28, A: 16}, {Op: 11, A: 1}, {Op: 30, A: 1, Flags: 1}, {Op: 12}, {Op: 26, A: 17}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 11}, {Op: 30, A: 2, Flags: 1}, {Op: 30, A: 3, B: 1, Flags: 2}, {Op: 32, A: 4}, {Op: 53}},
 								Names:       []string{"nil?", "call", "to_s", "__compile", "@src"},
 								Params:      []string{"template"},
 								NumRequired: 0,
@@ -6889,7 +6889,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:  "render",
-								Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 6}, {Op: 33}, {Op: 30, A: 1, Flags: 1}, {Op: 12}, {Op: 9}, {Op: 54, A: 1}, {Op: 27, A: 11}, {Op: 7}, {Op: 12, A: 1}, {Op: 9}, {Op: 72}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 2, C: 1, Flags: 1}, {Op: 9}, {Op: 5}, {Op: 31, A: 3}, {Op: 11, A: 2}, {Op: 1}, {Op: 1, A: 1}, {Op: 30, A: 4, B: 4}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 6}, {Op: 33}, {Op: 30, A: 1, Flags: 1}, {Op: 12}, {Op: 9}, {Op: 54, A: 1}, {Op: 27, A: 11}, {Op: 7}, {Op: 12, A: 1}, {Op: 9}, {Op: 72}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 2, C: 1, Flags: 1}, {Op: 9}, {Op: 5}, {Op: 31, A: 3}, {Op: 11, A: 2}, {Op: 1}, {Op: 1, A: 1}, {Op: 30, A: 4, B: 4, Flags: 2}, {Op: 53}},
 								Consts: []object.Value{
 									object.NewString("(haml)"),
 									object.IntValue(0),
@@ -6907,7 +6907,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:        "block in render",
-										Insns:       []bytecode.Instr{{Op: 11, A: 2, B: 1}, {Op: 11}, {Op: 11, A: 1}, {Op: 30, B: 2, Flags: 1}, {Op: 53}},
+										Insns:       []bytecode.Instr{{Op: 11, A: 2, B: 1}, {Op: 11}, {Op: 11, A: 1}, {Op: 30, B: 2, Flags: 3}, {Op: 53}},
 										Names:       []string{"local_variable_set"},
 										Params:      []string{"k", "v"},
 										NumRequired: 2,
@@ -6931,7 +6931,7 @@ func embeddedPrelude() *bytecode.ISeq {
 			},
 			&bytecode.ISeq{
 				Name:  "<class:OptionParser>",
-				Insns: []bytecode.Instr{{Op: 42}, {Op: 9}, {Op: 42, A: 1, B: 1}, {Op: 9}, {Op: 42, A: 2, B: 2}, {Op: 9}, {Op: 42, A: 3, B: 3}, {Op: 9}, {Op: 42, A: 4, B: 4}, {Op: 9}, {Op: 42, A: 5, B: 5}, {Op: 9}, {Op: 42, A: 6, B: 6}, {Op: 9}, {Op: 33, A: 7}, {Op: 1}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 1, A: 3}, {Op: 1, A: 4}, {Op: 1, A: 5}, {Op: 1, A: 6}, {Op: 1, A: 7}, {Op: 1, A: 8}, {Op: 30, A: 8, B: 9, Flags: 1}, {Op: 41, A: 9}, {Op: 53}},
+				Insns: []bytecode.Instr{{Op: 42}, {Op: 9}, {Op: 42, A: 1, B: 1}, {Op: 9}, {Op: 42, A: 2, B: 2}, {Op: 9}, {Op: 42, A: 3, B: 3}, {Op: 9}, {Op: 42, A: 4, B: 4}, {Op: 9}, {Op: 42, A: 5, B: 5}, {Op: 9}, {Op: 42, A: 6, B: 6}, {Op: 9}, {Op: 33, A: 7}, {Op: 1}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 1, A: 3}, {Op: 1, A: 4}, {Op: 1, A: 5}, {Op: 1, A: 6}, {Op: 1, A: 7}, {Op: 1, A: 8}, {Op: 30, A: 8, B: 9, Flags: 3}, {Op: 41, A: 9}, {Op: 53}},
 				Consts: []object.Value{
 					object.Symbol("short"),
 					object.Symbol("long"),
@@ -6954,7 +6954,7 @@ func embeddedPrelude() *bytecode.ISeq {
 				Children: []*bytecode.ISeq{
 					&bytecode.ISeq{
 						Name:  "<class:ParseError>",
-						Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 9}, {Op: 44, A: 1}, {Op: 9}, {Op: 45, A: 2, B: 1}, {Op: 9}, {Op: 44, A: 2, B: 2}, {Op: 9}, {Op: 44, A: 3, B: 3}, {Op: 9}, {Op: 78, A: 4, B: 3}, {Op: 9}, {Op: 44, A: 5, B: 4}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1, Flags: 2}, {Op: 9}, {Op: 44, A: 1}, {Op: 9}, {Op: 45, A: 2, B: 1}, {Op: 9}, {Op: 44, A: 2, B: 2}, {Op: 9}, {Op: 44, A: 3, B: 3}, {Op: 9}, {Op: 78, A: 4, B: 3}, {Op: 9}, {Op: 44, A: 5, B: 4}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("args"),
 						},
@@ -6969,7 +6969,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "initialize",
-								Insns: []bytecode.Instr{{Op: 11}, {Op: 32}, {Op: 9}, {Op: 5}, {Op: 30, A: 1}, {Op: 1}, {Op: 13}, {Op: 11}, {Op: 1, A: 1}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 13}, {Op: 47, A: 1}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 11}, {Op: 32}, {Op: 9}, {Op: 5}, {Op: 30, A: 1}, {Op: 1}, {Op: 13}, {Op: 11}, {Op: 1, A: 1}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 13}, {Op: 47, A: 1, Flags: 2}, {Op: 53}},
 								Consts: []object.Value{
 									object.NewString(": "),
 									object.NewString(" "),
@@ -7016,7 +7016,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:  "message",
-								Insns: []bytecode.Instr{{Op: 5}, {Op: 30}, {Op: 1}, {Op: 13}, {Op: 5}, {Op: 30, A: 1}, {Op: 1, A: 1}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 13}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 5}, {Op: 30}, {Op: 1}, {Op: 13}, {Op: 5}, {Op: 30, A: 1}, {Op: 1, A: 1}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 13}, {Op: 53}},
 								Consts: []object.Value{
 									object.NewString(": "),
 									object.NewString(" "),
@@ -7033,7 +7033,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:  "recover",
-								Insns: []bytecode.Instr{{Op: 11}, {Op: 1}, {Op: 1}, {Op: 31}, {Op: 12, A: 1}, {Op: 30, A: 1, B: 3, Flags: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 9}, {Op: 11}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 11}, {Op: 1}, {Op: 1}, {Op: 31}, {Op: 12, A: 1}, {Op: 30, A: 1, B: 3, Flags: 3}, {Op: 9}, {Op: 11, A: 1}, {Op: 9}, {Op: 11}, {Op: 53}},
 								Consts: []object.Value{
 									object.IntValue(0),
 								},
@@ -7237,7 +7237,7 @@ func embeddedPrelude() *bytecode.ISeq {
 			},
 			&bytecode.ISeq{
 				Name:  "<class:Tempfile>",
-				Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 9}, {Op: 45, A: 1}, {Op: 9}, {Op: 44, A: 2, B: 1}, {Op: 9}, {Op: 44, A: 3, B: 2}, {Op: 9}, {Op: 45, A: 3, B: 3}, {Op: 9}, {Op: 45, A: 4, B: 4}, {Op: 9}, {Op: 44, A: 5, B: 5}, {Op: 9}, {Op: 44, A: 6, B: 6}, {Op: 9}, {Op: 44, A: 7, B: 7}, {Op: 9}, {Op: 78, A: 8, B: 7}, {Op: 9}, {Op: 44, A: 9, B: 8}, {Op: 9}, {Op: 44, A: 10, B: 9}, {Op: 9}, {Op: 44, A: 11, B: 10}, {Op: 53}},
+				Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1, Flags: 2}, {Op: 9}, {Op: 45, A: 1}, {Op: 9}, {Op: 44, A: 2, B: 1}, {Op: 9}, {Op: 44, A: 3, B: 2}, {Op: 9}, {Op: 45, A: 3, B: 3}, {Op: 9}, {Op: 45, A: 4, B: 4}, {Op: 9}, {Op: 44, A: 5, B: 5}, {Op: 9}, {Op: 44, A: 6, B: 6}, {Op: 9}, {Op: 44, A: 7, B: 7}, {Op: 9}, {Op: 78, A: 8, B: 7}, {Op: 9}, {Op: 44, A: 9, B: 8}, {Op: 9}, {Op: 44, A: 10, B: 9}, {Op: 9}, {Op: 44, A: 11, B: 10}, {Op: 53}},
 				Consts: []object.Value{
 					object.Symbol("path"),
 				},
@@ -7269,7 +7269,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "initialize",
-						Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 5}, {Op: 1}, {Op: 12}, {Op: 9}, {Op: 54, A: 1}, {Op: 27, A: 10}, {Op: 2}, {Op: 12, A: 1}, {Op: 9}, {Op: 63}, {Op: 27, A: 15}, {Op: 1, A: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 5}, {Op: 1, A: 2}, {Op: 30, B: 1}, {Op: 9}, {Op: 11}, {Op: 33, A: 1}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 28, A: 25}, {Op: 11}, {Op: 26, A: 29}, {Op: 11}, {Op: 30, A: 3, Flags: 1}, {Op: 1, A: 3}, {Op: 6, A: 2}, {Op: 10}, {Op: 59, A: 2}, {Op: 12, A: 4}, {Op: 9}, {Op: 12, A: 5}, {Op: 9}, {Op: 9}, {Op: 11, A: 1}, {Op: 10}, {Op: 27, A: 42}, {Op: 9}, {Op: 33, A: 4}, {Op: 30, A: 5, Flags: 1}, {Op: 12, A: 6}, {Op: 9}, {Op: 2}, {Op: 32, A: 6}, {Op: 9}, {Op: 1, A: 4}, {Op: 30, A: 7, C: 1, Flags: 1}, {Op: 9}, {Op: 33, A: 8}, {Op: 31, A: 6}, {Op: 11, A: 2}, {Op: 30, A: 9, B: 2, Flags: 1}, {Op: 32, A: 10}, {Op: 9}, {Op: 52}, {Op: 28, A: 77}, {Op: 56, A: 69, B: 1}, {Op: 5}, {Op: 48, A: 1}, {Op: 57}, {Op: 5}, {Op: 30, A: 11}, {Op: 9}, {Op: 5}, {Op: 30, A: 12}, {Op: 9}, {Op: 26, A: 76}, {Op: 5}, {Op: 30, A: 11}, {Op: 9}, {Op: 5}, {Op: 30, A: 12}, {Op: 9}, {Op: 58}, {Op: 26, A: 78}, {Op: 2}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 5}, {Op: 1}, {Op: 12}, {Op: 9}, {Op: 54, A: 1}, {Op: 27, A: 10}, {Op: 2}, {Op: 12, A: 1}, {Op: 9}, {Op: 63}, {Op: 27, A: 15}, {Op: 1, A: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 5}, {Op: 1, A: 2}, {Op: 30, B: 1, Flags: 2}, {Op: 9}, {Op: 11}, {Op: 33, A: 1}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 28, A: 25}, {Op: 11}, {Op: 26, A: 29}, {Op: 11}, {Op: 30, A: 3, Flags: 1}, {Op: 1, A: 3}, {Op: 6, A: 2}, {Op: 10}, {Op: 59, A: 2}, {Op: 12, A: 4}, {Op: 9}, {Op: 12, A: 5}, {Op: 9}, {Op: 9}, {Op: 11, A: 1}, {Op: 10}, {Op: 27, A: 42}, {Op: 9}, {Op: 33, A: 4}, {Op: 30, A: 5, Flags: 1}, {Op: 12, A: 6}, {Op: 9}, {Op: 2}, {Op: 32, A: 6}, {Op: 9}, {Op: 1, A: 4}, {Op: 30, A: 7, C: 1, Flags: 1}, {Op: 9}, {Op: 33, A: 8}, {Op: 31, A: 6}, {Op: 11, A: 2}, {Op: 30, A: 9, B: 2, Flags: 3}, {Op: 32, A: 10}, {Op: 9}, {Op: 52}, {Op: 28, A: 77}, {Op: 56, A: 69, B: 1}, {Op: 5}, {Op: 48, A: 1, Flags: 2}, {Op: 57}, {Op: 5}, {Op: 30, A: 11}, {Op: 9}, {Op: 5}, {Op: 30, A: 12}, {Op: 9}, {Op: 26, A: 76}, {Op: 5}, {Op: 30, A: 11}, {Op: 9}, {Op: 5}, {Op: 30, A: 12}, {Op: 9}, {Op: 58}, {Op: 26, A: 78}, {Op: 2}, {Op: 53}},
 						Consts: []object.Value{
 							object.NewString(""),
 							object.NewString("w+"),
@@ -7292,7 +7292,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in initialize",
-								Insns: []bytecode.Instr{{Op: 1}, {Op: 1, A: 1}, {Op: 30}, {Op: 13}, {Op: 11, A: 4, B: 1}, {Op: 30}, {Op: 13}, {Op: 1, A: 2}, {Op: 30}, {Op: 13}, {Op: 33, A: 1}, {Op: 30, A: 2, Flags: 1}, {Op: 30}, {Op: 13}, {Op: 1, A: 3}, {Op: 30}, {Op: 13}, {Op: 33, A: 3}, {Op: 30, A: 4, Flags: 1}, {Op: 30}, {Op: 13}, {Op: 1, A: 4}, {Op: 30}, {Op: 13}, {Op: 5}, {Op: 1, A: 5}, {Op: 30, A: 5, B: 1}, {Op: 1, A: 6}, {Op: 30, B: 1, Flags: 1}, {Op: 30}, {Op: 13}, {Op: 1, A: 7}, {Op: 30}, {Op: 13}, {Op: 11, A: 5, B: 1}, {Op: 30}, {Op: 13}, {Op: 1, A: 8}, {Op: 30}, {Op: 13}, {Op: 12}, {Op: 9}, {Op: 33, A: 6}, {Op: 11, A: 6, B: 1}, {Op: 11}, {Op: 30, A: 7, B: 2, Flags: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 33, A: 6}, {Op: 11, A: 1}, {Op: 30, A: 8, B: 1, Flags: 1}, {Op: 25}, {Op: 28, A: 59}, {Op: 11, A: 1}, {Op: 32, A: 9}, {Op: 9}, {Op: 2}, {Op: 55}, {Op: 26, A: 60}, {Op: 2}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 1}, {Op: 1, A: 1}, {Op: 30}, {Op: 13}, {Op: 11, A: 4, B: 1}, {Op: 30}, {Op: 13}, {Op: 1, A: 2}, {Op: 30}, {Op: 13}, {Op: 33, A: 1}, {Op: 30, A: 2, Flags: 1}, {Op: 30}, {Op: 13}, {Op: 1, A: 3}, {Op: 30}, {Op: 13}, {Op: 33, A: 3}, {Op: 30, A: 4, Flags: 1}, {Op: 30}, {Op: 13}, {Op: 1, A: 4}, {Op: 30}, {Op: 13}, {Op: 5}, {Op: 1, A: 5}, {Op: 30, A: 5, B: 1, Flags: 2}, {Op: 1, A: 6}, {Op: 30, B: 1, Flags: 3}, {Op: 30}, {Op: 13}, {Op: 1, A: 7}, {Op: 30}, {Op: 13}, {Op: 11, A: 5, B: 1}, {Op: 30}, {Op: 13}, {Op: 1, A: 8}, {Op: 30}, {Op: 13}, {Op: 12}, {Op: 9}, {Op: 33, A: 6}, {Op: 11, A: 6, B: 1}, {Op: 11}, {Op: 30, A: 7, B: 2, Flags: 3}, {Op: 12, A: 1}, {Op: 9}, {Op: 33, A: 6}, {Op: 11, A: 1}, {Op: 30, A: 8, B: 1, Flags: 3}, {Op: 25}, {Op: 28, A: 59}, {Op: 11, A: 1}, {Op: 32, A: 9}, {Op: 9}, {Op: 2}, {Op: 55}, {Op: 26, A: 60}, {Op: 2}, {Op: 53}},
 								Consts: []object.Value{
 									object.NewString(""),
 									object.NewString(""),
@@ -7320,7 +7320,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "open",
-						Insns: []bytecode.Instr{{Op: 31}, {Op: 10}, {Op: 28, A: 6}, {Op: 9}, {Op: 31, A: 1}, {Op: 25}, {Op: 25}, {Op: 28, A: 14}, {Op: 33, A: 2}, {Op: 31, A: 3}, {Op: 1}, {Op: 30, A: 4, B: 2, Flags: 1}, {Op: 32}, {Op: 26, A: 15}, {Op: 2}, {Op: 9}, {Op: 4}, {Op: 32, A: 1}, {Op: 9}, {Op: 31}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 31}, {Op: 10}, {Op: 28, A: 6}, {Op: 9}, {Op: 31, A: 1}, {Op: 25}, {Op: 25}, {Op: 28, A: 14}, {Op: 33, A: 2}, {Op: 31, A: 3}, {Op: 1}, {Op: 30, A: 4, B: 2, Flags: 3}, {Op: 32}, {Op: 26, A: 15}, {Op: 2}, {Op: 9}, {Op: 4}, {Op: 32, A: 1}, {Op: 9}, {Op: 31}, {Op: 53}},
 						Consts: []object.Value{
 							object.NewString("r+"),
 						},
@@ -7336,7 +7336,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "open",
-						Insns:       []bytecode.Instr{{Op: 5}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 11, A: 1}, {Op: 67}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 5}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 11, A: 1}, {Op: 67, Flags: 2}, {Op: 53}},
 						Names:       []string{"new"},
 						Params:      []string{"args"},
 						NumRequired: 0,
@@ -7351,11 +7351,11 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "create",
-						Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 5}, {Op: 1}, {Op: 12}, {Op: 9}, {Op: 54, A: 1}, {Op: 27, A: 10}, {Op: 2}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 6}, {Op: 11}, {Op: 6, A: 1}, {Op: 61}, {Op: 11, A: 1}, {Op: 6, A: 1}, {Op: 61}, {Op: 7}, {Op: 11, A: 2}, {Op: 65}, {Op: 10}, {Op: 30}, {Op: 27, A: 27}, {Op: 6, A: 1}, {Op: 61}, {Op: 26, A: 28}, {Op: 9}, {Op: 62, A: 1}, {Op: 12, A: 3}, {Op: 9}, {Op: 52}, {Op: 28, A: 53}, {Op: 56, A: 45, B: 1}, {Op: 11, A: 3}, {Op: 48, A: 1}, {Op: 53}, {Op: 57}, {Op: 11, A: 3}, {Op: 30, A: 2, Flags: 1}, {Op: 9}, {Op: 11, A: 3}, {Op: 30, A: 3, Flags: 1}, {Op: 9}, {Op: 26, A: 52}, {Op: 11, A: 3}, {Op: 30, A: 2, Flags: 1}, {Op: 9}, {Op: 11, A: 3}, {Op: 30, A: 3, Flags: 1}, {Op: 9}, {Op: 58}, {Op: 26, A: 54}, {Op: 2}, {Op: 9}, {Op: 11, A: 3}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 5}, {Op: 1}, {Op: 12}, {Op: 9}, {Op: 54, A: 1}, {Op: 27, A: 10}, {Op: 2}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 6}, {Op: 11}, {Op: 6, A: 1}, {Op: 61}, {Op: 11, A: 1}, {Op: 6, A: 1}, {Op: 61}, {Op: 7}, {Op: 11, A: 2}, {Op: 65}, {Op: 6, A: 1}, {Op: 61}, {Op: 62, Flags: 4}, {Op: 12, A: 3}, {Op: 9}, {Op: 52}, {Op: 28, A: 48}, {Op: 56, A: 40, B: 1}, {Op: 11, A: 3}, {Op: 48, A: 1, Flags: 2}, {Op: 53}, {Op: 57}, {Op: 11, A: 3}, {Op: 30, A: 1, Flags: 1}, {Op: 9}, {Op: 11, A: 3}, {Op: 30, A: 2, Flags: 1}, {Op: 9}, {Op: 26, A: 47}, {Op: 11, A: 3}, {Op: 30, A: 1, Flags: 1}, {Op: 9}, {Op: 11, A: 3}, {Op: 30, A: 2, Flags: 1}, {Op: 9}, {Op: 58}, {Op: 26, A: 49}, {Op: 2}, {Op: 9}, {Op: 11, A: 3}, {Op: 53}},
 						Consts: []object.Value{
 							object.NewString(""),
 						},
-						Names:       []string{"empty?", "new", "close", "unlink"},
+						Names:       []string{"new", "close", "unlink"},
 						Params:      []string{"basename", "tmpdir"},
 						NumRequired: 0,
 						SplatIndex:  -1,
@@ -7363,7 +7363,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   4,
 						Locals:      []string{"basename", "tmpdir", "opts", "t"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2471}, {PC: 7, Line: 254}, {PC: 10, Line: 2472}, {PC: 31, Line: 2473}, {PC: 33, Line: 2474}, {PC: 34, Line: 2475}, {PC: 38, Line: 2477}, {PC: 41, Line: 2478}, {PC: 45, Line: 2477}, {PC: 48, Line: 2478}, {PC: 55, Line: 2481}},
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2471}, {PC: 7, Line: 254}, {PC: 10, Line: 2472}, {PC: 26, Line: 2473}, {PC: 28, Line: 2474}, {PC: 29, Line: 2475}, {PC: 33, Line: 2477}, {PC: 36, Line: 2478}, {PC: 40, Line: 2477}, {PC: 43, Line: 2478}, {PC: 50, Line: 2481}},
 						FirstLine:   2471,
 						Super:       "",
 					},
@@ -7384,7 +7384,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "close!",
-						Insns:       []bytecode.Instr{{Op: 5}, {Op: 3}, {Op: 30, B: 1}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 5}, {Op: 3}, {Op: 30, B: 1, Flags: 2}, {Op: 53}},
 						Names:       []string{"close"},
 						NumRequired: 0,
 						SplatIndex:  -1,
@@ -7397,7 +7397,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "unlink",
-						Insns:       []bytecode.Instr{{Op: 31}, {Op: 10}, {Op: 28, A: 7}, {Op: 9}, {Op: 33, A: 1}, {Op: 31}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 28, A: 12}, {Op: 33, A: 1}, {Op: 31}, {Op: 30, A: 3, B: 1, Flags: 1}, {Op: 26, A: 13}, {Op: 2}, {Op: 9}, {Op: 2}, {Op: 32}, {Op: 9}, {Op: 2}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 31}, {Op: 10}, {Op: 28, A: 7}, {Op: 9}, {Op: 33, A: 1}, {Op: 31}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 28, A: 12}, {Op: 33, A: 1}, {Op: 31}, {Op: 30, A: 3, B: 1, Flags: 3}, {Op: 26, A: 13}, {Op: 2}, {Op: 9}, {Op: 2}, {Op: 32}, {Op: 9}, {Op: 2}, {Op: 53}},
 						Names:       []string{"@path", "File", "exist?", "unlink"},
 						NumRequired: 0,
 						SplatIndex:  -1,
@@ -7410,7 +7410,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:  "chmod",
-						Insns: []bytecode.Instr{{Op: 31}, {Op: 10}, {Op: 28, A: 7}, {Op: 9}, {Op: 33, A: 1}, {Op: 1}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 28, A: 13}, {Op: 33, A: 1}, {Op: 11}, {Op: 31}, {Op: 30, A: 3, B: 2, Flags: 1}, {Op: 26, A: 14}, {Op: 2}, {Op: 53}},
+						Insns: []bytecode.Instr{{Op: 31}, {Op: 10}, {Op: 28, A: 7}, {Op: 9}, {Op: 33, A: 1}, {Op: 1}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 28, A: 13}, {Op: 33, A: 1}, {Op: 11}, {Op: 31}, {Op: 30, A: 3, B: 2, Flags: 3}, {Op: 26, A: 14}, {Op: 2}, {Op: 53}},
 						Consts: []object.Value{
 							object.Symbol("chmod"),
 						},
@@ -7428,7 +7428,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "respond_to_missing?",
-						Insns:       []bytecode.Instr{{Op: 54, A: 1}, {Op: 27, A: 5}, {Op: 4}, {Op: 12, A: 1}, {Op: 9}, {Op: 31}, {Op: 10}, {Op: 28, A: 13}, {Op: 9}, {Op: 31}, {Op: 11}, {Op: 11, A: 1}, {Op: 30, A: 1, B: 2, Flags: 1}, {Op: 10}, {Op: 27, A: 17}, {Op: 9}, {Op: 47, B: 1}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 54, A: 1}, {Op: 27, A: 5}, {Op: 4}, {Op: 12, A: 1}, {Op: 9}, {Op: 31}, {Op: 10}, {Op: 28, A: 13}, {Op: 9}, {Op: 31}, {Op: 11}, {Op: 11, A: 1}, {Op: 30, A: 1, B: 2, Flags: 3}, {Op: 10}, {Op: 27, A: 17}, {Op: 9}, {Op: 47, B: 1}, {Op: 53}},
 						Names:       []string{"@file", "respond_to?"},
 						Params:      []string{"name", "include_private"},
 						NumRequired: 1,
@@ -7443,7 +7443,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "method_missing",
-						Insns:       []bytecode.Instr{{Op: 31}, {Op: 10}, {Op: 28, A: 7}, {Op: 9}, {Op: 31}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 28, A: 19}, {Op: 31}, {Op: 6}, {Op: 11}, {Op: 6, A: 1}, {Op: 61}, {Op: 11, A: 1}, {Op: 60}, {Op: 61}, {Op: 11, A: 2}, {Op: 67, A: 2, Flags: 1}, {Op: 26, A: 20}, {Op: 47, B: 1}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 31}, {Op: 10}, {Op: 28, A: 7}, {Op: 9}, {Op: 31}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 28, A: 19}, {Op: 31}, {Op: 6}, {Op: 11}, {Op: 6, A: 1}, {Op: 61}, {Op: 11, A: 1}, {Op: 60}, {Op: 61}, {Op: 11, A: 2}, {Op: 67, A: 2, Flags: 3}, {Op: 26, A: 20}, {Op: 47, B: 1}, {Op: 53}},
 						Names:       []string{"@file", "respond_to?", "send"},
 						Params:      []string{"name", "args"},
 						NumRequired: 1,
@@ -7461,7 +7461,7 @@ func embeddedPrelude() *bytecode.ISeq {
 			},
 			&bytecode.ISeq{
 				Name:  "<module:Warning>",
-				Insns: []bytecode.Instr{{Op: 1}, {Op: 4}, {Op: 1, A: 1}, {Op: 3}, {Op: 1, A: 2}, {Op: 4}, {Op: 1, A: 3}, {Op: 4}, {Op: 7, A: 4}, {Op: 32}, {Op: 9}, {Op: 5}, {Op: 77}, {Op: 9}, {Op: 44, A: 1, B: 1}, {Op: 9}, {Op: 5}, {Op: 5}, {Op: 30, A: 2, B: 1}, {Op: 53}},
+				Insns: []bytecode.Instr{{Op: 1}, {Op: 4}, {Op: 1, A: 1}, {Op: 3}, {Op: 1, A: 2}, {Op: 4}, {Op: 1, A: 3}, {Op: 4}, {Op: 7, A: 4}, {Op: 32}, {Op: 9}, {Op: 5}, {Op: 77}, {Op: 9}, {Op: 44, A: 1, B: 1}, {Op: 9}, {Op: 5}, {Op: 5}, {Op: 30, A: 2, B: 1, Flags: 2}, {Op: 53}},
 				Consts: []object.Value{
 					object.Symbol("deprecated"),
 					object.Symbol("experimental"),
@@ -7491,7 +7491,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "[]",
-								Insns: []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 25}, {Op: 28, A: 20}, {Op: 5}, {Op: 33, A: 2}, {Op: 1}, {Op: 1, A: 1}, {Op: 30, A: 3}, {Op: 13}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 30, A: 3}, {Op: 13}, {Op: 1, A: 2}, {Op: 30, A: 3}, {Op: 13}, {Op: 30, A: 5, B: 2}, {Op: 26, A: 21}, {Op: 2}, {Op: 9}, {Op: 31, A: 6}, {Op: 11}, {Op: 30, A: 7, B: 1, Flags: 1}, {Op: 25}, {Op: 28, A: 41}, {Op: 5}, {Op: 33, A: 8}, {Op: 1, A: 3}, {Op: 1, A: 4}, {Op: 30, A: 3}, {Op: 13}, {Op: 11}, {Op: 30, A: 3}, {Op: 13}, {Op: 1, A: 5}, {Op: 30, A: 3}, {Op: 13}, {Op: 30, A: 5, B: 2}, {Op: 26, A: 42}, {Op: 2}, {Op: 9}, {Op: 31, A: 6}, {Op: 11}, {Op: 30, A: 9, B: 1, Flags: 1}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 25}, {Op: 28, A: 20}, {Op: 5}, {Op: 33, A: 2}, {Op: 1}, {Op: 1, A: 1}, {Op: 30, A: 3}, {Op: 13}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 30, A: 3}, {Op: 13}, {Op: 1, A: 2}, {Op: 30, A: 3}, {Op: 13}, {Op: 30, A: 5, B: 2, Flags: 2}, {Op: 26, A: 21}, {Op: 2}, {Op: 9}, {Op: 31, A: 6}, {Op: 11}, {Op: 30, A: 7, B: 1, Flags: 3}, {Op: 25}, {Op: 28, A: 41}, {Op: 5}, {Op: 33, A: 8}, {Op: 1, A: 3}, {Op: 1, A: 4}, {Op: 30, A: 3}, {Op: 13}, {Op: 11}, {Op: 30, A: 3}, {Op: 13}, {Op: 1, A: 5}, {Op: 30, A: 3}, {Op: 13}, {Op: 30, A: 5, B: 2, Flags: 2}, {Op: 26, A: 42}, {Op: 2}, {Op: 9}, {Op: 31, A: 6}, {Op: 11}, {Op: 30, A: 9, B: 1, Flags: 3}, {Op: 53}},
 								Consts: []object.Value{
 									object.NewString(""),
 									object.NewString("wrong argument type "),
@@ -7514,7 +7514,7 @@ func embeddedPrelude() *bytecode.ISeq {
 							},
 							&bytecode.ISeq{
 								Name:  "[]=",
-								Insns: []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 25}, {Op: 28, A: 20}, {Op: 5}, {Op: 33, A: 2}, {Op: 1}, {Op: 1, A: 1}, {Op: 30, A: 3}, {Op: 13}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 30, A: 3}, {Op: 13}, {Op: 1, A: 2}, {Op: 30, A: 3}, {Op: 13}, {Op: 30, A: 5, B: 2}, {Op: 26, A: 21}, {Op: 2}, {Op: 9}, {Op: 31, A: 6}, {Op: 11}, {Op: 30, A: 7, B: 1, Flags: 1}, {Op: 25}, {Op: 28, A: 41}, {Op: 5}, {Op: 33, A: 8}, {Op: 1, A: 3}, {Op: 1, A: 4}, {Op: 30, A: 3}, {Op: 13}, {Op: 11}, {Op: 30, A: 3}, {Op: 13}, {Op: 1, A: 5}, {Op: 30, A: 3}, {Op: 13}, {Op: 30, A: 5, B: 2}, {Op: 26, A: 42}, {Op: 2}, {Op: 9}, {Op: 31, A: 6}, {Op: 11}, {Op: 11, A: 1}, {Op: 12, A: 2}, {Op: 30, A: 9, B: 2, Flags: 1}, {Op: 9}, {Op: 11, A: 2}, {Op: 53}},
+								Insns: []bytecode.Instr{{Op: 11}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 25}, {Op: 28, A: 20}, {Op: 5}, {Op: 33, A: 2}, {Op: 1}, {Op: 1, A: 1}, {Op: 30, A: 3}, {Op: 13}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 30, A: 3}, {Op: 13}, {Op: 1, A: 2}, {Op: 30, A: 3}, {Op: 13}, {Op: 30, A: 5, B: 2, Flags: 2}, {Op: 26, A: 21}, {Op: 2}, {Op: 9}, {Op: 31, A: 6}, {Op: 11}, {Op: 30, A: 7, B: 1, Flags: 3}, {Op: 25}, {Op: 28, A: 41}, {Op: 5}, {Op: 33, A: 8}, {Op: 1, A: 3}, {Op: 1, A: 4}, {Op: 30, A: 3}, {Op: 13}, {Op: 11}, {Op: 30, A: 3}, {Op: 13}, {Op: 1, A: 5}, {Op: 30, A: 3}, {Op: 13}, {Op: 30, A: 5, B: 2, Flags: 2}, {Op: 26, A: 42}, {Op: 2}, {Op: 9}, {Op: 31, A: 6}, {Op: 11}, {Op: 11, A: 1}, {Op: 12, A: 2}, {Op: 30, A: 9, B: 2, Flags: 3}, {Op: 9}, {Op: 11, A: 2}, {Op: 53}},
 								Consts: []object.Value{
 									object.NewString(""),
 									object.NewString("wrong argument type "),
@@ -7553,7 +7553,7 @@ func embeddedPrelude() *bytecode.ISeq {
 					},
 					&bytecode.ISeq{
 						Name:        "warn",
-						Insns:       []bytecode.Instr{{Op: 63}, {Op: 27, A: 5}, {Op: 2}, {Op: 12, A: 1}, {Op: 9}, {Op: 36}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 9}, {Op: 2}, {Op: 53}},
+						Insns:       []bytecode.Instr{{Op: 63}, {Op: 27, A: 5}, {Op: 2}, {Op: 12, A: 1}, {Op: 9}, {Op: 36}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 9}, {Op: 2}, {Op: 53}},
 						Names:       []string{"$stderr", "write"},
 						Params:      []string{"message"},
 						NumRequired: 1,
diff --git a/internal/vm/vm.go b/internal/vm/vm.go
index 57883c20..1fef230c 100644
--- a/internal/vm/vm.go
+++ b/internal/vm/vm.go
@@ -614,6 +614,25 @@ type VM struct {
 	// at the top of exec, consumed synchronously before any nested call. GVL-guarded.
 	pendingEvalMethodDefinee *RClass
 
+	// sendNoKW carries one call site's keyword/positional verdict to the frame it
+	// is about to enter: true means "the last argument of this call is a
+	// POSITIONAL value", so a trailing Hash must not be re-read as keywords. It is
+	// bytecode.FlagSendNoKW in flight — MRI keeps the same fact on the call info
+	// (the absence of VM_CALL_KWARG / VM_CALL_KW_SPLAT), which
+	// setup_parameters_complex reads to decide whether `keyword_hash` exists at all
+	// (vm_args.c v3_4_0:591).
+	//
+	// It rides the VM rather than exec's parameter list because exec is reached
+	// through send / invoke / invokeInPlace / callBlock, whose signatures are
+	// shared with every built-in method file. Like the two pending fields above it
+	// is set immediately before a dispatch and consumed synchronously: exec reads
+	// and clears it before running any user code, and callNative clears it, so a
+	// call that lands on a native body cannot leave a verdict behind for the next
+	// frame. Unset (false) means "decide as rbgo always did" — peel a trailing
+	// Hash — which is what every path that cannot answer (Object#send, Proc#call,
+	// a define_method body) still gets. GVL-guarded.
+	sendNoKW bool
+
 	// children records finished synthetic child processes (Process.spawn /
 	// Kernel.fork), so Process.waitpid2 can report each one's exit status.
 	// childPidSeq assigns the next synthetic pid. GVL-guarded.
@@ -1078,9 +1097,15 @@ func (vm *VM) Run(iseq *bytecode.ISeq) (result object.Value, err error) {
 // convention), validates it against the method's keyword params (raising on
 // unknown/missing keywords), and returns it (never nil). It shortens *args by
 // the consumed hash so positional arity is checked on the remaining args.
-func (vm *VM) bindKeywords(iseq *bytecode.ISeq, args *[]object.Value) *object.Hash {
+func (vm *VM) bindKeywords(iseq *bytecode.ISeq, args *[]object.Value, noKW bool) *object.Hash {
 	kwargs := object.NewHash()
-	if a := *args; len(a) > 0 {
+	// noKW is the call site's answer, and it is the whole of MRI's rule: with
+	// neither VM_CALL_KWARG nor VM_CALL_KW_SPLAT set, setup_parameters_complex
+	// never assigns `keyword_hash`, so the trailing Hash stays positional and the
+	// keyword parameters are filled from nothing — which then makes the arity
+	// check below count it (vm_args.c v3_4_0:591, and the `args->rest = Qfalse`
+	// arm at :783 that only looks at the last argument `if (kw_flag & VM_CALL_KW_SPLAT)`).
+	if a := *args; len(a) > 0 && !noKW {
 		if h, ok := a[len(a)-1].(*object.Hash); ok {
 			kwargs = h
 			*args = a[:len(a)-1]
@@ -1119,6 +1144,41 @@ func (vm *VM) bindKeywords(iseq *bytecode.ISeq, args *[]object.Value) *object.Ha
 	return kwargs
 }
 
+// applyKWSplat is the VM half of a `**kw` call site: it drops an EMPTY keyword
+// splat from the argument list and returns the list to pass together with the
+// call's keyword/positional verdict for what is left.
+//
+// It is ignore_keyword_hash_p (vm_args.c v3_4_0:506): an empty keyword hash is
+// removed and the call's VM_CALL_KW_SPLAT bit cleared, so `f(**{})` passes no
+// argument at all. Clearing that bit is the part that matters beyond the count —
+// with no keyword flag left, whatever is now last is an ORDINARY positional
+// argument, which is why this returns noKW == true in that case. `f(x, **{})`
+// therefore passes one positional x, even when x is itself a Hash.
+//
+// MRI keeps an empty hash when the callee has a **kwrest parameter; rbgo does
+// not need to, because bindKeywords gives a kwrest an empty Hash when no keyword
+// hash arrives, which is the same binding.
+//
+// With no FlagSendKWSplat the list is untouched and the verdict is the compiled
+// FlagSendNoKW.
+func applyKWSplat(elems []object.Value, flags int) ([]object.Value, bool) {
+	if flags&bytecode.FlagSendKWSplat == 0 {
+		return elems, flags&bytecode.FlagSendNoKW != 0
+	}
+	if n := len(elems); n > 0 {
+		if h, ok := elems[n-1].(*object.Hash); ok && h.Len() == 0 {
+			return elems[:n-1], true
+		}
+	}
+	return elems, false
+}
+
+// setSendNoKW records the keyword/positional verdict of the call site about to
+// dispatch (see the sendNoKW field). It exists as a method so AOT-lowered Go
+// code (internal/aot/level2.go) can state the same fact its interpreted
+// counterpart states through bytecode.FlagSendNoKW.
+func (vm *VM) setSendNoKW(v bool) { vm.sendNoKW = v }
+
 // alwaysPrivateMethodName reports whether a method name is one MRI defines with
 // private visibility unconditionally (the object-initialization and
 // respond-to-missing hooks), independent of the surrounding default visibility.
@@ -1216,9 +1276,13 @@ func (vm *VM) exec(iseq *bytecode.ISeq, self object.Value, args []object.Value,
 	default:
 		fm = frameMethod{orig: methodName, callee: methodName}
 	}
+	// Consume the call site's keyword/positional verdict before anything below can
+	// run user code and start a nested frame that would read it (see sendNoKW).
+	noKW := vm.sendNoKW
+	vm.sendNoKW = false
 	var kwargs *object.Hash
 	if len(iseq.KwNames) > 0 || iseq.KwRestSlot >= 0 {
-		kwargs = vm.bindKeywords(iseq, &args)
+		kwargs = vm.bindKeywords(iseq, &args, noKW)
 	}
 	// minReq is the true minimum arity: the leading required params plus any
 	// required "post" params after a *splat (def m(a,*b,c) requires 2, not 1).
@@ -1235,6 +1299,26 @@ func (vm *VM) exec(iseq *bytecode.ISeq, self object.Value, args []object.Value,
 		}
 		raise("ArgumentError", "wrong number of arguments (given %d, expected %s)", len(args), expected)
 	}
+	// nPosGiven is how many of the supplied positional arguments are available to
+	// the LEADING and OPTIONAL parameters — the total minus the "post" parameters
+	// that bind from the tail.
+	//
+	// MRI sets the parameters in that order, not left to right:
+	// setup_parameters_complex runs args_setup_lead_parameters, then
+	// args_setup_post_parameters, which MEMCPYs the last post_num arguments and
+	// SHRINKS the argument list, and only then args_setup_opt_parameters over what
+	// is left (vm_args.c v3_4_0:878-892). So in `def m(a, b=9, *c, d)` called as
+	// m(1, 2), the 2 belongs to d and b falls back to its default — an optional is
+	// supplied only if an argument survives the post reservation.
+	//
+	// This is the number OpArgGiven answers against. Reading len(args) instead
+	// (which is what rbgo did) makes every optional before a post parameter look
+	// supplied, and it is then left nil because the default-filling prologue is
+	// skipped.
+	nPosGiven := len(args)
+	if iseq.SplatIndex >= 0 {
+		nPosGiven -= len(iseq.Params) - iseq.SplatIndex - 1
+	}
 	env := vm.getEnv()
 	env.parent, env.kwargs, env.captured = parentEnv, kwargs, false
 	if iseq.NumLocals <= len(env.inline) {
@@ -1774,6 +1858,7 @@ func (vm *VM) exec(iseq *bytecode.ISeq, self object.Value, args []object.Value,
 							if in.Flags&bytecode.FlagSendExplicit != 0 {
 								vm.checkVisibility(recv, name, rm, self)
 							}
+							vm.sendNoKW = in.Flags&bytecode.FlagSendNoKW != 0 // MRI: the call info decides, not the callee
 							res := vm.invokeInPlace(rm, recv, stack[base:], nil)
 							stack = stack[:base-1]
 							stack = append(stack, res)
@@ -1783,6 +1868,7 @@ func (vm *VM) exec(iseq *bytecode.ISeq, self object.Value, args []object.Value,
 					}
 					if _, isClass := recv.(*RClass); !isClass {
 						if m := vm.lookupCached(&caches[pc], recv, name); m != nil {
+							vm.sendNoKW = in.Flags&bytecode.FlagSendNoKW != 0 // MRI: the call info decides, not the callee
 							// An explicit-receiver send enforces method visibility
 							// (private/protected); an implicit or `self.` send does not. A
 							// blocked call routes to #method_missing (or raises).
@@ -1814,6 +1900,7 @@ func (vm *VM) exec(iseq *bytecode.ISeq, self object.Value, args []object.Value,
 					// passed directly here — no per-call args copy. The region is read
 					// (and copied into the callee's env by exec, or defensively by
 					// invokeInPlace) before this frame truncates the stack below.
+					vm.sendNoKW = in.Flags&bytecode.FlagSendNoKW != 0 // MRI: the call info decides, not the callee
 					res, done := vm.enforceSendVisRoute(in.Flags, recv, name, stack[base:], nil, self)
 					if !done {
 						res = vm.send(recv, name, stack[base:], nil)
@@ -1828,6 +1915,7 @@ func (vm *VM) exec(iseq *bytecode.ISeq, self object.Value, args []object.Value,
 					// A literal block: capture this frame's env, self, block.
 					markEnvCaptured(env)
 					blk := &Proc{iseq: iseq.Children[in.C-1], env: env, defLocals: iseq.Locals, self: self, block: block, cref: lexCref, home: homeTarget(), superName: homeSuperName, superDefinee: homeSuperDefinee, superArgs: homeSuperArgs, dmBody: homeDmBody, methodCtx: fm}
+					vm.sendNoKW = in.Flags&bytecode.FlagSendNoKW != 0 // MRI: the call info decides, not the callee
 					if res, done := vm.enforceSendVisRoute(in.Flags, recv, name, callArgs, blk, self); done {
 						push(res)
 						pc++
@@ -1852,6 +1940,7 @@ func (vm *VM) exec(iseq *bytecode.ISeq, self object.Value, args []object.Value,
 				vm.enforceSendVis(in.Flags, recv, iseq.Names[in.A], self)
 				bname := iseq.Names[in.A]
 				bblk := vm.toBlock(blockVal)
+				vm.sendNoKW = in.Flags&bytecode.FlagSendNoKW != 0 // MRI: the call info decides, not the callee
 				if vm.anyRefinements {
 					if rm := vm.refinedMethod(definee, recv, bname); rm != nil {
 						push(vm.invokeInPlace(rm, recv, callArgs, bblk))
@@ -2016,6 +2105,7 @@ func (vm *VM) exec(iseq *bytecode.ISeq, self object.Value, args []object.Value,
 					copy(superArgs, stack[len(stack)-in.A:])
 					stack = stack[:len(stack)-in.A]
 				}
+				vm.sendNoKW = in.Flags&bytecode.FlagSendNoKW != 0 // MRI: the call info decides, not the callee
 				push(vm.invokeSuper(self, homeSuperDefinee, homeSuperName, superArgs, superBlk))
 			case bytecode.OpInvokeSuperArray:
 				superBlk := block
@@ -2027,7 +2117,9 @@ func (vm *VM) exec(iseq *bytecode.ISeq, self object.Value, args []object.Value,
 					superBlk = &Proc{iseq: iseq.Children[in.C-2], env: env, defLocals: iseq.Locals, self: self, block: block, cref: lexCref, home: homeTarget(), superName: homeSuperName, superDefinee: homeSuperDefinee, superArgs: homeSuperArgs, dmBody: homeDmBody, methodCtx: fm}
 				}
 				argsArr := pop().(*object.Array)
-				push(vm.invokeSuper(self, homeSuperDefinee, homeSuperName, argsArr.Elems, superBlk))
+				suElems, suNoKW := applyKWSplat(argsArr.Elems, in.Flags)
+				vm.sendNoKW = suNoKW // MRI: the call info decides, not the callee
+				push(vm.invokeSuper(self, homeSuperDefinee, homeSuperName, suElems, superBlk))
 			case bytecode.OpInvokeBlock:
 				if block == nil {
 					raise("LocalJumpError", "no block given (yield)")
@@ -2035,12 +2127,15 @@ func (vm *VM) exec(iseq *bytecode.ISeq, self object.Value, args []object.Value,
 				yargs := make([]object.Value, in.A)
 				copy(yargs, stack[len(stack)-in.A:])
 				stack = stack[:len(stack)-in.A]
+				vm.sendNoKW = in.Flags&bytecode.FlagSendNoKW != 0 // MRI: the call info decides, not the callee
 				push(vm.callBlock(block, yargs))
 			case bytecode.OpInvokeBlockArray:
 				if block == nil {
 					raise("LocalJumpError", "no block given (yield)")
 				}
-				push(vm.callBlock(block, pop().(*object.Array).Elems))
+				yaargs, yaNoKW := applyKWSplat(pop().(*object.Array).Elems, in.Flags)
+				vm.sendNoKW = yaNoKW // MRI: the call info decides, not the callee
+				push(vm.callBlock(block, yaargs))
 			case bytecode.OpExcMatchAny:
 				classes := pop().(*object.Array)
 				exc := pop()
@@ -2159,7 +2254,7 @@ func (vm *VM) exec(iseq *bytecode.ISeq, self object.Value, args []object.Value,
 				markEnvCaptured(env)
 				push(&Binding{env: env, self: self, definee: definee, file: iseq.File, names: append([]string(nil), iseq.Locals...)})
 			case bytecode.OpArgGiven:
-				push(object.Bool(in.A < len(args)))
+				push(object.Bool(in.A < nPosGiven))
 			case bytecode.OpKwGiven:
 				_, ok := env.kwargs.Get(object.SymVal(iseq.KwNames[in.A]))
 				push(object.Bool(ok))
@@ -2335,13 +2430,20 @@ func (vm *VM) exec(iseq *bytecode.ISeq, self object.Value, args []object.Value,
 					markEnvCaptured(env)
 					blk = &Proc{iseq: iseq.Children[in.C-1], env: env, defLocals: iseq.Locals, self: self, block: block, cref: lexCref, home: homeTarget(), superName: homeSuperName, superDefinee: homeSuperDefinee, superArgs: homeSuperArgs, dmBody: homeDmBody, methodCtx: fm}
 				}
-				push(vm.dispatchSend(recv, iseq.Names[in.A], argsArr.Elems, blk))
+				saElems, saNoKW := applyKWSplat(argsArr.Elems, in.Flags)
+				vm.sendNoKW = saNoKW // MRI: the call info decides, not the callee
+				push(vm.dispatchSend(recv, iseq.Names[in.A], saElems, blk))
 			case bytecode.OpSendArrayBlockArg:
 				blockVal := pop()
 				argsArr := pop().(*object.Array)
 				recv := pop()
 				vm.enforceSendVis(in.Flags, recv, iseq.Names[in.A], self)
-				push(vm.dispatchSend(recv, iseq.Names[in.A], argsArr.Elems, vm.toBlock(blockVal)))
+				// toBlock first: a user-defined #to_proc runs a frame of its own, which
+				// would consume the verdict set below.
+				abblk := vm.toBlock(blockVal)
+				abElems, abNoKW := applyKWSplat(argsArr.Elems, in.Flags)
+				vm.sendNoKW = abNoKW // MRI: the call info decides, not the callee
+				push(vm.dispatchSend(recv, iseq.Names[in.A], abElems, abblk))
 			default:
 				raise("VMError", "unknown opcode %s", in.Op)
 			}

From f6051e20b0c7bc399cf7e9dd9483f43cba00fe68 Mon Sep 17 00:00:00 2001
From: tannevaled <tannevaled@users.noreply.github.com>
Date: Thu, 24 Sep 2026 22:32:45 +0200
Subject: [PATCH 2/6] compiler: refuse a duplicated parameter name, as MRI's
 parser does
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`def m(a, a)`, `def m(a, *a)`, `def m(a, a:)`, `def m(a, &a)`,
`proc { |x, x| }` and `proc { |x; x| }` are all SyntaxErrors in MRI and all
compiled without complaint in rbgo, leaving the second declaration dead and the
name silently meaning the first.

MRI raises them in the PARSER: every formal goes through shadowing_lvar_0
(parse.y v3_4_0:13589), which yyerror0s "duplicated argument name" when the
name is already in the current scope's table. A block-local takes the same
route through new_bv, which is why `proc { |x; x| }` is refused (the dvar_curr
arm) while `z = 1; proc { |; z| }` is not (the dvar_defined arm merely records
the shadow). Names is_private_local_id exempts — `_` and anything starting
with `_` (parse.y v3_4_0:13578) — are legal duplicates, and the anonymous
forms `*`, `**` and `&` declare no name at all.

go-ruby-parser v0.3.0 keeps no scope table and does not raise it, and the
compiler is the only place in rbgo that sees a whole parameter list, so it
raises it there. The observable behaviour is MRI's, because a compileError
already surfaces as a Ruby SyntaxError from eval and require — which is exactly
how ruby/spec asks the question.

Verified against MRI 4.0.5 on all 16 shapes of the probe, including the
exemptions: `def m(_, _)`, `def m(_a, _a)`, `proc { |_x; _x| }`,
`def m(*, **, &)` and `def m(...)` stay legal.

language/block_spec.rb 157 -> 159.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 internal/compiler/compiler.go | 75 +++++++++++++++++++++++++++++++++++
 1 file changed, 75 insertions(+)

diff --git a/internal/compiler/compiler.go b/internal/compiler/compiler.go
index 5bca7161..a2b73263 100644
--- a/internal/compiler/compiler.go
+++ b/internal/compiler/compiler.go
@@ -477,6 +477,68 @@ func (c *Compiler) refuseKeywordAssign(name string) {
 	}
 }
 
+// paramCheckName reduces one parser parameter entry to the local name it
+// declares, or "" when that entry declares no name a duplicate check applies to.
+//
+// It strips the sigils the parser keeps on a block's folded entries (`**rest`,
+// `name:`) and on an anonymous parameter, and it drops the three kinds MRI
+// exempts or never sees here:
+//
+//   - the anonymous forms `*`, `**`, `&`, which declare no name at all —
+//     `def m(*, **, &)` is legal;
+//   - a name beginning with `_` (and `_` itself), which is
+//     is_private_local_id (parse.y v3_4_0:13578): shadowing_lvar_0 returns
+//     without complaining for those, so `def m(_, _)` and `|_x; _x|` are legal;
+//   - the parser's `(N)` placeholder for a destructuring parameter, whose real
+//     names it does not expose.
+func paramCheckName(p string) string {
+	switch {
+	case strings.HasPrefix(p, "**"):
+		p = p[2:]
+	case strings.HasPrefix(p, "*"), strings.HasPrefix(p, "&"):
+		p = p[1:]
+	}
+	p = strings.TrimSuffix(p, ":")
+	if p == "" || p[0] == '_' || p[0] == '(' {
+		return ""
+	}
+	return p
+}
+
+// checkDuplicateParams refuses a parameter list that declares the same name
+// twice, as MRI's parser does.
+//
+// Every formal goes through shadowing_lvar_0 (parse.y v3_4_0:13589), which
+// yyerror0s "duplicated argument name" when the name is already in the CURRENT
+// scope's table — so `def m(a, *a)`, `def m(a, a:)`, `def m(a, &a)` and
+// `proc { |x, x| }` are all SyntaxErrors, and so is a block-local that repeats
+// one of its own block's parameters (`proc { |x; x| }`, the dvar_curr arm),
+// because new_bv routes block-locals through the same check. A block-local that
+// shadows a name from an ENCLOSING scope is not a duplicate — that is the
+// dvar_defined/local_id arm, which merely records it — so only names declared
+// by this one list are compared.
+//
+// go-ruby-parser v0.3.0 does not raise it (it has no scope table), and rbgo has
+// no other place that sees a whole parameter list, so the compiler raises it.
+// The observable behaviour is MRI's: the error surfaces where the code is
+// compiled — a SyntaxError from eval/require, a refusal to run a script.
+func (c *Compiler) checkDuplicateParams(names []string) {
+	var seen map[string]bool
+	for _, raw := range names {
+		n := paramCheckName(raw)
+		if n == "" {
+			continue
+		}
+		if seen[n] {
+			c.fail("duplicated argument name")
+		}
+		if seen == nil {
+			seen = make(map[string]bool, len(names))
+		}
+		seen[n] = true
+	}
+}
+
 func (c *Compiler) fail(format string, args ...any) {
 	panic(compileError{msg: "compile error: " + fmt.Sprintf(format, args...)})
 }
@@ -1747,6 +1809,9 @@ func splitBlockParams(blk *ast.Block) (positionals []string, posDefaults []ast.N
 // reach the enclosing locals by depth.
 func (c *Compiler) compileBlock(blk *ast.Block) int {
 	parent := c.cur()
+	// A block's parameters, its &block parameter and its block-locals share one
+	// declaration list for the duplicate check (see checkDuplicateParams).
+	c.checkDuplicateParams(append(append(append([]string(nil), blk.Params...), blk.BlockParam), blk.Locals...))
 	positionals, posDefaults, kwParams, kwRest := splitBlockParams(blk)
 	c.push(newBlockBuilder(blockLabel(parent), positionals, parent))
 	b := c.cur()
@@ -3261,6 +3326,16 @@ const (
 func (c *Compiler) compileMethodDef(v *ast.MethodDef) {
 	// `def f(...)` collects the forwarded positionals into a synthetic *splat
 	// after the explicit params; the keyword-rest and block are added below.
+	// Duplicate formals are a SyntaxError, checked on what was WRITTEN — before
+	// `def f(...)` splices in its synthetic forwarding locals below.
+	{
+		names := append([]string(nil), v.Params...)
+		for _, kp := range v.KwParams {
+			names = append(names, kp.Name)
+		}
+		names = append(names, v.KwRest, v.BlockParam)
+		c.checkDuplicateParams(names)
+	}
 	params := v.Params
 	splatIndex := v.SplatIndex
 	if v.Forward {

From 9d1265d15eea7a54d90add2ce143d4ea60bc7104 Mon Sep 17 00:00:00 2001
From: tannevaled <tannevaled@users.noreply.github.com>
Date: Fri, 25 Sep 2026 07:40:39 +0200
Subject: [PATCH 3/6] bytecode,vm: post parameters without a splat (def m(a=1,
 b), { |a=5, b, c, d| })
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`def m(a=1, b)` and `{ |a=5, b, c, d| }` have REQUIRED positional parameters
after an optional one and no *splat. bytecode.ISeq had no way to say so: with
only NumRequired and SplatIndex the shape read as "two optionals", b bound from
the FRONT, the optional was never defaulted, and m() was accepted.

MRI keeps post_num beside lead_num and opt_num whether or not there is a rest
parameter (rb_iseq_param, vm_core.h), because the two counts answer different
questions. min_argc is lead_num + post_num (vm_args.c v3_4_0:595), so a post
parameter is required with no splat too. And post parameters bind from the TAIL
before the optionals are filled from what is left — args_setup_post_parameters
MEMCPYs the last post_num arguments and SHRINKS the list, then
args_setup_opt_parameters runs over the remainder (v3_4_0:887-892). A block
extends a short list to min_argc first (arg_setup_block, v3_4_0:858), which is
why `{ |a=5, b, c, d| }` yielded [1, 2] gives [5, 1, 2, nil].

New ISeq.PostCount says it, computed from the parser's parallel Defaults: an
optional after a post parameter is a SyntaxError, so the optionals form one
contiguous run and the post count is the distance from the last of them to the
end. NumRequired keeps its old meaning (the LEADING required count), so a
reader that predates the field is unaffected. internal/aot/freeze.go emits it —
the regenerated prelude gains 450 lines rather than coming back
byte-identical, which is the check that the emitter is not dropping it.

Reflection, measured against MRI 4.0.5 for every shape now bound:

  Proc#arity is FIXED here — rb_iseq_min_max_arity returns lead_num + post_num
  (proc.c v3_4_0), so arityVal in object_model.go adds PostCount:
  `proc { |a=5, b, c, d| }.arity` was 0, is 3; `->(a=1, b) {}.arity` was -1,
  is -2. Proc#parameters already agreed (a proc reports every positional :opt).

  Method#arity and #parameters still disagree with MRI for this shape —
  `method(:m).arity` answers -1 where MRI says -2, and #parameters says
  [[:opt, :a], [:opt, :b]] where MRI says [[:opt, :a], [:req, :b]]. Both
  answered exactly that before this commit, so nothing is made to lie; the two
  helpers that decide them, iseqRequiredPositional / iseqHasOptional in
  internal/vm/method.go and buildParamsList in internal/vm/method_reflect2.go,
  are outside this branch's file set. They need PostCount added the same way:
  `req += is.PostCount`, `len(is.Params)-is.PostCount > is.NumRequired`, and a
  `i >= len(is.Params)-is.PostCount` arm in the required test.

language/block_spec.rb 157 -> 163, language/send_spec.rb 70 -> 72.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 internal/aot/freeze.go            |   1 +
 internal/bytecode/bytecode.go     |  34 ++-
 internal/compiler/compiler.go     |  35 +++
 internal/vm/object_model.go       |  20 +-
 internal/vm/prelude_frozen_gen.go | 450 ++++++++++++++++++++++++++++++
 internal/vm/vm.go                 |  39 ++-
 6 files changed, 561 insertions(+), 18 deletions(-)

diff --git a/internal/aot/freeze.go b/internal/aot/freeze.go
index 10bb9554..bf11d5b4 100644
--- a/internal/aot/freeze.go
+++ b/internal/aot/freeze.go
@@ -95,6 +95,7 @@ func (f *freezer) writeISeq(b *strings.Builder, s *bytecode.ISeq) {
 	writeStrings(b, "Params", s.Params)
 	fmt.Fprintf(b, "NumRequired: %d,\n", s.NumRequired)
 	fmt.Fprintf(b, "SplatIndex: %d,\n", s.SplatIndex)
+	fmt.Fprintf(b, "PostCount: %d,\n", s.PostCount)
 	writeStrings(b, "KwNames", s.KwNames)
 	writeBools(b, "KwRequired", s.KwRequired)
 	fmt.Fprintf(b, "KwRestSlot: %d,\n", s.KwRestSlot)
diff --git a/internal/bytecode/bytecode.go b/internal/bytecode/bytecode.go
index df68385c..9e31a3a4 100644
--- a/internal/bytecode/bytecode.go
+++ b/internal/bytecode/bytecode.go
@@ -297,14 +297,32 @@ type ISeq struct {
 	Params      []string       // parameter names
 	NumRequired int            // count of required (non-defaulted) leading params
 	SplatIndex  int            // index of the *splat param, or -1
-	KwNames     []string       // keyword-param names; slots follow the positionals
-	KwRequired  []bool         // parallel to KwNames; true = required (no default)
-	KwRestSlot  int            // slot of the **rest keyword-splat param, or -1
-	BlockSlot   int            // slot of the &block param, or -1
-	NumLocals   int            // total local slots (params first, then assigns)
-	Locals      []string       // local-variable names by slot (for Binding); "" for anonymous slots
-	Children    []*ISeq        // nested ISeqs (method bodies / class bodies defined here)
-	Super       string         // for a class body: the superclass name ("" → Object)
+
+	// PostCount is the number of trailing REQUIRED positional parameters when
+	// there is NO *splat — the post parameters of `def m(a=1, b)` or
+	// `{ |a=5, b, c, d| }`. It is 0 whenever SplatIndex >= 0, where the post
+	// parameters are already derivable as len(Params)-SplatIndex-1, and 0 for the
+	// ordinary shape where every required parameter leads.
+	//
+	// MRI keeps post_num beside lead_num and opt_num in every iseq
+	// (rb_iseq_param, vm_core.h), independent of has_rest, because the two counts
+	// answer different questions: min_argc is lead_num + post_num, and post
+	// parameters bind from the TAIL before the optionals are filled from what is
+	// left (setup_parameters_complex, vm_args.c v3_4_0:878-892). With only
+	// NumRequired and SplatIndex the no-splat case cannot be said at all: rbgo
+	// read `def m(a=1, b)` as two optionals and bound b from the front.
+	//
+	// NumRequired stays the LEADING required count, so a reader that predates this
+	// field keeps the meaning it had.
+	PostCount  int
+	KwNames    []string // keyword-param names; slots follow the positionals
+	KwRequired []bool   // parallel to KwNames; true = required (no default)
+	KwRestSlot int      // slot of the **rest keyword-splat param, or -1
+	BlockSlot  int      // slot of the &block param, or -1
+	NumLocals  int      // total local slots (params first, then assigns)
+	Locals     []string // local-variable names by slot (for Binding); "" for anonymous slots
+	Children   []*ISeq  // nested ISeqs (method bodies / class bodies defined here)
+	Super      string   // for a class body: the superclass name ("" → Object)
 
 	// Lines is the source map: which source line each instruction came from,
 	// COMPRESSED to one entry per line CHANGE and kept sorted by PC.
diff --git a/internal/compiler/compiler.go b/internal/compiler/compiler.go
index a2b73263..f5cb9ae7 100644
--- a/internal/compiler/compiler.go
+++ b/internal/compiler/compiler.go
@@ -40,6 +40,7 @@ type builder struct {
 	params      []string
 	numRequired int
 	splatIndex  int
+	postCount   int
 	kwNames     []string
 	kwRequired  []bool
 	kwRestSlot  int
@@ -229,6 +230,7 @@ func (b *builder) build() *bytecode.ISeq {
 		Params:      b.params,
 		NumRequired: b.numRequired,
 		SplatIndex:  b.splatIndex,
+		PostCount:   b.postCount,
 		KwNames:     b.kwNames,
 		KwRequired:  b.kwRequired,
 		KwRestSlot:  b.kwRestSlot,
@@ -539,6 +541,37 @@ func (c *Compiler) checkDuplicateParams(names []string) {
 	}
 }
 
+// postCountNoSplat counts the trailing REQUIRED positional parameters of a
+// parameter list that has no *splat — the "post" parameters of `def m(a=1, b)`.
+//
+// defaults is parallel to the positionals, non-nil where one carries a default.
+// Everything after the LAST defaulted parameter is required and binds from the
+// tail (args_setup_post_parameters, vm_args.c v3_4_0:887), so the count is the
+// distance from that last optional to the end. With no optional at all there is
+// nothing in front of the required run and the answer is 0 — the ordinary shape,
+// already described by NumRequired alone. A list WITH a splat gets 0 too: its
+// post parameters are the slots after SplatIndex, and the arity helpers already
+// read them there.
+//
+// Ruby has no third arrangement to worry about: an optional parameter after a
+// post one (`def m(a=1, b, c=2)`) is a SyntaxError, so the optionals form one
+// contiguous run.
+func postCountNoSplat(nparams int, defaults []ast.Node, splatIndex int) int {
+	if splatIndex >= 0 {
+		return 0
+	}
+	last := -1
+	for i, d := range defaults {
+		if d != nil && i < nparams {
+			last = i
+		}
+	}
+	if last < 0 {
+		return 0
+	}
+	return nparams - last - 1
+}
+
 func (c *Compiler) fail(format string, args ...any) {
 	panic(compileError{msg: "compile error: " + fmt.Sprintf(format, args...)})
 }
@@ -1838,6 +1871,7 @@ func (c *Compiler) compileBlock(blk *ast.Block) int {
 		b.patch(skip, b.here())
 	}
 	b.numRequired = nreq
+	b.postCount = postCountNoSplat(len(positionals), posDefaults, blk.SplatIndex)
 	// Keyword params take local slots right after the positionals (matching the
 	// VM's keyword binding in exec), so the body resolves them by name; record
 	// their names/required flags for the VM.
@@ -3385,6 +3419,7 @@ func (c *Compiler) compileMethodDef(v *ast.MethodDef) {
 		b.patch(skip, b.here())
 	}
 	b.numRequired = nreq
+	b.postCount = postCountNoSplat(len(params), v.Defaults, splatIndex)
 	// Optional keyword params: the VM binds the supplied ones natively, so the
 	// prologue only fills in defaults for the absent ones.
 	for i, kp := range v.KwParams {
diff --git a/internal/vm/object_model.go b/internal/vm/object_model.go
index 0e288141..b203c943 100644
--- a/internal/vm/object_model.go
+++ b/internal/vm/object_model.go
@@ -1943,9 +1943,11 @@ func (p *Proc) arityVal() int {
 		return p.nativeArity
 	}
 	is := p.iseq
-	// Required count: the leading required positionals, plus one when any keyword
-	// is mandatory (a single required-keyword group counts as one required arg).
-	req := is.NumRequired
+	// Required count: the leading required positionals PLUS the trailing post ones
+	// (rb_iseq_min_max_arity returns lead_num + post_num, proc.c v3_4_0), plus one
+	// when any keyword is mandatory (a single required-keyword group counts as one
+	// required arg).
+	req := is.NumRequired + is.PostCount
 	hasReqKw, hasOptKw := false, is.KwRestSlot >= 0
 	for _, r := range is.KwRequired {
 		if r {
@@ -2213,9 +2215,17 @@ func (vm *VM) bindBlockPositionals(p *Proc, args []object.Value) []object.Value
 		// (capped at np, dropping extras), leaving len(args) reflecting how many
 		// were actually supplied so the default-filling prologue (OpArgGiven) fires
 		// for the absent ones.
+		//
+		// The required count is the leading requireds PLUS any post parameters
+		// (`{ |a=5, b, c, d| }`), because MRI's min_argc is lead_num + post_num and
+		// arg_setup_block extends a short argument list to it before binding
+		// (vm_args.c v3_4_0:858). The padding nils land at the tail, where the post
+		// parameters bind — which is how `{ |a=5, b, c, d| }` yielded [1, 2] gives
+		// [5, 1, 2, nil].
+		minArgs := p.iseq.NumRequired + p.iseq.PostCount
 		n := len(args)
-		if n < p.iseq.NumRequired {
-			n = p.iseq.NumRequired
+		if n < minArgs {
+			n = minArgs
 		}
 		if n > np {
 			n = np
diff --git a/internal/vm/prelude_frozen_gen.go b/internal/vm/prelude_frozen_gen.go
index f3690fbf..082cafe7 100644
--- a/internal/vm/prelude_frozen_gen.go
+++ b/internal/vm/prelude_frozen_gen.go
@@ -15,6 +15,7 @@ func embeddedPrelude() *bytecode.ISeq {
 		Names:       []string{"Comparable", "Enumerable", "Numeric", "Integer", "Float", "String", "Symbol", "Array", "Range", "Hash", "Set", "Gem", "OpenStruct", "Forwardable", "SingleForwardable", "Delegator", "SimpleDelegator", "DelegateClass", "Pathname", "Singleton", "ERB", "Slim", "Haml", "OptionParser", "OptParse", "Tempfile", "Warning"},
 		NumRequired: 0,
 		SplatIndex:  -1,
+		PostCount:   0,
 		KwRestSlot:  -1,
 		BlockSlot:   -1,
 		NumLocals:   0,
@@ -30,6 +31,7 @@ func embeddedPrelude() *bytecode.ISeq {
 				Names:       []string{"__compare", "private", "<", "<=", ">", ">=", "==", "between?", "clamp"},
 				NumRequired: 0,
 				SplatIndex:  -1,
+				PostCount:   0,
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
@@ -49,6 +51,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"other"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   4,
@@ -67,6 +70,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"other"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -85,6 +89,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"other"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -103,6 +108,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"other"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -121,6 +127,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"other"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -139,6 +146,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"other"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -153,6 +161,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"min", "max"},
 						NumRequired: 2,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -189,6 +198,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"args"},
 						NumRequired: 0,
 						SplatIndex:  0,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   5,
@@ -211,6 +221,7 @@ func embeddedPrelude() *bytecode.ISeq {
 				Names:       []string{"__each_packed", "__pack", "__enum_int_arg", "private", "to_a", "entries", "to_set", "to_h", "map", "collect", "count", "min_by", "max_by", "sort", "sort_by", "select", "filter", "reject", "find", "detect", "include?", "member?", "sum", "min", "max", "minmax", "reduce", "inject", "any?", "all?", "none?", "one?", "uniq", "compact", "each_with_index", "reverse_each", "flat_map", "collect_concat", "each_entry", "each_with_object", "filter_map", "partition", "group_by", "tally", "zip", "find_index", "find_all", "grep", "grep_v", "take_while", "drop_while", "each_slice", "each_cons", "first", "take", "drop", "chunk_while", "slice_when", "chunk", "slice_before", "slice_after", "minmax_by", "cycle"},
 				NumRequired: 0,
 				SplatIndex:  -1,
+				PostCount:   0,
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
@@ -223,6 +234,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"each"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -236,6 +248,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"a"},
 								NumRequired: 0,
 								SplatIndex:  0,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -258,6 +271,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"a"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -287,6 +301,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"n"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -302,6 +317,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"args"},
 						NumRequired: 0,
 						SplatIndex:  0,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -316,6 +332,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"a"},
 								NumRequired: 0,
 								SplatIndex:  0,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -334,6 +351,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"klass", "args"},
 						NumRequired: 0,
 						SplatIndex:  1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   2,
 						NumLocals:   3,
@@ -349,6 +367,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"args"},
 						NumRequired: 0,
 						SplatIndex:  0,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -374,6 +393,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"a"},
 								NumRequired: 0,
 								SplatIndex:  0,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   4,
@@ -394,6 +414,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"enum_for", "each"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -410,6 +431,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"respond_to?", "size"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -424,6 +446,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"a"},
 								NumRequired: 0,
 								SplatIndex:  0,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -449,6 +472,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"args"},
 						NumRequired: 0,
 						SplatIndex:  0,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   3,
@@ -466,6 +490,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"a"},
 								NumRequired: 0,
 								SplatIndex:  0,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -483,6 +508,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"a"},
 								NumRequired: 0,
 								SplatIndex:  0,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -500,6 +526,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"a"},
 								NumRequired: 0,
 								SplatIndex:  0,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -521,6 +548,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"args"},
 						NumRequired: 0,
 						SplatIndex:  0,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -537,6 +565,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"respond_to?", "size"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -550,6 +579,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"x"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -571,6 +601,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"args"},
 						NumRequired: 0,
 						SplatIndex:  0,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -587,6 +618,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"respond_to?", "size"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -600,6 +632,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"x"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -617,6 +650,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"to_a", "sort"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   0,
 						NumLocals:   1,
@@ -634,6 +668,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"enum_for", "to_a", "sort_by"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -649,6 +684,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"respond_to?", "size"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -662,6 +698,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"x"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -682,6 +719,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"enum_for", "__each_packed"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -698,6 +736,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"respond_to?", "size"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -712,6 +751,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"x"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -732,6 +772,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"enum_for", "__each_packed"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -748,6 +789,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"respond_to?", "size"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -762,6 +804,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"x"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -783,6 +826,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"ifnone"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   3,
@@ -795,6 +839,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Insns:       []bytecode.Instr{{Op: 2}, {Op: 53}},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -808,6 +853,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"x"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -826,6 +872,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"value"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -839,6 +886,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"x"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -861,6 +909,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"init"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   4,
@@ -875,6 +924,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"x"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   3,
@@ -893,6 +943,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"n"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   1,
 						NumLocals:   4,
@@ -914,6 +965,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"x"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   2,
@@ -932,6 +984,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"n"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   1,
 						NumLocals:   4,
@@ -953,6 +1006,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"x"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   2,
@@ -970,6 +1024,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"min", "max"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   0,
 						NumLocals:   1,
@@ -998,6 +1053,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"args"},
 						NumRequired: 0,
 						SplatIndex:  0,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   6,
@@ -1012,6 +1068,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"x"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -1033,6 +1090,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"pattern"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   3,
@@ -1046,6 +1104,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"each"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -1062,6 +1121,7 @@ func embeddedPrelude() *bytecode.ISeq {
 										Params:      []string{"a"},
 										NumRequired: 0,
 										SplatIndex:  0,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   2,
@@ -1086,6 +1146,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"pattern"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   3,
@@ -1099,6 +1160,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"each"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -1115,6 +1177,7 @@ func embeddedPrelude() *bytecode.ISeq {
 										Params:      []string{"a"},
 										NumRequired: 0,
 										SplatIndex:  0,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   2,
@@ -1139,6 +1202,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"pattern"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   3,
@@ -1152,6 +1216,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"each"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -1168,6 +1233,7 @@ func embeddedPrelude() *bytecode.ISeq {
 										Params:      []string{"a"},
 										NumRequired: 0,
 										SplatIndex:  0,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   2,
@@ -1194,6 +1260,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"pattern"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   4,
@@ -1207,6 +1274,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"each"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -1224,6 +1292,7 @@ func embeddedPrelude() *bytecode.ISeq {
 										Params:      []string{"a"},
 										NumRequired: 0,
 										SplatIndex:  0,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   2,
@@ -1244,6 +1313,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"__each_packed"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   3,
@@ -1262,6 +1332,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"x"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   6,
@@ -1279,6 +1350,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"__each_packed"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -1293,6 +1365,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"x"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -1315,6 +1388,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"args"},
 						NumRequired: 0,
 						SplatIndex:  0,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -1331,6 +1405,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"respond_to?", "size"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -1348,6 +1423,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"a"},
 								NumRequired: 0,
 								SplatIndex:  0,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -1368,6 +1444,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"enum_for", "to_a", "reverse_each"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   0,
 						NumLocals:   1,
@@ -1384,6 +1461,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"respond_to?", "size"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -1403,6 +1481,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"enum_for", "__each_packed"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -1419,6 +1498,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"respond_to?", "size"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -1433,6 +1513,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"x"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   3,
@@ -1447,6 +1528,7 @@ func embeddedPrelude() *bytecode.ISeq {
 										Params:      []string{"e"},
 										NumRequired: 1,
 										SplatIndex:  -1,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   1,
@@ -1471,6 +1553,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"args"},
 						NumRequired: 0,
 						SplatIndex:  0,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -1487,6 +1570,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"respond_to?", "size"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -1501,6 +1585,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"a"},
 								NumRequired: 0,
 								SplatIndex:  0,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -1522,6 +1607,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"memo"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -1538,6 +1624,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"respond_to?", "size"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -1551,6 +1638,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"x"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -1571,6 +1659,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"enum_for", "__each_packed"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -1587,6 +1676,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"respond_to?", "size"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -1601,6 +1691,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"x"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   2,
@@ -1621,6 +1712,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"enum_for", "__each_packed"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -1637,6 +1729,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"respond_to?", "size"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -1651,6 +1744,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"x"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -1671,6 +1765,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"enum_for", "__each_packed"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -1687,6 +1782,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"respond_to?", "size"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -1701,6 +1797,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"x"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   5,
@@ -1736,6 +1833,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"args"},
 						NumRequired: 0,
 						SplatIndex:  0,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   3,
@@ -1760,6 +1858,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"x"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   4,
@@ -1781,6 +1880,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"others"},
 						NumRequired: 0,
 						SplatIndex:  0,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   4,
@@ -1802,6 +1902,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"o"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -1820,6 +1921,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"x"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   2,
@@ -1834,6 +1936,7 @@ func embeddedPrelude() *bytecode.ISeq {
 										Params:      []string{"o"},
 										NumRequired: 1,
 										SplatIndex:  -1,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   1,
@@ -1863,6 +1966,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"args"},
 						NumRequired: 0,
 						SplatIndex:  0,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   3,
@@ -1875,6 +1979,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Insns:       []bytecode.Instr{{Op: 2}, {Op: 53}},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -1893,6 +1998,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"a"},
 								NumRequired: 0,
 								SplatIndex:  0,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -1911,6 +2017,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"pattern"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -1925,6 +2032,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"x"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -1943,6 +2051,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"pattern"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -1957,6 +2066,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"x"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -1977,6 +2087,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"enum_for", "each"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -1989,6 +2100,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Insns:       []bytecode.Instr{{Op: 2}, {Op: 53}},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -2003,6 +2115,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"a"},
 								NumRequired: 0,
 								SplatIndex:  0,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -2023,6 +2136,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"enum_for", "__each_packed"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -2035,6 +2149,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Insns:       []bytecode.Instr{{Op: 2}, {Op: 53}},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -2049,6 +2164,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"x"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -2072,6 +2188,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"n"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -2089,6 +2206,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"respond_to?", "size"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -2104,6 +2222,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"x"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -2127,6 +2246,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"n"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -2145,6 +2265,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"respond_to?", "size"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -2160,6 +2281,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"x"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -2187,6 +2309,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"args"},
 						NumRequired: 0,
 						SplatIndex:  0,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   4,
@@ -2200,6 +2323,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"__each_packed"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -2216,6 +2340,7 @@ func embeddedPrelude() *bytecode.ISeq {
 										Params:      []string{"x"},
 										NumRequired: 1,
 										SplatIndex:  -1,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   1,
@@ -2233,6 +2358,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"__each_packed"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -2249,6 +2375,7 @@ func embeddedPrelude() *bytecode.ISeq {
 										Params:      []string{"x"},
 										NumRequired: 1,
 										SplatIndex:  -1,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   1,
@@ -2275,6 +2402,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"n"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -2288,6 +2416,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"__each_packed"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -2304,6 +2433,7 @@ func embeddedPrelude() *bytecode.ISeq {
 										Params:      []string{"x"},
 										NumRequired: 1,
 										SplatIndex:  -1,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   1,
@@ -2329,6 +2459,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"n"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   3,
@@ -2346,6 +2477,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"x"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -2369,6 +2501,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"ArgumentError", "raise", "to_a", "empty?", "to_enum", "[]", "length", "<<"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   4,
@@ -2389,6 +2522,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"ArgumentError", "raise", "to_a", "empty?", "to_enum", "[]", "length", "<<"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   4,
@@ -2407,6 +2541,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"enum_for", "__each_packed", "to_enum"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -2419,6 +2554,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Insns:       []bytecode.Instr{{Op: 2}, {Op: 53}},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -2442,6 +2578,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"x"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   2,
@@ -2455,6 +2592,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Insns:       []bytecode.Instr{{Op: 2}, {Op: 53}},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -2482,6 +2620,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"args"},
 						NumRequired: 0,
 						SplatIndex:  0,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   4,
@@ -2496,6 +2635,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"x"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -2509,6 +2649,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Insns:       []bytecode.Instr{{Op: 2}, {Op: 53}},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -2536,6 +2677,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"args"},
 						NumRequired: 0,
 						SplatIndex:  0,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   4,
@@ -2550,6 +2692,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"x"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -2563,6 +2706,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Insns:       []bytecode.Instr{{Op: 2}, {Op: 53}},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -2582,6 +2726,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"enum_for", "min_by", "max_by"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -2597,6 +2742,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"respond_to?", "size"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -2610,6 +2756,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"x"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -2624,6 +2771,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"x"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -2647,6 +2795,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"n"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -2664,6 +2813,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"respond_to?", "size", "nil?", "Float", "INFINITY"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -2679,6 +2829,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"a"},
 								NumRequired: 0,
 								SplatIndex:  0,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   2,
@@ -2693,6 +2844,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"each"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -2705,6 +2857,7 @@ func embeddedPrelude() *bytecode.ISeq {
 										Params:      []string{"x"},
 										NumRequired: 1,
 										SplatIndex:  -1,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   1,
@@ -2722,6 +2875,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"each"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -2734,6 +2888,7 @@ func embeddedPrelude() *bytecode.ISeq {
 										Params:      []string{"x"},
 										NumRequired: 1,
 										SplatIndex:  -1,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   1,
@@ -2757,6 +2912,7 @@ func embeddedPrelude() *bytecode.ISeq {
 				Names:       []string{"Comparable", "include", "numerator", "denominator"},
 				NumRequired: 0,
 				SplatIndex:  -1,
+				PostCount:   0,
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
@@ -2769,6 +2925,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"to_r", "numerator"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -2782,6 +2939,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"to_r", "denominator"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -2798,6 +2956,7 @@ func embeddedPrelude() *bytecode.ISeq {
 				Names:       []string{"numerator", "denominator"},
 				NumRequired: 0,
 				SplatIndex:  -1,
+				PostCount:   0,
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
@@ -2809,6 +2968,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Insns:       []bytecode.Instr{{Op: 5}, {Op: 53}},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -2824,6 +2984,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -2840,6 +3001,7 @@ func embeddedPrelude() *bytecode.ISeq {
 				Names:       []string{"numerator", "denominator"},
 				NumRequired: 0,
 				SplatIndex:  -1,
+				PostCount:   0,
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
@@ -2852,6 +3014,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"finite?", "to_r", "numerator"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -2868,6 +3031,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"finite?", "to_r", "denominator"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -2884,6 +3048,7 @@ func embeddedPrelude() *bytecode.ISeq {
 				Names:       []string{"Comparable", "include"},
 				NumRequired: 0,
 				SplatIndex:  -1,
+				PostCount:   0,
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
@@ -2897,6 +3062,7 @@ func embeddedPrelude() *bytecode.ISeq {
 				Names:       []string{"Comparable", "include"},
 				NumRequired: 0,
 				SplatIndex:  -1,
+				PostCount:   0,
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
@@ -2910,6 +3076,7 @@ func embeddedPrelude() *bytecode.ISeq {
 				Names:       []string{"Enumerable", "include", "deconstruct"},
 				NumRequired: 0,
 				SplatIndex:  -1,
+				PostCount:   0,
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
@@ -2921,6 +3088,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Insns:       []bytecode.Instr{{Op: 5}, {Op: 53}},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -2937,6 +3105,7 @@ func embeddedPrelude() *bytecode.ISeq {
 				Names:       []string{"Enumerable", "include", "==", "eql?", "hash"},
 				NumRequired: 0,
 				SplatIndex:  -1,
+				PostCount:   0,
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
@@ -2950,6 +3119,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"other"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -2965,6 +3135,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"other"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -2979,6 +3150,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"begin", "end", "exclude_end?", "hash"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -2995,6 +3167,7 @@ func embeddedPrelude() *bytecode.ISeq {
 				Names:       []string{"Enumerable", "include", "deconstruct_keys"},
 				NumRequired: 0,
 				SplatIndex:  -1,
+				PostCount:   0,
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
@@ -3007,6 +3180,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"keys"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -3030,6 +3204,7 @@ func embeddedPrelude() *bytecode.ISeq {
 				Names:       []string{"Enumerable", "include", "__do_with_enum", "private", "initialize", "each", "empty?", "add?", "delete?", "|", "union", "+", "&", "intersection", "-", "difference", "^", "merge", "subtract", "replace", "reset", "subset?", "<=", "proper_subset?", "<", "superset?", ">=", "proper_superset?", ">", "<=>", "==", "eql?", "hash", "disjoint?", "intersect?", "delete_if", "keep_if", "select!", "filter!", "reject!", "map!", "collect!", "classify", "divide", "__divide_graph", "flatten", "flatten!", "flatten_merge", "protected", "join", "to_set"},
 				NumRequired: 0,
 				SplatIndex:  -1,
+				PostCount:   0,
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
@@ -3048,6 +3223,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"enum"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   1,
 						NumLocals:   2,
@@ -3063,6 +3239,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"enum"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   1,
 						NumLocals:   2,
@@ -3077,6 +3254,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"o"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -3092,6 +3270,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"o"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -3112,6 +3291,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"enum_for", "__each"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   0,
 						NumLocals:   1,
@@ -3125,6 +3305,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"size"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -3144,6 +3325,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"size"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -3158,6 +3340,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"o"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -3173,6 +3356,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"o"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -3188,6 +3372,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"other"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -3202,6 +3387,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"o"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -3220,6 +3406,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"other"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -3234,6 +3421,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"o"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -3252,6 +3440,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"other"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -3266,6 +3455,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"o"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -3284,6 +3474,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"other"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -3298,6 +3489,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"o"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -3316,6 +3508,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"enums"},
 						NumRequired: 0,
 						SplatIndex:  0,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -3330,6 +3523,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"enum"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -3344,6 +3538,7 @@ func embeddedPrelude() *bytecode.ISeq {
 										Params:      []string{"o"},
 										NumRequired: 1,
 										SplatIndex:  -1,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   1,
@@ -3365,6 +3560,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"other"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -3379,6 +3575,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"o"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -3402,6 +3599,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"other"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -3416,6 +3614,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"o"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -3431,6 +3630,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"o"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -3448,6 +3648,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"to_a", "compare_by_identity?", "__replace_cbi", "each"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -3462,6 +3663,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"o"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -3483,6 +3685,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"other"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -3497,6 +3700,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"o"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -3518,6 +3722,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"other"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -3532,6 +3737,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"o"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -3553,6 +3759,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"other"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -3567,6 +3774,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"o"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -3588,6 +3796,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"other"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -3602,6 +3811,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"o"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -3625,6 +3835,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"other"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -3643,6 +3854,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"other"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -3657,6 +3869,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"o"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -3677,6 +3890,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"to_a", "map", "sort", "hash"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -3691,6 +3905,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"other"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -3705,6 +3920,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"o"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -3720,6 +3936,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"o"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -3738,6 +3955,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"other"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -3755,6 +3973,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"enum_for", "to_a", "each"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   0,
 						NumLocals:   1,
@@ -3768,6 +3987,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"size"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -3782,6 +4002,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"o"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -3802,6 +4023,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"enum_for", "to_a", "each"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   0,
 						NumLocals:   1,
@@ -3815,6 +4037,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"size"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -3829,6 +4052,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"o"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -3849,6 +4073,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"enum_for", "size", "keep_if"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   0,
 						NumLocals:   2,
@@ -3862,6 +4087,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"size"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -3881,6 +4107,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"enum_for", "size", "delete_if"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   0,
 						NumLocals:   2,
@@ -3894,6 +4121,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"size"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -3913,6 +4141,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"enum_for", "to_a", "map", "__replace_cbi", "each"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   0,
 						NumLocals:   2,
@@ -3926,6 +4155,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"size"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -3940,6 +4170,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"o"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -3960,6 +4191,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"enum_for", "each"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   0,
 						NumLocals:   2,
@@ -3973,6 +4205,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"size"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -3987,6 +4220,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"o"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   5,
@@ -4008,6 +4242,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"enum_for", "arity", "__divide_graph", "class", "classify", "values", "new"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   0,
 						NumLocals:   1,
@@ -4021,6 +4256,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"size"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -4040,6 +4276,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"to_a", "size", "Array", "new", "times", "lambda", "class", "map"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   0,
 						NumLocals:   11,
@@ -4052,6 +4289,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Insns:       []bytecode.Instr{{Op: 6}, {Op: 53}},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -4066,6 +4304,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"i"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -4080,6 +4319,7 @@ func embeddedPrelude() *bytecode.ISeq {
 										Params:      []string{"j"},
 										NumRequired: 1,
 										SplatIndex:  -1,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   1,
@@ -4101,6 +4341,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"v"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   5,
@@ -4115,6 +4356,7 @@ func embeddedPrelude() *bytecode.ISeq {
 										Params:      []string{"w"},
 										NumRequired: 1,
 										SplatIndex:  -1,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   3,
@@ -4129,6 +4371,7 @@ func embeddedPrelude() *bytecode.ISeq {
 										Names:       []string{"pop", "[]=", "[]", "<<"},
 										NumRequired: 0,
 										SplatIndex:  -1,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   2,
@@ -4147,6 +4390,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"v"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -4162,6 +4406,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"c"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -4179,6 +4424,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"class", "new", "flatten_merge"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -4192,6 +4438,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"any?", "flatten", "replace"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -4205,6 +4452,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"o"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -4223,6 +4471,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"other", "seen"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -4240,6 +4489,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"o"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   2,
@@ -4258,6 +4508,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"sep"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -4271,6 +4522,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Insns:       []bytecode.Instr{{Op: 5}, {Op: 53}},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -4287,6 +4539,7 @@ func embeddedPrelude() *bytecode.ISeq {
 				Names:       []string{"Version", "Requirement", "ruby_version", "win_platform?", "clear_paths", "Specification"},
 				NumRequired: 0,
 				SplatIndex:  -1,
+				PostCount:   0,
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
@@ -4305,6 +4558,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"Comparable", "include", "VERSION_PATTERN", "Regexp", "new", "ANCHORED_VERSION_PATTERN", "correct?", "create", "attr_reader", "initialize", "to_s", "inspect", "segments", "prerelease?", "release", "bump", "<=>", "==", "eql?", "hash", "private", "compare_segment"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -4318,6 +4572,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"str"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -4333,6 +4588,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"input"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -4356,6 +4612,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"version"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -4370,6 +4627,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"@version"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -4389,6 +4647,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"to_s", "class", "name", "@version", "inspect"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -4402,6 +4661,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"@segments", "@version", "[0-9]+|[a-zA-Z]+", "", "scan", "map"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -4415,6 +4675,7 @@ func embeddedPrelude() *bytecode.ISeq {
 										Params:      []string{"s"},
 										NumRequired: 1,
 										SplatIndex:  -1,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   1,
@@ -4432,6 +4693,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"@version", "[a-zA-Z]", "", "=~"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -4448,6 +4710,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"prerelease?", "segments", "empty?", "last", "Integer", "is_a?", "pop", "class", "join", "new"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -4467,6 +4730,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"segments", "dup", "empty?", "last", "Integer", "is_a?", "pop", "size", "[]", "[]=", "class", "join", "new"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   2,
@@ -4486,6 +4750,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"other"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   8,
@@ -4504,6 +4769,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"other"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -4519,6 +4785,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"other"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -4533,6 +4800,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"segments", "hash"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -4551,6 +4819,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"l", "r"},
 								NumRequired: 2,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   2,
@@ -4580,6 +4849,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"lambda", "OPS", "Regexp", "Version", "VERSION_PATTERN", "new", "PATTERN", "create", "default", "attr_reader", "initialize", "parse", "satisfied_by?", "===", "=~", "to_s"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -4592,6 +4862,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"v", "r"},
 								NumRequired: 2,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   2,
@@ -4606,6 +4877,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"v", "r"},
 								NumRequired: 2,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   2,
@@ -4620,6 +4892,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"v", "r"},
 								NumRequired: 2,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   2,
@@ -4634,6 +4907,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"v", "r"},
 								NumRequired: 2,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   2,
@@ -4648,6 +4922,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"v", "r"},
 								NumRequired: 2,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   2,
@@ -4662,6 +4937,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"v", "r"},
 								NumRequired: 2,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   2,
@@ -4677,6 +4953,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"v", "r"},
 								NumRequired: 2,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   2,
@@ -4692,6 +4969,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"input"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -4709,6 +4987,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"new"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -4726,6 +5005,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"reqs"},
 								NumRequired: 0,
 								SplatIndex:  0,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -4740,6 +5020,7 @@ func embeddedPrelude() *bytecode.ISeq {
 										Params:      []string{"r"},
 										NumRequired: 1,
 										SplatIndex:  -1,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   1,
@@ -4767,6 +5048,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"obj"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   3,
@@ -4782,6 +5064,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"version"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -4796,6 +5079,7 @@ func embeddedPrelude() *bytecode.ISeq {
 										Params:      []string{"op", "req"},
 										NumRequired: 2,
 										SplatIndex:  -1,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   2,
@@ -4816,6 +5100,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"@requirements", "map", "join"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -4835,6 +5120,7 @@ func embeddedPrelude() *bytecode.ISeq {
 										Params:      []string{"op", "req"},
 										NumRequired: 2,
 										SplatIndex:  -1,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   2,
@@ -4855,6 +5141,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"Version", "RUBY_VERSION", "new"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -4867,6 +5154,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Insns:       []bytecode.Instr{{Op: 4}, {Op: 53}},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -4879,6 +5167,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Insns:       []bytecode.Instr{{Op: 2}, {Op: 53}},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -4892,6 +5181,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"stubs"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -4903,6 +5193,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Insns:       []bytecode.Instr{{Op: 6}, {Op: 53}},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -4922,6 +5213,7 @@ func embeddedPrelude() *bytecode.ISeq {
 				Names:       []string{"initialize", "[]", "[]=", "to_h", "each_pair", "members", "dig", "delete_field", "respond_to_missing?", "method_missing", "==", "eql?", "respond_to?", "inspect", "to_s"},
 				NumRequired: 0,
 				SplatIndex:  -1,
+				PostCount:   0,
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
@@ -4935,6 +5227,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"hash"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -4949,6 +5242,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"k", "v"},
 								NumRequired: 2,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   3,
@@ -4967,6 +5261,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"name"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -4982,6 +5277,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"name", "value"},
 						NumRequired: 2,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   3,
@@ -4996,6 +5292,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"OpenStruct", "@table", "__data_to_h"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -5012,6 +5309,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"enum_for", "@table", "each_pair"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -5024,6 +5322,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"k", "v"},
 								NumRequired: 2,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   2,
@@ -5041,6 +5340,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"@table", "keys"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -5055,6 +5355,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"names"},
 						NumRequired: 0,
 						SplatIndex:  0,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -5070,6 +5371,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"name"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -5088,6 +5390,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"name", "include_private"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   3,
@@ -5112,6 +5415,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"name", "args"},
 						NumRequired: 1,
 						SplatIndex:  1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   4,
@@ -5127,6 +5431,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"other"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -5142,6 +5447,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"name", "include_private"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -5156,6 +5462,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"OpenStruct", "@table", "__data_inspect"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -5172,6 +5479,7 @@ func embeddedPrelude() *bytecode.ISeq {
 				Names:       []string{"def_delegator", "delegate", "def_delegators", "__resolve_accessor"},
 				NumRequired: 0,
 				SplatIndex:  -1,
+				PostCount:   0,
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
@@ -5185,6 +5493,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"accessor", "method", "ali"},
 						NumRequired: 2,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   3,
@@ -5199,6 +5508,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"args"},
 								NumRequired: 0,
 								SplatIndex:  0,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   1,
 								NumLocals:   3,
@@ -5217,6 +5527,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"accessor", "methods"},
 						NumRequired: 1,
 						SplatIndex:  1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -5231,6 +5542,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"m"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -5252,6 +5564,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"obj", "accessor"},
 						NumRequired: 2,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -5269,6 +5582,7 @@ func embeddedPrelude() *bytecode.ISeq {
 				Names:       []string{"def_single_delegator", "delegate", "def_single_delegators"},
 				NumRequired: 0,
 				SplatIndex:  -1,
+				PostCount:   0,
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
@@ -5282,6 +5596,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"accessor", "method", "ali"},
 						NumRequired: 2,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   3,
@@ -5296,6 +5611,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"args"},
 								NumRequired: 0,
 								SplatIndex:  0,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   1,
 								NumLocals:   3,
@@ -5314,6 +5630,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"accessor", "methods"},
 						NumRequired: 1,
 						SplatIndex:  1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -5328,6 +5645,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"m"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -5348,6 +5666,7 @@ func embeddedPrelude() *bytecode.ISeq {
 				Names:       []string{"initialize", "method_missing", "respond_to_missing?", "respond_to?", "==", "__getobj__", "__setobj__"},
 				NumRequired: 0,
 				SplatIndex:  -1,
+				PostCount:   0,
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
@@ -5361,6 +5680,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"obj"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -5376,6 +5696,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"name", "args"},
 						NumRequired: 1,
 						SplatIndex:  1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   2,
 						NumLocals:   4,
@@ -5391,6 +5712,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"name", "include_private"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -5406,6 +5728,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"name", "include_private"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -5421,6 +5744,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"other"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -5440,6 +5764,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"NotImplementedError", "to_s", "class", "raise"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -5459,6 +5784,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"_obj"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -5476,6 +5802,7 @@ func embeddedPrelude() *bytecode.ISeq {
 				Names:       []string{"__getobj__", "__setobj__"},
 				NumRequired: 0,
 				SplatIndex:  -1,
+				PostCount:   0,
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
@@ -5488,6 +5815,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"@delegate_sd_obj"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -5502,6 +5830,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"obj"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -5545,6 +5874,7 @@ func embeddedPrelude() *bytecode.ISeq {
 				Params:      []string{"superclass"},
 				NumRequired: 1,
 				SplatIndex:  -1,
+				PostCount:   0,
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   3,
@@ -5558,6 +5888,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"__getobj__", "__setobj__"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -5570,6 +5901,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"@delegate_dc_obj"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -5584,6 +5916,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"obj"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -5605,6 +5938,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"m"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -5619,6 +5953,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"args"},
 								NumRequired: 0,
 								SplatIndex:  0,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   1,
 								NumLocals:   2,
@@ -5642,6 +5977,7 @@ func embeddedPrelude() *bytecode.ISeq {
 				Names:       []string{"Comparable", "include", "SEPARATOR", "initialize", "to_s", "to_path", "inspect", "to_str", "freeze", "==", "eql?", "<=>", "hash", "absolute?", "relative?", "root?", "+", "/", "join", "basename", "dirname", "parent", "extname", "split", "each_filename", "ascend", "descend", "cleanpath", "sub_ext", "relative_path_from", "read", "write", "each_line", "exist?", "file?", "directory?", "open"},
 				NumRequired: 0,
 				SplatIndex:  -1,
+				PostCount:   0,
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
@@ -5658,6 +5994,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"path"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -5672,6 +6009,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"@path"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -5690,6 +6028,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"to_s", "@path"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -5703,6 +6042,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"@path"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -5716,6 +6056,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"@path", "freeze"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -5730,6 +6071,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"other"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -5745,6 +6087,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"other"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -5759,6 +6102,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"@path", "hash"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -5772,6 +6116,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"Pathname", "@path", "__lex_absolute?"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -5785,6 +6130,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"absolute?"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -5798,6 +6144,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"@path", "\\A/+\\z", "", "=~"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -5812,6 +6159,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"other"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -5826,6 +6174,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"other"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -5841,6 +6190,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"args"},
 						NumRequired: 0,
 						SplatIndex:  0,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -5854,6 +6204,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"a"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -5875,6 +6226,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"suffix"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -5889,6 +6241,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"Pathname", "@path", "__lex_dirname", "new"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -5902,6 +6255,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"Pathname", "@path", "__lex_extname"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -5915,6 +6269,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"dirname", "basename"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -5931,6 +6286,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"enum_for", "Pathname", "@path", "__lex_filenames", "each"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -5943,6 +6299,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"f"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -5963,6 +6320,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"enum_for", "Pathname", "@path", "__lex_ascend_paths", "each"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -5976,6 +6334,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"p"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -5996,6 +6355,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"enum_for", "Pathname", "@path", "__lex_ascend_paths", "reverse_each"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -6009,6 +6369,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"p"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -6026,6 +6387,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"Pathname", "@path", "__lex_cleanpath", "new"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -6040,6 +6402,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"repl"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -6055,6 +6418,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"base_directory"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -6070,6 +6434,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"args"},
 						NumRequired: 0,
 						SplatIndex:  0,
+						PostCount:   0,
 						KwRestSlot:  1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -6085,6 +6450,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"content", "args"},
 						NumRequired: 1,
 						SplatIndex:  1,
+						PostCount:   0,
 						KwRestSlot:  2,
 						BlockSlot:   -1,
 						NumLocals:   3,
@@ -6100,6 +6466,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"args"},
 						NumRequired: 0,
 						SplatIndex:  0,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   1,
 						NumLocals:   2,
@@ -6114,6 +6481,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"File", "@path", "exist?"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -6127,6 +6495,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"File", "@path", "file?"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -6140,6 +6509,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"File", "@path", "directory?"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -6154,6 +6524,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"args"},
 						NumRequired: 0,
 						SplatIndex:  0,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   1,
 						NumLocals:   2,
@@ -6171,6 +6542,7 @@ func embeddedPrelude() *bytecode.ISeq {
 				Names:       []string{"SingletonClassMethods", "included"},
 				NumRequired: 0,
 				SplatIndex:  -1,
+				PostCount:   0,
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
@@ -6183,6 +6555,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"instance"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -6195,6 +6568,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"@__singleton_instance__", "new"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -6216,6 +6590,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"klass"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -6239,6 +6614,7 @@ func embeddedPrelude() *bytecode.ISeq {
 				Names:       []string{"attr_reader", "attr_accessor", "initialize", "result", "result_with_hash", "run", "private", "new_toplevel"},
 				NumRequired: 0,
 				SplatIndex:  -1,
+				PostCount:   0,
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
@@ -6257,6 +6633,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"str"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwNames:     []string{"trim_mode", "eoutvar"},
 						KwRequired:  []bool{false, false},
 						KwRestSlot:  -1,
@@ -6277,6 +6654,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"b"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -6292,6 +6670,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"hash"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -6306,6 +6685,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"key", "value"},
 								NumRequired: 2,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   2,
@@ -6324,6 +6704,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"b"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -6337,6 +6718,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Insns:       []bytecode.Instr{{Op: 72}, {Op: 53}},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -6353,6 +6735,7 @@ func embeddedPrelude() *bytecode.ISeq {
 				Names:       []string{"Helpers", "Template", "Engine"},
 				NumRequired: 0,
 				SplatIndex:  -1,
+				PostCount:   0,
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
@@ -6365,6 +6748,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"Safe", "safe", "escape_html", "render_attribute", "render_attributes"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -6380,6 +6764,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"attr_reader", "initialize"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -6393,6 +6778,7 @@ func embeddedPrelude() *bytecode.ISeq {
 										Params:      []string{"v"},
 										NumRequired: 1,
 										SplatIndex:  -1,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   1,
@@ -6411,6 +6797,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"v"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -6438,6 +6825,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"s"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -6467,6 +6855,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"name", "value"},
 								NumRequired: 2,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   2,
@@ -6485,6 +6874,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"base", "splats"},
 								NumRequired: 1,
 								SplatIndex:  1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   5,
@@ -6508,6 +6898,7 @@ func embeddedPrelude() *bytecode.ISeq {
 										Params:      []string{"k", "v"},
 										NumRequired: 2,
 										SplatIndex:  -1,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   7,
@@ -6524,6 +6915,7 @@ func embeddedPrelude() *bytecode.ISeq {
 												Params:      []string{"x"},
 												NumRequired: 1,
 												SplatIndex:  -1,
+												PostCount:   0,
 												KwRestSlot:  -1,
 												BlockSlot:   -1,
 												NumLocals:   1,
@@ -6542,6 +6934,7 @@ func embeddedPrelude() *bytecode.ISeq {
 										Params:      []string{"k", "v"},
 										NumRequired: 2,
 										SplatIndex:  -1,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   2,
@@ -6557,6 +6950,7 @@ func embeddedPrelude() *bytecode.ISeq {
 										Params:      []string{"h"},
 										NumRequired: 1,
 										SplatIndex:  -1,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   1,
@@ -6571,6 +6965,7 @@ func embeddedPrelude() *bytecode.ISeq {
 												Params:      []string{"k", "v"},
 												NumRequired: 2,
 												SplatIndex:  -1,
+												PostCount:   0,
 												KwRestSlot:  -1,
 												BlockSlot:   -1,
 												NumLocals:   2,
@@ -6589,6 +6984,7 @@ func embeddedPrelude() *bytecode.ISeq {
 										Params:      []string{"k"},
 										NumRequired: 1,
 										SplatIndex:  -1,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   1,
@@ -6612,6 +7008,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"attr_reader", "initialize", "render"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -6625,6 +7022,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"template"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   1,
 								NumLocals:   2,
@@ -6644,6 +7042,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"_scope", "locals"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   3,
@@ -6658,6 +7057,7 @@ func embeddedPrelude() *bytecode.ISeq {
 										Params:      []string{"k", "v"},
 										NumRequired: 2,
 										SplatIndex:  -1,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   2,
@@ -6681,6 +7081,7 @@ func embeddedPrelude() *bytecode.ISeq {
 				Names:       []string{"Util", "HamlAttributes", "Template", "Engine"},
 				NumRequired: 0,
 				SplatIndex:  -1,
+				PostCount:   0,
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
@@ -6693,6 +7094,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"escape_html"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -6718,6 +7120,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"s"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -6755,6 +7158,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"freeze", "BOOL", "render"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -6771,6 +7175,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"h"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   3,
@@ -6797,6 +7202,7 @@ func embeddedPrelude() *bytecode.ISeq {
 										Params:      []string{"k", "v"},
 										NumRequired: 2,
 										SplatIndex:  -1,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   7,
@@ -6816,6 +7222,7 @@ func embeddedPrelude() *bytecode.ISeq {
 												Params:      []string{"dk", "dv"},
 												NumRequired: 2,
 												SplatIndex:  -1,
+												PostCount:   0,
 												KwRestSlot:  -1,
 												BlockSlot:   -1,
 												NumLocals:   3,
@@ -6843,6 +7250,7 @@ func embeddedPrelude() *bytecode.ISeq {
 										Params:      []string{"k"},
 										NumRequired: 1,
 										SplatIndex:  -1,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   2,
@@ -6866,6 +7274,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"attr_reader", "initialize", "render"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -6879,6 +7288,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"template"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   1,
 								NumLocals:   2,
@@ -6898,6 +7308,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"_scope", "locals"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   3,
@@ -6912,6 +7323,7 @@ func embeddedPrelude() *bytecode.ISeq {
 										Params:      []string{"k", "v"},
 										NumRequired: 2,
 										SplatIndex:  -1,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   2,
@@ -6946,6 +7358,7 @@ func embeddedPrelude() *bytecode.ISeq {
 				Names:       []string{"ParseError", "InvalidOption", "MissingArgument", "InvalidArgument", "AmbiguousOption", "AmbiguousArgument", "NeedlessArgument", "Struct", "new", "Switch"},
 				NumRequired: 0,
 				SplatIndex:  -1,
+				PostCount:   0,
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
@@ -6961,6 +7374,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"attr_reader", "initialize", "reason", "message", "to_s", "recover"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -6978,6 +7392,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"args"},
 								NumRequired: 0,
 								SplatIndex:  0,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -6994,6 +7409,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -7007,6 +7423,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"class", "reason"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -7024,6 +7441,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"reason", "args", "join"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -7041,6 +7459,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"argv"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   2,
@@ -7058,6 +7477,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"reason"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -7072,6 +7492,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -7088,6 +7509,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"reason"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -7102,6 +7524,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -7118,6 +7541,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"reason"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -7132,6 +7556,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -7148,6 +7573,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"reason"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -7162,6 +7588,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -7178,6 +7605,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"reason"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -7192,6 +7620,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -7208,6 +7637,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"reason"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -7222,6 +7652,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -7244,6 +7675,7 @@ func embeddedPrelude() *bytecode.ISeq {
 				Names:       []string{"attr_reader", "counter", "initialize", "open", "create", "close", "close!", "unlink", "delete", "chmod", "respond_to_missing?", "method_missing"},
 				NumRequired: 0,
 				SplatIndex:  -1,
+				PostCount:   0,
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
@@ -7260,6 +7692,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"@counter"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -7281,6 +7714,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"basename", "tmpdir"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwNames:     []string{"mode"},
 						KwRequired:  []bool{false},
 						KwRestSlot:  3,
@@ -7307,6 +7741,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"to_s", "Process", "pid", "Tempfile", "counter", "rand", "File", "join", "exist?", "@path"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   2,
@@ -7327,6 +7762,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"@file", "@closed", "File", "@path", "open"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -7341,6 +7777,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"args"},
 						NumRequired: 0,
 						SplatIndex:  0,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   1,
 						NumLocals:   2,
@@ -7359,6 +7796,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"basename", "tmpdir"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  2,
 						BlockSlot:   -1,
 						NumLocals:   4,
@@ -7374,6 +7812,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"unlink_now"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -7388,6 +7827,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"close"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -7401,6 +7841,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"@path", "File", "exist?", "unlink"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -7418,6 +7859,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"mode"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -7433,6 +7875,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"name", "include_private"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -7448,6 +7891,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"name", "args"},
 						NumRequired: 1,
 						SplatIndex:  1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   2,
 						NumLocals:   3,
@@ -7471,6 +7915,7 @@ func embeddedPrelude() *bytecode.ISeq {
 				Names:       []string{"@warning_categories", "warn", "extend"},
 				NumRequired: 0,
 				SplatIndex:  -1,
+				PostCount:   0,
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
@@ -7483,6 +7928,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Names:       []string{"[]", "[]=", "categories"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -7504,6 +7950,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"category"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -7527,6 +7974,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"category", "flag"},
 								NumRequired: 2,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   3,
@@ -7541,6 +7989,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Names:       []string{"@warning_categories", "keys"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -7558,6 +8007,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"message"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwNames:     []string{"category"},
 						KwRequired:  []bool{false},
 						KwRestSlot:  -1,
diff --git a/internal/vm/vm.go b/internal/vm/vm.go
index 1fef230c..e956b541 100644
--- a/internal/vm/vm.go
+++ b/internal/vm/vm.go
@@ -1144,6 +1144,17 @@ func (vm *VM) bindKeywords(iseq *bytecode.ISeq, args *[]object.Value, noKW bool)
 	return kwargs
 }
 
+// iseqPostCount reports how many positional parameters bind from the TAIL of the
+// argument list: the ones after a *splat, or — when there is none — the trailing
+// required run recorded as bytecode.ISeq.PostCount. It is MRI's param.post_num
+// (vm_core.h), which exists in both shapes.
+func iseqPostCount(is *bytecode.ISeq) int {
+	if is.SplatIndex >= 0 {
+		return len(is.Params) - is.SplatIndex - 1
+	}
+	return is.PostCount
+}
+
 // applyKWSplat is the VM half of a `**kw` call site: it drops an EMPTY keyword
 // splat from the argument list and returns the list to pass together with the
 // call's keyword/positional verdict for what is left.
@@ -1286,7 +1297,14 @@ func (vm *VM) exec(iseq *bytecode.ISeq, self object.Value, args []object.Value,
 	}
 	// minReq is the true minimum arity: the leading required params plus any
 	// required "post" params after a *splat (def m(a,*b,c) requires 2, not 1).
-	minReq := iseqRequiredPositional(iseq)
+	// iseqPostCount is the number of positional parameters that bind from the TAIL
+	// of the argument list: the slots after a *splat, or — with no splat —
+	// iseq.PostCount, the trailing required run of `def m(a=1, b)`.
+	npost := iseqPostCount(iseq)
+	// MRI's min_argc is lead_num + post_num whether or not there is a rest
+	// parameter (setup_parameters_complex, vm_args.c v3_4_0:595), so a post
+	// parameter with no splat is required too: `def m(a=1, b)` rejects m().
+	minReq := iseqRequiredPositional(iseq) + iseq.PostCount
 	if len(args) < minReq || (iseq.SplatIndex < 0 && len(args) > len(iseq.Params)) {
 		var expected string
 		switch {
@@ -1315,10 +1333,7 @@ func (vm *VM) exec(iseq *bytecode.ISeq, self object.Value, args []object.Value,
 	// (which is what rbgo did) makes every optional before a post parameter look
 	// supplied, and it is then left nil because the default-filling prologue is
 	// skipped.
-	nPosGiven := len(args)
-	if iseq.SplatIndex >= 0 {
-		nPosGiven -= len(iseq.Params) - iseq.SplatIndex - 1
-	}
+	nPosGiven := len(args) - npost
 	env := vm.getEnv()
 	env.parent, env.kwargs, env.captured = parentEnv, kwargs, false
 	if iseq.NumLocals <= len(env.inline) {
@@ -1354,6 +1369,20 @@ func (vm *VM) exec(iseq *bytecode.ISeq, self object.Value, args []object.Value,
 				env.slots[si+1+j] = args[srcIdx]
 			}
 		}
+	} else if npost > 0 {
+		// Post parameters with no splat (`def m(a=1, b)`). MRI binds them from the
+		// TAIL first and shrinks the argument list, so the optionals in front see
+		// only what is left (args_setup_post_parameters then
+		// args_setup_opt_parameters, vm_args.c v3_4_0:887-892). nPosGiven above is
+		// that remainder, which is what the default-filling prologue reads.
+		npre := len(iseq.Params) - npost
+		if nPosGiven < npre {
+			npre = nPosGiven
+		}
+		copy(env.slots[:npre], args[:npre])
+		for j := 0; j < npost; j++ {
+			env.slots[len(iseq.Params)-npost+j] = args[len(args)-npost+j]
+		}
 	} else {
 		copy(env.slots, args)
 	}

From 080a301b38d91bfb24607dcfadba0ef1680f4e57 Mon Sep 17 00:00:00 2001
From: tannevaled <tannevaled@users.noreply.github.com>
Date: Fri, 25 Sep 2026 07:48:52 +0200
Subject: [PATCH 4/6] vm: a bare `super` forwards a positional Hash as
 positional; whitebox tests
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

zsuperArgs appended the method's keyword parameters as a trailing hash only
when non-empty, and the send carried no keyword flag, so

    class P; def go(*a, **k); [a, k]; end; end
    class C < P; def go(*a, **k); super; end; end
    C.new.go({})

forwarded [{}] with no flag, the callee peeled the {} back into keywords, and
the positional Hash disappeared. MRI compiles a zsuper of a method with keyword
parameters with VM_CALL_KW_SPLAT (compile.c v3_4_0, the NODE_ZSUPER arm), so the
hash is a keyword argument; ignore_keyword_hash_p then drops it when empty AND
clears the keyword bit, which is what makes the argument before it positional.
zsuperArgs now always appends the hash and reports kwSplat, and the OpInvokeSuper
handler routes it through applyKWSplat like every other keyword-splat site.
Verified against MRI 4.0.5 for `super`, `super(*a, **k)` and `super(...)`.

Tests, all pinned to MRI 4.0.5 output:

  internal/compiler — FlagSendNoKW/FlagSendKWSplat over 27 written call shapes
  (call, splat, block-pass, yield, super, `...` forwarding, setters), the two
  lastArgIsPositional arms no call site reaches, the empty-kwsplat lowering on
  both sides of the call/non-call split, paramCheckName, postCountNoSplat and
  the 20 duplicated-argument-name shapes including every exemption.

  internal/vm — applyKWSplat's four arms (no flag, empty splat dropped,
  non-empty kept, tail not a Hash), iseqPostCount in both encodings,
  setSendNoKW, and 27 end-to-end programs.

  internal/aot — the guard for the trap this lane hit before: a frozen ISeq
  tree must carry PostCount out AND BACK with its value, in the nested child
  too, because an emitter that drops a field produces a byte-identical
  regeneration and looks fine. Plus the lowered sends stating the verdict.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 internal/aot/wave29_fields_test.go      |  80 +++++++
 internal/compiler/wave29_kwargs_test.go | 265 ++++++++++++++++++++++++
 internal/vm/vm.go                       |  31 ++-
 internal/vm/wave29_kwargs_test.go       | 250 ++++++++++++++++++++++
 4 files changed, 617 insertions(+), 9 deletions(-)
 create mode 100644 internal/aot/wave29_fields_test.go
 create mode 100644 internal/compiler/wave29_kwargs_test.go
 create mode 100644 internal/vm/wave29_kwargs_test.go

diff --git a/internal/aot/wave29_fields_test.go b/internal/aot/wave29_fields_test.go
new file mode 100644
index 00000000..2d74ceeb
--- /dev/null
+++ b/internal/aot/wave29_fields_test.go
@@ -0,0 +1,80 @@
+package aot
+
+import (
+	"regexp"
+	"strings"
+	"testing"
+
+	"github.com/go-embedded-ruby/ruby/internal/bytecode"
+)
+
+// TestFreezeCarriesPostCount is the guard for the failure mode a frozen prelude
+// cannot show you: the emitter silently omits a new ISeq field, the regenerated
+// file comes back byte-identical, everything looks fine, and every AOT-loaded
+// frame has lost the information.
+//
+// It is not enough that the field appears — it has to come back with the value
+// it went in with, including inside a nested child ISeq, where a per-scope
+// emitter is most likely to skip it.
+func TestFreezeCarriesPostCount(t *testing.T) {
+	child := &bytecode.ISeq{
+		Name: "m", Params: []string{"a", "b"}, SplatIndex: -1, PostCount: 1,
+		KwRestSlot: -1, BlockSlot: -1, NumLocals: 2,
+		Insns: []bytecode.Instr{{Op: bytecode.OpPushNil}, {Op: bytecode.OpReturn}},
+	}
+	top := &bytecode.ISeq{
+		Name: "<main>", SplatIndex: -1, PostCount: 0, KwRestSlot: -1, BlockSlot: -1,
+		Insns:    []bytecode.Instr{{Op: bytecode.OpPushNil}, {Op: bytecode.OpReturn}},
+		Children: []*bytecode.ISeq{child},
+	}
+	src := FreezeISeq(top, "p", "fn", "")
+	if n := strings.Count(src, "PostCount:"); n != 2 {
+		t.Fatalf("PostCount emitted %d times for a 2-ISeq tree, want 2:\n%s", n, src)
+	}
+	// go/format aligns the struct keys, so match past the padding.
+	if !regexp.MustCompile(`PostCount:\s+1,`).MatchString(src) {
+		t.Errorf("the child's PostCount: 1 did not survive the freeze:\n%s", src)
+	}
+	if !regexp.MustCompile(`PostCount:\s+0,`).MatchString(src) {
+		t.Errorf("the top-level PostCount: 0 was not written explicitly:\n%s", src)
+	}
+}
+
+// TestFreezeCarriesSendFlags: Instr.Flags already carried FlagSendExplicit, and
+// the keyword/positional verdict rides the same field. A send flagged only
+// FlagSendNoKW must survive, which the older "omit zero" emitter would still do
+// — the risk is a future emitter that special-cases the visibility bit.
+func TestFreezeCarriesSendFlags(t *testing.T) {
+	iseq := &bytecode.ISeq{
+		Name: "<main>", SplatIndex: -1, KwRestSlot: -1, BlockSlot: -1,
+		Names: []string{"f"},
+		Insns: []bytecode.Instr{
+			{Op: bytecode.OpPushSelf},
+			{Op: bytecode.OpSend, A: 0, B: 0, Flags: bytecode.FlagSendNoKW},
+			{Op: bytecode.OpReturn},
+		},
+	}
+	src := FreezeISeq(iseq, "p", "fn", "")
+	if !regexp.MustCompile(`Flags:\s*2`).MatchString(src) {
+		t.Errorf("FlagSendNoKW (2) did not survive the freeze:\n%s", src)
+	}
+}
+
+// TestLoweredSendStatesTheKeywordVerdict: AOT-lowered Go has to say what the
+// interpreter's OpSend handler says, or an AOT-built binary would bind
+// `f(1, 2, h)` as keywords where the interpreter binds it positionally.
+func TestLoweredSendStatesTheKeywordVerdict(t *testing.T) {
+	positional := mainSrc(t, "h = {k: 1}\nputs(h)")
+	if !strings.Contains(positional, "vm.setSendNoKW(true)") {
+		t.Errorf("a positional last argument did not state its verdict:\n%s", positional)
+	}
+	keywords := mainSrc(t, "puts(k: 1)")
+	if !strings.Contains(keywords, "vm.setSendNoKW(false)") {
+		t.Errorf("a keyword last argument did not state its verdict:\n%s", keywords)
+	}
+	// A send carrying a literal block takes the other arm of emitSend.
+	withBlock := mainSrc(t, "h = {k: 1}\n[1].each { |x| puts(h) }")
+	if !strings.Contains(withBlock, "vm.setSendNoKW(true)") {
+		t.Errorf("the literal-block arm did not state its verdict:\n%s", withBlock)
+	}
+}
diff --git a/internal/compiler/wave29_kwargs_test.go b/internal/compiler/wave29_kwargs_test.go
new file mode 100644
index 00000000..251bf917
--- /dev/null
+++ b/internal/compiler/wave29_kwargs_test.go
@@ -0,0 +1,265 @@
+package compiler
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/go-embedded-ruby/ruby/internal/bytecode"
+	"github.com/go-ruby-parser/parser/ast"
+)
+
+// lastSendFlags returns the Flags of the deepest-last send-shaped instruction in
+// the ISeq tree: children first (a `super` or a `yield` lives in the method body
+// the source wraps it in), then this scope, scanning backwards. Every construct
+// under test lowers to exactly one send of interest, and it is the last one
+// written.
+func lastSendFlags(iseq *bytecode.ISeq) (int, bool) {
+	for i := len(iseq.Children) - 1; i >= 0; i-- {
+		if f, ok := lastSendFlags(iseq.Children[i]); ok {
+			return f, true
+		}
+	}
+	for i := len(iseq.Insns) - 1; i >= 0; i-- {
+		switch iseq.Insns[i].Op {
+		case bytecode.OpSend, bytecode.OpSendArray, bytecode.OpSendBlockArg,
+			bytecode.OpSendArrayBlockArg, bytecode.OpInvokeBlock,
+			bytecode.OpInvokeBlockArray, bytecode.OpInvokeSuper, bytecode.OpInvokeSuperArray:
+			return iseq.Insns[i].Flags, true
+		}
+	}
+	return 0, false
+}
+
+func sendFlagsOf(t *testing.T, src string) int {
+	t.Helper()
+	iseq, err := compileString(src)
+	if err != nil {
+		t.Fatalf("compile %q: %v", src, err)
+	}
+	f, ok := lastSendFlags(iseq)
+	if !ok {
+		t.Fatalf("no send instruction compiled for %q", src)
+	}
+	return f
+}
+
+// TestSendNoKWFlagAtTheCallSite pins the compile-time half of MRI's
+// keyword/positional decision: FlagSendNoKW is set exactly when the last written
+// argument is something other than a hash literal, which is the only case
+// go-ruby-parser v0.3.0 lets the compiler decide (setup_parameters_complex reads
+// VM_CALL_KWARG / VM_CALL_KW_SPLAT, vm_args.c v3_4_0:591).
+func TestSendNoKWFlagAtTheCallSite(t *testing.T) {
+	for _, tc := range []struct {
+		src   string
+		noKW  bool
+		kwspl bool
+	}{
+		{src: "f(1, 2, h)", noKW: true},                       // a local/method value: positional
+		{src: "f(1, 2, k: 42)", noKW: false},                  // literal keywords
+		{src: "f(1, 2, {k: 42})", noKW: false},                // SAME AST as the line above (parser gap)
+		{src: "f(1, 2, **h)", noKW: false, kwspl: true},       // a keyword splat
+		{src: "f(*a)", noKW: true},                            // a splat is not keywords
+		{src: "f(*a, h)", noKW: true},                         // splat + positional tail
+		{src: "f(*a, **h)", noKW: false, kwspl: true},         // splat + keyword splat
+		{src: "f()", noKW: false},                             // no last argument to protect
+		{src: "f(1, &blk)", noKW: true},                       // a block-pass is not an argument
+		{src: "f(k: 1, &blk)", noKW: false},                   // ... even parked before the keywords
+		{src: "o.m(x)", noKW: true},                           // explicit receiver keeps both flags
+		{src: "f(1) { }", noKW: true},                         // literal block, static argc
+		{src: "f(*a) { }", noKW: true},                        // literal block, array argc
+		{src: "yield x", noKW: true},                          // yield is an ordinary call site
+		{src: "yield(k: 1)", noKW: false},                     //
+		{src: "yield(*a, **h)", noKW: false, kwspl: true},     //
+		{src: "def m; super(x); end", noKW: true},             // so is an explicit super
+		{src: "def m; super(k: 1); end", noKW: false},         //
+		{src: "def m; super(*a, **h); end", kwspl: true},      //
+		{src: "def m(...); g(...); end", kwspl: true},         // `...` forwards a kwsplat
+		{src: "def m(...); super(...); end", kwspl: true},     //
+		{src: "def m; super; end", noKW: false},               // bare super forwards keywords AS keywords
+		{src: "a[i] = v", noKW: true},                         // a setter is a call site too
+		{src: "a[*i] = v", noKW: true},                        //
+		{src: "o.x = h", noKW: true},                          //
+		{src: "f(1, 2, h, &blk)", noKW: true},                 // block-pass after the positional tail
+		{src: "f(1, 2, **h, &blk)", noKW: false, kwspl: true}, //
+	} {
+		src := tc.src
+		if strings.HasPrefix(src, "def m; super") || strings.HasPrefix(src, "def m(...)") {
+			// A super/forward only compiles inside a def; the helper already wraps it.
+			src = "class K\n" + src + "\nend"
+		}
+		flags := sendFlagsOf(t, src)
+		if got := flags&bytecode.FlagSendNoKW != 0; got != tc.noKW {
+			t.Errorf("%q: FlagSendNoKW = %v, want %v", tc.src, got, tc.noKW)
+		}
+		if got := flags&bytecode.FlagSendKWSplat != 0; got != tc.kwspl {
+			t.Errorf("%q: FlagSendKWSplat = %v, want %v", tc.src, got, tc.kwspl)
+		}
+	}
+}
+
+// TestLastArgIsPositional drives the helper directly over the shapes the call
+// compilers cannot reach: an empty list, and a list that is nothing but a
+// block-pass (both have no last ARGUMENT, so neither is protected).
+func TestLastArgIsPositional(t *testing.T) {
+	if lastArgIsPositional(nil) {
+		t.Error("no arguments: want false")
+	}
+	if lastArgIsPositional([]ast.Node{&ast.BlockPass{Value: &ast.VarRef{Name: "b"}}}) {
+		t.Error("only a block-pass: want false")
+	}
+	if !lastArgIsPositional([]ast.Node{&ast.IntLit{Value: 1}}) {
+		t.Error("an integer literal: want true")
+	}
+	if lastArgIsPositional([]ast.Node{&ast.HashLit{}}) {
+		t.Error("a hash literal: want false (the parser cannot say whether it was braced)")
+	}
+}
+
+// TestEmptyKwSplatIsAppendedForACall: the compiler no longer decides about an
+// empty `**kw` — it always concatenates the hash and lets the VM drop it
+// (ignore_keyword_hash_p, vm_args.c v3_4_0:506). The old `empty?` test is what
+// disappeared, so its absence is what this checks; the non-call uses of
+// compileSplatItems keep it.
+func TestEmptyKwSplatIsAppendedForACall(t *testing.T) {
+	hasEmptyQ := func(src string) bool {
+		iseq, err := compileString(src)
+		if err != nil {
+			t.Fatalf("compile %q: %v", src, err)
+		}
+		for _, in := range iseq.Insns {
+			if in.Op == bytecode.OpSend && iseq.Names[in.A] == "empty?" {
+				return true
+			}
+		}
+		return false
+	}
+	if hasEmptyQ("f(*a, **h)") {
+		t.Error("a call argument list still tests the kwsplat for emptiness in the compiler")
+	}
+	// A multiple-assignment index TARGET and an index op-assign are not call
+	// argument lists compiled by compileCall; they keep the older lowering.
+	if !hasEmptyQ("a[*i, **h] += 1") {
+		t.Error("an index op-assign should keep the compiler-side empty-kwsplat drop")
+	}
+	if !hasEmptyQ("a[*i, **h], b = 1, 2") {
+		t.Error("a masgn index target should keep the compiler-side empty-kwsplat drop")
+	}
+}
+
+// TestDuplicatedArgumentName pins shadowing_lvar_0 (parse.y v3_4_0:13589),
+// including the is_private_local_id exemption (:13578) and the anonymous forms,
+// which declare no name at all. Every expectation was run against MRI 4.0.5.
+func TestDuplicatedArgumentName(t *testing.T) {
+	for _, tc := range []struct {
+		src    string
+		refuse bool
+	}{
+		{"def m(a, a); end", true},
+		{"def m(a, *a); end", true},
+		{"def m(a, *b, a); end", true},
+		{"def m(a, a:); end", true},
+		{"def m(a, **a); end", true},
+		{"def m(a, b: 1, &a); end", true},
+		{"proc { |x, x| }", true},
+		{"proc { |*y, y| }", true},
+		{"proc { |x; x| }", true},
+		{"proc { |; q, q| }", true},
+		{"proc { |a, &a| }", true},
+		{"def m(_, _); end", false},
+		{"def m(_a, _a); end", false},
+		{"proc { |_x; _x| }", false},
+		{"def m(*, **, &); end", false},
+		{"def m(...); end", false},
+		{"def m(a, b); end", false},
+		{"z = 1; proc { |; z| }", false},
+		{"def m(a, (b, c)); end", false},
+		{"proc { |(a, b), (c, d)| }", false},
+	} {
+		_, err := compileString(tc.src)
+		refused := err != nil && strings.Contains(err.Error(), "duplicated argument name")
+		if refused != tc.refuse {
+			t.Errorf("%q: refused = %v (err %v), want %v", tc.src, refused, err, tc.refuse)
+		}
+	}
+}
+
+// TestParamCheckName drives the sigil stripping directly, including the entries
+// only a block's folded parameter list produces.
+func TestParamCheckName(t *testing.T) {
+	for in, want := range map[string]string{
+		"a":      "a",
+		"**rest": "rest",
+		"*":      "",
+		"**":     "",
+		"&":      "",
+		"&blk":   "blk",
+		"kw:":    "kw",
+		"_":      "",
+		"_x":     "",
+		"(0)":    "",
+		"":       "",
+	} {
+		if got := paramCheckName(in); got != want {
+			t.Errorf("paramCheckName(%q) = %q, want %q", in, got, want)
+		}
+	}
+}
+
+// TestPostCountNoSplat pins the count against the parameter shapes MRI allows.
+// An optional AFTER a post parameter is a SyntaxError, so the optionals are one
+// contiguous run and the post count is the distance from the last of them to the
+// end (args_setup_post_parameters, vm_args.c v3_4_0:887).
+func TestPostCountNoSplat(t *testing.T) {
+	d := &ast.IntLit{Value: 1}
+	for _, tc := range []struct {
+		name     string
+		nparams  int
+		defaults []ast.Node
+		splat    int
+		want     int
+	}{
+		{"no optional at all", 2, []ast.Node{nil, nil}, -1, 0},
+		{"m(a=1, b)", 2, []ast.Node{d, nil}, -1, 1},
+		{"m(a, b=2, c)", 3, []ast.Node{nil, d, nil}, -1, 1},
+		{"m(a, b=1, c=2, d)", 4, []ast.Node{nil, d, d, nil}, -1, 1},
+		{"m(a=5, b, c, d)", 4, []ast.Node{d, nil, nil, nil}, -1, 3},
+		{"m(a, b=1) — trailing optional", 2, []ast.Node{nil, d}, -1, 0},
+		{"a splat owns its own post run", 4, []ast.Node{nil, d, nil, nil}, 2, 0},
+	} {
+		if got := postCountNoSplat(tc.nparams, tc.defaults, tc.splat); got != tc.want {
+			t.Errorf("%s: postCountNoSplat = %d, want %d", tc.name, got, tc.want)
+		}
+	}
+}
+
+// TestPostCountIsCompiled checks the field actually lands on the ISeq for both a
+// method and a block, and stays 0 for the shapes it does not describe.
+func TestPostCountIsCompiled(t *testing.T) {
+	methodPost := func(src string) (int, int) {
+		iseq, err := compileString(src)
+		if err != nil {
+			t.Fatalf("compile %q: %v", src, err)
+		}
+		child := iseq.Children[0]
+		return child.PostCount, child.NumRequired
+	}
+	if got, req := methodPost("def m(a=1, b); end"); got != 1 || req != 0 {
+		t.Errorf("def m(a=1, b): PostCount=%d NumRequired=%d, want 1/0", got, req)
+	}
+	if got, req := methodPost("def m(a, b=2, c); end"); got != 1 || req != 1 {
+		t.Errorf("def m(a, b=2, c): PostCount=%d NumRequired=%d, want 1/1", got, req)
+	}
+	if got, _ := methodPost("def m(a, b); end"); got != 0 {
+		t.Errorf("def m(a, b): PostCount=%d, want 0", got)
+	}
+	if got, _ := methodPost("def m(a, b=9, *c, d); end"); got != 0 {
+		t.Errorf("a splat shape records its post run through SplatIndex, not PostCount: got %d", got)
+	}
+	blk, err := compileString("f { |a=5, b, c, d| }")
+	if err != nil {
+		t.Fatalf("compile block: %v", err)
+	}
+	if got := blk.Children[0].PostCount; got != 3 {
+		t.Errorf("{ |a=5, b, c, d| }: PostCount=%d, want 3", got)
+	}
+}
diff --git a/internal/vm/vm.go b/internal/vm/vm.go
index e956b541..8242fdd6 100644
--- a/internal/vm/vm.go
+++ b/internal/vm/vm.go
@@ -1233,8 +1233,16 @@ type frameMethod struct {
 // in the body, a filled-in optional or keyword default, and splat/post
 // rebinding are all reflected. Positional params contribute their slot value
 // (the splat slice is spliced in place); keyword params and any **kwrest are
-// gathered into a trailing hash, appended only when non-empty.
-func zsuperArgs(iseq *bytecode.ISeq, env *Env) []object.Value {
+// gathered into a trailing hash.
+//
+// kwSplat reports that the trailing hash is there because the method HAS
+// keyword parameters — MRI compiles such a zsuper with VM_CALL_KW_SPLAT
+// (compile.c v3_4_0, the NODE_ZSUPER arm), so the hash is a keyword argument and
+// an EMPTY one is dropped by ignore_keyword_hash_p, leaving whatever precedes it
+// positional. That is why the hash is appended even when empty and the drop is
+// left to applyKWSplat: `def go(*a, **k); super; end` called with one positional
+// Hash must forward it as a POSITIONAL, not turn it back into keywords.
+func zsuperArgs(iseq *bytecode.ISeq, env *Env) (args []object.Value, kwSplat bool) {
 	out := make([]object.Value, 0, len(iseq.Params)+1)
 	for i := 0; i < len(iseq.Params); i++ {
 		if i == iseq.SplatIndex {
@@ -1259,11 +1267,10 @@ func zsuperArgs(iseq *bytecode.ISeq, env *Env) []object.Value {
 				}
 			}
 		}
-		if h.Len() > 0 {
-			out = append(out, h)
-		}
+		out = append(out, h)
+		return out, true
 	}
-	return out
+	return out, false
 }
 
 func (vm *VM) exec(iseq *bytecode.ISeq, self object.Value, args []object.Value, definee *RClass, methodName string, parentEnv *Env, block, selfBlock, blockArg *Proc, methodLexScope *RClass) (execResult object.Value) {
@@ -2110,6 +2117,7 @@ func (vm *VM) exec(iseq *bytecode.ISeq, self object.Value, args []object.Value,
 					superBlk = &Proc{iseq: iseq.Children[in.C-1], env: env, defLocals: iseq.Locals, self: self, block: block, cref: lexCref, home: homeTarget(), superName: homeSuperName, superDefinee: homeSuperDefinee, superArgs: homeSuperArgs, dmBody: homeDmBody, methodCtx: fm}
 				}
 				var superArgs []object.Value
+				zsuperKW := false
 				if in.B == 1 { // bare super forwards the home method's arguments
 					if homeDmBody {
 						// MRI forbids implicit-argument super from a define_method body.
@@ -2120,7 +2128,7 @@ func (vm *VM) exec(iseq *bytecode.ISeq, self object.Value, args []object.Value,
 						// parameters, not the original argument list. This reflects any
 						// reassignment in the body, filled-in optional/keyword defaults,
 						// and splat/post rebinding.
-						superArgs = zsuperArgs(iseq, env)
+						superArgs, zsuperKW = zsuperArgs(iseq, env)
 					} else {
 						// A bare super inside a block forwards the home method's arguments
 						// as captured when the block was created (a block is transparent to
@@ -2134,8 +2142,13 @@ func (vm *VM) exec(iseq *bytecode.ISeq, self object.Value, args []object.Value,
 					copy(superArgs, stack[len(stack)-in.A:])
 					stack = stack[:len(stack)-in.A]
 				}
-				vm.sendNoKW = in.Flags&bytecode.FlagSendNoKW != 0 // MRI: the call info decides, not the callee
-				push(vm.invokeSuper(self, homeSuperDefinee, homeSuperName, superArgs, superBlk))
+				isFlags := in.Flags
+				if zsuperKW {
+					isFlags |= bytecode.FlagSendKWSplat
+				}
+				isElems, isNoKW := applyKWSplat(superArgs, isFlags)
+				vm.sendNoKW = isNoKW // MRI: the call info decides, not the callee
+				push(vm.invokeSuper(self, homeSuperDefinee, homeSuperName, isElems, superBlk))
 			case bytecode.OpInvokeSuperArray:
 				superBlk := block
 				switch {
diff --git a/internal/vm/wave29_kwargs_test.go b/internal/vm/wave29_kwargs_test.go
new file mode 100644
index 00000000..e8f2bd16
--- /dev/null
+++ b/internal/vm/wave29_kwargs_test.go
@@ -0,0 +1,250 @@
+package vm
+
+import (
+	"testing"
+
+	"github.com/go-embedded-ruby/ruby/internal/bytecode"
+	"github.com/go-embedded-ruby/ruby/internal/object"
+)
+
+// TestApplyKWSplat drives ignore_keyword_hash_p's rbgo half (vm_args.c
+// v3_4_0:506) over each arm: an empty keyword splat is dropped AND its keyword
+// bit cleared, so what is left behind is positional; a non-empty one stays and
+// keeps the call a keyword call; a site with no keyword splat at all answers
+// with whatever the compiler flagged.
+func TestApplyKWSplat(t *testing.T) {
+	empty := object.NewHash()
+	full := object.NewHash()
+	full.Set(object.SymVal("k"), object.IntValue(1))
+	one := object.IntValue(1)
+
+	t.Run("no kwsplat flag passes the compiled verdict through", func(t *testing.T) {
+		in := []object.Value{one, full}
+		got, noKW := applyKWSplat(in, 0)
+		if len(got) != 2 || noKW {
+			t.Fatalf("plain site: got %d args noKW=%v, want 2/false", len(got), noKW)
+		}
+		got, noKW = applyKWSplat(in, bytecode.FlagSendNoKW)
+		if len(got) != 2 || !noKW {
+			t.Fatalf("flagged positional site: got %d args noKW=%v, want 2/true", len(got), noKW)
+		}
+	})
+
+	t.Run("an empty kwsplat is dropped and leaves a positional tail", func(t *testing.T) {
+		got, noKW := applyKWSplat([]object.Value{one, empty}, bytecode.FlagSendKWSplat)
+		if len(got) != 1 || got[0] != one || !noKW {
+			t.Fatalf("f(1, **{}): got %v noKW=%v, want [1]/true", got, noKW)
+		}
+		// The point of the `true`: f(h, **{}) passes ONE POSITIONAL h, even though
+		// h is itself a Hash.
+		got, noKW = applyKWSplat([]object.Value{full, empty}, bytecode.FlagSendKWSplat)
+		if len(got) != 1 || got[0] != object.Value(full) || !noKW {
+			t.Fatalf("f(h, **{}): got %v noKW=%v, want [h]/true", got, noKW)
+		}
+		// f(**{}) passes no argument at all.
+		got, noKW = applyKWSplat([]object.Value{empty}, bytecode.FlagSendKWSplat)
+		if len(got) != 0 || !noKW {
+			t.Fatalf("f(**{}): got %v noKW=%v, want []/true", got, noKW)
+		}
+	})
+
+	t.Run("a non-empty kwsplat stays and keeps the call a keyword call", func(t *testing.T) {
+		got, noKW := applyKWSplat([]object.Value{one, full}, bytecode.FlagSendKWSplat)
+		if len(got) != 2 || noKW {
+			t.Fatalf("f(1, **{k: 1}): got %v noKW=%v, want 2 args/false", got, noKW)
+		}
+	})
+
+	t.Run("a kwsplat site whose tail is not a Hash", func(t *testing.T) {
+		// Reachable through `def m(...); g(...); end` when the forwarded **kw was
+		// already spliced away: nothing to drop, and the call stays a keyword call.
+		got, noKW := applyKWSplat([]object.Value{one}, bytecode.FlagSendKWSplat)
+		if len(got) != 1 || noKW {
+			t.Fatalf("tail is not a Hash: got %v noKW=%v, want 1 arg/false", got, noKW)
+		}
+		// An empty argument list cannot carry a keyword hash either.
+		got, noKW = applyKWSplat(nil, bytecode.FlagSendKWSplat)
+		if len(got) != 0 || noKW {
+			t.Fatalf("no arguments: got %v noKW=%v, want []/false", got, noKW)
+		}
+	})
+}
+
+// TestISeqPostCount: post parameters bind from the tail in both shapes MRI
+// records them in — after a *splat, and (with none) as ISeq.PostCount.
+func TestISeqPostCount(t *testing.T) {
+	withSplat := &bytecode.ISeq{Params: []string{"a", "b", "c", "d"}, SplatIndex: 2}
+	if got := iseqPostCount(withSplat); got != 1 {
+		t.Errorf("def m(a, b, *c, d): iseqPostCount = %d, want 1", got)
+	}
+	noSplat := &bytecode.ISeq{Params: []string{"a", "b"}, SplatIndex: -1, PostCount: 1}
+	if got := iseqPostCount(noSplat); got != 1 {
+		t.Errorf("def m(a=1, b): iseqPostCount = %d, want 1", got)
+	}
+	plain := &bytecode.ISeq{Params: []string{"a", "b"}, SplatIndex: -1}
+	if got := iseqPostCount(plain); got != 0 {
+		t.Errorf("def m(a, b): iseqPostCount = %d, want 0", got)
+	}
+}
+
+// TestSetSendNoKW is the seam AOT-lowered Go uses to say what an OpSend says
+// through its flags (internal/aot/level2.go, codegen.go).
+func TestSetSendNoKW(t *testing.T) {
+	vm := New(nil)
+	vm.setSendNoKW(true)
+	if !vm.sendNoKW {
+		t.Error("setSendNoKW(true) did not set the verdict")
+	}
+	vm.setSendNoKW(false)
+	if vm.sendNoKW {
+		t.Error("setSendNoKW(false) did not clear the verdict")
+	}
+}
+
+// TestKeywordsAreDecidedAtTheCallSite runs the separation end to end. Every
+// expectation was taken from MRI 4.0.5.
+func TestKeywordsAreDecidedAtTheCallSite(t *testing.T) {
+	for _, tc := range []struct{ name, src, want string }{
+		{
+			"a positional Hash is not converted to keywords",
+			`def foo(a, b, c, **hsh); hsh; end
+			 h = {key: 42}
+			 begin; foo(1, 2, 3, h); rescue ArgumentError => e; puts e.message; end`,
+			"wrong number of arguments (given 4, expected 3)",
+		},
+		{
+			"a keyword splat still is",
+			`def foo(a, b, c, **hsh); hsh; end
+			 h = {key: 42}
+			 p foo(1, 2, 3, **h)`,
+			"{key: 42}",
+		},
+		{
+			"literal keywords still are",
+			"def foo(a, b, c, **hsh); hsh; end\np foo(1, 2, 3, key: 42)",
+			"{key: 42}",
+		},
+		{
+			"a positional Hash against a key: parameter",
+			`def foo(key: 1); key; end
+			 h = {key: 42}
+			 begin; foo(h); rescue ArgumentError => e; puts e.message; end`,
+			"wrong number of arguments (given 1, expected 0)",
+		},
+		{
+			"separated for (*args, **kwargs)",
+			"def m(*args, **kwargs); [args, kwargs]; end\nempty = {}\np m(empty)",
+			"[[{}], {}]",
+		},
+		{
+			"an empty keyword splat passes no argument",
+			"def m(*args, **kwargs); [args, kwargs]; end\nempty = {}\np m(**empty)",
+			"[[], {}]",
+		},
+		{
+			"an empty keyword splat leaves the argument before it positional",
+			"def m(*a); a; end\nempty = {}\nh = {k: 1}\np m(h, **empty)",
+			"[{k: 1}]",
+		},
+		{
+			"delegation through (*args, **kwargs)",
+			`def target(*args, **kwargs); [args, kwargs]; end
+			 def m(*args, **kwargs); target(*args, **kwargs); end
+			 empty = {}
+			 p m(empty)`,
+			"[[{}], {}]",
+		},
+		{
+			"delegation through (...)",
+			`def target(*args, **kwargs); [args, kwargs]; end
+			 def m(...); target(...); end
+			 empty = {}
+			 p m(empty)`,
+			"[[{}], {}]",
+		},
+		{
+			"yield carries the same verdict",
+			`def y(*args, **kwargs); yield(*args, **kwargs); end
+			 empty = {}
+			 p(y(empty) { |*a| a })`,
+			"[{}]",
+		},
+		{
+			"super carries the same verdict",
+			`class SP; def go(*a, **k); [a, k]; end; end
+			 class SC < SP; def go(*a, **k); super(*a, **k); end; end
+			 empty = {}
+			 p SC.new.go(empty)`,
+			"[[{}], {}]",
+		},
+		{
+			"a bare super forwards a positional Hash as positional",
+			`class ZP; def go(*a, **k); [a, k]; end; end
+			 class ZC < ZP; def go(*a, **k); super; end; end
+			 empty = {}
+			 p ZC.new.go(empty)`,
+			"[[{}], {}]",
+		},
+		{
+			"a bare super still forwards real keywords as keywords",
+			`class YP; def go(*a, **k); [a, k]; end; end
+			 class YC < YP; def go(*a, **k); super; end; end
+			 p YC.new.go(1, k: 2)`,
+			"[[1], {k: 2}]",
+		},
+		{
+			"super(...) forwards a positional Hash as positional",
+			`class FP; def go(*a, **k); [a, k]; end; end
+			 class FC < FP; def go(...); super(...); end; end
+			 empty = {}
+			 p FC.new.go(empty)`,
+			"[[{}], {}]",
+		},
+		{
+			"Object#send keeps the older behaviour rather than losing keywords",
+			"def m(k: 0); k; end\np 1.instance_eval { }; p send(:m, k: 7)",
+			"nil\n7",
+		},
+	} {
+		if got := runSrc(t, tc.src); got != tc.want {
+			t.Errorf("%s:\ngot  %q\nwant %q", tc.name, got, tc.want)
+		}
+	}
+}
+
+// TestPostParametersWithoutASplat runs the binding end to end, against MRI 4.0.5.
+func TestPostParametersWithoutASplat(t *testing.T) {
+	for _, tc := range []struct{ name, src, want string }{
+		{"def m(a=1, b) given one", "def m(a=1, b); [a, b]; end\np m(2)", "[1, 2]"},
+		{"def m(a=1, b) given two", "def m(a=1, b); [a, b]; end\np m(2, 3)", "[2, 3]"},
+		{
+			"def m(a=1, b) is not callable with none",
+			"def m(a=1, b); end\nbegin; m(); rescue ArgumentError => e; puts e.message; end",
+			"wrong number of arguments (given 0, expected 1..2)",
+		},
+		{
+			"def m(a=1, b) is not callable with three",
+			"def m(a=1, b); end\nbegin; m(1, 2, 3); rescue ArgumentError => e; puts e.message; end",
+			"wrong number of arguments (given 3, expected 1..2)",
+		},
+		{"def n(a, b=2, c)", "def n(a, b=2, c); [a, b, c]; end\np n(1, 3)", "[1, 2, 3]"},
+		{"a block pads to lead+post", "p([[1, 2]].map { |a=5, b, c, d| [a, b, c, d] })", "[[5, 1, 2, nil]]"},
+		{"a block with everything supplied", "p(proc { |a=5, b, c, d| [a, b, c, d] }.call(1, 2, 3))", "[5, 1, 2, 3]"},
+		{"Proc#arity counts lead+post", "p(proc { |a=5, b, c, d| }.arity)", "3"},
+		{"a lambda's arity is negative", "p(->(a=1, b) {}.arity)", "-2"},
+		{"a lambda binds post first", "p(->(a=1, b) { [a, b] }.call(5))", "[1, 5]"},
+		// The splat shape: post binds from the tail, and the optional in front of
+		// it falls back to its DEFAULT rather than eating the post argument.
+		{"def q(a, b=9, *c, d)", "def q(a, b=9, *c, d); [a, b, c, d]; end\np q(1, 2)", "[1, 9, [], 2]"},
+		{"def q(a, b=9, *c, d) with more", "def q(a, b=9, *c, d); [a, b, c, d]; end\np q(1, 2, 3, 4)", "[1, 2, [3], 4]"},
+		{
+			"a block's optionals fill left to right after the post reservation",
+			"p(proc { |a, b=5, c=6, *d, e, f| [a, b, c, d, e, f] }.call(1))",
+			"[1, 5, 6, [], nil, nil]",
+		},
+	} {
+		if got := runSrc(t, tc.src); got != tc.want {
+			t.Errorf("%s:\ngot  %q\nwant %q", tc.name, got, tc.want)
+		}
+	}
+}

From 2aab4af30d242de9958f3a92080768b120df2b5a Mon Sep 17 00:00:00 2001
From: tannevaled <tannevaled@users.noreply.github.com>
Date: Fri, 25 Sep 2026 07:52:51 +0200
Subject: [PATCH 5/6] compiler: `_1` .. `_9` are reserved, so binding one as a
 local is a SyntaxError
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`_1 = 0` — at the top level, inside a block, as a multiple-assignment target, as
a `for` variable, as a pattern binder — is a SyntaxError in MRI, because the
name belongs to the numbered-parameter mechanism and a local of that name would
shadow it. rbgo bound it as an ordinary local, which then made
`_1 = 0; proc { _1 }.call("a")` answer 0 instead of refusing the program.

The reserved set is exactly `_1`..`_9`: MRI accepts `_0`, `_10` and `@_1`,
all verified against 4.0.5. storeLocal is the single place rbgo creates or
writes a named local, so the check lives there and covers every written form at
once.

Not done, and why: MRI also refuses `_1` as a PARAMETER (`proc { |_1| }`,
`def m(_1)`), but go-ruby-parser v0.3.0 SYNTHESISES the numbered parameters into
Block.Params — `proc { _1 + _2 }` arrives as params ["_1", "_2"] — so a written
`|_1|` and a synthesised one are the same tree and the compiler cannot refuse
one without refusing the other. Same shape of parser gap as the braced hash
literal; it needs the parser to mark what it synthesised.

language/numbered_parameters_spec.rb 11 -> 14.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 internal/compiler/compiler.go | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/internal/compiler/compiler.go b/internal/compiler/compiler.go
index f5cb9ae7..b20c77cf 100644
--- a/internal/compiler/compiler.go
+++ b/internal/compiler/compiler.go
@@ -3046,7 +3046,24 @@ func (c *Compiler) bindLocal(name string) (slot, depth int) {
 
 // storeLocal emits a SetLocal for name, resolving an existing local or
 // allocating a fresh slot, mirroring ast.Assign.
+// isNumberedParamName reports whether name is one of the nine names Ruby
+// reserves for a block's numbered parameters: `_1` through `_9`, and nothing
+// else — `_0` and `_10` are ordinary identifiers, and so is `@_1`.
+func isNumberedParamName(name string) bool {
+	return len(name) == 2 && name[0] == '_' && name[1] >= '1' && name[1] <= '9'
+}
+
 func (c *Compiler) storeLocal(name string) {
+	// Binding `_1`..`_9` as a local is a SyntaxError in MRI wherever the binding
+	// is written — a plain assignment, an op-assign, a multiple-assignment target,
+	// a `for` variable, a pattern binder — because the name belongs to the
+	// numbered-parameter mechanism and a local of that name would shadow it
+	// (parse.y v3_4_0, the numparam checks around assignable_gen). storeLocal is
+	// the single place rbgo creates or writes a named local, so it is the one
+	// place that has to say so.
+	if isNumberedParamName(name) {
+		c.fail("%s is reserved for numbered parameters", name)
+	}
 	slot, depth := c.bindLocal(name)
 	c.cur().emit(bytecode.OpSetLocal, slot, depth)
 }

From 06661514c94e9d16669c3eae9ab442502acc0e27 Mon Sep 17 00:00:00 2001
From: tannevaled <tannevaled@users.noreply.github.com>
Date: Fri, 25 Sep 2026 08:00:17 +0200
Subject: [PATCH 6/6] compiler: the implicit `it` parameter is nameless, as in
 MRI
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`proc { it }` gave rbgo a block parameter NAMED `it`, so `#parameters` answered
[[:opt, :it]] where MRI answers [[:opt]], `binding.local_variables` listed
`:it`, `binding.local_variable_get(:it)` returned the argument instead of
raising, `local_variable_set(:it, …)` overwrote it, and `eval("it")` reached it.
MRI's implicit parameter is not an entry in the local table the program can
reach; only the compiler, which resolved it lexically, can see it — which is why
`defined?(it)` inside the block is still "local-variable".

go-ruby-parser v0.3.0 SYNTHESISES `it` and `_1`..`_9` into Block.Params, so a
written `|it|` and an implicit one arrive as the same name. It does leave one
trace, and it is total over every written shape: a written parameter list pads
Defaults to one entry per parameter (nil where there is no default), a
synthesised one leaves Defaults empty. blockParamsAreImplicit reads that, and
the test pins it on all thirteen written shapes so a parser that starts padding
fails loudly instead of letting `it` become visible again.

The names are blanked AFTER the body is compiled, so resolution inside the body
used the real name and the ISeq that remains carries none — Params for
#parameters, Locals for Binding.

`_1`..`_9` are deliberately left visible. MRI names them in #parameters
([[:opt, :_1]]) either way, and ruby/spec pins their Binding visibility by
VERSION: `ruby_version_is ""..."4.0"` expects them listed, `ruby_version_is
"4.0"` expects them hidden. rbgo reports RUBY_VERSION "3.4.1", so the first is
the behaviour it has claimed; hiding them belongs with the version bump. (That
mismatch is worth routing on its own: the stated target is MRI 4.0.5, and at
3.4.1 every `ruby_version_is "4.0"` block in the corpus — 65 of them across 48
files — is skipped.)

language/it_parameter_spec.rb 11 -> 15.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 internal/compiler/compiler.go           |  50 ++++++++++
 internal/compiler/wave29_kwargs_test.go | 116 ++++++++++++++++++++++++
 internal/vm/wave29_kwargs_test.go       |  50 ++++++++++
 3 files changed, 216 insertions(+)

diff --git a/internal/compiler/compiler.go b/internal/compiler/compiler.go
index b20c77cf..ddd4bcb9 100644
--- a/internal/compiler/compiler.go
+++ b/internal/compiler/compiler.go
@@ -1927,12 +1927,62 @@ func (c *Compiler) compileBlock(blk *ast.Block) int {
 	c.compileBody(blk.Body)
 	c.ctxs = c.ctxs[:len(c.ctxs)-1]
 	c.cur().emit(bytecode.OpReturn, 0, 0)
+	hideImplicitBlockParams(b, blk, positionals)
 	child := c.pop().build()
 	idx := len(parent.children)
 	parent.children = append(parent.children, child)
 	return idx
 }
 
+// blockParamsAreImplicit reports whether the parser SYNTHESISED this block's
+// parameter list from `it` / `_1`..`_9` in its body, rather than reading a
+// written `|...|`.
+//
+// go-ruby-parser v0.3.0 records no flag for it, but it does leave a reliable
+// trace: for a written parameter list it pads Defaults to one entry per
+// parameter (nil where there is no default), and for a synthesised one it
+// leaves Defaults empty. `proc { |it| }` therefore arrives with Params ["it"]
+// and one nil Default, while `proc { it }` arrives with Params ["it"] and none
+// — the only thing that tells the two apart, since the names are identical.
+func blockParamsAreImplicit(blk *ast.Block) bool {
+	return len(blk.Defaults) < len(blk.Params)
+}
+
+// hideImplicitBlockParams takes the name off an `it` parameter the parser
+// synthesised, so the block's own frame is the only thing that can see it.
+//
+// MRI's `it` is not an entry in the local table the program can reach:
+// `-> { it }.parameters` is [[:req]] — NAMELESS — and `it` appears in no
+// `binding.local_variables`, answers no `binding.local_variable_get`, cannot be
+// set through `binding.local_variable_set` and cannot be reached by
+// `eval("it")`, while `defined?(it)` inside the block is still "local-variable"
+// because the compiler resolved it lexically. rbgo gets there by blanking the
+// name AFTER the body is compiled: resolution during the body used the real
+// name, and the ISeq that remains carries none.
+//
+// The numbered parameters `_1`..`_9` are deliberately NOT hidden. They are named
+// in #parameters ([[:opt, :_1]]) and, for the Ruby version rbgo reports
+// (RUBY_VERSION 3.4.1), they are visible to a Binding too — ruby/spec pins that
+// under `ruby_version_is ""..."4.0"` and pins the hiding only from 4.0. Hiding
+// them here would be answering a question rbgo has not yet said it is answering;
+// it belongs with the RUBY_VERSION bump.
+func hideImplicitBlockParams(b *builder, blk *ast.Block, positionals []string) {
+	if !blockParamsAreImplicit(blk) {
+		return
+	}
+	for i, name := range positionals {
+		if name != "it" {
+			continue
+		}
+		if i < len(b.locals) {
+			b.locals[i] = ""
+		}
+		if i < len(b.params) {
+			b.params[i] = ""
+		}
+	}
+}
+
 // scopeParent inspects a ClassDef/ModuleDef NamePath. It returns the parent
 // expression to evaluate (nil when none — a bare name or a leading-`::`
 // top-level name, both of which define into the global constant table) and the
diff --git a/internal/compiler/wave29_kwargs_test.go b/internal/compiler/wave29_kwargs_test.go
index 251bf917..23219a05 100644
--- a/internal/compiler/wave29_kwargs_test.go
+++ b/internal/compiler/wave29_kwargs_test.go
@@ -5,6 +5,7 @@ import (
 	"testing"
 
 	"github.com/go-embedded-ruby/ruby/internal/bytecode"
+	"github.com/go-ruby-parser/parser"
 	"github.com/go-ruby-parser/parser/ast"
 )
 
@@ -263,3 +264,118 @@ func TestPostCountIsCompiled(t *testing.T) {
 		t.Errorf("{ |a=5, b, c, d| }: PostCount=%d, want 3", got)
 	}
 }
+
+// TestNumberedParameterNameIsReserved pins the reserved set exactly: `_1`..`_9`
+// cannot be BOUND as a local anywhere, while `_0`, `_10` and `@_1` are ordinary
+// identifiers. Every expectation was run against MRI 4.0.5.
+func TestNumberedParameterNameIsReserved(t *testing.T) {
+	for _, tc := range []struct {
+		src    string
+		refuse bool
+	}{
+		{"_1 = 0", true},
+		{"_9 = 0", true},
+		{"proc { _1 = 0 }", true},
+		{"x = 1; _1 = 2", true},
+		{"_1, x = 1, 2", true},
+		{"for _1 in [1]; end", true},
+		{"begin; rescue => _1; end", true},
+		{"_0 = 0", false},
+		{"_10 = 0", false},
+		{"@_1 = 1", false},
+		{"_ = 1", false},
+		{"_1a = 1", false},
+		{"proc { _1 }", false}, // the parameter itself, synthesised by the parser
+	} {
+		_, err := compileString(tc.src)
+		refused := err != nil && strings.Contains(err.Error(), "reserved for numbered parameters")
+		if refused != tc.refuse {
+			t.Errorf("%q: refused = %v (err %v), want %v", tc.src, refused, err, tc.refuse)
+		}
+	}
+	if !isNumberedParamName("_1") || !isNumberedParamName("_9") {
+		t.Error("_1/_9 must be reserved")
+	}
+	for _, n := range []string{"_0", "_10", "_", "_a", "", "a1", "_1_"} {
+		if isNumberedParamName(n) {
+			t.Errorf("%q must not be reserved", n)
+		}
+	}
+}
+
+// TestImplicitBlockParamsAreHidden pins both halves: the discriminator that
+// tells a SYNTHESISED parameter list from a written one, and what is blanked.
+//
+// The discriminator is an artefact of go-ruby-parser v0.3.0 — a written list
+// pads Defaults to one entry per parameter, a synthesised one leaves it empty —
+// so it is pinned here on purpose: if the parser ever pads a synthesised list,
+// this fails rather than letting `it` quietly become a visible local again.
+func TestImplicitBlockParamsAreHidden(t *testing.T) {
+	blockOf := func(t *testing.T, src string) *bytecode.ISeq {
+		t.Helper()
+		iseq, err := compileString(src)
+		if err != nil {
+			t.Fatalf("compile %q: %v", src, err)
+		}
+		return iseq.Children[0]
+	}
+
+	// The discriminator, over every parameter shape the parser writes out.
+	implicit := func(src string) bool {
+		prog := mustBlock(t, src)
+		return blockParamsAreImplicit(prog)
+	}
+	for src, want := range map[string]bool{
+		"f { }":         false,
+		"f { |a| }":     false,
+		"f { |a, b| }":  false,
+		"f { |a=1| }":   false,
+		"f { |*a| }":    false,
+		"f { |it| it }": false,
+		"f { |x| it }":  false,
+		"f { it }":      true,
+		"f { _1 }":      true,
+		"f { _1 + _3 }": true,
+	} {
+		if got := implicit(src); got != want {
+			t.Errorf("blockParamsAreImplicit(%q) = %v, want %v", src, got, want)
+		}
+	}
+
+	// `it` loses its name in BOTH tables: #parameters reads Params, a Binding
+	// reads Locals.
+	itBlk := blockOf(t, "f { it }")
+	if len(itBlk.Params) != 1 || itBlk.Params[0] != "" {
+		t.Errorf("f { it }: Params = %q, want one empty name", itBlk.Params)
+	}
+	if len(itBlk.Locals) != 1 || itBlk.Locals[0] != "" {
+		t.Errorf("f { it }: Locals = %q, want one empty name", itBlk.Locals)
+	}
+	// A WRITTEN |it| keeps its name.
+	writtenIt := blockOf(t, "f { |it| it }")
+	if len(writtenIt.Params) != 1 || writtenIt.Params[0] != "it" {
+		t.Errorf("f { |it| it }: Params = %q, want [\"it\"]", writtenIt.Params)
+	}
+	// The numbered parameters keep theirs, in both tables.
+	np := blockOf(t, "f { _1 + _2 }")
+	if len(np.Params) != 2 || np.Params[0] != "_1" || np.Params[1] != "_2" {
+		t.Errorf("f { _1 + _2 }: Params = %q, want [\"_1\" \"_2\"]", np.Params)
+	}
+	if len(np.Locals) < 2 || np.Locals[0] != "_1" || np.Locals[1] != "_2" {
+		t.Errorf("f { _1 + _2 }: Locals = %q, want the numbered names kept", np.Locals)
+	}
+}
+
+// mustBlock parses src (one call carrying one block) and returns that block.
+func mustBlock(t *testing.T, src string) *ast.Block {
+	t.Helper()
+	prog, err := parser.Parse(src)
+	if err != nil {
+		t.Fatalf("parse %q: %v", src, err)
+	}
+	call, ok := prog.Body[0].(*ast.Call)
+	if !ok || call.Block == nil {
+		t.Fatalf("%q did not parse as a call carrying a block", src)
+	}
+	return call.Block
+}
diff --git a/internal/vm/wave29_kwargs_test.go b/internal/vm/wave29_kwargs_test.go
index e8f2bd16..b7e5756f 100644
--- a/internal/vm/wave29_kwargs_test.go
+++ b/internal/vm/wave29_kwargs_test.go
@@ -248,3 +248,53 @@ func TestPostParametersWithoutASplat(t *testing.T) {
 		}
 	}
 }
+
+// TestImplicitItIsInvisible runs the `it` parameter's visibility end to end,
+// against MRI 4.0.5. `it` resolves lexically inside the block and is invisible
+// to every reflective route out of it; a WRITTEN |it| is an ordinary parameter.
+func TestImplicitItIsInvisible(t *testing.T) {
+	for _, tc := range []struct{ name, src, want string }{
+		{"a lambda's it is nameless", "p(-> { it }.parameters)", "[[:req]]"},
+		{"a proc's it is nameless", "p(proc { it }.parameters)", "[[:opt]]"},
+		{"a written |it| keeps its name", "p(proc { |it| it }.parameters)", "[[:opt, :it]]"},
+		{"it is not a binding local", `p(-> { it; binding.local_variables }.call("a"))`, "[]"},
+		{
+			"binding.local_variable_get cannot reach it",
+			`begin
+			   proc { a = it; binding.local_variable_get(:it) }.call(1)
+			 rescue NameError => e
+			   puts "NameError"
+			 end`,
+			"NameError",
+		},
+		{
+			"binding.local_variable_set cannot reach it",
+			`p(-> { a = it; binding.local_variable_set(:it, :b); [a, it] }.call(:a))`,
+			"[:a, :a]",
+		},
+		{"defined?(it) is still resolved lexically", `p(-> { it; defined?(it) }.call(1))`, `"local-variable"`},
+		{"it still binds the argument", `p(-> { it }.call(7))`, "7"},
+		{"it affects arity", "p(-> { it }.arity)", "1"},
+		// The numbered parameters are NOT hidden: they are named in #parameters,
+		// and for the Ruby version rbgo reports they are visible to a Binding.
+		{"_1 keeps its name", "p(proc { _1 }.parameters)", "[[:opt, :_1]]"},
+		{"_1 is a binding local", `p(-> { _1; binding.local_variables }.call("a"))`, "[:_1]"},
+	} {
+		if got := runSrc(t, tc.src); got != tc.want {
+			t.Errorf("%s:\ngot  %q\nwant %q", tc.name, got, tc.want)
+		}
+	}
+}
+
+// TestNumberedParameterNameIsReservedAtRuntime: the refusal reaches Ruby as a
+// SyntaxError, which is the shape ruby/spec asks the question in.
+func TestNumberedParameterNameIsReservedAtRuntime(t *testing.T) {
+	src := `begin
+	          eval("_1 = 0")
+	        rescue SyntaxError => e
+	          puts e.message.include?("reserved for numbered parameters")
+	        end`
+	if got := runSrc(t, src); got != "true" {
+		t.Errorf("eval(\"_1 = 0\"): got %q, want a SyntaxError naming the reservation", got)
+	}
+}