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/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/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/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/bytecode/bytecode.go b/internal/bytecode/bytecode.go
index beed4217..9e31a3a4 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
@@ -252,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 a86f426d..ddd4bcb9 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,
@@ -477,6 +479,99 @@ 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
+	}
+}
+
+// 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...)})
 }
@@ -807,15 +902,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 +1052,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 +1066,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 +1094,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 +1298,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 +1338,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 +1660,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 +1682,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 +1691,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 +1718,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.
@@ -1663,6 +1842,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()
@@ -1689,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.
@@ -1744,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
@@ -1855,6 +2088,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 +2096,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 +2131,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
 	}
@@ -2850,7 +3096,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)
 }
@@ -3164,6 +3427,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 {
@@ -3213,6 +3486,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/compiler/wave29_kwargs_test.go b/internal/compiler/wave29_kwargs_test.go
new file mode 100644
index 00000000..23219a05
--- /dev/null
+++ b/internal/compiler/wave29_kwargs_test.go
@@ -0,0 +1,381 @@
+package compiler
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/go-embedded-ruby/ruby/internal/bytecode"
+	"github.com/go-ruby-parser/parser"
+	"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)
+	}
+}
+
+// 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/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..b203c943 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)
 }
 
@@ -1936,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 {
@@ -2206,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 f8f79fb8..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,
@@ -23,13 +24,14 @@ 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"),
 				},
 				Names:       []string{"__compare", "private", "<", "<=", ">", ">=", "==", "between?", "clamp"},
 				NumRequired: 0,
 				SplatIndex:  -1,
+				PostCount:   0,
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
@@ -38,7 +40,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 "),
@@ -49,6 +51,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"other"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   4,
@@ -59,7 +62,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),
 						},
@@ -67,6 +70,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"other"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -77,7 +81,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),
 						},
@@ -85,6 +89,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"other"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -95,7 +100,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),
 						},
@@ -103,6 +108,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"other"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -113,7 +119,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),
 						},
@@ -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,
@@ -163,7 +172,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),
@@ -189,6 +198,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"args"},
 						NumRequired: 0,
 						SplatIndex:  0,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   5,
@@ -202,7 +212,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"),
@@ -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,
@@ -231,11 +243,12 @@ 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,
 								SplatIndex:  0,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -249,7 +262,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),
@@ -258,6 +271,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"a"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -268,7 +282,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(""),
@@ -287,6 +301,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"n"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -297,11 +312,12 @@ 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,
 						SplatIndex:  0,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -311,11 +327,12 @@ 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,
 								SplatIndex:  0,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -329,11 +346,12 @@ 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,
 						SplatIndex:  1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   2,
 						NumLocals:   3,
@@ -344,11 +362,12 @@ 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,
 						SplatIndex:  0,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -358,7 +377,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 "),
@@ -374,6 +393,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"a"},
 								NumRequired: 0,
 								SplatIndex:  0,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   4,
@@ -387,13 +407,14 @@ 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"),
 						},
 						Names:       []string{"enum_for", "each"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -403,13 +424,14 @@ 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"),
 								},
 								Names:       []string{"respond_to?", "size"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -419,11 +441,12 @@ 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,
 								SplatIndex:  0,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -437,7 +460,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(""),
@@ -449,6 +472,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"args"},
 						NumRequired: 0,
 						SplatIndex:  0,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   3,
@@ -458,7 +482,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),
 								},
@@ -466,6 +490,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"a"},
 								NumRequired: 0,
 								SplatIndex:  0,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -476,13 +501,14 @@ 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),
 								},
 								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,
@@ -513,7 +540,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"),
 						},
@@ -521,6 +548,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"args"},
 						NumRequired: 0,
 						SplatIndex:  0,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -530,13 +558,14 @@ 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"),
 								},
 								Names:       []string{"respond_to?", "size"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -546,10 +575,11 @@ 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,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -563,7 +593,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"),
 						},
@@ -571,6 +601,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"args"},
 						NumRequired: 0,
 						SplatIndex:  0,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -580,13 +611,14 @@ 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"),
 								},
 								Names:       []string{"respond_to?", "size"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -596,10 +628,11 @@ 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,
+								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,
@@ -627,13 +661,14 @@ 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"),
 						},
 						Names:       []string{"enum_for", "to_a", "sort_by"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -642,13 +677,14 @@ 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"),
 								},
 								Names:       []string{"respond_to?", "size"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -658,10 +694,11 @@ 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,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -675,13 +712,14 @@ 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"),
 						},
 						Names:       []string{"enum_for", "__each_packed"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -691,13 +729,14 @@ 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"),
 								},
 								Names:       []string{"respond_to?", "size"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -707,11 +746,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -725,13 +765,14 @@ 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"),
 						},
 						Names:       []string{"enum_for", "__each_packed"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -741,13 +782,14 @@ 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"),
 								},
 								Names:       []string{"respond_to?", "size"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -757,11 +799,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -775,7 +818,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"),
 						},
@@ -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,
@@ -804,10 +849,11 @@ 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,
+								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,
@@ -852,7 +900,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),
@@ -861,6 +909,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"init"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   4,
@@ -870,11 +919,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   3,
@@ -888,11 +938,12 @@ 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,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   1,
 						NumLocals:   4,
@@ -902,7 +953,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 "),
@@ -914,6 +965,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"x"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   2,
@@ -927,11 +979,12 @@ 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,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   1,
 						NumLocals:   4,
@@ -941,7 +994,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 "),
@@ -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,
@@ -980,7 +1035,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(""),
@@ -998,6 +1053,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"args"},
 						NumRequired: 0,
 						SplatIndex:  0,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   6,
@@ -1007,11 +1063,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -1025,7 +1082,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"),
 						},
@@ -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,
@@ -1054,7 +1113,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"),
 										},
@@ -1062,6 +1121,7 @@ func embeddedPrelude() *bytecode.ISeq {
 										Params:      []string{"a"},
 										NumRequired: 0,
 										SplatIndex:  0,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   2,
@@ -1078,7 +1138,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"),
 						},
@@ -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,
@@ -1107,7 +1169,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"),
 										},
@@ -1115,6 +1177,7 @@ func embeddedPrelude() *bytecode.ISeq {
 										Params:      []string{"a"},
 										NumRequired: 0,
 										SplatIndex:  0,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   2,
@@ -1131,7 +1194,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"),
 						},
@@ -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,
@@ -1160,7 +1225,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"),
 										},
@@ -1168,6 +1233,7 @@ func embeddedPrelude() *bytecode.ISeq {
 										Params:      []string{"a"},
 										NumRequired: 0,
 										SplatIndex:  0,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   2,
@@ -1184,7 +1250,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"),
@@ -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,
@@ -1215,7 +1283,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"),
@@ -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,
@@ -1253,7 +1323,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),
@@ -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,
@@ -1306,7 +1379,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),
@@ -1315,6 +1388,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"args"},
 						NumRequired: 0,
 						SplatIndex:  0,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -1324,13 +1398,14 @@ 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"),
 								},
 								Names:       []string{"respond_to?", "size"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -1340,7 +1415,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),
 								},
@@ -1348,6 +1423,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"a"},
 								NumRequired: 0,
 								SplatIndex:  0,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -1361,13 +1437,14 @@ 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"),
 						},
 						Names:       []string{"enum_for", "to_a", "reverse_each"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   0,
 						NumLocals:   1,
@@ -1377,13 +1454,14 @@ 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"),
 								},
 								Names:       []string{"respond_to?", "size"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -1396,13 +1474,14 @@ 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"),
 						},
 						Names:       []string{"enum_for", "__each_packed"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -1412,13 +1491,14 @@ 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"),
 								},
 								Names:       []string{"respond_to?", "size"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -1428,11 +1508,12 @@ 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,
 								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,
@@ -1463,7 +1545,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"),
 						},
@@ -1471,6 +1553,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"args"},
 						NumRequired: 0,
 						SplatIndex:  0,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -1480,13 +1563,14 @@ 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"),
 								},
 								Names:       []string{"respond_to?", "size"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -1496,11 +1580,12 @@ 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,
 								SplatIndex:  0,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -1514,7 +1599,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"),
 						},
@@ -1522,6 +1607,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"memo"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -1531,13 +1617,14 @@ 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"),
 								},
 								Names:       []string{"respond_to?", "size"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -1547,10 +1634,11 @@ 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,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -1564,13 +1652,14 @@ 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"),
 						},
 						Names:       []string{"enum_for", "__each_packed"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -1580,13 +1669,14 @@ 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"),
 								},
 								Names:       []string{"respond_to?", "size"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -1596,11 +1686,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   2,
@@ -1614,13 +1705,14 @@ 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"),
 						},
 						Names:       []string{"enum_for", "__each_packed"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -1630,13 +1722,14 @@ 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"),
 								},
 								Names:       []string{"respond_to?", "size"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -1646,11 +1739,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -1664,13 +1758,14 @@ 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"),
 						},
 						Names:       []string{"enum_for", "__each_packed"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -1680,13 +1775,14 @@ 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"),
 								},
 								Names:       []string{"respond_to?", "size"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -1696,11 +1792,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   5,
@@ -1714,7 +1811,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(""),
@@ -1736,6 +1833,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"args"},
 						NumRequired: 0,
 						SplatIndex:  0,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   3,
@@ -1745,7 +1843,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"),
@@ -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,
@@ -1790,7 +1890,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"),
@@ -1802,6 +1902,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"o"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -1812,7 +1913,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),
 								},
@@ -1820,6 +1921,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"x"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   2,
@@ -1829,11 +1931,12 @@ 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,
 										SplatIndex:  -1,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   1,
@@ -1850,7 +1953,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(""),
@@ -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,
@@ -1884,7 +1989,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),
@@ -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,
@@ -1920,11 +2027,12 @@ 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,
 								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,
@@ -1952,11 +2061,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -1970,13 +2080,14 @@ 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"),
 						},
 						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,
@@ -1998,11 +2110,12 @@ 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,
 								SplatIndex:  0,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -2016,13 +2129,14 @@ 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"),
 						},
 						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,
@@ -2044,11 +2159,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -2062,7 +2178,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"),
@@ -2072,6 +2188,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"n"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -2081,7 +2198,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),
@@ -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,
@@ -2099,11 +2217,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -2117,7 +2236,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"),
@@ -2127,6 +2246,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"n"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -2136,7 +2256,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),
@@ -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,
@@ -2155,11 +2276,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -2173,7 +2295,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(""),
@@ -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,
@@ -2208,7 +2332,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"),
 										},
@@ -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,
@@ -2241,7 +2367,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"),
 										},
@@ -2249,6 +2375,7 @@ func embeddedPrelude() *bytecode.ISeq {
 										Params:      []string{"x"},
 										NumRequired: 1,
 										SplatIndex:  -1,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   1,
@@ -2265,7 +2392,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"),
@@ -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,
@@ -2296,7 +2425,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"),
 										},
@@ -2304,6 +2433,7 @@ func embeddedPrelude() *bytecode.ISeq {
 										Params:      []string{"x"},
 										NumRequired: 1,
 										SplatIndex:  -1,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   1,
@@ -2320,7 +2450,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"),
@@ -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,
@@ -2359,7 +2491,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"),
@@ -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,
@@ -2379,7 +2512,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"),
@@ -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,
@@ -2399,7 +2533,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"),
@@ -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,
@@ -2428,7 +2564,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"),
@@ -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,
@@ -2467,7 +2605,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(""),
@@ -2482,6 +2620,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"args"},
 						NumRequired: 0,
 						SplatIndex:  0,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   4,
@@ -2491,11 +2630,12 @@ 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,
 								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,
@@ -2521,7 +2662,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(""),
@@ -2536,6 +2677,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"args"},
 						NumRequired: 0,
 						SplatIndex:  0,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   4,
@@ -2545,11 +2687,12 @@ 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,
 								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,
@@ -2575,13 +2719,14 @@ 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"),
 						},
 						Names:       []string{"enum_for", "min_by", "max_by"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -2590,13 +2735,14 @@ 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"),
 								},
 								Names:       []string{"respond_to?", "size"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
@@ -2606,10 +2752,11 @@ 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,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -2620,10 +2767,11 @@ 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,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -2637,7 +2785,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),
@@ -2647,6 +2795,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"n"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -2656,7 +2805,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),
@@ -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,
@@ -2674,11 +2824,12 @@ 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,
 								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,
@@ -2701,10 +2853,11 @@ 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,
+										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,
@@ -2730,10 +2884,11 @@ 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,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   1,
@@ -2753,10 +2908,11 @@ 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,
+				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,
@@ -2880,10 +3044,11 @@ 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,
+				PostCount:   0,
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
@@ -2893,10 +3058,11 @@ 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,
+				PostCount:   0,
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
@@ -2906,10 +3072,11 @@ 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,
+				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,
@@ -2933,10 +3101,11 @@ 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,
+				PostCount:   0,
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
@@ -2945,11 +3114,12 @@ 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,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -2960,11 +3130,12 @@ 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,
 						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,
@@ -2991,10 +3163,11 @@ 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,
+				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,
@@ -3020,7 +3194,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"),
@@ -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,
@@ -3038,7 +3213,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"),
@@ -3048,6 +3223,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"enum"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   1,
 						NumLocals:   2,
@@ -3058,11 +3234,12 @@ 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,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   1,
 						NumLocals:   2,
@@ -3072,11 +3249,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -3087,11 +3265,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -3105,13 +3284,14 @@ 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"),
 						},
 						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,
@@ -3153,11 +3335,12 @@ 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,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -3168,11 +3351,12 @@ 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,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -3183,11 +3367,12 @@ 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,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -3197,11 +3382,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -3215,11 +3401,12 @@ 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,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -3229,11 +3416,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -3247,11 +3435,12 @@ 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,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -3261,11 +3450,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -3279,11 +3469,12 @@ 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,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -3293,11 +3484,12 @@ 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,
 								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,
@@ -3325,11 +3518,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -3339,11 +3533,12 @@ 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,
 										SplatIndex:  -1,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   1,
@@ -3360,11 +3555,12 @@ 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,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -3374,11 +3570,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -3392,7 +3589,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"),
@@ -3402,6 +3599,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"other"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -3411,11 +3609,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -3426,11 +3625,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -3444,10 +3644,11 @@ 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,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -3457,11 +3658,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -3475,7 +3677,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"),
 						},
@@ -3483,6 +3685,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"other"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -3492,11 +3695,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -3510,7 +3714,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"),
 						},
@@ -3518,6 +3722,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"other"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -3527,11 +3732,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -3545,7 +3751,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"),
 						},
@@ -3553,6 +3759,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"other"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -3562,11 +3769,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -3580,7 +3788,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"),
 						},
@@ -3588,6 +3796,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"other"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -3597,11 +3806,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -3615,7 +3825,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),
@@ -3625,6 +3835,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"other"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -3635,7 +3846,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?"),
 						},
@@ -3643,6 +3854,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"other"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -3652,11 +3864,12 @@ 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,
 								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,
@@ -3700,11 +3915,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -3715,11 +3931,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -3733,11 +3950,12 @@ 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,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -3748,13 +3966,14 @@ 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"),
 						},
 						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,
@@ -3777,11 +3997,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -3795,13 +4016,14 @@ 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"),
 						},
 						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,
@@ -3824,11 +4047,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -3842,13 +4066,14 @@ 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!"),
 						},
 						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,
@@ -3874,13 +4100,14 @@ 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!"),
 						},
 						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,
@@ -3906,13 +4134,14 @@ 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!"),
 						},
 						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,
@@ -3935,11 +4165,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -3953,13 +4184,14 @@ 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"),
 						},
 						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,
@@ -3982,11 +4215,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   5,
@@ -4000,7 +4234,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),
@@ -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,
@@ -4033,13 +4269,14 @@ 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),
 						},
 						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,
@@ -4075,11 +4314,12 @@ 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,
 										SplatIndex:  -1,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   1,
@@ -4093,7 +4333,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),
 								},
@@ -4101,6 +4341,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"v"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   5,
@@ -4110,11 +4351,12 @@ 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,
 										SplatIndex:  -1,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   3,
@@ -4125,10 +4367,11 @@ 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,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   2,
@@ -4142,11 +4385,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -4157,11 +4401,12 @@ 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,
 								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,
@@ -4188,10 +4434,11 @@ 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,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -4200,11 +4447,12 @@ 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,
 								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,
@@ -4232,7 +4481,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"),
 								},
@@ -4240,6 +4489,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"o"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   2,
@@ -4253,11 +4503,12 @@ 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,
 						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,
@@ -4295,7 +4548,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*("),
@@ -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,
@@ -4328,11 +4583,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -4343,7 +4599,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 "),
@@ -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,
@@ -4398,10 +4657,11 @@ 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,
+								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,
@@ -4441,13 +4703,14 @@ 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("."),
 								},
 								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,
@@ -4458,7 +4721,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),
@@ -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,
@@ -4477,7 +4741,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),
@@ -4486,6 +4750,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"other"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   8,
@@ -4496,7 +4761,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),
 								},
@@ -4504,6 +4769,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"other"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -4514,11 +4780,12 @@ 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,
 								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,
@@ -4542,7 +4810,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),
@@ -4551,6 +4819,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"l", "r"},
 								NumRequired: 2,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   2,
@@ -4564,7 +4833,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("!="),
@@ -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,
@@ -4687,11 +4964,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -4702,13 +4980,14 @@ 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"),
 								},
 								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,
@@ -4735,11 +5015,12 @@ 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,
 										SplatIndex:  -1,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   1,
@@ -4753,7 +5034,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(""),
@@ -4767,6 +5048,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"obj"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   3,
@@ -4777,11 +5059,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -4791,11 +5074,12 @@ 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,
 										SplatIndex:  -1,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   2,
@@ -4809,13 +5093,14 @@ 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(", "),
 								},
 								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,
@@ -4851,10 +5137,11 @@ 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,
+						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,
@@ -4944,11 +5237,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   3,
@@ -4962,11 +5256,12 @@ 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,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -4977,11 +5272,12 @@ 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,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   3,
@@ -4992,10 +5288,11 @@ 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,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -5005,13 +5302,14 @@ 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"),
 						},
 						Names:       []string{"enum_for", "@table", "each_pair"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -5020,10 +5318,11 @@ 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,
+								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,
@@ -5050,11 +5350,12 @@ 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,
 						SplatIndex:  0,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -5065,11 +5366,12 @@ 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,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -5080,7 +5382,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("="),
 						},
@@ -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,
@@ -5098,7 +5401,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),
@@ -5112,6 +5415,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"name", "args"},
 						NumRequired: 1,
 						SplatIndex:  1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   4,
@@ -5122,11 +5426,12 @@ 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,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -5137,11 +5442,12 @@ 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,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -5152,10 +5458,11 @@ 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,
+						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,
@@ -5180,11 +5488,12 @@ 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,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   3,
@@ -5194,11 +5503,12 @@ 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,
 								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,
@@ -5226,11 +5537,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -5244,7 +5556,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("@"),
 						},
@@ -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,
@@ -5277,11 +5591,12 @@ 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,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   3,
@@ -5291,11 +5606,12 @@ 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,
 								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,
@@ -5323,11 +5640,12 @@ 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,
 								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,
@@ -5356,11 +5675,12 @@ 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,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -5371,11 +5691,12 @@ 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,
 						SplatIndex:  1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   2,
 						NumLocals:   4,
@@ -5386,11 +5707,12 @@ 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,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -5401,11 +5723,12 @@ 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,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -5416,11 +5739,12 @@ 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,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -5431,7 +5755,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(""),
@@ -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,
@@ -5449,7 +5774,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(""),
@@ -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,
@@ -5515,7 +5844,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__"),
@@ -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,
@@ -5597,7 +5930,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"),
 						},
@@ -5605,6 +5938,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"m"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -5614,11 +5948,12 @@ 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,
 								SplatIndex:  0,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   1,
 								NumLocals:   2,
@@ -5635,13 +5970,14 @@ 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("/"),
 				},
 				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,
@@ -5650,7 +5986,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"),
 						},
@@ -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,
@@ -5725,11 +6066,12 @@ 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,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -5740,11 +6082,12 @@ 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,
 						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,
@@ -5768,10 +6112,11 @@ 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,
+						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,
@@ -5807,11 +6154,12 @@ 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,
 						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,
@@ -5867,7 +6218,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(""),
 						},
@@ -5875,6 +6226,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"suffix"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -5885,10 +6237,11 @@ 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,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -5898,10 +6251,11 @@ 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,
+						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,
@@ -5924,13 +6279,14 @@ 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"),
 						},
 						Names:       []string{"enum_for", "Pathname", "@path", "__lex_filenames", "each"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -5939,10 +6295,11 @@ 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,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -5956,13 +6313,14 @@ 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"),
 						},
 						Names:       []string{"enum_for", "Pathname", "@path", "__lex_ascend_paths", "each"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -5971,11 +6329,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -5989,13 +6348,14 @@ 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"),
 						},
 						Names:       []string{"enum_for", "Pathname", "@path", "__lex_ascend_paths", "reverse_each"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -6004,11 +6364,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -6022,10 +6383,11 @@ 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,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -6035,11 +6397,12 @@ 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,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -6050,11 +6413,12 @@ 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,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -6065,11 +6429,12 @@ 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,
 						SplatIndex:  0,
+						PostCount:   0,
 						KwRestSlot:  1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -6080,11 +6445,12 @@ 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,
 						SplatIndex:  1,
+						PostCount:   0,
 						KwRestSlot:  2,
 						BlockSlot:   -1,
 						NumLocals:   3,
@@ -6095,11 +6461,12 @@ 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,
 						SplatIndex:  0,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   1,
 						NumLocals:   2,
@@ -6110,10 +6477,11 @@ 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,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -6123,10 +6491,11 @@ 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,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -6136,10 +6505,11 @@ 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,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -6149,11 +6519,12 @@ 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,
 						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,
@@ -6207,7 +6581,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"),
@@ -6216,6 +6590,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"klass"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -6229,7 +6604,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"),
@@ -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,
@@ -6247,7 +6623,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),
@@ -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,
@@ -6269,7 +6646,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)"),
 						},
@@ -6277,6 +6654,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"b"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -6287,11 +6665,12 @@ 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,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -6301,11 +6680,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   2,
@@ -6319,11 +6699,12 @@ 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,
 						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,
@@ -6373,13 +6757,14 @@ 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"),
 								},
 								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,
@@ -6406,11 +6792,12 @@ 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,
 								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,
@@ -6448,7 +6836,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(""),
@@ -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,
@@ -6494,7 +6884,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"),
@@ -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,
@@ -6537,11 +6929,12 @@ 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,
 										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,
@@ -6566,11 +6960,12 @@ 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,
 												SplatIndex:  -1,
+												PostCount:   0,
 												KwRestSlot:  -1,
 												BlockSlot:   -1,
 												NumLocals:   2,
@@ -6584,11 +6979,12 @@ 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,
 										SplatIndex:  -1,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   1,
@@ -6605,13 +7001,14 @@ 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"),
 						},
 						Names:       []string{"attr_reader", "initialize", "render"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -6620,11 +7017,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   1,
 								NumLocals:   2,
@@ -6635,7 +7033,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),
@@ -6644,6 +7042,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"_scope", "locals"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   3,
@@ -6653,11 +7052,12 @@ 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,
 										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,
@@ -6780,7 +7185,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"),
@@ -6797,6 +7202,7 @@ func embeddedPrelude() *bytecode.ISeq {
 										Params:      []string{"k", "v"},
 										NumRequired: 2,
 										SplatIndex:  -1,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   7,
@@ -6806,7 +7212,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-"),
@@ -6816,6 +7222,7 @@ func embeddedPrelude() *bytecode.ISeq {
 												Params:      []string{"dk", "dv"},
 												NumRequired: 2,
 												SplatIndex:  -1,
+												PostCount:   0,
 												KwRestSlot:  -1,
 												BlockSlot:   -1,
 												NumLocals:   3,
@@ -6829,7 +7236,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(" "),
@@ -6843,6 +7250,7 @@ func embeddedPrelude() *bytecode.ISeq {
 										Params:      []string{"k"},
 										NumRequired: 1,
 										SplatIndex:  -1,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   2,
@@ -6859,13 +7267,14 @@ 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"),
 						},
 						Names:       []string{"attr_reader", "initialize", "render"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -6874,11 +7283,12 @@ 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,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   1,
 								NumLocals:   2,
@@ -6889,7 +7299,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),
@@ -6898,6 +7308,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"_scope", "locals"},
 								NumRequired: 0,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   3,
@@ -6907,11 +7318,12 @@ 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,
 										SplatIndex:  -1,
+										PostCount:   0,
 										KwRestSlot:  -1,
 										BlockSlot:   -1,
 										NumLocals:   2,
@@ -6931,7 +7343,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"),
@@ -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,
@@ -6954,13 +7367,14 @@ 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"),
 						},
 						Names:       []string{"attr_reader", "initialize", "reason", "message", "to_s", "recover"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -6969,7 +7383,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(" "),
@@ -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,
@@ -7016,7 +7433,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(" "),
@@ -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,
@@ -7033,7 +7451,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),
 								},
@@ -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,
@@ -7237,13 +7668,14 @@ 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"),
 				},
 				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,
@@ -7269,7 +7702,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+"),
@@ -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,
@@ -7292,7 +7726,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(""),
@@ -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,
@@ -7320,13 +7755,14 @@ 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+"),
 						},
 						Names:       []string{"@file", "@closed", "File", "@path", "open"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -7336,11 +7772,12 @@ 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,
 						SplatIndex:  0,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   1,
 						NumLocals:   2,
@@ -7351,19 +7788,20 @@ 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,
+						PostCount:   0,
 						KwRestSlot:  2,
 						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:       "",
 					},
@@ -7374,6 +7812,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"unlink_now"},
 						NumRequired: 0,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -7384,10 +7823,11 @@ 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,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -7397,10 +7837,11 @@ 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,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
@@ -7410,7 +7851,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"),
 						},
@@ -7418,6 +7859,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						Params:      []string{"mode"},
 						NumRequired: 1,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   1,
@@ -7428,11 +7870,12 @@ 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,
 						SplatIndex:  -1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   2,
@@ -7443,11 +7886,12 @@ 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,
 						SplatIndex:  1,
+						PostCount:   0,
 						KwRestSlot:  -1,
 						BlockSlot:   2,
 						NumLocals:   3,
@@ -7461,7 +7905,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"),
@@ -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,
@@ -7491,7 +7937,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 "),
@@ -7504,6 +7950,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								Params:      []string{"category"},
 								NumRequired: 1,
 								SplatIndex:  -1,
+								PostCount:   0,
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   1,
@@ -7514,7 +7961,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 "),
@@ -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,
@@ -7553,11 +8002,12 @@ 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,
 						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 57883c20..8242fdd6 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,52 @@ func (vm *VM) bindKeywords(iseq *bytecode.ISeq, args *[]object.Value) *object.Ha
 	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.
+//
+// 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.
@@ -1162,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 {
@@ -1188,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) {
@@ -1216,13 +1294,24 @@ 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).
-	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 {
@@ -1235,6 +1324,23 @@ 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) - npost
 	env := vm.getEnv()
 	env.parent, env.kwargs, env.captured = parentEnv, kwargs, false
 	if iseq.NumLocals <= len(env.inline) {
@@ -1270,6 +1376,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)
 	}
@@ -1774,6 +1894,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 +1904,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 +1936,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 +1951,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 +1976,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))
@@ -1992,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.
@@ -2002,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
@@ -2016,7 +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]
 				}
-				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 {
@@ -2027,7 +2159,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 +2169,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 +2296,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 +2472,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)
 			}
diff --git a/internal/vm/wave29_kwargs_test.go b/internal/vm/wave29_kwargs_test.go
new file mode 100644
index 00000000..b7e5756f
--- /dev/null
+++ b/internal/vm/wave29_kwargs_test.go
@@ -0,0 +1,300 @@
+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)
+		}
+	}
+}
+
+// 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)
+	}
+}