diff --git a/internal/vm/autoload.go b/internal/vm/autoload.go
index cbd3b74c..c8592dbf 100644
--- a/internal/vm/autoload.go
+++ b/internal/vm/autoload.go
@@ -257,18 +257,22 @@ func (vm *VM) tryAutoload(cls *RClass, name string) bool {
 // It goes through rb_warning, not rb_warn, so only $VERBOSE == true shows it —
 // the same gate warnCircularRequire applies — and it is emitted at most once
 // per registration because the caller has already retired the entry.
+//
+// rbWarning, not a curStderr() write: rb_warning ends in rb_write_warning_str
+// like every other internal warning, so an overridden Warning.warn intercepts
+// this one too, and it carries the file:lineno prefix warning_string composes. The
+// gate was ALSO reading vm.globals["$VERBOSE"] out of the map, which is unset
+// until a program assigns it, so a Bool type assertion there could never be true
+// on a run that only passed -w.
 func (vm *VM) warnAutoloadDidNotDefine(cls *RClass, name, path string) {
 	if _, defined := cls.consts[name]; defined {
 		return
 	}
-	if v, ok := vm.globals["$VERBOSE"].(object.Bool); !ok || !bool(v) {
-		return
-	}
 	qualified := name
 	if cls != vm.cObject {
 		qualified = vm.moduleToSStr(cls) + "::" + name
 	}
-	vm.curStderr().writeStr("warning: Expected " + path + " to define " + qualified + " but it didn't\n")
+	vm.rbWarning("Expected " + path + " to define " + qualified + " but it didn't")
 }
 
 // featureLoaded reports whether path names a file that has already been loaded,
diff --git a/internal/vm/builtins.go b/internal/vm/builtins.go
index 93336714..171773d0 100644
--- a/internal/vm/builtins.go
+++ b/internal/vm/builtins.go
@@ -1,6 +1,7 @@
 package vm
 
 import (
+	"fmt"
 	"math"
 	"math/big"
 	"sort"
@@ -1706,13 +1707,12 @@ func (vm *VM) bootstrap() {
 		name := vm.coerceConstName(args[0])
 		// Overwriting an already-initialised constant (a real value, not a pending
 		// autoload — those live in cls.autoloads, so cls.consts misses them and no
-		// warning fires) warns "already initialized constant X". MRI uses rb_warn
-		// here, which fires whenever $VERBOSE is non-nil (false or true), suppressed
-		// only when $VERBOSE is nil. Reference: ruby/ruby v3_4_0 variable.c
-		// rb_const_set → const_set_raise / rb_warn on the already-set case.
-		if _, existed := cls.consts[name]; existed && !object.IsNil(vm.globals["$VERBOSE"]) {
-			vm.warnRedefineConst(cls, name)
-		}
+		// warning fires) is variable.c's const_tbl_update redefinition arm, the same
+		// one a syntactic `X = 2` reaches, so it goes through the same helper: both
+		// lines, the file:lineno prefix, and rb_warn's gate. This used to open-code a
+		// third behaviour of its own — a raw vm.globals read for the gate (never
+		// seeded, so always silent) and Kernel#warn for the sink.
+		vm.warnAlreadyInitialized(cls, name)
 		// Route through assignConstIn so an anonymous class/module bound here gains
 		// the qualified name of its constant (Ruby's "permanent name on first
 		// constant binding" rule) — the same path a `Foo::Bar = ...` literal takes.
@@ -3103,7 +3103,7 @@ func (vm *VM) bootstrap() {
 			// rb_ary_initialize uses rb_warning here, not rb_warn, so this one is
 			// only heard under -w / $VERBOSE = true.
 			if blk != nil {
-				vm.rbWarning1("given block not used")
+				vm.rbWarning("given block not used")
 			}
 			return self
 		}
@@ -3132,7 +3132,7 @@ func (vm *VM) bootstrap() {
 		// Build the array incrementally so that if the block calls break, the array
 		// is left holding the elements produced before the break, as MRI does.
 		if blk != nil && len(args) == 2 {
-			vm.rbWarn1("block supersedes default value argument")
+			vm.rbWarn("block supersedes default value argument")
 		}
 		arr.Elems = make([]object.Value, 0, n)
 		for i := int64(0); i < n; i++ {
@@ -3258,7 +3258,7 @@ func (vm *VM) bootstrap() {
 		//     if (block_given && argc == 2) rb_warn("block supersedes default value argument");
 		// so the warning fires whether or not the index is in range.
 		if blk != nil && len(args) == 2 {
-			vm.rbWarn1("block supersedes default value argument")
+			vm.rbWarn("block supersedes default value argument")
 		}
 		v, orig, ok := vm.arrayFetchAt(a, args[0])
 		if ok {
@@ -4425,7 +4425,7 @@ func (vm *VM) bootstrap() {
 		// array.c v3_4_0 rb_ary_index: with a value argument the block is dead,
 		// and MRI says so — `if (rb_block_given_p()) rb_warn("given block not used");`
 		if len(args) > 0 && blk != nil {
-			vm.rbWarn1("given block not used")
+			vm.rbWarn("given block not used")
 		}
 		for i := 0; i < len(a.Elems); i++ {
 			var match bool
@@ -4453,7 +4453,7 @@ func (vm *VM) bootstrap() {
 		}
 		// rb_ary_rindex warns for the dead block exactly as rb_ary_index does.
 		if len(args) > 0 && blk != nil {
-			vm.rbWarn1("given block not used")
+			vm.rbWarn("given block not used")
 		}
 		for i := len(a.Elems) - 1; i >= 0; i-- {
 			// A block may shrink the array; realign to the new end and re-check size
@@ -5036,7 +5036,7 @@ func (vm *VM) bootstrap() {
 		// hash.c v3_4_0 rb_hash_fetch_m warns on the clash before the lookup:
 		//     if (block_given && argc == 2) rb_warn("block supersedes default value argument");
 		if blk != nil && len(args) == 2 {
-			vm.rbWarn1("block supersedes default value argument")
+			vm.rbWarn("block supersedes default value argument")
 		}
 		if v, ok := self.(*object.Hash).Get(args[0]); ok {
 			return v
@@ -12215,34 +12215,85 @@ func (vm *VM) qualifiedConstName(scope *RClass, name string) string {
 	return vm.moduleToSStr(scope) + "::" + name
 }
 
-// rbWarn1 is error.c's rb_warn at tag v3_4_0 (error.c:466): the message gets the
-// CALLING frame's "path:lineno: warning: " in front (rb_warn builds it through
-// rb_warning_string, which starts at the current frame), it is silenced only
-// under -W0 where $VERBOSE is nil (`if (!NIL_P(ruby_verbose))`), and it is then
-// handed to rb_write_warning_str. `ruby -e 'p [1].index(1){}'` prints
-// "-e:1: warning: given block not used".
+// rbWarn is error.c's rb_warn at tag v3_4_0 (error.c:466). Three things happen
+// here and NOWHERE else, because a rule restated at its call sites drifts — and
+// this one had drifted three ways at once:
+//
+//  1. the gate is warnEnabled (`!NIL_P(ruby_verbose)`), so the default
+//     $VERBOSE == false speaks and only -W0's nil silences it;
+//  2. the message is composed by warningString, which is error.c's
+//     warning_string → warn_vsprintf → err_vcatf: the CURRENT Ruby frame's
+//     "path:lineno: ", then the literal "warning: ", then the text, then "\n".
+//     Callers pass the text ALONE — no "warning: " of their own;
+//  3. the sink is writeWarningStr, error.c's rb_write_warning_str, which is
+//     `rb_funcallv(Warning, :warn, str)` — so an overridden Warning.warn
+//     intercepts it and a $stderr that merely answers #write collects it.
 //
-// It emits through writeWarningStr — Warning.warn — and NOT to curStderr(), which
-// was the defect: rb_warn reaches $stderr only via the default Warning.warn's
-// `$stderr.write(message)`, so an overridden Warning.warn intercepts it and a
-// $stderr that merely answers #write collects it. See writeWarningStr in io.go
-// for the C chain and for why a StringIO double could witness neither.
-func (vm *VM) rbWarn1(msg string) {
-	if object.IsNil(vm.gvar("$VERBOSE")) {
+// `ruby -e 'p [1].index(1){}'` prints "-e:1: warning: given block not used".
+func (vm *VM) rbWarn(msg string) {
+	if !vm.warnEnabled() {
+		return
+	}
+	vm.writeWarningStr(vm.warningString(msg))
+}
+
+// rbWarnf is rbWarn with a format string. It exists only so a caller building a
+// message out of values does not reach for fmt itself; the gate, the prefix and
+// the sink are still rbWarn's.
+func (vm *VM) rbWarnf(format string, a ...any) {
+	vm.rbWarn(fmt.Sprintf(format, a...))
+}
+
+// rbWarning is error.c's rb_warning (error.c:497), the quieter sibling of
+// rb_warn: same composition and same sink, but the stricter RTEST gate, so it
+// prints only when $VERBOSE is TRUE (ruby -w). This is why the specs that assert
+// one of these pass `verbose: true` to `complain`.
+func (vm *VM) rbWarning(msg string) {
+	if !vm.warningEnabled() {
 		return
 	}
-	vm.writeWarningStr(vm.warnUplevelPrefix(0) + msg + "\n")
+	vm.writeWarningStr(vm.warningString(msg))
 }
 
-// rbWarning1 is error.c's rb_warning (error.c:497), the quieter sibling of
-// rb_warn: it prints only when $VERBOSE is TRUE (ruby -w), which is why the specs
-// that assert one of these pass `verbose: true` to `complain`. Same sink as
-// rbWarn1 — rb_warning also ends in rb_write_warning_str.
-func (vm *VM) rbWarning1(msg string) {
-	if v := vm.gvar("$VERBOSE"); v != object.True {
+// rbWarningf is rbWarning with a format string, standing to rbWarning as rbWarnf
+// stands to rbWarn.
+func (vm *VM) rbWarningf(format string, a ...any) {
+	vm.rbWarning(fmt.Sprintf(format, a...))
+}
+
+// rbCompileWarn is error.c's rb_compile_warn (error.c:397): rb_warn's gate and
+// rb_warn's sink, but an EXPLICIT source position instead of the current frame's.
+// MRI uses it for a diagnostic that points where the interpreter is not standing
+// any more — the "previous definition of X was here" line beside a constant
+// redefinition, whose position is the entry's own ce->file / ce->line.
+func (vm *VM) rbCompileWarn(file string, line int, msg string) {
+	if !vm.warnEnabled() {
 		return
 	}
-	vm.writeWarningStr(vm.warnUplevelPrefix(0) + msg + "\n")
+	vm.writeWarningStr(warningStringAt(file, line, msg))
+}
+
+// warningString is error.c's warning_string (error.c:450): warn_vsprintf over the
+// position rb_source_location_cstr reports for the current frame.
+func (vm *VM) warningString(msg string) string {
+	return vm.warnUplevelPrefix(0) + msg + "\n"
+}
+
+// warningStringAt is warn_vsprintf (error.c:381) with a caller-supplied position,
+// formatted by err_vcatf (error.c:125): the file, then ":line" only when the line
+// is non-zero, then ": ", then "warning: ". A file of "" drops the whole location
+// — err_vcatf tests `if (file)` — leaving the bare "warning: " prefix, which is
+// also what a constant defined by this VM's own bootstrap has (MRI: a ce->file of
+// nil, so no second line at all — see warnAlreadyInitialized).
+func warningStringAt(file string, line int, msg string) string {
+	if file == "" {
+		return "warning: " + msg + "\n"
+	}
+	loc := file
+	if line != 0 {
+		loc += ":" + strconv.Itoa(line)
+	}
+	return loc + ": warning: " + msg + "\n"
 }
 
 // symbolNames interns the frozen String that Symbol#name answers. MRI's symbol
diff --git a/internal/vm/env.go b/internal/vm/env.go
index c4dece94..b9cf86bd 100644
--- a/internal/vm/env.go
+++ b/internal/vm/env.go
@@ -70,7 +70,7 @@ func (vm *VM) registerENV() {
 	def("fetch", func(vm *VM, _ object.Value, args []object.Value, blk *Proc) object.Value {
 		key := vm.envStr(args[0])
 		if blk != nil && len(args) > 1 {
-			vm.rbWarn("warning: block supersedes default value argument")
+			vm.rbWarn("block supersedes default value argument")
 		}
 		if v, ok := envLookup(key); ok {
 			return envStrV(v)
diff --git a/internal/vm/env_wave16_test.go b/internal/vm/env_wave16_test.go
index 09739885..7fb5f505 100644
--- a/internal/vm/env_wave16_test.go
+++ b/internal/vm/env_wave16_test.go
@@ -116,8 +116,14 @@ func TestENVWave16(t *testing.T) {
 		{`ENV.clear; ENV["A"]="1"; p ENV.fetch("A")`, `"1"`},
 		{`ENV.clear; p ENV.fetch("X","d")`, `"d"`},
 		// block + default: the block supersedes the default (and MRI warns).
-		{`ENV.clear; ENV["A"]="1"; p ENV.fetch("A","d"){|k| "blk"}`, `"1"`},
-		{`ENV.clear; p ENV.fetch("X","d"){|k| "blk:#{k}"}`, `"blk:X"`},
+		// hash.c env_fetch warns through rb_warn when a default AND a block are given,
+		// so the default $VERBOSE (false) prints it, prefixed with the caller's
+		// position. Measured on MRI 4.0.5. These two rows asserted silence, which was
+		// only true while rbgo's rb_warn gate read an unset slot.
+		{`ENV.clear; ENV["A"]="1"; p ENV.fetch("A","d"){|k| "blk"}`,
+			"(rbgo):1: warning: block supersedes default value argument\n" + `"1"`},
+		{`ENV.clear; p ENV.fetch("X","d"){|k| "blk:#{k}"}`,
+			"(rbgo):1: warning: block supersedes default value argument\n" + `"blk:X"`},
 		{`ENV.clear; p ENV.fetch("X"){|k| "blk:#{k}"}`, `"blk:X"`},
 		{`ENV.clear; begin; ENV.fetch("X"); rescue KeyError => e; p [e.message, e.key, e.receiver.equal?(ENV)]; end`,
 			`["key not found: \"X\"", "X", true]`},
diff --git a/internal/vm/getoptlong_test.go b/internal/vm/getoptlong_test.go
index 63720a06..09b9d802 100644
--- a/internal/vm/getoptlong_test.go
+++ b/internal/vm/getoptlong_test.go
@@ -169,12 +169,15 @@ g = GetoptLong.new(["-a",GetoptLong::NO_ARGUMENT])
 ARGV.replace(["-a","z"])
 r=[]; g.each{|o,a| r<<[o,a]}; p r; p ARGV`,
 			"[[\"-a\", \"\"]]\n[\"z\"]\n"},
-		// A non-Array ARGV (reassigned) is treated as empty: nothing to scan.
+		// A non-Array ARGV (reassigned) is treated as empty: nothing to scan. The
+		// reassignment warns: ARGV is already initialised, and MRI warns there too
+		// (`ruby -e 'ARGV = "x"'` prints "-e:1: warning: already initialized constant
+		// ARGV"), with no "previous definition" line because ARGV is defined natively.
 		{golReq + `
 ARGV = "notarray"
 g = GetoptLong.new(["-a",GetoptLong::NO_ARGUMENT])
 p g.get`,
-			"[nil, nil]\n"},
+			"(rbgo):2: warning: already initialized constant ARGV\n[nil, nil]\n"},
 	}
 	for _, c := range cases {
 		if got := eval(t, c.src); got != c.want {
diff --git a/internal/vm/globals.go b/internal/vm/globals.go
index 69875a13..edd3ec3d 100644
--- a/internal/vm/globals.go
+++ b/internal/vm/globals.go
@@ -202,12 +202,41 @@ func (vm *VM) verboseSlot(name string) object.Value {
 	return object.Bool(false)
 }
 
+// $VERBOSE has THREE states in MRI, not two, and the two warning families split
+// on exactly that (error.c v3_4_0):
+//
+//	nil   (-W0)          every rb_warn and rb_warning is silent
+//	false (the default)  rb_warn speaks, rb_warning stays quiet
+//	true  (-w / -W2)     both speak
+//
+// verbose_setter (ruby.c v3_4_0) coerces anything truthy to Qtrue, so these are
+// the only three values a slot can hold, and `$VERBOSE = 1` reads back as true.
+//
+// warnEnabled and warningEnabled are the ONLY two places that decide. Every gate
+// in this VM asks one of them, because the defect they replace was a second
+// representation of one value: four call sites read vm.globals["$VERBOSE"]
+// straight out of the map, which is unset until a program assigns it, while every
+// Ruby-level read went through verboseSlot and answered false. The gate read the
+// representation nobody writes, so `$VERBOSE.nil?` agreed on both engines and no
+// Ruby-level probe could see it. Reading the slot through verboseSlot here
+// removes the second representation rather than seeding it, so a future `delete`
+// or a fresh VM cannot re-open the same hole.
+func (vm *VM) warnEnabled() bool {
+	return !object.IsNil(vm.verboseSlot("$VERBOSE"))
+}
+
+// warningEnabled is rb_warning's stricter gate, `RTEST(ruby_verbose)`: only a
+// TRUE $VERBOSE. It is what ruby/spec's `complain(verbose: true)` arranges.
+func (vm *VM) warningEnabled() bool {
+	return truthyValue(vm.verboseSlot("$VERBOSE"))
+}
+
 // warnDeprecatedGvar emits a special-variable deprecation warning through
 // Warning.warn, but only while Warning[:deprecated] is enabled — error.c v3_4_0
 // deprecation_warning_enabled() requires both a non-nil $VERBOSE and the
 // category, and the category is off by default, so an ordinary run is silent.
 func (vm *VM) warnDeprecatedGvar(msg string) {
-	if object.IsNil(vm.verboseSlot("$VERBOSE")) {
+	if !vm.warnEnabled() {
 		return
 	}
 	w := vm.consts["Warning"]
diff --git a/internal/vm/io.go b/internal/vm/io.go
index ede1c99d..8354c379 100644
--- a/internal/vm/io.go
+++ b/internal/vm/io.go
@@ -511,7 +511,7 @@ func (vm *VM) registerIO() {
 		// `if (!NIL_P(ruby_verbose) && argc > 0)`, so a $VERBOSE of nil (the -W0
 		// level) makes Kernel#warn a no-op — nothing is written, nothing is
 		// validated and Warning.warn is not called. $VERBOSE false still warns.
-		if object.IsNil(vm.verboseSlot("$VERBOSE")) || len(pos) == 0 {
+		if !vm.warnEnabled() || len(pos) == 0 {
 			return object.NilV
 		}
 		lev := int64(0)
@@ -608,7 +608,7 @@ func (vm *VM) registerIO() {
 		// rb_io_s_new warns when handed a block it will not call: File.new always
 		// returns the open stream, and only File.open yields it.
 		if blk != nil {
-			vm.rbWarn("warning: File::new() does not take block; use File::open() instead")
+			vm.rbWarn("File::new() does not take block; use File::open() instead")
 		}
 		return vm.openFileArgs(fileRecvClass(self, cFile), args)
 	}}
@@ -1413,7 +1413,7 @@ func (vm *VM) writeArityIsOne(sink object.Value) bool {
 // whatever that #to_s returns. Measured — the first version of this function used
 // #to_s and printed the overridden value.
 func (vm *VM) warnOutdatedWrite(sink object.Value) {
-	if sink == vm.stderrValue() || vm.gvar("$VERBOSE") != object.True {
+	if sink == vm.stderrValue() || !vm.warningEnabled() {
 		return
 	}
 	if !vm.send(vm.consts["Warning"], "[]", []object.Value{object.SymVal("deprecated")}, nil).Truthy() {
diff --git a/internal/vm/io_class.go b/internal/vm/io_class.go
index 018c0b1a..af083cf9 100644
--- a/internal/vm/io_class.go
+++ b/internal/vm/io_class.go
@@ -5,7 +5,6 @@
 package vm
 
 import (
-	"fmt"
 	"os"
 	"strings"
 
@@ -1071,7 +1070,7 @@ func (vm *VM) extractEncodingOption(opts *object.Hash, ms *ioModeSpec) bool {
 		if !hasExt {
 			which = "internal"
 		}
-		vm.rbWarn("Ignoring encoding parameter '%s': %s_encoding is used", vm.displayStr(encV), which)
+		vm.rbWarnf("Ignoring encoding parameter '%s': %s_encoding is used", vm.displayStr(encV), which)
 		hasEnc = false
 	}
 	extName := ""
@@ -1125,24 +1124,6 @@ func isDashString(v object.Value) bool {
 	return ok && s.Str() == "-"
 }
 
-// rbWarn emits an MRI rb_warn-style warning line, but only when $VERBOSE is
-// non-nil (false or true) — the gate rb_warn applies. Used for the encoding
-// options that IO.new silently overrides.
-//
-// It goes through writeWarningStr (error.c rb_write_warning_str → Warning.warn),
-// like every other rb_warn here. It used to write to curStderr() instead, and the
-// comment that justified it — "still honouring a $stderr reassigned to a StringIO
-// (mspec's `complain` matcher)" — names the reason the defect survived: a StringIO
-// IS an *IOObj in rbgo, so it satisfied the type assertion curStderr() makes and
-// the harness's own double could never show the warning being dropped for a
-// $stderr that merely answers #write.
-func (vm *VM) rbWarn(format string, a ...any) {
-	if object.IsNil(vm.globals["$VERBOSE"]) {
-		return
-	}
-	vm.writeWarningStr(fmt.Sprintf(format, a...) + "\n")
-}
-
 // ioOptEncoding returns the canonical encoding name selected by the :encoding /
 // :external_encoding option, or "" when none is given.
 func (vm *VM) ioOptEncoding(opts *object.Hash) string {
diff --git a/internal/vm/io_modeenc_internal_test.go b/internal/vm/io_modeenc_internal_test.go
index 2482c6aa..8917bbaa 100644
--- a/internal/vm/io_modeenc_internal_test.go
+++ b/internal/vm/io_modeenc_internal_test.go
@@ -133,8 +133,12 @@ func TestIOBinmodeTextmodeAutoclose(t *testing.T) {
 // TestIOEncodingOptions covers extractEncodingOption / isDashString / rbWarn: the
 // :external_encoding / :internal_encoding / :encoding options, the nil and "-"
 // internal-encoding forms, the int==ext collapse, and the "Ignoring encoding
-// parameter" override (whose external/internal wording is exercised both with
-// $VERBOSE set, so the warning fires, and unset, so rbWarn early-returns).
+// parameter" override. io.c ruby_4_0:6852 warns through rb_warn, so the DEFAULT
+// $VERBOSE (false) prints it with the caller's position — measured on MRI 4.0.5:
+// `ruby -e 'IO.new(1, "w", external_encoding: "ibm866", encoding: "utf-8")'`
+// prints "-e:1: warning: Ignoring encoding parameter …". The unset row below used
+// to assert silence and the $VERBOSE = true rows a bare "Ignoring …"; both were
+// rbgo's divergence.
 func TestIOEncodingOptions(t *testing.T) {
 	cases := []struct{ body, want string }{
 		{`io = IO.new(wo, "w", external_encoding: "utf-8", internal_encoding: "ibm866"); p [io.external_encoding.to_s, io.internal_encoding.to_s]`, "[\"UTF-8\", \"IBM866\"]\n"},
@@ -146,10 +150,10 @@ func TestIOEncodingOptions(t *testing.T) {
 		{`io = IO.new(wo, "w", external_encoding: "utf-8", internal_encoding: "utf-8"); p io.internal_encoding.to_s`, "\"\"\n"},
 		{`io = IO.new(wo, "w", encoding: "utf-8:utf-8"); p io.internal_encoding.to_s`, "\"\"\n"},
 		// :encoding is ignored when :external_encoding is present (external wording).
-		{`io = IO.new(wo, "w", external_encoding: "ibm866", encoding: "utf-8"); p io.external_encoding.to_s`, "\"IBM866\"\n"},
-		{`$VERBOSE = true; io = IO.new(wo, "w", external_encoding: "ibm866", encoding: "utf-8"); p io.external_encoding.to_s`, "Ignoring encoding parameter 'utf-8': external_encoding is used\n\"IBM866\"\n"},
+		{`io = IO.new(wo, "w", external_encoding: "ibm866", encoding: "utf-8"); p io.external_encoding.to_s`, "(rbgo):7: warning: Ignoring encoding parameter 'utf-8': external_encoding is used\n\"IBM866\"\n"},
+		{`$VERBOSE = true; io = IO.new(wo, "w", external_encoding: "ibm866", encoding: "utf-8"); p io.external_encoding.to_s`, "(rbgo):7: warning: Ignoring encoding parameter 'utf-8': external_encoding is used\n\"IBM866\"\n"},
 		// :encoding is ignored when :internal_encoding is present (internal wording).
-		{`$VERBOSE = true; io = IO.new(wo, "w", internal_encoding: "ibm866", encoding: "utf-8"); p io.internal_encoding.to_s`, "Ignoring encoding parameter 'utf-8': internal_encoding is used\n\"IBM866\"\n"},
+		{`$VERBOSE = true; io = IO.new(wo, "w", internal_encoding: "ibm866", encoding: "utf-8"); p io.internal_encoding.to_s`, "(rbgo):7: warning: Ignoring encoding parameter 'utf-8': internal_encoding is used\n\"IBM866\"\n"},
 	}
 	for _, c := range cases {
 		if got := eval(t, ioFdProg(c.body)); got != c.want {
@@ -221,16 +225,21 @@ func TestIOOpenBlock(t *testing.T) {
 	}
 }
 
-// TestIORbWarnSilentByDefault confirms rbWarn's $VERBOSE gate: with no warning
-// level set the ignored-encoding override is silent, yet still resolves the
-// external encoding to the winning option. $VERBOSE itself READS false, not nil
-// — ruby.c v3_4_0 ruby_prog_init binds it to ruby_verbose, which the interpreter
-// starts at Qfalse and only -W0 moves to nil (`ruby -e "p $VERBOSE"` prints
-// false on 4.0.5). rbgo's rb_warn gate still keys on the raw, unset slot, which
-// is why nothing is printed here.
-func TestIORbWarnSilentByDefault(t *testing.T) {
+// TestIORbWarnSpeaksAtTheDefaultLevel is the same probe this file used to run
+// under the name TestIORbWarnSilentByDefault, inverted, because the behaviour it
+// asserted was rbgo's defect and its own comment said so: "rbgo's rb_warn gate
+// still keys on the raw, unset slot, which is why nothing is printed here".
+//
+// $VERBOSE READS false, not nil — ruby.c ruby_prog_init binds it to ruby_verbose,
+// which starts at Qfalse and only -W0 moves to nil — and error.c rb_warn fires on
+// anything non-nil. So MRI prints the override warning with no -w at all, and the
+// interesting property is that $VERBOSE still reads false while it does: the value
+// a program can SEE has one representation now, and the gate reads that one.
+func TestIORbWarnSpeaksAtTheDefaultLevel(t *testing.T) {
 	got := eval(t, ioFdProg(`io = IO.new(wo, "w", external_encoding: "ibm866", encoding: "utf-8"); p [$VERBOSE, io.external_encoding.to_s]`))
-	if want := fmt.Sprintf("[false, %q]\n", "IBM866"); got != want {
-		t.Errorf("silent warn: got %q want %q", got, want)
+	want := "(rbgo):7: warning: Ignoring encoding parameter 'utf-8': external_encoding is used\n" +
+		fmt.Sprintf("[false, %q]\n", "IBM866")
+	if got != want {
+		t.Errorf("default-level warn: got %q want %q", got, want)
 	}
 }
diff --git a/internal/vm/modulefunc.go b/internal/vm/modulefunc.go
index 2087b8a0..f146e68d 100644
--- a/internal/vm/modulefunc.go
+++ b/internal/vm/modulefunc.go
@@ -191,7 +191,7 @@ func (vm *VM) registerModuleExtras() {
 			vm.raiseFrozen(mod)
 		}
 		skip := func(name, why string) {
-			vm.rbWarn("warning: Skipping set of ruby2_keywords flag for %s (%s)", name, why)
+			vm.rbWarnf("Skipping set of ruby2_keywords flag for %s (%s)", name, why)
 		}
 		for _, a := range args {
 			name := vm.coerceNameArg(a)
diff --git a/internal/vm/phase5f_test.go b/internal/vm/phase5f_test.go
index bc52e593..9ef093ce 100644
--- a/internal/vm/phase5f_test.go
+++ b/internal/vm/phase5f_test.go
@@ -10,7 +10,11 @@ func TestConstantAssignment(t *testing.T) {
 		{"int", "X = 5\np X", "5\n"},
 		{"float", "PI = 3.14\np PI", "3.14\n"},
 		{"expr", "X = 5\nY = X + 1\np Y", "6\n"},
-		{"reassign", "X = 1\nX = 2\np X", "2\n"},
+		// The reassignment warns, as it does in MRI (variable.c const_tbl_update).
+		// One line, not two: eval() compiles a path-less ISeq, so no location is
+		// recorded for X and MRI's ce->file guard suppresses "previous definition".
+		{"reassign", "X = 1\nX = 2\np X",
+			"(rbgo):2: warning: already initialized constant X\n2\n"},
 		{"string", "NAME = \"ruby\"\np NAME", "\"ruby\"\n"},
 	}
 	for _, tc := range tests {
diff --git a/internal/vm/prelude.rb b/internal/vm/prelude.rb
index dc5ec238..af0c4bbc 100644
--- a/internal/vm/prelude.rb
+++ b/internal/vm/prelude.rb
@@ -201,6 +201,11 @@ def count(*args)
     raise ArgumentError, "wrong number of arguments (given #{args.length}, expected 0..1)" if args.length > 1
     n = 0
     if !args.empty?
+      # enum.c v3_4_0 enum_count: an item argument makes the block dead, and MRI
+      # says so through rb_warn. `warn ..., uplevel: 1` IS rb_warn here -- same
+      # gate (Kernel#warn is `!NIL_P(ruby_verbose)`), same sink (Warning.warn) and
+      # the caller's "path:lineno: warning: " rather than this prelude's.
+      warn "given block not used", uplevel: 1 if block_given?
       item = args[0]
       each { |*a| n = n + 1 if __pack(a) == item }
     elsif block_given?
@@ -350,6 +355,11 @@ def reduce(*args)
     has_init = false
     init = nil
     if args.length == 2
+      # enum.c v3_4_0 enum_inject, the two-argument arm: the block is dead and MRI
+      # warns -- but through rb_warning, not rb_warn, so ONLY a true $VERBOSE
+      # prints it. The explicit `$VERBOSE` test is what turns Kernel#warn's
+      # non-nil gate into rb_warning's RTEST one.
+      warn "given block not used", uplevel: 1 if block_given? && $VERBOSE
       init = args[0]
       sym = args[1]
       has_init = true
@@ -393,6 +403,9 @@ def reduce(*args)
   # records whether a pattern was actually passed.
   def any?(pattern = (no_pat = true; nil))
     blk = block_given?
+    # enum.c v3_4_0 WARN_UNUSED_BLOCK(argc): a pattern argument makes the block
+    # dead. rb_warn, so the default $VERBOSE == false still prints it.
+    warn "given block not used", uplevel: 1 if blk && !no_pat
     catch(:__enum_any) do
       each { |*a|
         truth = no_pat ? (blk ? yield(*a) : __pack(a)) : (pattern === __pack(a))
@@ -404,6 +417,9 @@ def any?(pattern = (no_pat = true; nil))
 
   def all?(pattern = (no_pat = true; nil))
     blk = block_given?
+    # enum.c v3_4_0 WARN_UNUSED_BLOCK(argc): a pattern argument makes the block
+    # dead. rb_warn, so the default $VERBOSE == false still prints it.
+    warn "given block not used", uplevel: 1 if blk && !no_pat
     catch(:__enum_all) do
       each { |*a|
         truth = no_pat ? (blk ? yield(*a) : __pack(a)) : (pattern === __pack(a))
@@ -415,6 +431,9 @@ def all?(pattern = (no_pat = true; nil))
 
   def none?(pattern = (no_pat = true; nil))
     blk = block_given?
+    # enum.c v3_4_0 WARN_UNUSED_BLOCK(argc): a pattern argument makes the block
+    # dead. rb_warn, so the default $VERBOSE == false still prints it.
+    warn "given block not used", uplevel: 1 if blk && !no_pat
     catch(:__enum_none) do
       each { |*a|
         truth = no_pat ? (blk ? yield(*a) : __pack(a)) : (pattern === __pack(a))
@@ -430,6 +449,8 @@ def none?(pattern = (no_pat = true; nil))
   # matches against the packed value.
   def one?(pattern = (no_pat = true; nil))
     blk = block_given?
+    # enum.c v3_4_0 WARN_UNUSED_BLOCK(argc), as in any?/all?/none? above.
+    warn "given block not used", uplevel: 1 if blk && !no_pat
     n = 0
     catch(:__enum_one) do
       each { |*a|
@@ -641,6 +662,8 @@ def zip(*others)
   def find_index(*args)
     raise ArgumentError, "wrong number of arguments (given #{args.length}, expected 0..1)" if args.length > 1
     return enum_for(:find_index) { nil } if args.empty? && !block_given?
+    # enum.c v3_4_0 enum_find_index: a value argument makes the block dead.
+    warn "given block not used", uplevel: 1 if !args.empty? && block_given?
     idx = nil
     i = 0
     each { |*a|
@@ -2258,7 +2281,12 @@ def render(_scope = Object.new, locals = {})
     end
   end
 
-  Engine = Template
+  # Slim::Engine is NOT assigned here: slim.go's registerSlim already binds it to
+  # this same Template class, and re-assigning a constant that is already
+  # initialised is exactly what MRI's const_tbl_update warns about. It stayed
+  # invisible while rb_warn was gated on an unset $VERBOSE slot; with the gate
+  # fixed it printed "already initialized constant Slim::Engine" on EVERY run,
+  # a warning MRI never emits.
 end
 
 # ---------------------------------------------------------------------------
@@ -2344,7 +2372,8 @@ def render(_scope = Object.new, locals = {})
     end
   end
 
-  Engine = Template
+  # Haml::Engine: as with Slim above, haml.go's registerHaml already binds it to
+  # this Template class, so assigning it here only warned.
 end
 
 # ---------------------------------------------------------------------------
@@ -2414,7 +2443,8 @@ def self.reason; "needless argument"; end
                       :conv, :desc, :block)
 end
 
-OptParse = OptionParser
+# OptParse: optparse.go's registerOptionParser already binds both OptParse and
+# OptionParser::OptParse to this class, so assigning it here only warned.
 
 # ---------------------------------------------------------------------------
 # Tempfile (tempfile): a from-scratch pure-Ruby temporary file built over File
diff --git a/internal/vm/prelude_frozen_gen.go b/internal/vm/prelude_frozen_gen.go
index 871ae45a..5ddd5c02 100644
--- a/internal/vm/prelude_frozen_gen.go
+++ b/internal/vm/prelude_frozen_gen.go
@@ -11,15 +11,15 @@ import (
 func embeddedPrelude() *bytecode.ISeq {
 	return &bytecode.ISeq{
 		Name:        "<main>",
-		Insns:       []bytecode.Instr{{Op: 43}, {Op: 9}, {Op: 43, 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: 42, A: 7, B: 7}, {Op: 9}, {Op: 42, A: 8, B: 8}, {Op: 9}, {Op: 42, A: 9, B: 9}, {Op: 9}, {Op: 42, A: 10, B: 10}, {Op: 9}, {Op: 43, A: 11, B: 11}, {Op: 9}, {Op: 42, A: 12, B: 12}, {Op: 9}, {Op: 43, A: 13, B: 13}, {Op: 9}, {Op: 43, A: 14, B: 14}, {Op: 9}, {Op: 42, A: 15, B: 15}, {Op: 9}, {Op: 42, A: 16, B: 16}, {Op: 9}, {Op: 44, A: 17, B: 17}, {Op: 9}, {Op: 42, A: 18, B: 18}, {Op: 9}, {Op: 43, A: 19, B: 19}, {Op: 9}, {Op: 42, A: 20, B: 20}, {Op: 9}, {Op: 43, A: 21, B: 21}, {Op: 9}, {Op: 43, A: 22, B: 22}, {Op: 9}, {Op: 42, A: 23, B: 23}, {Op: 9}, {Op: 33, A: 23}, {Op: 41, A: 24}, {Op: 9}, {Op: 42, A: 25, B: 24}, {Op: 9}, {Op: 43, A: 26, B: 25}, {Op: 9}, {Op: 43, A: 27, B: 26}, {Op: 53}},
-		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", "Kernel"},
+		Insns:       []bytecode.Instr{{Op: 43}, {Op: 9}, {Op: 43, 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: 42, A: 7, B: 7}, {Op: 9}, {Op: 42, A: 8, B: 8}, {Op: 9}, {Op: 42, A: 9, B: 9}, {Op: 9}, {Op: 42, A: 10, B: 10}, {Op: 9}, {Op: 43, A: 11, B: 11}, {Op: 9}, {Op: 42, A: 12, B: 12}, {Op: 9}, {Op: 43, A: 13, B: 13}, {Op: 9}, {Op: 43, A: 14, B: 14}, {Op: 9}, {Op: 42, A: 15, B: 15}, {Op: 9}, {Op: 42, A: 16, B: 16}, {Op: 9}, {Op: 44, A: 17, B: 17}, {Op: 9}, {Op: 42, A: 18, B: 18}, {Op: 9}, {Op: 43, A: 19, B: 19}, {Op: 9}, {Op: 42, A: 20, B: 20}, {Op: 9}, {Op: 43, A: 21, B: 21}, {Op: 9}, {Op: 43, A: 22, B: 22}, {Op: 9}, {Op: 42, A: 23, B: 23}, {Op: 9}, {Op: 42, A: 24, B: 24}, {Op: 9}, {Op: 43, A: 25, B: 25}, {Op: 9}, {Op: 43, A: 26, B: 26}, {Op: 53}},
+		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", "Tempfile", "Warning", "Kernel"},
 		NumRequired: 0,
 		SplatIndex:  -1,
 		PostCount:   0,
 		KwRestSlot:  -1,
 		BlockSlot:   -1,
 		NumLocals:   0,
-		Lines:       []bytecode.LineEntry{{PC: 0, Line: 10}, {PC: 2, Line: 116}, {PC: 4, Line: 975}, {PC: 6, Line: 990}, {PC: 8, Line: 1001}, {PC: 10, Line: 1014}, {PC: 12, Line: 1018}, {PC: 14, Line: 1027}, {PC: 16, Line: 1036}, {PC: 18, Line: 1069}, {PC: 20, Line: 1084}, {PC: 22, Line: 1456}, {PC: 24, Line: 1676}, {PC: 26, Line: 1755}, {PC: 28, Line: 1786}, {PC: 30, Line: 1806}, {PC: 32, Line: 1846}, {PC: 34, Line: 1859}, {PC: 36, Line: 1899}, {PC: 38, Line: 2070}, {PC: 40, Line: 2106}, {PC: 42, Line: 2170}, {PC: 44, Line: 2273}, {PC: 46, Line: 2372}, {PC: 48, Line: 2417}, {PC: 51, Line: 2427}, {PC: 53, Line: 2552}, {PC: 55, Line: 2610}},
+		Lines:       []bytecode.LineEntry{{PC: 0, Line: 10}, {PC: 2, Line: 116}, {PC: 4, Line: 998}, {PC: 6, Line: 1013}, {PC: 8, Line: 1024}, {PC: 10, Line: 1037}, {PC: 12, Line: 1041}, {PC: 14, Line: 1050}, {PC: 16, Line: 1059}, {PC: 18, Line: 1092}, {PC: 20, Line: 1107}, {PC: 22, Line: 1479}, {PC: 24, Line: 1699}, {PC: 26, Line: 1778}, {PC: 28, Line: 1809}, {PC: 30, Line: 1829}, {PC: 32, Line: 1869}, {PC: 34, Line: 1882}, {PC: 36, Line: 1922}, {PC: 38, Line: 2093}, {PC: 40, Line: 2129}, {PC: 42, Line: 2193}, {PC: 44, Line: 2301}, {PC: 46, Line: 2401}, {PC: 48, Line: 2457}, {PC: 50, Line: 2582}, {PC: 52, Line: 2640}},
 		FirstLine:   1,
 		Children: []*bytecode.ISeq{
 			&bytecode.ISeq{
@@ -56,7 +56,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   4,
 						Locals:      []string{"other", "cmp", "", "right"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 5, Line: 18}, {PC: 8, Line: 19}, {PC: 23, Line: 254}, {PC: 36, Line: 21}, {PC: 39, Line: 23}, {PC: 43, Line: 25}, {PC: 49, Line: 109}, {PC: 56, Line: 25}, {PC: 66, Line: 27}},
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 5, Line: 18}, {PC: 8, Line: 19}, {PC: 23, Line: 259}, {PC: 36, Line: 21}, {PC: 39, Line: 23}, {PC: 43, Line: 25}, {PC: 49, Line: 109}, {PC: 56, Line: 25}, {PC: 66, Line: 27}},
 						FirstLine:   16,
 						Super:       "",
 					},
@@ -225,7 +225,7 @@ func embeddedPrelude() *bytecode.ISeq {
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
-				Lines:       []bytecode.LineEntry{{PC: 0, Line: 122}, {PC: 2, Line: 131}, {PC: 4, Line: 139}, {PC: 6, Line: 155}, {PC: 12, Line: 159}, {PC: 14, Line: 164}, {PC: 16, Line: 169}, {PC: 18, Line: 176}, {PC: 20, Line: 188}, {PC: 22, Line: 198}, {PC: 24, Line: 200}, {PC: 26, Line: 216}, {PC: 28, Line: 221}, {PC: 30, Line: 226}, {PC: 32, Line: 230}, {PC: 34, Line: 235}, {PC: 36, Line: 241}, {PC: 38, Line: 243}, {PC: 40, Line: 253}, {PC: 42, Line: 268}, {PC: 44, Line: 270}, {PC: 46, Line: 275}, {PC: 48, Line: 280}, {PC: 50, Line: 305}, {PC: 52, Line: 322}, {PC: 54, Line: 339}, {PC: 56, Line: 343}, {PC: 58, Line: 388}, {PC: 60, Line: 394}, {PC: 62, Line: 405}, {PC: 64, Line: 416}, {PC: 66, Line: 431}, {PC: 68, Line: 450}, {PC: 70, Line: 477}, {PC: 72, Line: 483}, {PC: 74, Line: 497}, {PC: 76, Line: 503}, {PC: 78, Line: 519}, {PC: 80, Line: 526}, {PC: 82, Line: 532}, {PC: 84, Line: 538}, {PC: 86, Line: 548}, {PC: 88, Line: 562}, {PC: 90, Line: 576}, {PC: 92, Line: 612}, {PC: 94, Line: 641}, {PC: 96, Line: 653}, {PC: 98, Line: 657}, {PC: 100, Line: 663}, {PC: 102, Line: 669}, {PC: 104, Line: 684}, {PC: 106, Line: 701}, {PC: 108, Line: 721}, {PC: 110, Line: 745}, {PC: 112, Line: 767}, {PC: 114, Line: 781}, {PC: 116, Line: 798}, {PC: 118, Line: 818}, {PC: 120, Line: 844}, {PC: 122, Line: 877}, {PC: 124, Line: 900}, {PC: 126, Line: 923}, {PC: 128, Line: 930}},
+				Lines:       []bytecode.LineEntry{{PC: 0, Line: 122}, {PC: 2, Line: 131}, {PC: 4, Line: 139}, {PC: 6, Line: 155}, {PC: 12, Line: 159}, {PC: 14, Line: 164}, {PC: 16, Line: 169}, {PC: 18, Line: 176}, {PC: 20, Line: 188}, {PC: 22, Line: 198}, {PC: 24, Line: 200}, {PC: 26, Line: 221}, {PC: 28, Line: 226}, {PC: 30, Line: 231}, {PC: 32, Line: 235}, {PC: 34, Line: 240}, {PC: 36, Line: 246}, {PC: 38, Line: 248}, {PC: 40, Line: 258}, {PC: 42, Line: 273}, {PC: 44, Line: 275}, {PC: 46, Line: 280}, {PC: 48, Line: 285}, {PC: 50, Line: 310}, {PC: 52, Line: 327}, {PC: 54, Line: 344}, {PC: 56, Line: 348}, {PC: 58, Line: 398}, {PC: 60, Line: 404}, {PC: 62, Line: 418}, {PC: 64, Line: 432}, {PC: 66, Line: 450}, {PC: 68, Line: 471}, {PC: 70, Line: 498}, {PC: 72, Line: 504}, {PC: 74, Line: 518}, {PC: 76, Line: 524}, {PC: 78, Line: 540}, {PC: 80, Line: 547}, {PC: 82, Line: 553}, {PC: 84, Line: 559}, {PC: 86, Line: 569}, {PC: 88, Line: 583}, {PC: 90, Line: 597}, {PC: 92, Line: 633}, {PC: 94, Line: 662}, {PC: 96, Line: 676}, {PC: 98, Line: 680}, {PC: 100, Line: 686}, {PC: 102, Line: 692}, {PC: 104, Line: 707}, {PC: 106, Line: 724}, {PC: 108, Line: 744}, {PC: 110, Line: 768}, {PC: 112, Line: 790}, {PC: 114, Line: 804}, {PC: 116, Line: 821}, {PC: 118, Line: 841}, {PC: 120, Line: 867}, {PC: 122, Line: 900}, {PC: 124, Line: 923}, {PC: 126, Line: 946}, {PC: 128, Line: 953}},
 				FirstLine:   116,
 				Children: []*bytecode.ISeq{
 					&bytecode.ISeq{
@@ -276,7 +276,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"a"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 132}, {PC: 3, Line: 254}, {PC: 5, Line: 132}},
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 132}, {PC: 3, Line: 259}, {PC: 5, Line: 132}},
 						FirstLine:   131,
 						Super:       "",
 					},
@@ -460,15 +460,17 @@ 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, 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}},
+						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: 48}, {Op: 52}, {Op: 28, A: 38}, {Op: 5}, {Op: 1, A: 5}, {Op: 1, A: 6}, {Op: 1}, {Op: 7, A: 1}, {Op: 30, A: 5, B: 2}, {Op: 26, A: 39}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 1, A: 4}, {Op: 30, A: 6, B: 1, Flags: 3}, {Op: 12, A: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 7, C: 1}, {Op: 26, A: 55}, {Op: 52}, {Op: 28, A: 53}, {Op: 5}, {Op: 30, A: 7, C: 2}, {Op: 26, A: 55}, {Op: 5}, {Op: 30, A: 7, C: 3}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}},
 						Consts: []object.Value{
 							object.IntValue(1),
 							object.NewString(""),
 							object.NewString("wrong number of arguments (given "),
 							object.NewString(", expected 0..1)"),
 							object.IntValue(0),
+							object.NewString("given block not used"),
+							object.Symbol("uplevel"),
 						},
-						Names:       []string{"length", "ArgumentError", "to_s", "raise", "empty?", "[]", "each"},
+						Names:       []string{"length", "ArgumentError", "to_s", "raise", "empty?", "warn", "[]", "each"},
 						Params:      []string{"args"},
 						NumRequired: 0,
 						SplatIndex:  0,
@@ -477,7 +479,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   3,
 						Locals:      []string{"args", "n", "item"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 201}, {PC: 22, Line: 202}, {PC: 25, Line: 203}, {PC: 29, Line: 204}, {PC: 34, Line: 205}, {PC: 39, Line: 207}, {PC: 42, Line: 209}, {PC: 45, Line: 211}},
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 201}, {PC: 22, Line: 202}, {PC: 25, Line: 203}, {PC: 29, Line: 208}, {PC: 40, Line: 209}, {PC: 45, Line: 210}, {PC: 50, Line: 212}, {PC: 53, Line: 214}, {PC: 56, Line: 216}},
 						FirstLine:   200,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
@@ -495,8 +497,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"a"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 205}},
-								FirstLine:   205,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 210}},
+								FirstLine:   210,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -513,8 +515,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"a"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 207}},
-								FirstLine:   207,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 212}},
+								FirstLine:   212,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -531,8 +533,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"a"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 209}},
-								FirstLine:   209,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 214}},
+								FirstLine:   214,
 								Super:       "",
 							},
 						},
@@ -553,8 +555,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"args"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 217}, {PC: 16, Line: 218}},
-						FirstLine:   216,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 222}, {PC: 16, Line: 223}},
+						FirstLine:   221,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in min_by",
@@ -569,8 +571,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 217}},
-								FirstLine:   217,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 222}},
+								FirstLine:   222,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -584,8 +586,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"x"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 218}},
-								FirstLine:   218,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 223}},
+								FirstLine:   223,
 								Super:       "",
 							},
 						},
@@ -606,8 +608,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"args"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 222}, {PC: 16, Line: 223}},
-						FirstLine:   221,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 227}, {PC: 16, Line: 228}},
+						FirstLine:   226,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in max_by",
@@ -622,8 +624,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 222}},
-								FirstLine:   222,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 227}},
+								FirstLine:   227,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -637,8 +639,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"x"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 223}},
-								FirstLine:   223,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 228}},
+								FirstLine:   228,
 								Super:       "",
 							},
 						},
@@ -655,8 +657,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   0,
 						NumLocals:   1,
 						Locals:      []string{"block"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 227}},
-						FirstLine:   226,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 232}},
+						FirstLine:   231,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -672,8 +674,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 231}, {PC: 10, Line: 232}},
-						FirstLine:   230,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 236}, {PC: 10, Line: 237}},
+						FirstLine:   235,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in sort_by",
@@ -688,8 +690,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 231}},
-								FirstLine:   231,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 236}},
+								FirstLine:   236,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -703,8 +705,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"x"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 232}},
-								FirstLine:   232,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 237}},
+								FirstLine:   237,
 								Super:       "",
 							},
 						},
@@ -724,8 +726,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"r"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 236}, {PC: 10, Line: 237}, {PC: 13, Line: 238}, {PC: 16, Line: 239}},
-						FirstLine:   235,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 241}, {PC: 10, Line: 242}, {PC: 13, Line: 243}, {PC: 16, Line: 244}},
+						FirstLine:   240,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in select",
@@ -740,8 +742,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 236}},
-								FirstLine:   236,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 241}},
+								FirstLine:   241,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -756,8 +758,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"x"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 238}},
-								FirstLine:   238,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 243}},
+								FirstLine:   243,
 								Super:       "",
 							},
 						},
@@ -777,8 +779,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"r"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 244}, {PC: 10, Line: 245}, {PC: 13, Line: 246}, {PC: 16, Line: 247}},
-						FirstLine:   243,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 249}, {PC: 10, Line: 250}, {PC: 13, Line: 251}, {PC: 16, Line: 252}},
+						FirstLine:   248,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in reject",
@@ -793,8 +795,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 244}},
-								FirstLine:   244,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 249}},
+								FirstLine:   249,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -809,8 +811,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"x"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 246}},
-								FirstLine:   246,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 251}},
+								FirstLine:   251,
 								Super:       "",
 							},
 						},
@@ -831,8 +833,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   3,
 						Locals:      []string{"ifnone", "found", "result"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 253}, {PC: 2, Line: 254}, {PC: 16, Line: 255}, {PC: 19, Line: 254}, {PC: 22, Line: 257}, {PC: 25, Line: 265}, {PC: 32, Line: 266}, {PC: 35, Line: 254}},
-						FirstLine:   253,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 258}, {PC: 2, Line: 259}, {PC: 16, Line: 260}, {PC: 19, Line: 259}, {PC: 22, Line: 262}, {PC: 25, Line: 270}, {PC: 32, Line: 271}, {PC: 35, Line: 259}},
+						FirstLine:   258,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in find",
@@ -843,8 +845,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 254}},
-								FirstLine:   254,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 259}},
+								FirstLine:   259,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -858,8 +860,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"x"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 258}, {PC: 3, Line: 259}, {PC: 6, Line: 260}, {PC: 9, Line: 261}},
-								FirstLine:   257,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 263}, {PC: 3, Line: 264}, {PC: 6, Line: 265}, {PC: 9, Line: 266}},
+								FirstLine:   262,
 								Super:       "",
 							},
 						},
@@ -877,8 +879,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   2,
 						Locals:      []string{"value", "found"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 271}, {PC: 3, Line: 272}, {PC: 6, Line: 273}},
-						FirstLine:   270,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 276}, {PC: 3, Line: 277}, {PC: 6, Line: 278}},
+						FirstLine:   275,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in include?",
@@ -891,8 +893,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"x"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 272}},
-								FirstLine:   272,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 277}},
+								FirstLine:   277,
 								Super:       "",
 							},
 						},
@@ -914,8 +916,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   4,
 						Locals:      []string{"init", "total", "compensation", "float_mode"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 280}, {PC: 5, Line: 281}, {PC: 8, Line: 282}, {PC: 11, Line: 283}, {PC: 16, Line: 284}, {PC: 19, Line: 298}},
-						FirstLine:   280,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 285}, {PC: 5, Line: 286}, {PC: 8, Line: 287}, {PC: 11, Line: 288}, {PC: 16, Line: 289}, {PC: 19, Line: 303}},
+						FirstLine:   285,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in sum",
@@ -929,8 +931,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   3,
 								Locals:      []string{"x", "v", "t"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 285}, {PC: 8, Line: 286}, {PC: 17, Line: 287}, {PC: 21, Line: 288}, {PC: 26, Line: 290}, {PC: 34, Line: 291}, {PC: 39, Line: 292}, {PC: 60, Line: 293}, {PC: 63, Line: 295}},
-								FirstLine:   284,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 290}, {PC: 8, Line: 291}, {PC: 17, Line: 292}, {PC: 21, Line: 293}, {PC: 26, Line: 295}, {PC: 34, Line: 296}, {PC: 39, Line: 297}, {PC: 60, Line: 298}, {PC: 63, Line: 300}},
+								FirstLine:   289,
 								Super:       "",
 							},
 						},
@@ -948,8 +950,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   1,
 						NumLocals:   4,
 						Locals:      []string{"n", "block", "result", "first"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 305}, {PC: 2, Line: 254}, {PC: 5, Line: 306}, {PC: 19, Line: 254}, {PC: 22, Line: 308}, {PC: 25, Line: 309}, {PC: 28, Line: 319}},
-						FirstLine:   305,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 310}, {PC: 2, Line: 259}, {PC: 5, Line: 311}, {PC: 19, Line: 259}, {PC: 22, Line: 313}, {PC: 25, Line: 314}, {PC: 28, Line: 324}},
+						FirstLine:   310,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in min",
@@ -970,8 +972,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   2,
 								Locals:      []string{"x", "c"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 310}, {PC: 2, Line: 311}, {PC: 5, Line: 312}, {PC: 8, Line: 314}, {PC: 20, Line: 315}, {PC: 47, Line: 316}},
-								FirstLine:   309,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 315}, {PC: 2, Line: 316}, {PC: 5, Line: 317}, {PC: 8, Line: 319}, {PC: 20, Line: 320}, {PC: 47, Line: 321}},
+								FirstLine:   314,
 								Super:       "",
 							},
 						},
@@ -989,8 +991,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   1,
 						NumLocals:   4,
 						Locals:      []string{"n", "block", "result", "first"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 322}, {PC: 2, Line: 254}, {PC: 5, Line: 323}, {PC: 20, Line: 254}, {PC: 23, Line: 325}, {PC: 26, Line: 326}, {PC: 29, Line: 336}},
-						FirstLine:   322,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 327}, {PC: 2, Line: 259}, {PC: 5, Line: 328}, {PC: 20, Line: 259}, {PC: 23, Line: 330}, {PC: 26, Line: 331}, {PC: 29, Line: 341}},
+						FirstLine:   327,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in max",
@@ -1011,8 +1013,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   2,
 								Locals:      []string{"x", "c"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 327}, {PC: 2, Line: 328}, {PC: 5, Line: 329}, {PC: 8, Line: 331}, {PC: 20, Line: 332}, {PC: 47, Line: 333}},
-								FirstLine:   326,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 332}, {PC: 2, Line: 333}, {PC: 5, Line: 334}, {PC: 8, Line: 336}, {PC: 20, Line: 337}, {PC: 47, Line: 338}},
+								FirstLine:   331,
 								Super:       "",
 							},
 						},
@@ -1029,27 +1031,29 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   0,
 						NumLocals:   1,
 						Locals:      []string{"block"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 340}},
-						FirstLine:   339,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 345}},
+						FirstLine:   344,
 						Super:       "",
 					},
 					&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, 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}},
+						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: 64}, {Op: 52}, {Op: 10}, {Op: 28, A: 41}, {Op: 9}, {Op: 36, A: 4}, {Op: 28, A: 49}, {Op: 5}, {Op: 1, A: 4}, {Op: 1, A: 5}, {Op: 1, A: 6}, {Op: 7, A: 1}, {Op: 30, A: 5, B: 2}, {Op: 26, A: 50}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 1, A: 7}, {Op: 30, A: 6, B: 1, Flags: 3}, {Op: 12, A: 3}, {Op: 9}, {Op: 11}, {Op: 1, A: 6}, {Op: 30, A: 6, B: 1, Flags: 3}, {Op: 12, A: 1}, {Op: 9}, {Op: 3}, {Op: 12, A: 2}, {Op: 26, A: 93}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 1, A: 6}, {Op: 22}, {Op: 28, A: 84}, {Op: 52}, {Op: 28, A: 79}, {Op: 11}, {Op: 1, A: 7}, {Op: 30, A: 6, B: 1, Flags: 3}, {Op: 12, A: 3}, {Op: 9}, {Op: 3}, {Op: 12, A: 2}, {Op: 26, A: 83}, {Op: 11}, {Op: 1, A: 7}, {Op: 30, A: 6, B: 1, Flags: 3}, {Op: 12, A: 1}, {Op: 26, A: 93}, {Op: 52}, {Op: 25}, {Op: 28, A: 92}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 8}, {Op: 30, A: 3, B: 2, Flags: 2}, {Op: 26, A: 93}, {Op: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 7, Flags: 1}, {Op: 10}, {Op: 27, A: 102}, {Op: 9}, {Op: 11, A: 1}, {Op: 33, A: 8}, {Op: 30, A: 9, B: 1, Flags: 3}, {Op: 10}, {Op: 27, A: 108}, {Op: 9}, {Op: 11, A: 1}, {Op: 33, A: 10}, {Op: 30, A: 9, B: 1, Flags: 3}, {Op: 25}, {Op: 28, A: 133}, {Op: 11, A: 1}, {Op: 1, A: 9}, {Op: 30, A: 11, B: 1, Flags: 3}, {Op: 28, A: 118}, {Op: 11, A: 1}, {Op: 30, A: 12, Flags: 1}, {Op: 12, A: 1}, {Op: 26, A: 132}, {Op: 5}, {Op: 33, A: 13}, {Op: 1, A: 10}, {Op: 1, A: 11}, {Op: 30, A: 2}, {Op: 13}, {Op: 11, A: 1}, {Op: 30, A: 14, Flags: 1}, {Op: 30, A: 2}, {Op: 13}, {Op: 1, A: 12}, {Op: 30, A: 2}, {Op: 13}, {Op: 30, A: 3, B: 2, Flags: 2}, {Op: 26, A: 134}, {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: 15, C: 1}, {Op: 9}, {Op: 11, A: 4}, {Op: 53}},
 						Consts: []object.Value{
 							object.IntValue(2),
 							object.NewString(""),
 							object.NewString("wrong number of arguments (given "),
 							object.NewString(", expected 1..2)"),
-							object.IntValue(0),
+							object.NewString("given block not used"),
+							object.Symbol("uplevel"),
 							object.IntValue(1),
+							object.IntValue(0),
 							object.NewString("wrong number of arguments (given 0, expected 1..2)"),
 							object.Symbol("to_str"),
 							object.NewString(""),
 							object.NewString(""),
 							object.NewString(" is not a symbol nor a string"),
 						},
-						Names:       []string{"length", "ArgumentError", "to_s", "raise", "[]", "nil?", "Symbol", "is_a?", "String", "respond_to?", "to_str", "TypeError", "inspect", "__each_packed"},
+						Names:       []string{"length", "ArgumentError", "to_s", "raise", "$VERBOSE", "warn", "[]", "nil?", "Symbol", "is_a?", "String", "respond_to?", "to_str", "TypeError", "inspect", "__each_packed"},
 						Params:      []string{"args"},
 						NumRequired: 0,
 						SplatIndex:  0,
@@ -1058,8 +1062,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   6,
 						Locals:      []string{"args", "sym", "has_init", "init", "acc", "started"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 348}, {PC: 22, Line: 254}, {PC: 25, Line: 350}, {PC: 28, Line: 254}, {PC: 31, Line: 352}, {PC: 36, Line: 353}, {PC: 41, Line: 354}, {PC: 46, Line: 355}, {PC: 54, Line: 357}, {PC: 56, Line: 358}, {PC: 61, Line: 359}, {PC: 64, Line: 361}, {PC: 72, Line: 364}, {PC: 79, Line: 366}, {PC: 95, Line: 367}, {PC: 99, Line: 368}, {PC: 103, Line: 370}, {PC: 120, Line: 373}, {PC: 123, Line: 374}, {PC: 126, Line: 375}, {PC: 129, Line: 385}},
-						FirstLine:   343,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 353}, {PC: 22, Line: 259}, {PC: 25, Line: 355}, {PC: 28, Line: 259}, {PC: 31, Line: 357}, {PC: 36, Line: 362}, {PC: 51, Line: 363}, {PC: 56, Line: 364}, {PC: 61, Line: 365}, {PC: 69, Line: 367}, {PC: 71, Line: 368}, {PC: 76, Line: 369}, {PC: 79, Line: 371}, {PC: 87, Line: 374}, {PC: 94, Line: 376}, {PC: 110, Line: 377}, {PC: 114, Line: 378}, {PC: 118, Line: 380}, {PC: 135, Line: 383}, {PC: 138, Line: 384}, {PC: 141, Line: 385}, {PC: 144, Line: 395}},
+						FirstLine:   348,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in reduce",
@@ -1073,8 +1077,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"x"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 376}, {PC: 3, Line: 377}, {PC: 6, Line: 378}, {PC: 11, Line: 380}, {PC: 17, Line: 382}},
-								FirstLine:   375,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 386}, {PC: 3, Line: 387}, {PC: 6, Line: 388}, {PC: 11, Line: 390}, {PC: 17, Line: 392}},
+								FirstLine:   385,
 								Super:       "",
 							},
 						},
@@ -1082,11 +1086,14 @@ 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, Flags: 2}, {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: 11, A: 2}, {Op: 10}, {Op: 28, A: 17}, {Op: 9}, {Op: 11, A: 1}, {Op: 25}, {Op: 28, A: 25}, {Op: 5}, {Op: 1}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 7, A: 1}, {Op: 30, B: 2}, {Op: 26, A: 26}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 1, A: 3}, {Op: 30, A: 1, B: 1, C: 1, Flags: 2}, {Op: 53}},
 						Consts: []object.Value{
+							object.NewString("given block not used"),
+							object.Symbol("uplevel"),
+							object.IntValue(1),
 							object.Symbol("__enum_any"),
 						},
-						Names:       []string{"catch"},
+						Names:       []string{"warn", "catch"},
 						Params:      []string{"pattern"},
 						NumRequired: 0,
 						SplatIndex:  -1,
@@ -1095,8 +1102,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   3,
 						Locals:      []string{"pattern", "no_pat", "blk"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 394}, {PC: 5, Line: 254}, {PC: 8, Line: 395}, {PC: 11, Line: 396}},
-						FirstLine:   394,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 404}, {PC: 5, Line: 259}, {PC: 8, Line: 405}, {PC: 11, Line: 408}, {PC: 27, Line: 409}},
+						FirstLine:   404,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in any?",
@@ -1108,8 +1115,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 397}, {PC: 3, Line: 401}},
-								FirstLine:   396,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 410}, {PC: 3, Line: 414}},
+								FirstLine:   409,
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:  "block (2 levels) in any?",
@@ -1126,8 +1133,8 @@ func embeddedPrelude() *bytecode.ISeq {
 										BlockSlot:   -1,
 										NumLocals:   2,
 										Locals:      []string{"a", "truth"},
-										Lines:       []bytecode.LineEntry{{PC: 0, Line: 398}, {PC: 21, Line: 399}},
-										FirstLine:   397,
+										Lines:       []bytecode.LineEntry{{PC: 0, Line: 411}, {PC: 21, Line: 412}},
+										FirstLine:   410,
 										Super:       "",
 									},
 								},
@@ -1138,11 +1145,14 @@ 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, Flags: 2}, {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: 11, A: 2}, {Op: 10}, {Op: 28, A: 17}, {Op: 9}, {Op: 11, A: 1}, {Op: 25}, {Op: 28, A: 25}, {Op: 5}, {Op: 1}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 7, A: 1}, {Op: 30, B: 2}, {Op: 26, A: 26}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 1, A: 3}, {Op: 30, A: 1, B: 1, C: 1, Flags: 2}, {Op: 53}},
 						Consts: []object.Value{
+							object.NewString("given block not used"),
+							object.Symbol("uplevel"),
+							object.IntValue(1),
 							object.Symbol("__enum_all"),
 						},
-						Names:       []string{"catch"},
+						Names:       []string{"warn", "catch"},
 						Params:      []string{"pattern"},
 						NumRequired: 0,
 						SplatIndex:  -1,
@@ -1151,8 +1161,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   3,
 						Locals:      []string{"pattern", "no_pat", "blk"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 405}, {PC: 5, Line: 254}, {PC: 8, Line: 406}, {PC: 11, Line: 407}},
-						FirstLine:   405,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 418}, {PC: 5, Line: 259}, {PC: 8, Line: 419}, {PC: 11, Line: 422}, {PC: 27, Line: 423}},
+						FirstLine:   418,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in all?",
@@ -1164,8 +1174,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 408}, {PC: 3, Line: 412}},
-								FirstLine:   407,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 424}, {PC: 3, Line: 428}},
+								FirstLine:   423,
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:  "block (2 levels) in all?",
@@ -1182,8 +1192,8 @@ func embeddedPrelude() *bytecode.ISeq {
 										BlockSlot:   -1,
 										NumLocals:   2,
 										Locals:      []string{"a", "truth"},
-										Lines:       []bytecode.LineEntry{{PC: 0, Line: 409}, {PC: 21, Line: 410}},
-										FirstLine:   408,
+										Lines:       []bytecode.LineEntry{{PC: 0, Line: 425}, {PC: 21, Line: 426}},
+										FirstLine:   424,
 										Super:       "",
 									},
 								},
@@ -1194,11 +1204,14 @@ 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, Flags: 2}, {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: 11, A: 2}, {Op: 10}, {Op: 28, A: 17}, {Op: 9}, {Op: 11, A: 1}, {Op: 25}, {Op: 28, A: 25}, {Op: 5}, {Op: 1}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 7, A: 1}, {Op: 30, B: 2}, {Op: 26, A: 26}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 1, A: 3}, {Op: 30, A: 1, B: 1, C: 1, Flags: 2}, {Op: 53}},
 						Consts: []object.Value{
+							object.NewString("given block not used"),
+							object.Symbol("uplevel"),
+							object.IntValue(1),
 							object.Symbol("__enum_none"),
 						},
-						Names:       []string{"catch"},
+						Names:       []string{"warn", "catch"},
 						Params:      []string{"pattern"},
 						NumRequired: 0,
 						SplatIndex:  -1,
@@ -1207,8 +1220,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   3,
 						Locals:      []string{"pattern", "no_pat", "blk"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 416}, {PC: 5, Line: 254}, {PC: 8, Line: 417}, {PC: 11, Line: 418}},
-						FirstLine:   416,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 432}, {PC: 5, Line: 259}, {PC: 8, Line: 433}, {PC: 11, Line: 436}, {PC: 27, Line: 437}},
+						FirstLine:   432,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in none?",
@@ -1220,8 +1233,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 419}, {PC: 3, Line: 423}},
-								FirstLine:   418,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 438}, {PC: 3, Line: 442}},
+								FirstLine:   437,
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:  "block (2 levels) in none?",
@@ -1238,8 +1251,8 @@ func embeddedPrelude() *bytecode.ISeq {
 										BlockSlot:   -1,
 										NumLocals:   2,
 										Locals:      []string{"a", "truth"},
-										Lines:       []bytecode.LineEntry{{PC: 0, Line: 420}, {PC: 21, Line: 421}},
-										FirstLine:   419,
+										Lines:       []bytecode.LineEntry{{PC: 0, Line: 439}, {PC: 21, Line: 440}},
+										FirstLine:   438,
 										Super:       "",
 									},
 								},
@@ -1250,13 +1263,15 @@ 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, Flags: 2}, {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: 11, A: 2}, {Op: 10}, {Op: 28, A: 17}, {Op: 9}, {Op: 11, A: 1}, {Op: 25}, {Op: 28, A: 25}, {Op: 5}, {Op: 1}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 7, A: 1}, {Op: 30, B: 2}, {Op: 26, A: 26}, {Op: 2}, {Op: 9}, {Op: 1, A: 3}, {Op: 12, A: 3}, {Op: 9}, {Op: 5}, {Op: 1, A: 4}, {Op: 30, A: 1, B: 1, C: 1, Flags: 2}, {Op: 9}, {Op: 11, A: 3}, {Op: 1, A: 2}, {Op: 22}, {Op: 53}},
 						Consts: []object.Value{
+							object.NewString("given block not used"),
+							object.Symbol("uplevel"),
+							object.IntValue(1),
 							object.IntValue(0),
 							object.Symbol("__enum_one"),
-							object.IntValue(1),
 						},
-						Names:       []string{"catch"},
+						Names:       []string{"warn", "catch"},
 						Params:      []string{"pattern"},
 						NumRequired: 0,
 						SplatIndex:  -1,
@@ -1265,8 +1280,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   4,
 						Locals:      []string{"pattern", "no_pat", "blk", "n"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 431}, {PC: 5, Line: 254}, {PC: 8, Line: 432}, {PC: 11, Line: 433}, {PC: 14, Line: 434}, {PC: 18, Line: 443}},
-						FirstLine:   431,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 450}, {PC: 5, Line: 259}, {PC: 8, Line: 451}, {PC: 11, Line: 453}, {PC: 27, Line: 454}, {PC: 30, Line: 455}, {PC: 34, Line: 464}},
+						FirstLine:   450,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in one?",
@@ -1278,8 +1293,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 435}},
-								FirstLine:   434,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 456}},
+								FirstLine:   455,
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:  "block (2 levels) in one?",
@@ -1297,8 +1312,8 @@ func embeddedPrelude() *bytecode.ISeq {
 										BlockSlot:   -1,
 										NumLocals:   2,
 										Locals:      []string{"a", "truth"},
-										Lines:       []bytecode.LineEntry{{PC: 0, Line: 436}, {PC: 21, Line: 437}, {PC: 23, Line: 438}, {PC: 28, Line: 439}},
-										FirstLine:   435,
+										Lines:       []bytecode.LineEntry{{PC: 0, Line: 457}, {PC: 21, Line: 458}, {PC: 23, Line: 459}, {PC: 28, Line: 460}},
+										FirstLine:   456,
 										Super:       "",
 									},
 								},
@@ -1318,8 +1333,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   3,
 						Locals:      []string{"result", "keys", "hashes"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 451}, {PC: 3, Line: 452}, {PC: 6, Line: 453}, {PC: 9, Line: 454}, {PC: 12, Line: 472}},
-						FirstLine:   450,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 472}, {PC: 3, Line: 473}, {PC: 6, Line: 474}, {PC: 9, Line: 475}, {PC: 12, Line: 493}},
+						FirstLine:   471,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in uniq",
@@ -1337,8 +1352,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   6,
 								Locals:      []string{"x", "key", "h", "seen", "i", ""},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 455}, {PC: 8, Line: 456}, {PC: 12, Line: 457}, {PC: 15, Line: 458}, {PC: 18, Line: 459}, {PC: 23, Line: 460}, {PC: 37, Line: 461}, {PC: 40, Line: 462}, {PC: 47, Line: 464}, {PC: 57, Line: 466}, {PC: 60, Line: 467}, {PC: 64, Line: 468}, {PC: 68, Line: 469}},
-								FirstLine:   454,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 476}, {PC: 8, Line: 477}, {PC: 12, Line: 478}, {PC: 15, Line: 479}, {PC: 18, Line: 480}, {PC: 23, Line: 481}, {PC: 37, Line: 482}, {PC: 40, Line: 483}, {PC: 47, Line: 485}, {PC: 57, Line: 487}, {PC: 60, Line: 488}, {PC: 64, Line: 489}, {PC: 68, Line: 490}},
+								FirstLine:   475,
 								Super:       "",
 							},
 						},
@@ -1355,8 +1370,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"result"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 478}, {PC: 3, Line: 479}, {PC: 6, Line: 480}},
-						FirstLine:   477,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 499}, {PC: 3, Line: 500}, {PC: 6, Line: 501}},
+						FirstLine:   498,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in compact",
@@ -1370,8 +1385,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"x"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 479}},
-								FirstLine:   479,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 500}},
+								FirstLine:   500,
 								Super:       "",
 							},
 						},
@@ -1393,8 +1408,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   2,
 						Locals:      []string{"args", "i"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 484}, {PC: 16, Line: 485}, {PC: 19, Line: 486}, {PC: 26, Line: 109}},
-						FirstLine:   483,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 505}, {PC: 16, Line: 506}, {PC: 19, Line: 507}, {PC: 26, Line: 109}},
+						FirstLine:   504,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in each_with_index",
@@ -1409,8 +1424,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 484}},
-								FirstLine:   484,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 505}},
+								FirstLine:   505,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -1428,8 +1443,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"a"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 487}, {PC: 6, Line: 488}},
-								FirstLine:   486,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 508}, {PC: 6, Line: 509}},
+								FirstLine:   507,
 								Super:       "",
 							},
 						},
@@ -1449,8 +1464,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   0,
 						NumLocals:   1,
 						Locals:      []string{"block"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 498}, {PC: 10, Line: 499}, {PC: 15, Line: 109}},
-						FirstLine:   497,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 519}, {PC: 10, Line: 520}, {PC: 15, Line: 109}},
+						FirstLine:   518,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in reverse_each",
@@ -1465,8 +1480,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 498}, {PC: 7, Line: 254}},
-								FirstLine:   498,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 519}, {PC: 7, Line: 259}},
+								FirstLine:   519,
 								Super:       "",
 							},
 						},
@@ -1486,8 +1501,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"r"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 504}, {PC: 10, Line: 505}, {PC: 13, Line: 506}, {PC: 16, Line: 515}},
-						FirstLine:   503,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 525}, {PC: 10, Line: 526}, {PC: 13, Line: 527}, {PC: 16, Line: 536}},
+						FirstLine:   524,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in flat_map",
@@ -1502,8 +1517,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 504}},
-								FirstLine:   504,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 525}},
+								FirstLine:   525,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -1518,8 +1533,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   3,
 								Locals:      []string{"x", "v", "ary"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 507}, {PC: 4, Line: 508}, {PC: 9, Line: 509}, {PC: 12, Line: 510}, {PC: 16, Line: 512}},
-								FirstLine:   506,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 528}, {PC: 4, Line: 529}, {PC: 9, Line: 530}, {PC: 12, Line: 531}, {PC: 16, Line: 533}},
+								FirstLine:   527,
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:        "block (2 levels) in flat_map",
@@ -1533,8 +1548,8 @@ func embeddedPrelude() *bytecode.ISeq {
 										BlockSlot:   -1,
 										NumLocals:   1,
 										Locals:      []string{"e"},
-										Lines:       []bytecode.LineEntry{{PC: 0, Line: 512}},
-										FirstLine:   512,
+										Lines:       []bytecode.LineEntry{{PC: 0, Line: 533}},
+										FirstLine:   533,
 										Super:       "",
 									},
 								},
@@ -1558,8 +1573,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"args"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 527}, {PC: 16, Line: 528}, {PC: 23, Line: 109}},
-						FirstLine:   526,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 548}, {PC: 16, Line: 549}, {PC: 23, Line: 109}},
+						FirstLine:   547,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in each_entry",
@@ -1574,8 +1589,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 527}},
-								FirstLine:   527,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 548}},
+								FirstLine:   548,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -1590,8 +1605,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"a"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 528}},
-								FirstLine:   528,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 549}},
+								FirstLine:   549,
 								Super:       "",
 							},
 						},
@@ -1612,8 +1627,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"memo"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 533}, {PC: 11, Line: 534}, {PC: 14, Line: 535}},
-						FirstLine:   532,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 554}, {PC: 11, Line: 555}, {PC: 14, Line: 556}},
+						FirstLine:   553,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in each_with_object",
@@ -1628,8 +1643,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 533}},
-								FirstLine:   533,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 554}},
+								FirstLine:   554,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -1643,8 +1658,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"x"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 534}},
-								FirstLine:   534,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 555}},
+								FirstLine:   555,
 								Super:       "",
 							},
 						},
@@ -1664,8 +1679,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"r"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 539}, {PC: 10, Line: 540}, {PC: 13, Line: 541}, {PC: 16, Line: 545}},
-						FirstLine:   538,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 560}, {PC: 10, Line: 561}, {PC: 13, Line: 562}, {PC: 16, Line: 566}},
+						FirstLine:   559,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in filter_map",
@@ -1680,8 +1695,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 539}},
-								FirstLine:   539,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 560}},
+								FirstLine:   560,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -1696,8 +1711,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   2,
 								Locals:      []string{"x", "v"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 542}, {PC: 4, Line: 543}},
-								FirstLine:   541,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 563}, {PC: 4, Line: 564}},
+								FirstLine:   562,
 								Super:       "",
 							},
 						},
@@ -1717,8 +1732,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   2,
 						Locals:      []string{"yes", "no"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 549}, {PC: 10, Line: 550}, {PC: 13, Line: 551}, {PC: 16, Line: 552}, {PC: 19, Line: 559}},
-						FirstLine:   548,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 570}, {PC: 10, Line: 571}, {PC: 13, Line: 572}, {PC: 16, Line: 573}, {PC: 19, Line: 580}},
+						FirstLine:   569,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in partition",
@@ -1733,8 +1748,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 549}},
-								FirstLine:   549,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 570}},
+								FirstLine:   570,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -1749,8 +1764,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"x"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 553}, {PC: 3, Line: 554}, {PC: 7, Line: 556}},
-								FirstLine:   552,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 574}, {PC: 3, Line: 575}, {PC: 7, Line: 577}},
+								FirstLine:   573,
 								Super:       "",
 							},
 						},
@@ -1770,8 +1785,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"h"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 563}, {PC: 10, Line: 564}, {PC: 13, Line: 565}, {PC: 16, Line: 569}},
-						FirstLine:   562,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 584}, {PC: 10, Line: 585}, {PC: 13, Line: 586}, {PC: 16, Line: 590}},
+						FirstLine:   583,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in group_by",
@@ -1786,8 +1801,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 563}},
-								FirstLine:   563,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 584}},
+								FirstLine:   584,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -1802,8 +1817,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   5,
 								Locals:      []string{"x", "k", "", "", ""},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 566}, {PC: 4, Line: 567}},
-								FirstLine:   565,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 587}, {PC: 4, Line: 588}},
+								FirstLine:   586,
 								Super:       "",
 							},
 						},
@@ -1838,8 +1853,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   3,
 						Locals:      []string{"args", "h", "a"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 577}, {PC: 22, Line: 578}, {PC: 25, Line: 579}, {PC: 28, Line: 581}, {PC: 33, Line: 582}, {PC: 38, Line: 583}, {PC: 42, Line: 584}, {PC: 46, Line: 585}, {PC: 86, Line: 587}, {PC: 108, Line: 590}, {PC: 111, Line: 592}, {PC: 114, Line: 604}},
-						FirstLine:   576,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 598}, {PC: 22, Line: 599}, {PC: 25, Line: 600}, {PC: 28, Line: 602}, {PC: 33, Line: 603}, {PC: 38, Line: 604}, {PC: 42, Line: 605}, {PC: 46, Line: 606}, {PC: 86, Line: 608}, {PC: 108, Line: 611}, {PC: 111, Line: 613}, {PC: 114, Line: 625}},
+						FirstLine:   597,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in tally",
@@ -1863,8 +1878,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   4,
 								Locals:      []string{"x", "c", "tn", ""},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 593}, {PC: 4, Line: 594}, {PC: 9, Line: 595}, {PC: 14, Line: 596}, {PC: 35, Line: 597}, {PC: 51, Line: 600}, {PC: 54, Line: 602}},
-								FirstLine:   592,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 614}, {PC: 4, Line: 615}, {PC: 9, Line: 616}, {PC: 14, Line: 617}, {PC: 35, Line: 618}, {PC: 51, Line: 621}, {PC: 54, Line: 623}},
+								FirstLine:   613,
 								Super:       "",
 							},
 						},
@@ -1885,8 +1900,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   4,
 						Locals:      []string{"others", "blk", "r", "i"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 613}, {PC: 4, Line: 622}, {PC: 7, Line: 623}, {PC: 9, Line: 254}, {PC: 14, Line: 624}, {PC: 17, Line: 625}, {PC: 20, Line: 635}},
-						FirstLine:   612,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 634}, {PC: 4, Line: 643}, {PC: 7, Line: 644}, {PC: 9, Line: 259}, {PC: 14, Line: 645}, {PC: 17, Line: 646}, {PC: 20, Line: 656}},
+						FirstLine:   633,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in zip",
@@ -1907,8 +1922,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"o"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 614}, {PC: 4, Line: 615}, {PC: 11, Line: 617}, {PC: 16, Line: 619}},
-								FirstLine:   613,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 635}, {PC: 4, Line: 636}, {PC: 11, Line: 638}, {PC: 16, Line: 640}},
+								FirstLine:   634,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -1926,8 +1941,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   2,
 								Locals:      []string{"x", "row"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 626}, {PC: 4, Line: 627}, {PC: 7, Line: 628}, {PC: 9, Line: 629}, {PC: 12, Line: 631}, {PC: 16, Line: 633}},
-								FirstLine:   625,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 647}, {PC: 4, Line: 648}, {PC: 7, Line: 649}, {PC: 9, Line: 650}, {PC: 12, Line: 652}, {PC: 16, Line: 654}},
+								FirstLine:   646,
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:        "block (2 levels) in zip",
@@ -1941,8 +1956,8 @@ func embeddedPrelude() *bytecode.ISeq {
 										BlockSlot:   -1,
 										NumLocals:   1,
 										Locals:      []string{"o"},
-										Lines:       []bytecode.LineEntry{{PC: 0, Line: 627}},
-										FirstLine:   627,
+										Lines:       []bytecode.LineEntry{{PC: 0, Line: 648}},
+										FirstLine:   648,
 										Super:       "",
 									},
 								},
@@ -1953,16 +1968,18 @@ 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, 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}},
+						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: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 25}, {Op: 10}, {Op: 28, A: 44}, {Op: 9}, {Op: 52}, {Op: 28, A: 52}, {Op: 5}, {Op: 1, A: 5}, {Op: 1, A: 6}, {Op: 1}, {Op: 7, A: 1}, {Op: 30, A: 6, B: 2}, {Op: 26, A: 53}, {Op: 2}, {Op: 9}, {Op: 2}, {Op: 12, A: 1}, {Op: 9}, {Op: 1, A: 7}, {Op: 12, A: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 7, C: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}},
 						Consts: []object.Value{
 							object.IntValue(1),
 							object.NewString(""),
 							object.NewString("wrong number of arguments (given "),
 							object.NewString(", expected 0..1)"),
 							object.Symbol("find_index"),
+							object.NewString("given block not used"),
+							object.Symbol("uplevel"),
 							object.IntValue(0),
 						},
-						Names:       []string{"length", "ArgumentError", "to_s", "raise", "empty?", "enum_for", "each"},
+						Names:       []string{"length", "ArgumentError", "to_s", "raise", "empty?", "enum_for", "warn", "each"},
 						Params:      []string{"args"},
 						NumRequired: 0,
 						SplatIndex:  0,
@@ -1971,8 +1988,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   3,
 						Locals:      []string{"args", "idx", "i"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 642}, {PC: 22, Line: 643}, {PC: 37, Line: 254}, {PC: 40, Line: 645}, {PC: 43, Line: 646}, {PC: 46, Line: 650}},
-						FirstLine:   641,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 663}, {PC: 22, Line: 664}, {PC: 37, Line: 666}, {PC: 54, Line: 259}, {PC: 57, Line: 668}, {PC: 60, Line: 669}, {PC: 63, Line: 673}},
+						FirstLine:   662,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in find_index",
@@ -1983,8 +2000,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 254}},
-								FirstLine:   643,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 259}},
+								FirstLine:   664,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -2003,8 +2020,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"a"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 647}, {PC: 27, Line: 648}},
-								FirstLine:   646,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 670}, {PC: 27, Line: 671}},
+								FirstLine:   669,
 								Super:       "",
 							},
 						},
@@ -2022,8 +2039,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   2,
 						Locals:      []string{"pattern", "result"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 658}, {PC: 3, Line: 659}, {PC: 6, Line: 660}},
-						FirstLine:   657,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 681}, {PC: 3, Line: 682}, {PC: 6, Line: 683}},
+						FirstLine:   680,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in grep",
@@ -2037,8 +2054,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"x"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 659}},
-								FirstLine:   659,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 682}},
+								FirstLine:   682,
 								Super:       "",
 							},
 						},
@@ -2056,8 +2073,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   2,
 						Locals:      []string{"pattern", "result"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 664}, {PC: 3, Line: 665}, {PC: 6, Line: 666}},
-						FirstLine:   663,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 687}, {PC: 3, Line: 688}, {PC: 6, Line: 689}},
+						FirstLine:   686,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in grep_v",
@@ -2071,8 +2088,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"x"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 665}},
-								FirstLine:   665,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 688}},
+								FirstLine:   688,
 								Super:       "",
 							},
 						},
@@ -2092,8 +2109,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   2,
 						Locals:      []string{"r", "taking"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 670}, {PC: 10, Line: 671}, {PC: 13, Line: 672}, {PC: 16, Line: 673}, {PC: 19, Line: 681}},
-						FirstLine:   669,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 693}, {PC: 10, Line: 694}, {PC: 13, Line: 695}, {PC: 16, Line: 696}, {PC: 19, Line: 704}},
+						FirstLine:   692,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in take_while",
@@ -2104,8 +2121,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 254}},
-								FirstLine:   670,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 259}},
+								FirstLine:   693,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -2120,8 +2137,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"a"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 674}, {PC: 8, Line: 675}, {PC: 14, Line: 676}, {PC: 20, Line: 678}},
-								FirstLine:   673,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 697}, {PC: 8, Line: 698}, {PC: 14, Line: 699}, {PC: 20, Line: 701}},
+								FirstLine:   696,
 								Super:       "",
 							},
 						},
@@ -2141,8 +2158,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   2,
 						Locals:      []string{"r", "dropping"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 685}, {PC: 10, Line: 686}, {PC: 13, Line: 687}, {PC: 16, Line: 688}, {PC: 19, Line: 692}},
-						FirstLine:   684,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 708}, {PC: 10, Line: 709}, {PC: 13, Line: 710}, {PC: 16, Line: 711}, {PC: 19, Line: 715}},
+						FirstLine:   707,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in drop_while",
@@ -2153,8 +2170,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 254}},
-								FirstLine:   685,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 259}},
+								FirstLine:   708,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -2169,8 +2186,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"x"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 689}, {PC: 13, Line: 690}},
-								FirstLine:   688,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 712}, {PC: 13, Line: 713}},
+								FirstLine:   711,
 								Super:       "",
 							},
 						},
@@ -2193,8 +2210,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   2,
 						Locals:      []string{"n", "buf"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 702}, {PC: 5, Line: 703}, {PC: 16, Line: 704}, {PC: 19, Line: 705}, {PC: 27, Line: 709}, {PC: 30, Line: 710}, {PC: 33, Line: 717}, {PC: 42, Line: 109}},
-						FirstLine:   701,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 725}, {PC: 5, Line: 726}, {PC: 16, Line: 727}, {PC: 19, Line: 728}, {PC: 27, Line: 732}, {PC: 30, Line: 733}, {PC: 33, Line: 740}, {PC: 42, Line: 109}},
+						FirstLine:   724,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in each_slice",
@@ -2211,8 +2228,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"sz"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 706}, {PC: 18, Line: 254}},
-								FirstLine:   705,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 729}, {PC: 18, Line: 259}},
+								FirstLine:   728,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -2227,8 +2244,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"x"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 711}, {PC: 4, Line: 712}, {PC: 9, Line: 713}, {PC: 12, Line: 714}},
-								FirstLine:   710,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 734}, {PC: 4, Line: 735}, {PC: 9, Line: 736}, {PC: 12, Line: 737}},
+								FirstLine:   733,
 								Super:       "",
 							},
 						},
@@ -2251,8 +2268,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   2,
 						Locals:      []string{"n", "window"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 722}, {PC: 5, Line: 723}, {PC: 16, Line: 724}, {PC: 19, Line: 725}, {PC: 27, Line: 731}, {PC: 30, Line: 732}, {PC: 33, Line: 109}},
-						FirstLine:   721,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 745}, {PC: 5, Line: 746}, {PC: 16, Line: 747}, {PC: 19, Line: 748}, {PC: 27, Line: 754}, {PC: 30, Line: 755}, {PC: 33, Line: 109}},
+						FirstLine:   744,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in each_cons",
@@ -2270,8 +2287,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"sz"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 726}, {PC: 10, Line: 727}},
-								FirstLine:   725,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 749}, {PC: 10, Line: 750}},
+								FirstLine:   748,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -2286,8 +2303,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"x"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 733}, {PC: 4, Line: 734}, {PC: 14, Line: 735}},
-								FirstLine:   732,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 756}, {PC: 4, Line: 757}, {PC: 14, Line: 758}},
+								FirstLine:   755,
 								Super:       "",
 							},
 						},
@@ -2314,8 +2331,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   4,
 						Locals:      []string{"args", "result", "n", "r"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 746}, {PC: 22, Line: 747}, {PC: 25, Line: 254}, {PC: 28, Line: 749}, {PC: 32, Line: 752}, {PC: 37, Line: 754}, {PC: 44, Line: 755}, {PC: 55, Line: 756}, {PC: 64, Line: 757}, {PC: 67, Line: 758}, {PC: 71, Line: 764}},
-						FirstLine:   745,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 769}, {PC: 22, Line: 770}, {PC: 25, Line: 259}, {PC: 28, Line: 772}, {PC: 32, Line: 775}, {PC: 37, Line: 777}, {PC: 44, Line: 778}, {PC: 55, Line: 779}, {PC: 64, Line: 780}, {PC: 67, Line: 781}, {PC: 71, Line: 787}},
+						FirstLine:   768,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in first",
@@ -2327,8 +2344,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 750}},
-								FirstLine:   749,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 773}},
+								FirstLine:   772,
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:  "block (2 levels) in first",
@@ -2345,8 +2362,8 @@ func embeddedPrelude() *bytecode.ISeq {
 										BlockSlot:   -1,
 										NumLocals:   1,
 										Locals:      []string{"x"},
-										Lines:       []bytecode.LineEntry{{PC: 0, Line: 750}},
-										FirstLine:   750,
+										Lines:       []bytecode.LineEntry{{PC: 0, Line: 773}},
+										FirstLine:   773,
 										Super:       "",
 									},
 								},
@@ -2362,8 +2379,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 759}},
-								FirstLine:   758,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 782}},
+								FirstLine:   781,
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:  "block (2 levels) in first",
@@ -2380,8 +2397,8 @@ func embeddedPrelude() *bytecode.ISeq {
 										BlockSlot:   -1,
 										NumLocals:   1,
 										Locals:      []string{"x"},
-										Lines:       []bytecode.LineEntry{{PC: 0, Line: 760}, {PC: 4, Line: 761}},
-										FirstLine:   759,
+										Lines:       []bytecode.LineEntry{{PC: 0, Line: 783}, {PC: 4, Line: 784}},
+										FirstLine:   782,
 										Super:       "",
 									},
 								},
@@ -2407,8 +2424,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   2,
 						Locals:      []string{"n", "r"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 768}, {PC: 5, Line: 769}, {PC: 16, Line: 770}, {PC: 25, Line: 771}, {PC: 28, Line: 772}, {PC: 32, Line: 778}},
-						FirstLine:   767,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 791}, {PC: 5, Line: 792}, {PC: 16, Line: 793}, {PC: 25, Line: 794}, {PC: 28, Line: 795}, {PC: 32, Line: 801}},
+						FirstLine:   790,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in take",
@@ -2420,8 +2437,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 773}},
-								FirstLine:   772,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 796}},
+								FirstLine:   795,
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:  "block (2 levels) in take",
@@ -2438,8 +2455,8 @@ func embeddedPrelude() *bytecode.ISeq {
 										BlockSlot:   -1,
 										NumLocals:   1,
 										Locals:      []string{"x"},
-										Lines:       []bytecode.LineEntry{{PC: 0, Line: 774}, {PC: 4, Line: 775}},
-										FirstLine:   773,
+										Lines:       []bytecode.LineEntry{{PC: 0, Line: 797}, {PC: 4, Line: 798}},
+										FirstLine:   796,
 										Super:       "",
 									},
 								},
@@ -2464,8 +2481,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   3,
 						Locals:      []string{"n", "r", "i"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 782}, {PC: 5, Line: 783}, {PC: 16, Line: 784}, {PC: 19, Line: 785}, {PC: 22, Line: 786}, {PC: 25, Line: 790}},
-						FirstLine:   781,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 805}, {PC: 5, Line: 806}, {PC: 16, Line: 807}, {PC: 19, Line: 808}, {PC: 22, Line: 809}, {PC: 25, Line: 813}},
+						FirstLine:   804,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in drop",
@@ -2482,8 +2499,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"x"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 787}, {PC: 10, Line: 788}},
-								FirstLine:   786,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 810}, {PC: 10, Line: 811}},
+								FirstLine:   809,
 								Super:       "",
 							},
 						},
@@ -2506,8 +2523,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   4,
 						Locals:      []string{"a", "chunks", "cur", "i"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 799}, {PC: 10, Line: 800}, {PC: 14, Line: 801}, {PC: 24, Line: 802}, {PC: 27, Line: 803}, {PC: 33, Line: 804}, {PC: 36, Line: 805}, {PC: 41, Line: 806}, {PC: 51, Line: 807}, {PC: 57, Line: 809}, {PC: 61, Line: 810}, {PC: 67, Line: 812}, {PC: 75, Line: 814}, {PC: 79, Line: 815}},
-						FirstLine:   798,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 822}, {PC: 10, Line: 823}, {PC: 14, Line: 824}, {PC: 24, Line: 825}, {PC: 27, Line: 826}, {PC: 33, Line: 827}, {PC: 36, Line: 828}, {PC: 41, Line: 829}, {PC: 51, Line: 830}, {PC: 57, Line: 832}, {PC: 61, Line: 833}, {PC: 67, Line: 835}, {PC: 75, Line: 837}, {PC: 79, Line: 838}},
+						FirstLine:   821,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -2527,8 +2544,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   4,
 						Locals:      []string{"a", "chunks", "cur", "i"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 819}, {PC: 10, Line: 820}, {PC: 14, Line: 821}, {PC: 24, Line: 822}, {PC: 27, Line: 823}, {PC: 33, Line: 824}, {PC: 36, Line: 825}, {PC: 41, Line: 826}, {PC: 51, Line: 827}, {PC: 55, Line: 828}, {PC: 61, Line: 830}, {PC: 67, Line: 832}, {PC: 75, Line: 834}, {PC: 79, Line: 835}},
-						FirstLine:   818,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 842}, {PC: 10, Line: 843}, {PC: 14, Line: 844}, {PC: 24, Line: 845}, {PC: 27, Line: 846}, {PC: 33, Line: 847}, {PC: 36, Line: 848}, {PC: 41, Line: 849}, {PC: 51, Line: 850}, {PC: 55, Line: 851}, {PC: 61, Line: 853}, {PC: 67, Line: 855}, {PC: 75, Line: 857}, {PC: 79, Line: 858}},
+						FirstLine:   841,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -2546,8 +2563,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   2,
 						Locals:      []string{"result", "open"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 845}, {PC: 10, Line: 846}, {PC: 13, Line: 847}, {PC: 16, Line: 848}, {PC: 19, Line: 867}},
-						FirstLine:   844,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 868}, {PC: 10, Line: 869}, {PC: 13, Line: 870}, {PC: 16, Line: 871}, {PC: 19, Line: 890}},
+						FirstLine:   867,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in chunk",
@@ -2558,8 +2575,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 254}},
-								FirstLine:   845,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 259}},
+								FirstLine:   868,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -2583,8 +2600,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   2,
 								Locals:      []string{"x", "k"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 849}, {PC: 4, Line: 850}, {PC: 13, Line: 851}, {PC: 20, Line: 853}, {PC: 27, Line: 854}, {PC: 30, Line: 856}, {PC: 41, Line: 857}, {PC: 48, Line: 859}, {PC: 60, Line: 860}, {PC: 68, Line: 862}, {PC: 75, Line: 863}},
-								FirstLine:   848,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 872}, {PC: 4, Line: 873}, {PC: 13, Line: 874}, {PC: 20, Line: 876}, {PC: 27, Line: 877}, {PC: 30, Line: 879}, {PC: 41, Line: 880}, {PC: 48, Line: 882}, {PC: 60, Line: 883}, {PC: 68, Line: 885}, {PC: 75, Line: 886}},
+								FirstLine:   871,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -2596,8 +2613,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 254}},
-								FirstLine:   867,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 259}},
+								FirstLine:   890,
 								Super:       "",
 							},
 						},
@@ -2625,8 +2642,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   4,
 						Locals:      []string{"args", "pat", "runs", "cur"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 878}, {PC: 22, Line: 879}, {PC: 24, Line: 880}, {PC: 35, Line: 882}, {PC: 45, Line: 883}, {PC: 50, Line: 885}, {PC: 53, Line: 254}, {PC: 56, Line: 887}, {PC: 59, Line: 896}, {PC: 69, Line: 897}},
-						FirstLine:   877,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 901}, {PC: 22, Line: 902}, {PC: 24, Line: 903}, {PC: 35, Line: 905}, {PC: 45, Line: 906}, {PC: 50, Line: 908}, {PC: 53, Line: 259}, {PC: 56, Line: 910}, {PC: 59, Line: 919}, {PC: 69, Line: 920}},
+						FirstLine:   900,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in slice_before",
@@ -2640,8 +2657,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"x"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 888}, {PC: 9, Line: 889}, {PC: 19, Line: 890}, {PC: 23, Line: 892}, {PC: 31, Line: 893}},
-								FirstLine:   887,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 911}, {PC: 9, Line: 912}, {PC: 19, Line: 913}, {PC: 23, Line: 915}, {PC: 31, Line: 916}},
+								FirstLine:   910,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -2653,8 +2670,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 254}},
-								FirstLine:   897,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 259}},
+								FirstLine:   920,
 								Super:       "",
 							},
 						},
@@ -2682,8 +2699,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   4,
 						Locals:      []string{"args", "pat", "runs", "cur"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 901}, {PC: 22, Line: 902}, {PC: 24, Line: 903}, {PC: 35, Line: 905}, {PC: 45, Line: 906}, {PC: 50, Line: 908}, {PC: 53, Line: 909}, {PC: 56, Line: 910}, {PC: 59, Line: 917}, {PC: 69, Line: 918}},
-						FirstLine:   900,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 924}, {PC: 22, Line: 925}, {PC: 24, Line: 926}, {PC: 35, Line: 928}, {PC: 45, Line: 929}, {PC: 50, Line: 931}, {PC: 53, Line: 932}, {PC: 56, Line: 933}, {PC: 59, Line: 940}, {PC: 69, Line: 941}},
+						FirstLine:   923,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in slice_after",
@@ -2697,8 +2714,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"x"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 911}, {PC: 4, Line: 912}, {PC: 13, Line: 913}, {PC: 17, Line: 914}},
-								FirstLine:   910,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 934}, {PC: 4, Line: 935}, {PC: 13, Line: 936}, {PC: 17, Line: 937}},
+								FirstLine:   933,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -2710,8 +2727,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 254}},
-								FirstLine:   918,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 259}},
+								FirstLine:   941,
 								Super:       "",
 							},
 						},
@@ -2730,8 +2747,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 924}, {PC: 10, Line: 925}},
-						FirstLine:   923,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 947}, {PC: 10, Line: 948}},
+						FirstLine:   946,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in minmax_by",
@@ -2746,8 +2763,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 924}},
-								FirstLine:   924,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 947}},
+								FirstLine:   947,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -2761,8 +2778,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"x"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 925}},
-								FirstLine:   925,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 948}},
+								FirstLine:   948,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -2776,8 +2793,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"x"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 925}},
-								FirstLine:   925,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 948}},
+								FirstLine:   948,
 								Super:       "",
 							},
 						},
@@ -2800,8 +2817,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   2,
 						Locals:      []string{"n", "buffer"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 930}, {PC: 2, Line: 254}, {PC: 5, Line: 931}, {PC: 8, Line: 936}, {PC: 16, Line: 948}, {PC: 20, Line: 949}, {PC: 25, Line: 950}, {PC: 29, Line: 254}, {PC: 36, Line: 954}, {PC: 39, Line: 955}, {PC: 42, Line: 960}, {PC: 45, Line: 254}, {PC: 50, Line: 961}, {PC: 53, Line: 962}, {PC: 56, Line: 964}, {PC: 61, Line: 254}},
-						FirstLine:   930,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 953}, {PC: 2, Line: 259}, {PC: 5, Line: 954}, {PC: 8, Line: 959}, {PC: 16, Line: 971}, {PC: 20, Line: 972}, {PC: 25, Line: 973}, {PC: 29, Line: 259}, {PC: 36, Line: 977}, {PC: 39, Line: 978}, {PC: 42, Line: 983}, {PC: 45, Line: 259}, {PC: 50, Line: 984}, {PC: 53, Line: 985}, {PC: 56, Line: 987}, {PC: 61, Line: 259}},
+						FirstLine:   953,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in cycle",
@@ -2818,8 +2835,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"sz"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 937}, {PC: 7, Line: 254}, {PC: 10, Line: 938}, {PC: 19, Line: 939}, {PC: 24, Line: 941}, {PC: 27, Line: 943}},
-								FirstLine:   936,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 960}, {PC: 7, Line: 259}, {PC: 10, Line: 961}, {PC: 19, Line: 962}, {PC: 24, Line: 964}, {PC: 27, Line: 966}},
+								FirstLine:   959,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -2834,8 +2851,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   2,
 								Locals:      []string{"a", "v"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 956}, {PC: 5, Line: 957}, {PC: 9, Line: 958}},
-								FirstLine:   955,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 979}, {PC: 5, Line: 980}, {PC: 9, Line: 981}},
+								FirstLine:   978,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -2848,8 +2865,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 962}},
-								FirstLine:   962,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 985}},
+								FirstLine:   985,
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:        "block (2 levels) in cycle",
@@ -2862,8 +2879,8 @@ func embeddedPrelude() *bytecode.ISeq {
 										BlockSlot:   -1,
 										NumLocals:   1,
 										Locals:      []string{"x"},
-										Lines:       []bytecode.LineEntry{{PC: 0, Line: 962}},
-										FirstLine:   962,
+										Lines:       []bytecode.LineEntry{{PC: 0, Line: 985}},
+										FirstLine:   985,
 										Super:       "",
 									},
 								},
@@ -2879,8 +2896,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 964}},
-								FirstLine:   964,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 987}},
+								FirstLine:   987,
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:        "block (2 levels) in cycle",
@@ -2893,8 +2910,8 @@ func embeddedPrelude() *bytecode.ISeq {
 										BlockSlot:   -1,
 										NumLocals:   1,
 										Locals:      []string{"x"},
-										Lines:       []bytecode.LineEntry{{PC: 0, Line: 964}},
-										FirstLine:   964,
+										Lines:       []bytecode.LineEntry{{PC: 0, Line: 987}},
+										FirstLine:   987,
 										Super:       "",
 									},
 								},
@@ -2916,8 +2933,8 @@ func embeddedPrelude() *bytecode.ISeq {
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
-				Lines:       []bytecode.LineEntry{{PC: 0, Line: 976}, {PC: 4, Line: 981}, {PC: 6, Line: 985}},
-				FirstLine:   975,
+				Lines:       []bytecode.LineEntry{{PC: 0, Line: 999}, {PC: 4, Line: 1004}, {PC: 6, Line: 1008}},
+				FirstLine:   998,
 				Children: []*bytecode.ISeq{
 					&bytecode.ISeq{
 						Name:        "numerator",
@@ -2929,8 +2946,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 982}},
-						FirstLine:   981,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1005}},
+						FirstLine:   1004,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -2943,8 +2960,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 986}},
-						FirstLine:   985,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1009}},
+						FirstLine:   1008,
 						Super:       "",
 					},
 				},
@@ -2960,8 +2977,8 @@ func embeddedPrelude() *bytecode.ISeq {
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
-				Lines:       []bytecode.LineEntry{{PC: 0, Line: 992}, {PC: 2, Line: 996}},
-				FirstLine:   990,
+				Lines:       []bytecode.LineEntry{{PC: 0, Line: 1015}, {PC: 2, Line: 1019}},
+				FirstLine:   1013,
 				Children: []*bytecode.ISeq{
 					&bytecode.ISeq{
 						Name:        "numerator",
@@ -2973,7 +2990,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   0,
 						Lines:       []bytecode.LineEntry{{PC: 0, Line: 109}},
-						FirstLine:   992,
+						FirstLine:   1015,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -2988,8 +3005,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 997}},
-						FirstLine:   996,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1020}},
+						FirstLine:   1019,
 						Super:       "",
 					},
 				},
@@ -3005,8 +3022,8 @@ func embeddedPrelude() *bytecode.ISeq {
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
-				Lines:       []bytecode.LineEntry{{PC: 0, Line: 1005}, {PC: 2, Line: 1009}},
-				FirstLine:   1001,
+				Lines:       []bytecode.LineEntry{{PC: 0, Line: 1028}, {PC: 2, Line: 1032}},
+				FirstLine:   1024,
 				Children: []*bytecode.ISeq{
 					&bytecode.ISeq{
 						Name:        "numerator",
@@ -3018,8 +3035,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1006}, {PC: 7, Line: 109}},
-						FirstLine:   1005,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1029}, {PC: 7, Line: 109}},
+						FirstLine:   1028,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -3035,8 +3052,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1010}},
-						FirstLine:   1009,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1033}},
+						FirstLine:   1032,
 						Super:       "",
 					},
 				},
@@ -3052,8 +3069,8 @@ func embeddedPrelude() *bytecode.ISeq {
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
-				Lines:       []bytecode.LineEntry{{PC: 0, Line: 1015}},
-				FirstLine:   1014,
+				Lines:       []bytecode.LineEntry{{PC: 0, Line: 1038}},
+				FirstLine:   1037,
 				Super:       "",
 			},
 			&bytecode.ISeq{
@@ -3066,8 +3083,8 @@ func embeddedPrelude() *bytecode.ISeq {
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
-				Lines:       []bytecode.LineEntry{{PC: 0, Line: 1019}},
-				FirstLine:   1018,
+				Lines:       []bytecode.LineEntry{{PC: 0, Line: 1042}},
+				FirstLine:   1041,
 				Super:       "",
 			},
 			&bytecode.ISeq{
@@ -3080,8 +3097,8 @@ func embeddedPrelude() *bytecode.ISeq {
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
-				Lines:       []bytecode.LineEntry{{PC: 0, Line: 1028}, {PC: 4, Line: 1031}},
-				FirstLine:   1027,
+				Lines:       []bytecode.LineEntry{{PC: 0, Line: 1051}, {PC: 4, Line: 1054}},
+				FirstLine:   1050,
 				Children: []*bytecode.ISeq{
 					&bytecode.ISeq{
 						Name:        "deconstruct",
@@ -3093,7 +3110,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   0,
 						Lines:       []bytecode.LineEntry{{PC: 0, Line: 109}},
-						FirstLine:   1031,
+						FirstLine:   1054,
 						Super:       "",
 					},
 				},
@@ -3109,8 +3126,8 @@ func embeddedPrelude() *bytecode.ISeq {
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
-				Lines:       []bytecode.LineEntry{{PC: 0, Line: 1037}, {PC: 4, Line: 1044}, {PC: 6, Line: 1051}, {PC: 8, Line: 1061}},
-				FirstLine:   1036,
+				Lines:       []bytecode.LineEntry{{PC: 0, Line: 1060}, {PC: 4, Line: 1067}, {PC: 6, Line: 1074}, {PC: 8, Line: 1084}},
+				FirstLine:   1059,
 				Children: []*bytecode.ISeq{
 					&bytecode.ISeq{
 						Name:        "==",
@@ -3124,8 +3141,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"other"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1045}, {PC: 9, Line: 1046}, {PC: 19, Line: 109}},
-						FirstLine:   1044,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1068}, {PC: 9, Line: 1069}, {PC: 19, Line: 109}},
+						FirstLine:   1067,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -3140,8 +3157,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"other"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1052}, {PC: 9, Line: 1053}, {PC: 19, Line: 109}},
-						FirstLine:   1051,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1075}, {PC: 9, Line: 1076}, {PC: 19, Line: 109}},
+						FirstLine:   1074,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -3155,7 +3172,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   0,
 						Lines:       []bytecode.LineEntry{{PC: 0, Line: 109}},
-						FirstLine:   1061,
+						FirstLine:   1084,
 						Super:       "",
 					},
 				},
@@ -3171,8 +3188,8 @@ func embeddedPrelude() *bytecode.ISeq {
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
-				Lines:       []bytecode.LineEntry{{PC: 0, Line: 1070}, {PC: 4, Line: 1073}},
-				FirstLine:   1069,
+				Lines:       []bytecode.LineEntry{{PC: 0, Line: 1093}, {PC: 4, Line: 1096}},
+				FirstLine:   1092,
 				Children: []*bytecode.ISeq{
 					&bytecode.ISeq{
 						Name:        "deconstruct_keys",
@@ -3186,7 +3203,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						NumLocals:   1,
 						Locals:      []string{"keys"},
 						Lines:       []bytecode.LineEntry{{PC: 0, Line: 109}},
-						FirstLine:   1073,
+						FirstLine:   1096,
 						Super:       "",
 					},
 				},
@@ -3208,8 +3225,8 @@ func embeddedPrelude() *bytecode.ISeq {
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
-				Lines:       []bytecode.LineEntry{{PC: 0, Line: 1085}, {PC: 4, Line: 1091}, {PC: 6, Line: 1100}, {PC: 10, Line: 1104}, {PC: 12, Line: 1112}, {PC: 16, Line: 1116}, {PC: 18, Line: 1122}, {PC: 20, Line: 1128}, {PC: 22, Line: 1132}, {PC: 24, Line: 1138}, {PC: 26, Line: 1143}, {PC: 28, Line: 1144}, {PC: 30, Line: 1148}, {PC: 32, Line: 1153}, {PC: 34, Line: 1157}, {PC: 36, Line: 1162}, {PC: 38, Line: 1166}, {PC: 40, Line: 1173}, {PC: 42, Line: 1179}, {PC: 44, Line: 1187}, {PC: 46, Line: 1201}, {PC: 48, Line: 1209}, {PC: 50, Line: 1214}, {PC: 52, Line: 1217}, {PC: 54, Line: 1222}, {PC: 56, Line: 1225}, {PC: 58, Line: 1230}, {PC: 60, Line: 1233}, {PC: 62, Line: 1238}, {PC: 64, Line: 1242}, {PC: 66, Line: 1253}, {PC: 68, Line: 1262}, {PC: 70, Line: 1266}, {PC: 72, Line: 1272}, {PC: 74, Line: 1280}, {PC: 76, Line: 1286}, {PC: 78, Line: 1292}, {PC: 80, Line: 1300}, {PC: 82, Line: 1306}, {PC: 84, Line: 1308}, {PC: 86, Line: 1317}, {PC: 88, Line: 1324}, {PC: 90, Line: 1328}, {PC: 92, Line: 1342}, {PC: 94, Line: 1351}, {PC: 96, Line: 1395}, {PC: 100, Line: 1401}, {PC: 102, Line: 1405}, {PC: 104, Line: 1416}, {PC: 106, Line: 1429}, {PC: 110, Line: 1432}, {PC: 112, Line: 1437}},
-				FirstLine:   1084,
+				Lines:       []bytecode.LineEntry{{PC: 0, Line: 1108}, {PC: 4, Line: 1114}, {PC: 6, Line: 1123}, {PC: 10, Line: 1127}, {PC: 12, Line: 1135}, {PC: 16, Line: 1139}, {PC: 18, Line: 1145}, {PC: 20, Line: 1151}, {PC: 22, Line: 1155}, {PC: 24, Line: 1161}, {PC: 26, Line: 1166}, {PC: 28, Line: 1167}, {PC: 30, Line: 1171}, {PC: 32, Line: 1176}, {PC: 34, Line: 1180}, {PC: 36, Line: 1185}, {PC: 38, Line: 1189}, {PC: 40, Line: 1196}, {PC: 42, Line: 1202}, {PC: 44, Line: 1210}, {PC: 46, Line: 1224}, {PC: 48, Line: 1232}, {PC: 50, Line: 1237}, {PC: 52, Line: 1240}, {PC: 54, Line: 1245}, {PC: 56, Line: 1248}, {PC: 58, Line: 1253}, {PC: 60, Line: 1256}, {PC: 62, Line: 1261}, {PC: 64, Line: 1265}, {PC: 66, Line: 1276}, {PC: 68, Line: 1285}, {PC: 70, Line: 1289}, {PC: 72, Line: 1295}, {PC: 74, Line: 1303}, {PC: 76, Line: 1309}, {PC: 78, Line: 1315}, {PC: 80, Line: 1323}, {PC: 82, Line: 1329}, {PC: 84, Line: 1331}, {PC: 86, Line: 1340}, {PC: 88, Line: 1347}, {PC: 90, Line: 1351}, {PC: 92, Line: 1365}, {PC: 94, Line: 1374}, {PC: 96, Line: 1418}, {PC: 100, Line: 1424}, {PC: 102, Line: 1428}, {PC: 104, Line: 1439}, {PC: 106, Line: 1452}, {PC: 110, Line: 1455}, {PC: 112, Line: 1460}},
+				FirstLine:   1107,
 				Children: []*bytecode.ISeq{
 					&bytecode.ISeq{
 						Name:  "__do_with_enum",
@@ -3228,8 +3245,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   1,
 						NumLocals:   2,
 						Locals:      []string{"enum", "block"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1092}, {PC: 4, Line: 1093}, {PC: 12, Line: 1095}, {PC: 16, Line: 1097}},
-						FirstLine:   1091,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1115}, {PC: 4, Line: 1116}, {PC: 12, Line: 1118}, {PC: 16, Line: 1120}},
+						FirstLine:   1114,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -3244,8 +3261,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   1,
 						NumLocals:   2,
 						Locals:      []string{"enum", "block"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1104}, {PC: 2, Line: 254}, {PC: 5, Line: 1105}, {PC: 13, Line: 1106}, {PC: 15, Line: 1107}, {PC: 19, Line: 1109}},
-						FirstLine:   1104,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1127}, {PC: 2, Line: 259}, {PC: 5, Line: 1128}, {PC: 13, Line: 1129}, {PC: 15, Line: 1130}, {PC: 19, Line: 1132}},
+						FirstLine:   1127,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in initialize",
@@ -3259,8 +3276,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"o"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1107}},
-								FirstLine:   1107,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1130}},
+								FirstLine:   1130,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -3275,8 +3292,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"o"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1109}},
-								FirstLine:   1109,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1132}},
+								FirstLine:   1132,
 								Super:       "",
 							},
 						},
@@ -3296,8 +3313,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   0,
 						NumLocals:   1,
 						Locals:      []string{"block"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1117}, {PC: 10, Line: 1118}, {PC: 14, Line: 109}},
-						FirstLine:   1116,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1140}, {PC: 10, Line: 1141}, {PC: 14, Line: 109}},
+						FirstLine:   1139,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in each",
@@ -3309,8 +3326,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1117}},
-								FirstLine:   1117,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1140}},
+								FirstLine:   1140,
 								Super:       "",
 							},
 						},
@@ -3329,8 +3346,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1123}},
-						FirstLine:   1122,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1146}},
+						FirstLine:   1145,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -3345,8 +3362,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"o"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1129}, {PC: 4, Line: 254}},
-						FirstLine:   1128,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1152}, {PC: 4, Line: 259}},
+						FirstLine:   1151,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -3361,8 +3378,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"o"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1133}, {PC: 8, Line: 254}},
-						FirstLine:   1132,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1156}, {PC: 8, Line: 259}},
+						FirstLine:   1155,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -3377,8 +3394,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   2,
 						Locals:      []string{"other", "n"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1139}, {PC: 4, Line: 1140}, {PC: 8, Line: 1141}},
-						FirstLine:   1138,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1162}, {PC: 4, Line: 1163}, {PC: 8, Line: 1164}},
+						FirstLine:   1161,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in |",
@@ -3392,8 +3409,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"o"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1140}},
-								FirstLine:   1140,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1163}},
+								FirstLine:   1163,
 								Super:       "",
 							},
 						},
@@ -3411,8 +3428,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   2,
 						Locals:      []string{"other", "n"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 5, Line: 1150}, {PC: 9, Line: 1151}},
-						FirstLine:   1148,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 5, Line: 1173}, {PC: 9, Line: 1174}},
+						FirstLine:   1171,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in &",
@@ -3426,8 +3443,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"o"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1150}},
-								FirstLine:   1150,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1173}},
+								FirstLine:   1173,
 								Super:       "",
 							},
 						},
@@ -3445,8 +3462,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   2,
 						Locals:      []string{"other", "n"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1158}, {PC: 4, Line: 1159}, {PC: 8, Line: 1160}},
-						FirstLine:   1157,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1181}, {PC: 4, Line: 1182}, {PC: 8, Line: 1183}},
+						FirstLine:   1180,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in -",
@@ -3460,8 +3477,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"o"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1159}},
-								FirstLine:   1159,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1182}},
+								FirstLine:   1182,
 								Super:       "",
 							},
 						},
@@ -3479,8 +3496,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   2,
 						Locals:      []string{"other", "n"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1168}, {PC: 9, Line: 1169}},
-						FirstLine:   1166,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1191}, {PC: 9, Line: 1192}},
+						FirstLine:   1189,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in ^",
@@ -3494,8 +3511,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"o"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1168}},
-								FirstLine:   1168,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1191}},
+								FirstLine:   1191,
 								Super:       "",
 							},
 						},
@@ -3513,8 +3530,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"enums"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1174}, {PC: 3, Line: 109}},
-						FirstLine:   1173,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1197}, {PC: 3, Line: 109}},
+						FirstLine:   1196,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in merge",
@@ -3528,8 +3545,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"enum"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1174}},
-								FirstLine:   1174,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1197}},
+								FirstLine:   1197,
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:        "block (2 levels) in merge",
@@ -3543,8 +3560,8 @@ func embeddedPrelude() *bytecode.ISeq {
 										BlockSlot:   -1,
 										NumLocals:   1,
 										Locals:      []string{"o"},
-										Lines:       []bytecode.LineEntry{{PC: 0, Line: 1174}},
-										FirstLine:   1174,
+										Lines:       []bytecode.LineEntry{{PC: 0, Line: 1197}},
+										FirstLine:   1197,
 										Super:       "",
 									},
 								},
@@ -3565,8 +3582,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"other"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1180}, {PC: 4, Line: 109}},
-						FirstLine:   1179,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1203}, {PC: 4, Line: 109}},
+						FirstLine:   1202,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in subtract",
@@ -3580,8 +3597,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"o"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1180}},
-								FirstLine:   1180,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1203}},
+								FirstLine:   1203,
 								Super:       "",
 							},
 						},
@@ -3604,8 +3621,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"other"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1188}, {PC: 4, Line: 1189}, {PC: 9, Line: 1190}, {PC: 12, Line: 1192}, {PC: 30, Line: 1193}, {PC: 35, Line: 1194}, {PC: 39, Line: 109}},
-						FirstLine:   1187,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1211}, {PC: 4, Line: 1212}, {PC: 9, Line: 1213}, {PC: 12, Line: 1215}, {PC: 30, Line: 1216}, {PC: 35, Line: 1217}, {PC: 39, Line: 109}},
+						FirstLine:   1210,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in replace",
@@ -3619,8 +3636,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"o"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1190}},
-								FirstLine:   1190,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1213}},
+								FirstLine:   1213,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -3635,8 +3652,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"o"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1194}},
-								FirstLine:   1194,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1217}},
+								FirstLine:   1217,
 								Super:       "",
 							},
 						},
@@ -3653,8 +3670,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"vals"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1202}, {PC: 4, Line: 1203}, {PC: 9, Line: 1204}, {PC: 12, Line: 109}},
-						FirstLine:   1201,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1225}, {PC: 4, Line: 1226}, {PC: 9, Line: 1227}, {PC: 12, Line: 109}},
+						FirstLine:   1224,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in reset",
@@ -3668,8 +3685,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"o"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1204}},
-								FirstLine:   1204,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1227}},
+								FirstLine:   1227,
 								Super:       "",
 							},
 						},
@@ -3690,8 +3707,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"other"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1210}, {PC: 12, Line: 1211}, {PC: 23, Line: 1212}},
-						FirstLine:   1209,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1233}, {PC: 12, Line: 1234}, {PC: 23, Line: 1235}},
+						FirstLine:   1232,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in subset?",
@@ -3705,8 +3722,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"o"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1212}},
-								FirstLine:   1212,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1235}},
+								FirstLine:   1235,
 								Super:       "",
 							},
 						},
@@ -3727,8 +3744,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"other"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1218}, {PC: 12, Line: 1219}, {PC: 23, Line: 1220}},
-						FirstLine:   1217,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1241}, {PC: 12, Line: 1242}, {PC: 23, Line: 1243}},
+						FirstLine:   1240,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in proper_subset?",
@@ -3742,8 +3759,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"o"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1220}},
-								FirstLine:   1220,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1243}},
+								FirstLine:   1243,
 								Super:       "",
 							},
 						},
@@ -3764,8 +3781,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"other"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1226}, {PC: 12, Line: 1227}, {PC: 23, Line: 1228}},
-						FirstLine:   1225,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1249}, {PC: 12, Line: 1250}, {PC: 23, Line: 1251}},
+						FirstLine:   1248,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in superset?",
@@ -3779,8 +3796,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"o"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1228}},
-								FirstLine:   1228,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1251}},
+								FirstLine:   1251,
 								Super:       "",
 							},
 						},
@@ -3801,8 +3818,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"other"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1234}, {PC: 12, Line: 1235}, {PC: 23, Line: 1236}},
-						FirstLine:   1233,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1257}, {PC: 12, Line: 1258}, {PC: 23, Line: 1259}},
+						FirstLine:   1256,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in proper_superset?",
@@ -3816,8 +3833,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"o"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1236}},
-								FirstLine:   1236,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1259}},
+								FirstLine:   1259,
 								Super:       "",
 							},
 						},
@@ -3840,8 +3857,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   2,
 						Locals:      []string{"other", ""},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1243}, {PC: 5, Line: 254}, {PC: 10, Line: 1244}, {PC: 22, Line: 1245}, {PC: 28, Line: 254}, {PC: 35, Line: 1246}, {PC: 41, Line: 254}, {PC: 43, Line: 109}, {PC: 49, Line: 254}},
-						FirstLine:   1242,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1266}, {PC: 5, Line: 259}, {PC: 10, Line: 1267}, {PC: 22, Line: 1268}, {PC: 28, Line: 259}, {PC: 35, Line: 1269}, {PC: 41, Line: 259}, {PC: 43, Line: 109}, {PC: 49, Line: 259}},
+						FirstLine:   1265,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -3859,8 +3876,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"other"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1254}, {PC: 9, Line: 1255}, {PC: 19, Line: 1256}, {PC: 31, Line: 1257}, {PC: 36, Line: 1259}, {PC: 48, Line: 1260}},
-						FirstLine:   1253,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1277}, {PC: 9, Line: 1278}, {PC: 19, Line: 1279}, {PC: 31, Line: 1280}, {PC: 36, Line: 1282}, {PC: 48, Line: 1283}},
+						FirstLine:   1276,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in ==",
@@ -3874,8 +3891,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"o"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1260}},
-								FirstLine:   1260,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1283}},
+								FirstLine:   1283,
 								Super:       "",
 							},
 						},
@@ -3894,8 +3911,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1267}},
-						FirstLine:   1266,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1290}},
+						FirstLine:   1289,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -3910,8 +3927,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"other"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1273}, {PC: 6, Line: 1274}, {PC: 9, Line: 1276}},
-						FirstLine:   1272,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1296}, {PC: 6, Line: 1297}, {PC: 9, Line: 1299}},
+						FirstLine:   1295,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in disjoint?",
@@ -3925,8 +3942,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"o"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1274}},
-								FirstLine:   1274,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1297}},
+								FirstLine:   1297,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -3941,8 +3958,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"o"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1276}},
-								FirstLine:   1276,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1299}},
+								FirstLine:   1299,
 								Super:       "",
 							},
 						},
@@ -3960,8 +3977,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"other"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1281}},
-						FirstLine:   1280,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1304}},
+						FirstLine:   1303,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -3978,8 +3995,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   0,
 						NumLocals:   1,
 						Locals:      []string{"block"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1287}, {PC: 10, Line: 1288}, {PC: 14, Line: 109}},
-						FirstLine:   1286,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1310}, {PC: 10, Line: 1311}, {PC: 14, Line: 109}},
+						FirstLine:   1309,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in delete_if",
@@ -3991,8 +4008,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1287}},
-								FirstLine:   1287,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1310}},
+								FirstLine:   1310,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -4007,8 +4024,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"o"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1288}},
-								FirstLine:   1288,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1311}},
+								FirstLine:   1311,
 								Super:       "",
 							},
 						},
@@ -4028,8 +4045,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   0,
 						NumLocals:   1,
 						Locals:      []string{"block"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1293}, {PC: 10, Line: 1294}, {PC: 14, Line: 109}},
-						FirstLine:   1292,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1316}, {PC: 10, Line: 1317}, {PC: 14, Line: 109}},
+						FirstLine:   1315,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in keep_if",
@@ -4041,8 +4058,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1293}},
-								FirstLine:   1293,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1316}},
+								FirstLine:   1316,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -4057,8 +4074,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"o"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1294}},
-								FirstLine:   1294,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1317}},
+								FirstLine:   1317,
 								Super:       "",
 							},
 						},
@@ -4078,8 +4095,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   0,
 						NumLocals:   2,
 						Locals:      []string{"block", "n"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1301}, {PC: 10, Line: 1302}, {PC: 14, Line: 1303}, {PC: 18, Line: 1304}, {PC: 23, Line: 254}, {PC: 25, Line: 109}},
-						FirstLine:   1300,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1324}, {PC: 10, Line: 1325}, {PC: 14, Line: 1326}, {PC: 18, Line: 1327}, {PC: 23, Line: 259}, {PC: 25, Line: 109}},
+						FirstLine:   1323,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in select!",
@@ -4091,8 +4108,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1301}},
-								FirstLine:   1301,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1324}},
+								FirstLine:   1324,
 								Super:       "",
 							},
 						},
@@ -4112,8 +4129,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   0,
 						NumLocals:   2,
 						Locals:      []string{"block", "n"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1309}, {PC: 10, Line: 1310}, {PC: 14, Line: 1311}, {PC: 18, Line: 1312}, {PC: 23, Line: 254}, {PC: 25, Line: 109}},
-						FirstLine:   1308,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1332}, {PC: 10, Line: 1333}, {PC: 14, Line: 1334}, {PC: 18, Line: 1335}, {PC: 23, Line: 259}, {PC: 25, Line: 109}},
+						FirstLine:   1331,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in reject!",
@@ -4125,8 +4142,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1309}},
-								FirstLine:   1309,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1332}},
+								FirstLine:   1332,
 								Super:       "",
 							},
 						},
@@ -4146,8 +4163,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   0,
 						NumLocals:   2,
 						Locals:      []string{"block", "vals"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1318}, {PC: 10, Line: 1319}, {PC: 16, Line: 1320}, {PC: 20, Line: 1321}, {PC: 23, Line: 109}},
-						FirstLine:   1317,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1341}, {PC: 10, Line: 1342}, {PC: 16, Line: 1343}, {PC: 20, Line: 1344}, {PC: 23, Line: 109}},
+						FirstLine:   1340,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in map!",
@@ -4159,8 +4176,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1318}},
-								FirstLine:   1318,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1341}},
+								FirstLine:   1341,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -4175,8 +4192,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"o"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1321}},
-								FirstLine:   1321,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1344}},
+								FirstLine:   1344,
 								Super:       "",
 							},
 						},
@@ -4196,8 +4213,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   0,
 						NumLocals:   2,
 						Locals:      []string{"block", "h"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1329}, {PC: 10, Line: 1330}, {PC: 13, Line: 1331}, {PC: 16, Line: 1335}},
-						FirstLine:   1328,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1352}, {PC: 10, Line: 1353}, {PC: 13, Line: 1354}, {PC: 16, Line: 1358}},
+						FirstLine:   1351,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in classify",
@@ -4209,8 +4226,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1329}},
-								FirstLine:   1329,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1352}},
+								FirstLine:   1352,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -4225,8 +4242,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   5,
 								Locals:      []string{"o", "k", "", "", ""},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1332}, {PC: 5, Line: 1333}, {PC: 17, Line: 109}},
-								FirstLine:   1331,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1355}, {PC: 5, Line: 1356}, {PC: 17, Line: 109}},
+								FirstLine:   1354,
 								Super:       "",
 							},
 						},
@@ -4247,8 +4264,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   0,
 						NumLocals:   1,
 						Locals:      []string{"func"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1343}, {PC: 10, Line: 1344}, {PC: 15, Line: 1345}, {PC: 19, Line: 109}},
-						FirstLine:   1342,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1366}, {PC: 10, Line: 1367}, {PC: 15, Line: 1368}, {PC: 19, Line: 109}},
+						FirstLine:   1365,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in divide",
@@ -4260,8 +4277,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1343}},
-								FirstLine:   1343,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1366}},
+								FirstLine:   1366,
 								Super:       "",
 							},
 						},
@@ -4281,8 +4298,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   0,
 						NumLocals:   11,
 						Locals:      []string{"func", "items", "n", "adj", "idx", "indices", "low", "onstack", "stack", "comps", "connect"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1352}, {PC: 4, Line: 1353}, {PC: 8, Line: 1354}, {PC: 13, Line: 1355}, {PC: 16, Line: 1360}, {PC: 19, Line: 1361}, {PC: 24, Line: 1362}, {PC: 30, Line: 1363}, {PC: 36, Line: 1364}, {PC: 39, Line: 1365}, {PC: 42, Line: 254}, {PC: 45, Line: 1367}, {PC: 49, Line: 1392}, {PC: 52, Line: 109}},
-						FirstLine:   1351,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1375}, {PC: 4, Line: 1376}, {PC: 8, Line: 1377}, {PC: 13, Line: 1378}, {PC: 16, Line: 1383}, {PC: 19, Line: 1384}, {PC: 24, Line: 1385}, {PC: 30, Line: 1386}, {PC: 36, Line: 1387}, {PC: 39, Line: 1388}, {PC: 42, Line: 259}, {PC: 45, Line: 1390}, {PC: 49, Line: 1415}, {PC: 52, Line: 109}},
+						FirstLine:   1374,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in __divide_graph",
@@ -4293,8 +4310,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1354}},
-								FirstLine:   1354,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1377}},
+								FirstLine:   1377,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -4309,8 +4326,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"i"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1356}},
-								FirstLine:   1355,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1379}},
+								FirstLine:   1378,
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:        "block (2 levels) in __divide_graph",
@@ -4324,8 +4341,8 @@ func embeddedPrelude() *bytecode.ISeq {
 										BlockSlot:   -1,
 										NumLocals:   1,
 										Locals:      []string{"j"},
-										Lines:       []bytecode.LineEntry{{PC: 0, Line: 1357}},
-										FirstLine:   1356,
+										Lines:       []bytecode.LineEntry{{PC: 0, Line: 1380}},
+										FirstLine:   1379,
 										Super:       "",
 									},
 								},
@@ -4346,8 +4363,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   5,
 								Locals:      []string{"v", "", "", "", "comp"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1368}, {PC: 8, Line: 1369}, {PC: 16, Line: 1370}, {PC: 21, Line: 1371}, {PC: 25, Line: 1372}, {PC: 33, Line: 1373}, {PC: 38, Line: 1381}, {PC: 46, Line: 1382}, {PC: 49, Line: 1383}, {PC: 52, Line: 1389}},
-								FirstLine:   1367,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1391}, {PC: 8, Line: 1392}, {PC: 16, Line: 1393}, {PC: 21, Line: 1394}, {PC: 25, Line: 1395}, {PC: 33, Line: 1396}, {PC: 38, Line: 1404}, {PC: 46, Line: 1405}, {PC: 49, Line: 1406}, {PC: 52, Line: 1412}},
+								FirstLine:   1390,
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:        "block (2 levels) in __divide_graph",
@@ -4361,8 +4378,8 @@ func embeddedPrelude() *bytecode.ISeq {
 										BlockSlot:   -1,
 										NumLocals:   3,
 										Locals:      []string{"w", "", ""},
-										Lines:       []bytecode.LineEntry{{PC: 0, Line: 1374}, {PC: 5, Line: 1375}, {PC: 9, Line: 1376}, {PC: 33, Line: 1378}},
-										FirstLine:   1373,
+										Lines:       []bytecode.LineEntry{{PC: 0, Line: 1397}, {PC: 5, Line: 1398}, {PC: 9, Line: 1399}, {PC: 33, Line: 1401}},
+										FirstLine:   1396,
 										Super:       "",
 									},
 									&bytecode.ISeq{
@@ -4376,8 +4393,8 @@ func embeddedPrelude() *bytecode.ISeq {
 										BlockSlot:   -1,
 										NumLocals:   2,
 										Locals:      []string{"w", ""},
-										Lines:       []bytecode.LineEntry{{PC: 0, Line: 1384}, {PC: 4, Line: 1385}, {PC: 12, Line: 1386}, {PC: 18, Line: 1387}},
-										FirstLine:   1383,
+										Lines:       []bytecode.LineEntry{{PC: 0, Line: 1407}, {PC: 4, Line: 1408}, {PC: 12, Line: 1409}, {PC: 18, Line: 1410}},
+										FirstLine:   1406,
 										Super:       "",
 									},
 								},
@@ -4395,8 +4412,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"v"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1392}},
-								FirstLine:   1392,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1415}},
+								FirstLine:   1415,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -4429,7 +4446,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   0,
 						Lines:       []bytecode.LineEntry{{PC: 0, Line: 109}},
-						FirstLine:   1401,
+						FirstLine:   1424,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -4442,8 +4459,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1406}, {PC: 3, Line: 1407}, {PC: 8, Line: 109}, {PC: 10, Line: 254}},
-						FirstLine:   1405,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1429}, {PC: 3, Line: 1430}, {PC: 8, Line: 109}, {PC: 10, Line: 259}},
+						FirstLine:   1428,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in flatten!",
@@ -4457,8 +4474,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"o"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1406}},
-								FirstLine:   1406,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1429}},
+								FirstLine:   1429,
 								Super:       "",
 							},
 						},
@@ -4476,8 +4493,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   2,
 						Locals:      []string{"other", "seen"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1416}, {PC: 5, Line: 1417}, {PC: 8, Line: 109}},
-						FirstLine:   1416,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1439}, {PC: 5, Line: 1440}, {PC: 8, Line: 109}},
+						FirstLine:   1439,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in flatten_merge",
@@ -4494,8 +4511,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   2,
 								Locals:      []string{"o", ""},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1418}, {PC: 4, Line: 1419}, {PC: 16, Line: 1420}, {PC: 25, Line: 1421}, {PC: 30, Line: 1422}, {PC: 35, Line: 1424}},
-								FirstLine:   1417,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1441}, {PC: 4, Line: 1442}, {PC: 16, Line: 1443}, {PC: 25, Line: 1444}, {PC: 30, Line: 1445}, {PC: 35, Line: 1447}},
+								FirstLine:   1440,
 								Super:       "",
 							},
 						},
@@ -4513,8 +4530,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"sep"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1432}, {PC: 2, Line: 254}, {PC: 5, Line: 1433}},
-						FirstLine:   1432,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1455}, {PC: 2, Line: 259}, {PC: 5, Line: 1456}},
+						FirstLine:   1455,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -4527,7 +4544,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   0,
 						Lines:       []bytecode.LineEntry{{PC: 0, Line: 109}},
-						FirstLine:   1437,
+						FirstLine:   1460,
 						Super:       "",
 					},
 				},
@@ -4543,8 +4560,8 @@ func embeddedPrelude() *bytecode.ISeq {
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
-				Lines:       []bytecode.LineEntry{{PC: 0, Line: 1460}, {PC: 2, Line: 1584}, {PC: 4, Line: 1641}, {PC: 6, Line: 1645}, {PC: 8, Line: 1651}, {PC: 10, Line: 1655}},
-				FirstLine:   1456,
+				Lines:       []bytecode.LineEntry{{PC: 0, Line: 1483}, {PC: 2, Line: 1607}, {PC: 4, Line: 1664}, {PC: 6, Line: 1668}, {PC: 8, Line: 1674}, {PC: 10, Line: 1678}},
+				FirstLine:   1479,
 				Children: []*bytecode.ISeq{
 					&bytecode.ISeq{
 						Name:  "<class:Version>",
@@ -4562,8 +4579,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1461}, {PC: 4, Line: 1463}, {PC: 7, Line: 1464}, {PC: 16, Line: 1468}, {PC: 18, Line: 1473}, {PC: 20, Line: 1483}, {PC: 24, Line: 1485}, {PC: 26, Line: 1493}, {PC: 28, Line: 1497}, {PC: 30, Line: 1503}, {PC: 32, Line: 1510}, {PC: 34, Line: 1514}, {PC: 36, Line: 1523}, {PC: 38, Line: 1531}, {PC: 40, Line: 1551}, {PC: 42, Line: 1557}, {PC: 44, Line: 1561}, {PC: 46, Line: 1565}, {PC: 49, Line: 1569}},
-						FirstLine:   1460,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1484}, {PC: 4, Line: 1486}, {PC: 7, Line: 1487}, {PC: 16, Line: 1491}, {PC: 18, Line: 1496}, {PC: 20, Line: 1506}, {PC: 24, Line: 1508}, {PC: 26, Line: 1516}, {PC: 28, Line: 1520}, {PC: 30, Line: 1526}, {PC: 32, Line: 1533}, {PC: 34, Line: 1537}, {PC: 36, Line: 1546}, {PC: 38, Line: 1554}, {PC: 40, Line: 1574}, {PC: 42, Line: 1580}, {PC: 44, Line: 1584}, {PC: 46, Line: 1588}, {PC: 49, Line: 1592}},
+						FirstLine:   1483,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "correct?",
@@ -4577,8 +4594,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"str"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1469}, {PC: 8, Line: 1470}},
-								FirstLine:   1468,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1492}, {PC: 8, Line: 1493}},
+								FirstLine:   1491,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -4593,8 +4610,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"input"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1474}, {PC: 4, Line: 1475}, {PC: 9, Line: 254}, {PC: 11, Line: 1479}},
-								FirstLine:   1473,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1497}, {PC: 4, Line: 1498}, {PC: 9, Line: 259}, {PC: 11, Line: 1502}},
+								FirstLine:   1496,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -4617,8 +4634,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"version"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1487}, {PC: 22, Line: 1489}, {PC: 30, Line: 1490}},
-								FirstLine:   1485,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1510}, {PC: 22, Line: 1512}, {PC: 30, Line: 1513}},
+								FirstLine:   1508,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -4631,8 +4648,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1494}},
-								FirstLine:   1493,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1517}},
+								FirstLine:   1516,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -4651,8 +4668,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1498}, {PC: 4, Line: 109}, {PC: 12, Line: 1498}},
-								FirstLine:   1497,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1521}, {PC: 4, Line: 109}, {PC: 12, Line: 1521}},
+								FirstLine:   1520,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -4665,8 +4682,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1504}},
-								FirstLine:   1503,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1527}},
+								FirstLine:   1526,
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:        "block in segments",
@@ -4680,8 +4697,8 @@ func embeddedPrelude() *bytecode.ISeq {
 										BlockSlot:   -1,
 										NumLocals:   1,
 										Locals:      []string{"s"},
-										Lines:       []bytecode.LineEntry{{PC: 0, Line: 1505}},
-										FirstLine:   1504,
+										Lines:       []bytecode.LineEntry{{PC: 0, Line: 1528}},
+										FirstLine:   1527,
 										Super:       "",
 									},
 								},
@@ -4697,8 +4714,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1511}},
-								FirstLine:   1510,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1534}},
+								FirstLine:   1533,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -4715,8 +4732,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"segs"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1515}, {PC: 4, Line: 109}, {PC: 9, Line: 1516}, {PC: 13, Line: 1517}, {PC: 31, Line: 109}},
-								FirstLine:   1514,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1538}, {PC: 4, Line: 109}, {PC: 9, Line: 1539}, {PC: 13, Line: 1540}, {PC: 31, Line: 109}},
+								FirstLine:   1537,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -4735,8 +4752,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   2,
 								Locals:      []string{"segs", ""},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1524}, {PC: 5, Line: 1525}, {PC: 23, Line: 1526}, {PC: 33, Line: 1527}, {PC: 45, Line: 109}},
-								FirstLine:   1523,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1547}, {PC: 5, Line: 1548}, {PC: 23, Line: 1549}, {PC: 33, Line: 1550}, {PC: 45, Line: 109}},
+								FirstLine:   1546,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -4755,8 +4772,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   8,
 								Locals:      []string{"other", "lhs", "rhs", "limit", "i", "l", "r", "c"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1533}, {PC: 9, Line: 254}, {PC: 14, Line: 1534}, {PC: 18, Line: 1535}, {PC: 22, Line: 1536}, {PC: 35, Line: 1537}, {PC: 38, Line: 1538}, {PC: 42, Line: 1539}, {PC: 47, Line: 1540}, {PC: 52, Line: 1542}, {PC: 60, Line: 1543}, {PC: 68, Line: 1544}, {PC: 74, Line: 1545}, {PC: 84, Line: 1546}, {PC: 92, Line: 1548}},
-								FirstLine:   1531,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1556}, {PC: 9, Line: 259}, {PC: 14, Line: 1557}, {PC: 18, Line: 1558}, {PC: 22, Line: 1559}, {PC: 35, Line: 1560}, {PC: 38, Line: 1561}, {PC: 42, Line: 1562}, {PC: 47, Line: 1563}, {PC: 52, Line: 1565}, {PC: 60, Line: 1566}, {PC: 68, Line: 1567}, {PC: 74, Line: 1568}, {PC: 84, Line: 1569}, {PC: 92, Line: 1571}},
+								FirstLine:   1554,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -4774,8 +4791,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"other"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1553}, {PC: 14, Line: 109}},
-								FirstLine:   1551,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1576}, {PC: 14, Line: 109}},
+								FirstLine:   1574,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -4790,8 +4807,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"other"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1558}},
-								FirstLine:   1557,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1581}},
+								FirstLine:   1580,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -4804,8 +4821,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1562}},
-								FirstLine:   1561,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1585}},
+								FirstLine:   1584,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -4824,8 +4841,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   2,
 								Locals:      []string{"l", "r"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1570}, {PC: 10, Line: 1571}, {PC: 24, Line: 1573}, {PC: 32, Line: 1575}, {PC: 34, Line: 1577}},
-								FirstLine:   1569,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1593}, {PC: 10, Line: 1594}, {PC: 24, Line: 1596}, {PC: 32, Line: 1598}, {PC: 34, Line: 1600}},
+								FirstLine:   1592,
 								Super:       "",
 							},
 						},
@@ -4853,8 +4870,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1585}, {PC: 24, Line: 1598}, {PC: 34, Line: 1600}, {PC: 36, Line: 1604}, {PC: 38, Line: 1608}, {PC: 42, Line: 1610}, {PC: 44, Line: 1618}, {PC: 46, Line: 1627}, {PC: 48, Line: 1631}, {PC: 50, Line: 1632}, {PC: 52, Line: 1634}},
-						FirstLine:   1584,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1608}, {PC: 24, Line: 1621}, {PC: 34, Line: 1623}, {PC: 36, Line: 1627}, {PC: 38, Line: 1631}, {PC: 42, Line: 1633}, {PC: 44, Line: 1641}, {PC: 46, Line: 1650}, {PC: 48, Line: 1654}, {PC: 50, Line: 1655}, {PC: 52, Line: 1657}},
+						FirstLine:   1607,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in <class:Requirement>",
@@ -4867,8 +4884,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   2,
 								Locals:      []string{"v", "r"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1586}},
-								FirstLine:   1585,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1609}},
+								FirstLine:   1608,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -4882,8 +4899,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   2,
 								Locals:      []string{"v", "r"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1587}},
-								FirstLine:   1585,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1610}},
+								FirstLine:   1608,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -4897,8 +4914,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   2,
 								Locals:      []string{"v", "r"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1588}},
-								FirstLine:   1585,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1611}},
+								FirstLine:   1608,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -4912,8 +4929,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   2,
 								Locals:      []string{"v", "r"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1589}},
-								FirstLine:   1585,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1612}},
+								FirstLine:   1608,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -4927,8 +4944,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   2,
 								Locals:      []string{"v", "r"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1590}},
-								FirstLine:   1585,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1613}},
+								FirstLine:   1608,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -4942,8 +4959,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   2,
 								Locals:      []string{"v", "r"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1591}},
-								FirstLine:   1585,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1614}},
+								FirstLine:   1608,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -4958,8 +4975,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   2,
 								Locals:      []string{"v", "r"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1592}},
-								FirstLine:   1585,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1615}},
+								FirstLine:   1608,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -4974,8 +4991,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"input"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1601}},
-								FirstLine:   1600,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1624}},
+								FirstLine:   1623,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -4991,8 +5008,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1605}},
-								FirstLine:   1604,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1628}},
+								FirstLine:   1627,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -5010,8 +5027,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"reqs"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1611}, {PC: 4, Line: 1612}, {PC: 13, Line: 1613}},
-								FirstLine:   1610,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1634}, {PC: 4, Line: 1635}, {PC: 13, Line: 1636}},
+								FirstLine:   1633,
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:        "block in initialize",
@@ -5026,7 +5043,7 @@ func embeddedPrelude() *bytecode.ISeq {
 										NumLocals:   1,
 										Locals:      []string{"r"},
 										Lines:       []bytecode.LineEntry{{PC: 0, Line: 109}},
-										FirstLine:   1613,
+										FirstLine:   1636,
 										Super:       "",
 									},
 								},
@@ -5053,8 +5070,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   3,
 								Locals:      []string{"obj", "m", "op"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1619}, {PC: 11, Line: 1620}, {PC: 17, Line: 1621}, {PC: 37, Line: 1622}, {PC: 46, Line: 1623}},
-								FirstLine:   1618,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1642}, {PC: 11, Line: 1643}, {PC: 17, Line: 1644}, {PC: 37, Line: 1645}, {PC: 46, Line: 1646}},
+								FirstLine:   1641,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -5069,8 +5086,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"version"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1628}, {PC: 5, Line: 1629}},
-								FirstLine:   1627,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1651}, {PC: 5, Line: 1652}},
+								FirstLine:   1650,
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:        "block in satisfied_by?",
@@ -5084,8 +5101,8 @@ func embeddedPrelude() *bytecode.ISeq {
 										BlockSlot:   -1,
 										NumLocals:   2,
 										Locals:      []string{"op", "req"},
-										Lines:       []bytecode.LineEntry{{PC: 0, Line: 1629}},
-										FirstLine:   1629,
+										Lines:       []bytecode.LineEntry{{PC: 0, Line: 1652}},
+										FirstLine:   1652,
 										Super:       "",
 									},
 								},
@@ -5104,8 +5121,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1635}},
-								FirstLine:   1634,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1658}},
+								FirstLine:   1657,
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:  "block in to_s",
@@ -5125,8 +5142,8 @@ func embeddedPrelude() *bytecode.ISeq {
 										BlockSlot:   -1,
 										NumLocals:   2,
 										Locals:      []string{"op", "req"},
-										Lines:       []bytecode.LineEntry{{PC: 0, Line: 1635}},
-										FirstLine:   1635,
+										Lines:       []bytecode.LineEntry{{PC: 0, Line: 1658}},
+										FirstLine:   1658,
 										Super:       "",
 									},
 								},
@@ -5145,8 +5162,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1642}},
-						FirstLine:   1641,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1665}},
+						FirstLine:   1664,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -5158,8 +5175,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1646}},
-						FirstLine:   1645,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1669}},
+						FirstLine:   1668,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -5171,8 +5188,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1651}},
-						FirstLine:   1651,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1674}},
+						FirstLine:   1674,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -5185,8 +5202,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1656}},
-						FirstLine:   1655,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1679}},
+						FirstLine:   1678,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "stubs",
@@ -5197,8 +5214,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1657}},
-								FirstLine:   1656,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1680}},
+								FirstLine:   1679,
 								Super:       "",
 							},
 						},
@@ -5217,8 +5234,8 @@ func embeddedPrelude() *bytecode.ISeq {
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
-				Lines:       []bytecode.LineEntry{{PC: 0, Line: 1677}, {PC: 2, Line: 1684}, {PC: 4, Line: 1688}, {PC: 6, Line: 1692}, {PC: 8, Line: 1696}, {PC: 10, Line: 1702}, {PC: 12, Line: 1706}, {PC: 14, Line: 1710}, {PC: 16, Line: 1714}, {PC: 18, Line: 1719}, {PC: 20, Line: 1731}, {PC: 22, Line: 1734}, {PC: 24, Line: 1736}, {PC: 26, Line: 1740}, {PC: 28, Line: 1743}},
-				FirstLine:   1676,
+				Lines:       []bytecode.LineEntry{{PC: 0, Line: 1700}, {PC: 2, Line: 1707}, {PC: 4, Line: 1711}, {PC: 6, Line: 1715}, {PC: 8, Line: 1719}, {PC: 10, Line: 1725}, {PC: 12, Line: 1729}, {PC: 14, Line: 1733}, {PC: 16, Line: 1737}, {PC: 18, Line: 1742}, {PC: 20, Line: 1754}, {PC: 22, Line: 1757}, {PC: 24, Line: 1759}, {PC: 26, Line: 1763}, {PC: 28, Line: 1766}},
+				FirstLine:   1699,
 				Children: []*bytecode.ISeq{
 					&bytecode.ISeq{
 						Name:        "initialize",
@@ -5232,8 +5249,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"hash"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1677}, {PC: 2, Line: 254}, {PC: 5, Line: 1678}, {PC: 8, Line: 1679}, {PC: 10, Line: 1680}},
-						FirstLine:   1677,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1700}, {PC: 2, Line: 259}, {PC: 5, Line: 1701}, {PC: 8, Line: 1702}, {PC: 10, Line: 1703}},
+						FirstLine:   1700,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in initialize",
@@ -5247,8 +5264,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   3,
 								Locals:      []string{"k", "v", ""},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1680}},
-								FirstLine:   1680,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1703}},
+								FirstLine:   1703,
 								Super:       "",
 							},
 						},
@@ -5266,8 +5283,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"name"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1685}},
-						FirstLine:   1684,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1708}},
+						FirstLine:   1707,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -5282,8 +5299,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   3,
 						Locals:      []string{"name", "value", ""},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1689}},
-						FirstLine:   1688,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1712}},
+						FirstLine:   1711,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -5296,8 +5313,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1693}},
-						FirstLine:   1692,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1716}},
+						FirstLine:   1715,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -5313,8 +5330,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1697}, {PC: 10, Line: 1698}, {PC: 13, Line: 109}},
-						FirstLine:   1696,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1720}, {PC: 10, Line: 1721}, {PC: 13, Line: 109}},
+						FirstLine:   1719,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in each_pair",
@@ -5327,8 +5344,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   2,
 								Locals:      []string{"k", "v"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1698}},
-								FirstLine:   1698,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1721}},
+								FirstLine:   1721,
 								Super:       "",
 							},
 						},
@@ -5344,8 +5361,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1703}},
-						FirstLine:   1702,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1726}},
+						FirstLine:   1725,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -5360,8 +5377,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"names"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1707}},
-						FirstLine:   1706,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1730}},
+						FirstLine:   1729,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -5376,8 +5393,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"name"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1711}},
-						FirstLine:   1710,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1734}},
+						FirstLine:   1733,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -5395,8 +5412,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   3,
 						Locals:      []string{"name", "include_private", "n"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1714}, {PC: 5, Line: 1715}, {PC: 9, Line: 1716}},
-						FirstLine:   1714,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1737}, {PC: 5, Line: 1738}, {PC: 9, Line: 1739}},
+						FirstLine:   1737,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -5420,8 +5437,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   4,
 						Locals:      []string{"name", "args", "n", ""},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1720}, {PC: 4, Line: 1721}, {PC: 8, Line: 1722}, {PC: 31, Line: 1723}, {PC: 49, Line: 1725}, {PC: 53, Line: 1727}},
-						FirstLine:   1719,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1743}, {PC: 4, Line: 1744}, {PC: 8, Line: 1745}, {PC: 31, Line: 1746}, {PC: 49, Line: 1748}, {PC: 53, Line: 1750}},
+						FirstLine:   1742,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -5436,8 +5453,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"other"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1732}, {PC: 9, Line: 254}},
-						FirstLine:   1731,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1755}, {PC: 9, Line: 259}},
+						FirstLine:   1754,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -5452,8 +5469,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   2,
 						Locals:      []string{"name", "include_private"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1736}, {PC: 5, Line: 1737}},
-						FirstLine:   1736,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1759}, {PC: 5, Line: 1760}},
+						FirstLine:   1759,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -5466,8 +5483,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1741}},
-						FirstLine:   1740,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1764}},
+						FirstLine:   1763,
 						Super:       "",
 					},
 				},
@@ -5483,8 +5500,8 @@ func embeddedPrelude() *bytecode.ISeq {
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
-				Lines:       []bytecode.LineEntry{{PC: 0, Line: 1758}, {PC: 2, Line: 1766}, {PC: 4, Line: 1769}, {PC: 6, Line: 1775}},
-				FirstLine:   1755,
+				Lines:       []bytecode.LineEntry{{PC: 0, Line: 1781}, {PC: 2, Line: 1789}, {PC: 4, Line: 1792}, {PC: 6, Line: 1798}},
+				FirstLine:   1778,
 				Children: []*bytecode.ISeq{
 					&bytecode.ISeq{
 						Name:        "def_delegator",
@@ -5498,8 +5515,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   3,
 						Locals:      []string{"accessor", "method", "ali"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1758}, {PC: 5, Line: 1759}, {PC: 9, Line: 1760}, {PC: 13, Line: 1764}},
-						FirstLine:   1758,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1781}, {PC: 5, Line: 1782}, {PC: 9, Line: 1783}, {PC: 13, Line: 1787}},
+						FirstLine:   1781,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in def_delegator",
@@ -5513,8 +5530,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   1,
 								NumLocals:   3,
 								Locals:      []string{"args", "block", "target"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1761}, {PC: 1, Line: 109}, {PC: 6, Line: 1762}},
-								FirstLine:   1760,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1784}, {PC: 1, Line: 109}, {PC: 6, Line: 1785}},
+								FirstLine:   1783,
 								Super:       "",
 							},
 						},
@@ -5532,8 +5549,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   2,
 						Locals:      []string{"accessor", "methods"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1770}},
-						FirstLine:   1769,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1793}},
+						FirstLine:   1792,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in def_delegators",
@@ -5547,8 +5564,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"m"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1770}},
-								FirstLine:   1770,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1793}},
+								FirstLine:   1793,
 								Super:       "",
 							},
 						},
@@ -5569,8 +5586,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   2,
 						Locals:      []string{"obj", "accessor"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1776}, {PC: 4, Line: 1777}, {PC: 9, Line: 1779}},
-						FirstLine:   1775,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1799}, {PC: 4, Line: 1800}, {PC: 9, Line: 1802}},
+						FirstLine:   1798,
 						Super:       "",
 					},
 				},
@@ -5586,8 +5603,8 @@ func embeddedPrelude() *bytecode.ISeq {
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
-				Lines:       []bytecode.LineEntry{{PC: 0, Line: 1787}, {PC: 2, Line: 1795}, {PC: 4, Line: 1797}},
-				FirstLine:   1786,
+				Lines:       []bytecode.LineEntry{{PC: 0, Line: 1810}, {PC: 2, Line: 1818}, {PC: 4, Line: 1820}},
+				FirstLine:   1809,
 				Children: []*bytecode.ISeq{
 					&bytecode.ISeq{
 						Name:        "def_single_delegator",
@@ -5601,8 +5618,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   3,
 						Locals:      []string{"accessor", "method", "ali"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1787}, {PC: 5, Line: 1788}, {PC: 9, Line: 1789}, {PC: 13, Line: 1793}},
-						FirstLine:   1787,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1810}, {PC: 5, Line: 1811}, {PC: 9, Line: 1812}, {PC: 13, Line: 1816}},
+						FirstLine:   1810,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in def_single_delegator",
@@ -5616,8 +5633,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   1,
 								NumLocals:   3,
 								Locals:      []string{"args", "block", "target"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1790}, {PC: 1, Line: 109}, {PC: 6, Line: 1791}},
-								FirstLine:   1789,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1813}, {PC: 1, Line: 109}, {PC: 6, Line: 1814}},
+								FirstLine:   1812,
 								Super:       "",
 							},
 						},
@@ -5635,8 +5652,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   2,
 						Locals:      []string{"accessor", "methods"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1798}},
-						FirstLine:   1797,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1821}},
+						FirstLine:   1820,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in def_single_delegators",
@@ -5650,8 +5667,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"m"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1798}},
-								FirstLine:   1798,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1821}},
+								FirstLine:   1821,
 								Super:       "",
 							},
 						},
@@ -5670,8 +5687,8 @@ func embeddedPrelude() *bytecode.ISeq {
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
-				Lines:       []bytecode.LineEntry{{PC: 0, Line: 1807}, {PC: 2, Line: 1813}, {PC: 4, Line: 1822}, {PC: 6, Line: 1826}, {PC: 8, Line: 1830}, {PC: 10, Line: 1835}, {PC: 12, Line: 1839}},
-				FirstLine:   1806,
+				Lines:       []bytecode.LineEntry{{PC: 0, Line: 1830}, {PC: 2, Line: 1836}, {PC: 4, Line: 1845}, {PC: 6, Line: 1849}, {PC: 8, Line: 1853}, {PC: 10, Line: 1858}, {PC: 12, Line: 1862}},
+				FirstLine:   1829,
 				Children: []*bytecode.ISeq{
 					&bytecode.ISeq{
 						Name:        "initialize",
@@ -5685,8 +5702,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"obj"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1808}},
-						FirstLine:   1807,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1831}},
+						FirstLine:   1830,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -5701,8 +5718,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   2,
 						NumLocals:   4,
 						Locals:      []string{"name", "args", "block", "target"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1814}, {PC: 4, Line: 1815}, {PC: 8, Line: 1816}, {PC: 19, Line: 1818}},
-						FirstLine:   1813,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1837}, {PC: 4, Line: 1838}, {PC: 8, Line: 1839}, {PC: 19, Line: 1841}},
+						FirstLine:   1836,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -5717,8 +5734,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   2,
 						Locals:      []string{"name", "include_private"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1822}, {PC: 5, Line: 1823}},
-						FirstLine:   1822,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1845}, {PC: 5, Line: 1846}},
+						FirstLine:   1845,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -5733,8 +5750,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   2,
 						Locals:      []string{"name", "include_private"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1826}, {PC: 5, Line: 1827}},
-						FirstLine:   1826,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1849}, {PC: 5, Line: 1850}},
+						FirstLine:   1849,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -5749,8 +5766,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"other"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1831}, {PC: 1, Line: 109}, {PC: 9, Line: 1832}},
-						FirstLine:   1830,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1854}, {PC: 1, Line: 109}, {PC: 9, Line: 1855}},
+						FirstLine:   1853,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -5768,8 +5785,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1836}, {PC: 6, Line: 109}},
-						FirstLine:   1835,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1859}, {PC: 6, Line: 109}},
+						FirstLine:   1858,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -5789,8 +5806,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"_obj"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1840}, {PC: 6, Line: 109}},
-						FirstLine:   1839,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1863}, {PC: 6, Line: 109}},
+						FirstLine:   1862,
 						Super:       "",
 					},
 				},
@@ -5806,8 +5823,8 @@ func embeddedPrelude() *bytecode.ISeq {
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
-				Lines:       []bytecode.LineEntry{{PC: 0, Line: 1847}, {PC: 2, Line: 1851}},
-				FirstLine:   1846,
+				Lines:       []bytecode.LineEntry{{PC: 0, Line: 1870}, {PC: 2, Line: 1874}},
+				FirstLine:   1869,
 				Children: []*bytecode.ISeq{
 					&bytecode.ISeq{
 						Name:        "__getobj__",
@@ -5819,8 +5836,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1848}},
-						FirstLine:   1847,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1871}},
+						FirstLine:   1870,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -5835,8 +5852,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"obj"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1852}},
-						FirstLine:   1851,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1875}},
+						FirstLine:   1874,
 						Super:       "",
 					},
 				},
@@ -5879,8 +5896,8 @@ func embeddedPrelude() *bytecode.ISeq {
 				BlockSlot:   -1,
 				NumLocals:   3,
 				Locals:      []string{"superclass", "klass", "skip"},
-				Lines:       []bytecode.LineEntry{{PC: 0, Line: 1860}, {PC: 5, Line: 1861}, {PC: 8, Line: 1879}, {PC: 34, Line: 1886}, {PC: 38, Line: 1892}},
-				FirstLine:   1859,
+				Lines:       []bytecode.LineEntry{{PC: 0, Line: 1883}, {PC: 5, Line: 1884}, {PC: 8, Line: 1902}, {PC: 34, Line: 1909}, {PC: 38, Line: 1915}},
+				FirstLine:   1882,
 				Children: []*bytecode.ISeq{
 					&bytecode.ISeq{
 						Name:        "block in DelegateClass",
@@ -5892,8 +5909,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1862}, {PC: 2, Line: 1866}},
-						FirstLine:   1861,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1885}, {PC: 2, Line: 1889}},
+						FirstLine:   1884,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "__getobj__",
@@ -5905,8 +5922,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1863}},
-								FirstLine:   1862,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1886}},
+								FirstLine:   1885,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -5921,8 +5938,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"obj"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1867}},
-								FirstLine:   1866,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1890}},
+								FirstLine:   1889,
 								Super:       "",
 							},
 						},
@@ -5943,8 +5960,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"m"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1887}, {PC: 9, Line: 1888}},
-						FirstLine:   1886,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1910}, {PC: 9, Line: 1911}},
+						FirstLine:   1909,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block (2 levels) in DelegateClass",
@@ -5958,8 +5975,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   1,
 								NumLocals:   2,
 								Locals:      []string{"args", "block"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1889}},
-								FirstLine:   1888,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1912}},
+								FirstLine:   1911,
 								Super:       "",
 							},
 						},
@@ -5981,8 +5998,8 @@ func embeddedPrelude() *bytecode.ISeq {
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
-				Lines:       []bytecode.LineEntry{{PC: 0, Line: 1900}, {PC: 4, Line: 1901}, {PC: 7, Line: 1903}, {PC: 9, Line: 1909}, {PC: 11, Line: 1912}, {PC: 13, Line: 1914}, {PC: 15, Line: 1918}, {PC: 17, Line: 1922}, {PC: 19, Line: 1927}, {PC: 21, Line: 1930}, {PC: 23, Line: 1932}, {PC: 25, Line: 1937}, {PC: 27, Line: 1947}, {PC: 29, Line: 1951}, {PC: 31, Line: 1955}, {PC: 33, Line: 1962}, {PC: 35, Line: 1967}, {PC: 37, Line: 1971}, {PC: 39, Line: 1979}, {PC: 41, Line: 1983}, {PC: 43, Line: 1986}, {PC: 45, Line: 1988}, {PC: 47, Line: 1992}, {PC: 49, Line: 1996}, {PC: 51, Line: 2003}, {PC: 53, Line: 2009}, {PC: 55, Line: 2016}, {PC: 57, Line: 2020}, {PC: 59, Line: 2028}, {PC: 61, Line: 2037}, {PC: 63, Line: 2041}, {PC: 65, Line: 2045}, {PC: 67, Line: 2049}, {PC: 69, Line: 2053}, {PC: 71, Line: 2057}, {PC: 73, Line: 2061}},
-				FirstLine:   1899,
+				Lines:       []bytecode.LineEntry{{PC: 0, Line: 1923}, {PC: 4, Line: 1924}, {PC: 7, Line: 1926}, {PC: 9, Line: 1932}, {PC: 11, Line: 1935}, {PC: 13, Line: 1937}, {PC: 15, Line: 1941}, {PC: 17, Line: 1945}, {PC: 19, Line: 1950}, {PC: 21, Line: 1953}, {PC: 23, Line: 1955}, {PC: 25, Line: 1960}, {PC: 27, Line: 1970}, {PC: 29, Line: 1974}, {PC: 31, Line: 1978}, {PC: 33, Line: 1985}, {PC: 35, Line: 1990}, {PC: 37, Line: 1994}, {PC: 39, Line: 2002}, {PC: 41, Line: 2006}, {PC: 43, Line: 2009}, {PC: 45, Line: 2011}, {PC: 47, Line: 2015}, {PC: 49, Line: 2019}, {PC: 51, Line: 2026}, {PC: 53, Line: 2032}, {PC: 55, Line: 2039}, {PC: 57, Line: 2043}, {PC: 59, Line: 2051}, {PC: 61, Line: 2060}, {PC: 63, Line: 2064}, {PC: 65, Line: 2068}, {PC: 67, Line: 2072}, {PC: 69, Line: 2076}, {PC: 71, Line: 2080}, {PC: 73, Line: 2084}},
+				FirstLine:   1922,
 				Children: []*bytecode.ISeq{
 					&bytecode.ISeq{
 						Name:  "initialize",
@@ -5999,8 +6016,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"path"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1904}, {PC: 10, Line: 1905}, {PC: 22, Line: 1906}},
-						FirstLine:   1903,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1927}, {PC: 10, Line: 1928}, {PC: 22, Line: 1929}},
+						FirstLine:   1926,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -6013,8 +6030,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1910}},
-						FirstLine:   1909,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1933}},
+						FirstLine:   1932,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -6032,8 +6049,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1915}},
-						FirstLine:   1914,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1938}},
+						FirstLine:   1937,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -6046,8 +6063,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1919}},
-						FirstLine:   1918,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1942}},
+						FirstLine:   1941,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -6060,8 +6077,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1923}, {PC: 3, Line: 1924}},
-						FirstLine:   1922,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1946}, {PC: 3, Line: 1947}},
+						FirstLine:   1945,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -6076,8 +6093,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"other"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1928}},
-						FirstLine:   1927,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1951}},
+						FirstLine:   1950,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -6092,8 +6109,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"other"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1933}, {PC: 5, Line: 254}, {PC: 10, Line: 1934}},
-						FirstLine:   1932,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1956}, {PC: 5, Line: 259}, {PC: 10, Line: 1957}},
+						FirstLine:   1955,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -6106,8 +6123,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1938}},
-						FirstLine:   1937,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1961}},
+						FirstLine:   1960,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -6120,8 +6137,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1948}},
-						FirstLine:   1947,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1971}},
+						FirstLine:   1970,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -6134,8 +6151,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1952}},
-						FirstLine:   1951,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1975}},
+						FirstLine:   1974,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -6148,8 +6165,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1956}},
-						FirstLine:   1955,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1979}},
+						FirstLine:   1978,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -6164,8 +6181,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"other"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1963}, {PC: 12, Line: 1964}},
-						FirstLine:   1962,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1986}, {PC: 12, Line: 1987}},
+						FirstLine:   1985,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -6180,7 +6197,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						NumLocals:   1,
 						Locals:      []string{"other"},
 						Lines:       []bytecode.LineEntry{{PC: 0, Line: 109}},
-						FirstLine:   1967,
+						FirstLine:   1990,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -6195,8 +6212,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   2,
 						Locals:      []string{"args", "result"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 3, Line: 1973}, {PC: 6, Line: 1974}},
-						FirstLine:   1971,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 3, Line: 1996}, {PC: 6, Line: 1997}},
+						FirstLine:   1994,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in join",
@@ -6209,8 +6226,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"a"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1973}},
-								FirstLine:   1973,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1996}},
+								FirstLine:   1996,
 								Super:       "",
 							},
 						},
@@ -6231,8 +6248,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"suffix"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1979}, {PC: 5, Line: 1980}},
-						FirstLine:   1979,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2002}, {PC: 5, Line: 2003}},
+						FirstLine:   2002,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -6245,8 +6262,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1984}},
-						FirstLine:   1983,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2007}},
+						FirstLine:   2006,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -6259,8 +6276,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1989}},
-						FirstLine:   1988,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2012}},
+						FirstLine:   2011,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -6273,8 +6290,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1993}},
-						FirstLine:   1992,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2016}},
+						FirstLine:   2015,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -6290,8 +6307,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 1997}, {PC: 10, Line: 1998}},
-						FirstLine:   1996,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2020}, {PC: 10, Line: 2021}},
+						FirstLine:   2019,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in each_filename",
@@ -6304,8 +6321,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"f"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 1998}},
-								FirstLine:   1998,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2021}},
+								FirstLine:   2021,
 								Super:       "",
 							},
 						},
@@ -6324,8 +6341,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2004}, {PC: 10, Line: 2005}, {PC: 15, Line: 109}},
-						FirstLine:   2003,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2027}, {PC: 10, Line: 2028}, {PC: 15, Line: 109}},
+						FirstLine:   2026,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in ascend",
@@ -6339,8 +6356,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"p"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2005}},
-								FirstLine:   2005,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2028}},
+								FirstLine:   2028,
 								Super:       "",
 							},
 						},
@@ -6359,8 +6376,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2010}, {PC: 10, Line: 2011}, {PC: 15, Line: 109}},
-						FirstLine:   2009,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2033}, {PC: 10, Line: 2034}, {PC: 15, Line: 109}},
+						FirstLine:   2032,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in descend",
@@ -6374,8 +6391,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"p"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2011}},
-								FirstLine:   2011,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2034}},
+								FirstLine:   2034,
 								Super:       "",
 							},
 						},
@@ -6391,8 +6408,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2017}},
-						FirstLine:   2016,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2040}},
+						FirstLine:   2039,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -6407,8 +6424,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"repl"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2021}},
-						FirstLine:   2020,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2044}},
+						FirstLine:   2043,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -6423,8 +6440,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"base_directory"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2029}, {PC: 12, Line: 2030}},
-						FirstLine:   2028,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2052}, {PC: 12, Line: 2053}},
+						FirstLine:   2051,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -6439,8 +6456,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   2,
 						Locals:      []string{"args", "opts"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2038}},
-						FirstLine:   2037,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2061}},
+						FirstLine:   2060,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -6455,8 +6472,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   3,
 						Locals:      []string{"content", "args", "opts"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2042}},
-						FirstLine:   2041,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2065}},
+						FirstLine:   2064,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -6471,8 +6488,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   1,
 						NumLocals:   2,
 						Locals:      []string{"args", "block"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2046}},
-						FirstLine:   2045,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2069}},
+						FirstLine:   2068,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -6485,8 +6502,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2050}},
-						FirstLine:   2049,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2073}},
+						FirstLine:   2072,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -6499,8 +6516,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2054}},
-						FirstLine:   2053,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2077}},
+						FirstLine:   2076,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -6513,8 +6530,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2058}},
-						FirstLine:   2057,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2081}},
+						FirstLine:   2080,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -6529,8 +6546,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   1,
 						NumLocals:   2,
 						Locals:      []string{"args", "block"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2062}},
-						FirstLine:   2061,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2085}},
+						FirstLine:   2084,
 						Super:       "",
 					},
 				},
@@ -6546,8 +6563,8 @@ func embeddedPrelude() *bytecode.ISeq {
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
-				Lines:       []bytecode.LineEntry{{PC: 0, Line: 2072}, {PC: 2, Line: 2083}},
-				FirstLine:   2070,
+				Lines:       []bytecode.LineEntry{{PC: 0, Line: 2095}, {PC: 2, Line: 2106}},
+				FirstLine:   2093,
 				Children: []*bytecode.ISeq{
 					&bytecode.ISeq{
 						Name:        "<module:SingletonClassMethods>",
@@ -6559,8 +6576,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2075}},
-						FirstLine:   2072,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2098}},
+						FirstLine:   2095,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "instance",
@@ -6572,8 +6589,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2076}},
-								FirstLine:   2075,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2099}},
+								FirstLine:   2098,
 								Super:       "",
 							},
 						},
@@ -6595,8 +6612,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"klass"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2084}, {PC: 4, Line: 2085}},
-						FirstLine:   2083,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2107}, {PC: 4, Line: 2108}},
+						FirstLine:   2106,
 						Super:       "",
 					},
 				},
@@ -6618,8 +6635,8 @@ func embeddedPrelude() *bytecode.ISeq {
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
-				Lines:       []bytecode.LineEntry{{PC: 0, Line: 2108}, {PC: 5, Line: 2109}, {PC: 10, Line: 2115}, {PC: 12, Line: 2128}, {PC: 14, Line: 2135}, {PC: 16, Line: 2144}, {PC: 18, Line: 2148}, {PC: 21, Line: 2152}},
-				FirstLine:   2106,
+				Lines:       []bytecode.LineEntry{{PC: 0, Line: 2131}, {PC: 5, Line: 2132}, {PC: 10, Line: 2138}, {PC: 12, Line: 2151}, {PC: 14, Line: 2158}, {PC: 16, Line: 2167}, {PC: 18, Line: 2171}, {PC: 21, Line: 2175}},
+				FirstLine:   2129,
 				Children: []*bytecode.ISeq{
 					&bytecode.ISeq{
 						Name:  "initialize",
@@ -6640,8 +6657,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   3,
 						Locals:      []string{"str", "trim_mode", "eoutvar"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2115}, {PC: 2, Line: 254}, {PC: 13, Line: 2117}, {PC: 16, Line: 2118}, {PC: 19, Line: 2122}},
-						FirstLine:   2115,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2138}, {PC: 2, Line: 259}, {PC: 13, Line: 2140}, {PC: 16, Line: 2141}, {PC: 19, Line: 2145}},
+						FirstLine:   2138,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -6659,8 +6676,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"b"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2128}, {PC: 6, Line: 2129}},
-						FirstLine:   2128,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2151}, {PC: 6, Line: 2152}},
+						FirstLine:   2151,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -6675,8 +6692,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   2,
 						Locals:      []string{"hash", "b"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2136}, {PC: 4, Line: 2137}, {PC: 7, Line: 2140}},
-						FirstLine:   2135,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2159}, {PC: 4, Line: 2160}, {PC: 7, Line: 2163}},
+						FirstLine:   2158,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "block in result_with_hash",
@@ -6690,8 +6707,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   2,
 								Locals:      []string{"key", "value"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2138}},
-								FirstLine:   2137,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2161}},
+								FirstLine:   2160,
 								Super:       "",
 							},
 						},
@@ -6709,8 +6726,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"b"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2144}, {PC: 6, Line: 2145}},
-						FirstLine:   2144,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2167}, {PC: 6, Line: 2168}},
+						FirstLine:   2167,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -6722,8 +6739,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2153}},
-						FirstLine:   2152,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2176}},
+						FirstLine:   2175,
 						Super:       "",
 					},
 				},
@@ -6731,16 +6748,16 @@ func embeddedPrelude() *bytecode.ISeq {
 			},
 			&bytecode.ISeq{
 				Name:        "<module:Slim>",
-				Insns:       []bytecode.Instr{{Op: 43}, {Op: 9}, {Op: 42, A: 1, B: 1}, {Op: 9}, {Op: 33, A: 1}, {Op: 41, A: 2}, {Op: 53}},
-				Names:       []string{"Helpers", "Template", "Engine"},
+				Insns:       []bytecode.Instr{{Op: 43}, {Op: 9}, {Op: 42, A: 1, B: 1}, {Op: 53}},
+				Names:       []string{"Helpers", "Template"},
 				NumRequired: 0,
 				SplatIndex:  -1,
 				PostCount:   0,
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
-				Lines:       []bytecode.LineEntry{{PC: 0, Line: 2171}, {PC: 2, Line: 2240}, {PC: 4, Line: 2261}},
-				FirstLine:   2170,
+				Lines:       []bytecode.LineEntry{{PC: 0, Line: 2194}, {PC: 2, Line: 2263}},
+				FirstLine:   2193,
 				Children: []*bytecode.ISeq{
 					&bytecode.ISeq{
 						Name:        "<module:Helpers>",
@@ -6752,8 +6769,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2174}, {PC: 2, Line: 2181}, {PC: 4, Line: 2188}, {PC: 6, Line: 2197}, {PC: 8, Line: 2210}},
-						FirstLine:   2171,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2197}, {PC: 2, Line: 2204}, {PC: 4, Line: 2211}, {PC: 6, Line: 2220}, {PC: 8, Line: 2233}},
+						FirstLine:   2194,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "<class:Safe>",
@@ -6768,8 +6785,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2175}, {PC: 4, Line: 2176}},
-								FirstLine:   2174,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2198}, {PC: 4, Line: 2199}},
+								FirstLine:   2197,
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:        "initialize",
@@ -6783,8 +6800,8 @@ func embeddedPrelude() *bytecode.ISeq {
 										BlockSlot:   -1,
 										NumLocals:   1,
 										Locals:      []string{"v"},
-										Lines:       []bytecode.LineEntry{{PC: 0, Line: 2177}},
-										FirstLine:   2176,
+										Lines:       []bytecode.LineEntry{{PC: 0, Line: 2200}},
+										FirstLine:   2199,
 										Super:       "",
 									},
 								},
@@ -6802,8 +6819,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"v"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2182}},
-								FirstLine:   2181,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2205}},
+								FirstLine:   2204,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -6830,8 +6847,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"s"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2189}},
-								FirstLine:   2188,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2212}},
+								FirstLine:   2211,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -6860,8 +6877,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   2,
 								Locals:      []string{"name", "value"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2198}, {PC: 14, Line: 2199}, {PC: 22, Line: 1}, {PC: 32, Line: 2200}, {PC: 40, Line: 1}, {PC: 57, Line: 2202}, {PC: 61, Line: 1}},
-								FirstLine:   2197,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2221}, {PC: 14, Line: 2222}, {PC: 22, Line: 1}, {PC: 32, Line: 2223}, {PC: 40, Line: 1}, {PC: 57, Line: 2225}, {PC: 61, Line: 1}},
+								FirstLine:   2220,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -6879,8 +6896,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   5,
 								Locals:      []string{"base", "splats", "merged", "add", "out"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2211}, {PC: 3, Line: 2212}, {PC: 7, Line: 2224}, {PC: 10, Line: 2225}, {PC: 13, Line: 2227}, {PC: 16, Line: 2228}, {PC: 21, Line: 2231}},
-								FirstLine:   2210,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2234}, {PC: 3, Line: 2235}, {PC: 7, Line: 2247}, {PC: 10, Line: 2248}, {PC: 13, Line: 2250}, {PC: 16, Line: 2251}, {PC: 21, Line: 2254}},
+								FirstLine:   2233,
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:  "block in render_attributes",
@@ -6903,8 +6920,8 @@ func embeddedPrelude() *bytecode.ISeq {
 										BlockSlot:   -1,
 										NumLocals:   7,
 										Locals:      []string{"k", "v", "existing", "val", "", "", ""},
-										Lines:       []bytecode.LineEntry{{PC: 0, Line: 2213}, {PC: 4, Line: 2214}, {PC: 8, Line: 2215}, {PC: 13, Line: 2216}, {PC: 24, Line: 2217}, {PC: 42, Line: 2219}, {PC: 50, Line: 2221}},
-										FirstLine:   2212,
+										Lines:       []bytecode.LineEntry{{PC: 0, Line: 2236}, {PC: 4, Line: 2237}, {PC: 8, Line: 2238}, {PC: 13, Line: 2239}, {PC: 24, Line: 2240}, {PC: 42, Line: 2242}, {PC: 50, Line: 2244}},
+										FirstLine:   2235,
 										Children: []*bytecode.ISeq{
 											&bytecode.ISeq{
 												Name:  "block (2 levels) in render_attributes",
@@ -6920,8 +6937,8 @@ func embeddedPrelude() *bytecode.ISeq {
 												BlockSlot:   -1,
 												NumLocals:   1,
 												Locals:      []string{"x"},
-												Lines:       []bytecode.LineEntry{{PC: 0, Line: 2217}},
-												FirstLine:   2217,
+												Lines:       []bytecode.LineEntry{{PC: 0, Line: 2240}},
+												FirstLine:   2240,
 												Super:       "",
 											},
 										},
@@ -6939,8 +6956,8 @@ func embeddedPrelude() *bytecode.ISeq {
 										BlockSlot:   -1,
 										NumLocals:   2,
 										Locals:      []string{"k", "v"},
-										Lines:       []bytecode.LineEntry{{PC: 0, Line: 2224}},
-										FirstLine:   2224,
+										Lines:       []bytecode.LineEntry{{PC: 0, Line: 2247}},
+										FirstLine:   2247,
 										Super:       "",
 									},
 									&bytecode.ISeq{
@@ -6955,8 +6972,8 @@ func embeddedPrelude() *bytecode.ISeq {
 										BlockSlot:   -1,
 										NumLocals:   1,
 										Locals:      []string{"h"},
-										Lines:       []bytecode.LineEntry{{PC: 0, Line: 2225}},
-										FirstLine:   2225,
+										Lines:       []bytecode.LineEntry{{PC: 0, Line: 2248}},
+										FirstLine:   2248,
 										Children: []*bytecode.ISeq{
 											&bytecode.ISeq{
 												Name:        "block (2 levels) in render_attributes",
@@ -6970,8 +6987,8 @@ func embeddedPrelude() *bytecode.ISeq {
 												BlockSlot:   -1,
 												NumLocals:   2,
 												Locals:      []string{"k", "v"},
-												Lines:       []bytecode.LineEntry{{PC: 0, Line: 2225}},
-												FirstLine:   2225,
+												Lines:       []bytecode.LineEntry{{PC: 0, Line: 2248}},
+												FirstLine:   2248,
 												Super:       "",
 											},
 										},
@@ -6989,8 +7006,8 @@ func embeddedPrelude() *bytecode.ISeq {
 										BlockSlot:   -1,
 										NumLocals:   1,
 										Locals:      []string{"k"},
-										Lines:       []bytecode.LineEntry{{PC: 0, Line: 2229}},
-										FirstLine:   2228,
+										Lines:       []bytecode.LineEntry{{PC: 0, Line: 2252}},
+										FirstLine:   2251,
 										Super:       "",
 									},
 								},
@@ -7012,8 +7029,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2241}, {PC: 4, Line: 2245}, {PC: 6, Line: 2254}},
-						FirstLine:   2240,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2264}, {PC: 4, Line: 2268}, {PC: 6, Line: 2277}},
+						FirstLine:   2263,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "initialize",
@@ -7027,8 +7044,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   1,
 								NumLocals:   2,
 								Locals:      []string{"template", "block"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2245}, {PC: 2, Line: 254}, {PC: 5, Line: 2246}, {PC: 18, Line: 2247}},
-								FirstLine:   2245,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2268}, {PC: 2, Line: 259}, {PC: 5, Line: 2269}, {PC: 18, Line: 2270}},
+								FirstLine:   2268,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -7047,8 +7064,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   3,
 								Locals:      []string{"_scope", "locals", "b"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2254}, {PC: 11, Line: 2255}, {PC: 14, Line: 2256}, {PC: 17, Line: 2257}},
-								FirstLine:   2254,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2277}, {PC: 11, Line: 2278}, {PC: 14, Line: 2279}, {PC: 17, Line: 2280}},
+								FirstLine:   2277,
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:        "block in render",
@@ -7062,8 +7079,8 @@ func embeddedPrelude() *bytecode.ISeq {
 										BlockSlot:   -1,
 										NumLocals:   2,
 										Locals:      []string{"k", "v"},
-										Lines:       []bytecode.LineEntry{{PC: 0, Line: 2256}},
-										FirstLine:   2256,
+										Lines:       []bytecode.LineEntry{{PC: 0, Line: 2279}},
+										FirstLine:   2279,
 										Super:       "",
 									},
 								},
@@ -7077,16 +7094,16 @@ func embeddedPrelude() *bytecode.ISeq {
 			},
 			&bytecode.ISeq{
 				Name:        "<module:Haml>",
-				Insns:       []bytecode.Instr{{Op: 43}, {Op: 9}, {Op: 43, A: 1, B: 1}, {Op: 9}, {Op: 42, A: 2, B: 2}, {Op: 9}, {Op: 33, A: 2}, {Op: 41, A: 3}, {Op: 53}},
-				Names:       []string{"Util", "HamlAttributes", "Template", "Engine"},
+				Insns:       []bytecode.Instr{{Op: 43}, {Op: 9}, {Op: 43, A: 1, B: 1}, {Op: 9}, {Op: 42, A: 2, B: 2}, {Op: 53}},
+				Names:       []string{"Util", "HamlAttributes", "Template"},
 				NumRequired: 0,
 				SplatIndex:  -1,
 				PostCount:   0,
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
-				Lines:       []bytecode.LineEntry{{PC: 0, Line: 2274}, {PC: 2, Line: 2287}, {PC: 4, Line: 2327}, {PC: 6, Line: 2347}},
-				FirstLine:   2273,
+				Lines:       []bytecode.LineEntry{{PC: 0, Line: 2302}, {PC: 2, Line: 2315}, {PC: 4, Line: 2355}},
+				FirstLine:   2301,
 				Children: []*bytecode.ISeq{
 					&bytecode.ISeq{
 						Name:        "<module:Util>",
@@ -7098,8 +7115,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2277}},
-						FirstLine:   2274,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2305}},
+						FirstLine:   2302,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "escape_html",
@@ -7125,8 +7142,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"s"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2278}},
-								FirstLine:   2277,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2306}},
+								FirstLine:   2305,
 								Super:       "",
 							},
 						},
@@ -7162,8 +7179,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2288}, {PC: 22, Line: 2292}},
-						FirstLine:   2287,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2316}, {PC: 22, Line: 2320}},
+						FirstLine:   2315,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "render",
@@ -7180,8 +7197,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   3,
 								Locals:      []string{"h", "pairs", "out"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2293}, {PC: 3, Line: 2294}, {PC: 6, Line: 2309}, {PC: 9, Line: 2310}, {PC: 14, Line: 2320}},
-								FirstLine:   2292,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2321}, {PC: 3, Line: 2322}, {PC: 6, Line: 2337}, {PC: 9, Line: 2338}, {PC: 14, Line: 2348}},
+								FirstLine:   2320,
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:  "block in render",
@@ -7207,8 +7224,8 @@ func embeddedPrelude() *bytecode.ISeq {
 										BlockSlot:   -1,
 										NumLocals:   7,
 										Locals:      []string{"k", "v", "existing", "merged", "", "", ""},
-										Lines:       []bytecode.LineEntry{{PC: 0, Line: 2295}, {PC: 4, Line: 2296}, {PC: 14, Line: 2297}, {PC: 21, Line: 2299}, {PC: 26, Line: 2300}, {PC: 42, Line: 2301}, {PC: 54, Line: 2303}, {PC: 59, Line: 2304}, {PC: 72, Line: 2306}},
-										FirstLine:   2294,
+										Lines:       []bytecode.LineEntry{{PC: 0, Line: 2323}, {PC: 4, Line: 2324}, {PC: 14, Line: 2325}, {PC: 21, Line: 2327}, {PC: 26, Line: 2328}, {PC: 42, Line: 2329}, {PC: 54, Line: 2331}, {PC: 59, Line: 2332}, {PC: 72, Line: 2334}},
+										FirstLine:   2322,
 										Children: []*bytecode.ISeq{
 											&bytecode.ISeq{
 												Name:  "block (2 levels) in render",
@@ -7227,8 +7244,8 @@ func embeddedPrelude() *bytecode.ISeq {
 												BlockSlot:   -1,
 												NumLocals:   3,
 												Locals:      []string{"dk", "dv", ""},
-												Lines:       []bytecode.LineEntry{{PC: 0, Line: 2297}},
-												FirstLine:   2297,
+												Lines:       []bytecode.LineEntry{{PC: 0, Line: 2325}},
+												FirstLine:   2325,
 												Super:       "",
 											},
 										},
@@ -7255,8 +7272,8 @@ func embeddedPrelude() *bytecode.ISeq {
 										BlockSlot:   -1,
 										NumLocals:   2,
 										Locals:      []string{"k", "v"},
-										Lines:       []bytecode.LineEntry{{PC: 0, Line: 2311}, {PC: 5, Line: 2312}, {PC: 9, Line: 2313}, {PC: 32, Line: 2315}, {PC: 40, Line: 2317}, {PC: 45, Line: 1}},
-										FirstLine:   2310,
+										Lines:       []bytecode.LineEntry{{PC: 0, Line: 2339}, {PC: 5, Line: 2340}, {PC: 9, Line: 2341}, {PC: 32, Line: 2343}, {PC: 40, Line: 2345}, {PC: 45, Line: 1}},
+										FirstLine:   2338,
 										Super:       "",
 									},
 								},
@@ -7278,8 +7295,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2328}, {PC: 4, Line: 2332}, {PC: 6, Line: 2340}},
-						FirstLine:   2327,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2356}, {PC: 4, Line: 2360}, {PC: 6, Line: 2368}},
+						FirstLine:   2355,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:        "initialize",
@@ -7293,8 +7310,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   1,
 								NumLocals:   2,
 								Locals:      []string{"template", "block"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2332}, {PC: 2, Line: 254}, {PC: 5, Line: 2333}, {PC: 18, Line: 2334}},
-								FirstLine:   2332,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2360}, {PC: 2, Line: 259}, {PC: 5, Line: 2361}, {PC: 18, Line: 2362}},
+								FirstLine:   2360,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -7313,8 +7330,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   3,
 								Locals:      []string{"_scope", "locals", "b"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2340}, {PC: 11, Line: 2341}, {PC: 14, Line: 2342}, {PC: 17, Line: 2343}},
-								FirstLine:   2340,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2368}, {PC: 11, Line: 2369}, {PC: 14, Line: 2370}, {PC: 17, Line: 2371}},
+								FirstLine:   2368,
 								Children: []*bytecode.ISeq{
 									&bytecode.ISeq{
 										Name:        "block in render",
@@ -7328,8 +7345,8 @@ func embeddedPrelude() *bytecode.ISeq {
 										BlockSlot:   -1,
 										NumLocals:   2,
 										Locals:      []string{"k", "v"},
-										Lines:       []bytecode.LineEntry{{PC: 0, Line: 2342}},
-										FirstLine:   2342,
+										Lines:       []bytecode.LineEntry{{PC: 0, Line: 2370}},
+										FirstLine:   2370,
 										Super:       "",
 									},
 								},
@@ -7362,8 +7379,8 @@ func embeddedPrelude() *bytecode.ISeq {
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
-				Lines:       []bytecode.LineEntry{{PC: 0, Line: 2373}, {PC: 2, Line: 2394}, {PC: 4, Line: 2397}, {PC: 6, Line: 2400}, {PC: 8, Line: 2403}, {PC: 10, Line: 2406}, {PC: 12, Line: 2409}, {PC: 14, Line: 2413}},
-				FirstLine:   2372,
+				Lines:       []bytecode.LineEntry{{PC: 0, Line: 2402}, {PC: 2, Line: 2423}, {PC: 4, Line: 2426}, {PC: 6, Line: 2429}, {PC: 8, Line: 2432}, {PC: 10, Line: 2435}, {PC: 12, Line: 2438}, {PC: 14, Line: 2442}},
+				FirstLine:   2401,
 				Children: []*bytecode.ISeq{
 					&bytecode.ISeq{
 						Name:  "<class:ParseError>",
@@ -7378,8 +7395,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2374}, {PC: 4, Line: 2375}, {PC: 6, Line: 2382}, {PC: 8, Line: 2383}, {PC: 10, Line: 2384}, {PC: 12, Line: 2387}, {PC: 14, Line: 2388}},
-						FirstLine:   2373,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2403}, {PC: 4, Line: 2404}, {PC: 6, Line: 2411}, {PC: 8, Line: 2412}, {PC: 10, Line: 2413}, {PC: 12, Line: 2416}, {PC: 14, Line: 2417}},
+						FirstLine:   2402,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "initialize",
@@ -7397,8 +7414,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"args"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2376}, {PC: 3, Line: 2380}},
-								FirstLine:   2375,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2405}, {PC: 3, Line: 2409}},
+								FirstLine:   2404,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -7413,8 +7430,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2382}},
-								FirstLine:   2382,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2411}},
+								FirstLine:   2411,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -7428,7 +7445,7 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   0,
 								Lines:       []bytecode.LineEntry{{PC: 0, Line: 109}},
-								FirstLine:   2383,
+								FirstLine:   2412,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -7445,8 +7462,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2385}},
-								FirstLine:   2384,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2414}},
+								FirstLine:   2413,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -7464,8 +7481,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   2,
 								Locals:      []string{"argv", ""},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2389}, {PC: 9, Line: 2390}},
-								FirstLine:   2388,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2418}, {PC: 9, Line: 2419}},
+								FirstLine:   2417,
 								Super:       "",
 							},
 						},
@@ -7481,8 +7498,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2395}},
-						FirstLine:   2394,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2424}},
+						FirstLine:   2423,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "reason",
@@ -7496,8 +7513,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2395}},
-								FirstLine:   2395,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2424}},
+								FirstLine:   2424,
 								Super:       "",
 							},
 						},
@@ -7513,8 +7530,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2398}},
-						FirstLine:   2397,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2427}},
+						FirstLine:   2426,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "reason",
@@ -7528,8 +7545,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2398}},
-								FirstLine:   2398,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2427}},
+								FirstLine:   2427,
 								Super:       "",
 							},
 						},
@@ -7545,8 +7562,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2401}},
-						FirstLine:   2400,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2430}},
+						FirstLine:   2429,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "reason",
@@ -7560,8 +7577,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2401}},
-								FirstLine:   2401,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2430}},
+								FirstLine:   2430,
 								Super:       "",
 							},
 						},
@@ -7577,8 +7594,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2404}},
-						FirstLine:   2403,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2433}},
+						FirstLine:   2432,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "reason",
@@ -7592,8 +7609,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2404}},
-								FirstLine:   2404,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2433}},
+								FirstLine:   2433,
 								Super:       "",
 							},
 						},
@@ -7609,8 +7626,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2407}},
-						FirstLine:   2406,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2436}},
+						FirstLine:   2435,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "reason",
@@ -7624,8 +7641,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2407}},
-								FirstLine:   2407,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2436}},
+								FirstLine:   2436,
 								Super:       "",
 							},
 						},
@@ -7641,8 +7658,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2410}},
-						FirstLine:   2409,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2439}},
+						FirstLine:   2438,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "reason",
@@ -7656,8 +7673,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2410}},
-								FirstLine:   2410,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2439}},
+								FirstLine:   2439,
 								Super:       "",
 							},
 						},
@@ -7679,8 +7696,8 @@ func embeddedPrelude() *bytecode.ISeq {
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
-				Lines:       []bytecode.LineEntry{{PC: 0, Line: 2428}, {PC: 4, Line: 2430}, {PC: 6, Line: 2451}, {PC: 8, Line: 2482}, {PC: 10, Line: 2488}, {PC: 12, Line: 2497}, {PC: 14, Line: 2512}, {PC: 16, Line: 2519}, {PC: 18, Line: 2523}, {PC: 20, Line: 2530}, {PC: 22, Line: 2532}, {PC: 24, Line: 2536}, {PC: 26, Line: 2540}},
-				FirstLine:   2427,
+				Lines:       []bytecode.LineEntry{{PC: 0, Line: 2458}, {PC: 4, Line: 2460}, {PC: 6, Line: 2481}, {PC: 8, Line: 2512}, {PC: 10, Line: 2518}, {PC: 12, Line: 2527}, {PC: 14, Line: 2542}, {PC: 16, Line: 2549}, {PC: 18, Line: 2553}, {PC: 20, Line: 2560}, {PC: 22, Line: 2562}, {PC: 24, Line: 2566}, {PC: 26, Line: 2570}},
+				FirstLine:   2457,
 				Children: []*bytecode.ISeq{
 					&bytecode.ISeq{
 						Name:  "counter",
@@ -7696,8 +7713,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2431}},
-						FirstLine:   2430,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2461}},
+						FirstLine:   2460,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -7723,8 +7740,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   9,
 						Locals:      []string{"basename", "tmpdir", "mode", "opts", "prefix", "suffix", "dir", "fopts", ""},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2451}, {PC: 7, Line: 254}, {PC: 15, Line: 2452}, {PC: 19, Line: 2453}, {PC: 36, Line: 2454}, {PC: 44, Line: 254}, {PC: 47, Line: 2456}, {PC: 50, Line: 2464}, {PC: 62, Line: 2465}, {PC: 65, Line: 2466}, {PC: 68, Line: 2467}, {PC: 76, Line: 2468}, {PC: 92, Line: 2469}, {PC: 94, Line: 2470}, {PC: 95, Line: 109}, {PC: 98, Line: 2473}, {PC: 101, Line: 2474}, {PC: 105, Line: 2473}, {PC: 108, Line: 2474}},
-						FirstLine:   2451,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2481}, {PC: 7, Line: 259}, {PC: 15, Line: 2482}, {PC: 19, Line: 2483}, {PC: 36, Line: 2484}, {PC: 44, Line: 259}, {PC: 47, Line: 2486}, {PC: 50, Line: 2494}, {PC: 62, Line: 2495}, {PC: 65, Line: 2496}, {PC: 68, Line: 2497}, {PC: 76, Line: 2498}, {PC: 92, Line: 2499}, {PC: 94, Line: 2500}, {PC: 95, Line: 109}, {PC: 98, Line: 2503}, {PC: 101, Line: 2504}, {PC: 105, Line: 2503}, {PC: 108, Line: 2504}},
+						FirstLine:   2481,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in initialize",
@@ -7748,8 +7765,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   2,
 								Locals:      []string{"name", "candidate"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2457}, {PC: 42, Line: 2458}, {PC: 48, Line: 2459}, {PC: 53, Line: 2460}, {PC: 56, Line: 2461}},
-								FirstLine:   2456,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2487}, {PC: 42, Line: 2488}, {PC: 48, Line: 2489}, {PC: 53, Line: 2490}, {PC: 56, Line: 2491}},
+								FirstLine:   2486,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -7767,8 +7784,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   3,
 								Locals:      []string{"k", "v", ""},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2466}},
-								FirstLine:   2466,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2496}},
+								FirstLine:   2496,
 								Super:       "",
 							},
 						},
@@ -7787,8 +7804,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2483}, {PC: 16, Line: 2484}, {PC: 19, Line: 2485}},
-						FirstLine:   2482,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2513}, {PC: 16, Line: 2514}, {PC: 19, Line: 2515}},
+						FirstLine:   2512,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -7803,8 +7820,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   1,
 						NumLocals:   2,
 						Locals:      []string{"args", "block"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2489}},
-						FirstLine:   2488,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2519}},
+						FirstLine:   2518,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -7822,8 +7839,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   5,
 						Locals:      []string{"basename", "tmpdir", "opts", "fwd", "t"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2497}, {PC: 7, Line: 254}, {PC: 10, Line: 2498}, {PC: 13, Line: 2499}, {PC: 16, Line: 2500}, {PC: 32, Line: 2501}, {PC: 34, Line: 2502}, {PC: 35, Line: 2503}, {PC: 39, Line: 2505}, {PC: 42, Line: 2506}, {PC: 46, Line: 2505}, {PC: 49, Line: 2506}, {PC: 56, Line: 2509}},
-						FirstLine:   2497,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2527}, {PC: 7, Line: 259}, {PC: 10, Line: 2528}, {PC: 13, Line: 2529}, {PC: 16, Line: 2530}, {PC: 32, Line: 2531}, {PC: 34, Line: 2532}, {PC: 35, Line: 2533}, {PC: 39, Line: 2535}, {PC: 42, Line: 2536}, {PC: 46, Line: 2535}, {PC: 49, Line: 2536}, {PC: 56, Line: 2539}},
+						FirstLine:   2527,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "block in create",
@@ -7840,8 +7857,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   3,
 								Locals:      []string{"k", "v", ""},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2499}},
-								FirstLine:   2499,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2529}},
+								FirstLine:   2529,
 								Super:       "",
 							},
 						},
@@ -7859,8 +7876,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"unlink_now"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2512}, {PC: 5, Line: 2513}, {PC: 17, Line: 2514}, {PC: 20, Line: 2515}, {PC: 27, Line: 254}},
-						FirstLine:   2512,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2542}, {PC: 5, Line: 2543}, {PC: 17, Line: 2544}, {PC: 20, Line: 2545}, {PC: 27, Line: 259}},
+						FirstLine:   2542,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -7873,8 +7890,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2520}},
-						FirstLine:   2519,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2550}},
+						FirstLine:   2549,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -7887,8 +7904,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2524}, {PC: 8, Line: 2525}, {PC: 14, Line: 254}},
-						FirstLine:   2523,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2554}, {PC: 8, Line: 2555}, {PC: 14, Line: 259}},
+						FirstLine:   2553,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -7906,8 +7923,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   1,
 						Locals:      []string{"mode"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2533}},
-						FirstLine:   2532,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2563}},
+						FirstLine:   2562,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -7922,8 +7939,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   2,
 						Locals:      []string{"name", "include_private"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2536}, {PC: 5, Line: 2537}},
-						FirstLine:   2536,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2566}, {PC: 5, Line: 2567}},
+						FirstLine:   2566,
 						Super:       "",
 					},
 					&bytecode.ISeq{
@@ -7938,8 +7955,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   2,
 						NumLocals:   3,
 						Locals:      []string{"name", "args", "block"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2541}, {PC: 8, Line: 2542}, {PC: 19, Line: 2544}},
-						FirstLine:   2540,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2571}, {PC: 8, Line: 2572}, {PC: 19, Line: 2574}},
+						FirstLine:   2570,
 						Super:       "",
 					},
 				},
@@ -7961,8 +7978,8 @@ func embeddedPrelude() *bytecode.ISeq {
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
-				Lines:       []bytecode.LineEntry{{PC: 0, Line: 2553}, {PC: 11, Line: 109}, {PC: 14, Line: 2593}, {PC: 16, Line: 2597}, {PC: 17, Line: 109}},
-				FirstLine:   2552,
+				Lines:       []bytecode.LineEntry{{PC: 0, Line: 2583}, {PC: 11, Line: 109}, {PC: 14, Line: 2623}, {PC: 16, Line: 2627}, {PC: 17, Line: 109}},
+				FirstLine:   2582,
 				Children: []*bytecode.ISeq{
 					&bytecode.ISeq{
 						Name:        "<singleton class>",
@@ -7974,8 +7991,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						KwRestSlot:  -1,
 						BlockSlot:   -1,
 						NumLocals:   0,
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2563}, {PC: 2, Line: 2575}, {PC: 4, Line: 2586}},
-						FirstLine:   2560,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2593}, {PC: 2, Line: 2605}, {PC: 4, Line: 2616}},
+						FirstLine:   2590,
 						Children: []*bytecode.ISeq{
 							&bytecode.ISeq{
 								Name:  "[]",
@@ -7997,8 +8014,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   1,
 								Locals:      []string{"category"},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2564}, {PC: 5, Line: 2565}, {PC: 22, Line: 2567}, {PC: 27, Line: 2568}, {PC: 43, Line: 2570}},
-								FirstLine:   2563,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2594}, {PC: 5, Line: 2595}, {PC: 22, Line: 2597}, {PC: 27, Line: 2598}, {PC: 43, Line: 2600}},
+								FirstLine:   2593,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -8021,8 +8038,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								BlockSlot:   -1,
 								NumLocals:   3,
 								Locals:      []string{"category", "flag", ""},
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2576}, {PC: 5, Line: 2577}, {PC: 22, Line: 2579}, {PC: 27, Line: 2580}, {PC: 43, Line: 2582}},
-								FirstLine:   2575,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2606}, {PC: 5, Line: 2607}, {PC: 22, Line: 2609}, {PC: 27, Line: 2610}, {PC: 43, Line: 2612}},
+								FirstLine:   2605,
 								Super:       "",
 							},
 							&bytecode.ISeq{
@@ -8035,8 +8052,8 @@ func embeddedPrelude() *bytecode.ISeq {
 								KwRestSlot:  -1,
 								BlockSlot:   -1,
 								NumLocals:   0,
-								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2587}},
-								FirstLine:   2586,
+								Lines:       []bytecode.LineEntry{{PC: 0, Line: 2617}},
+								FirstLine:   2616,
 								Super:       "",
 							},
 						},
@@ -8056,8 +8073,8 @@ func embeddedPrelude() *bytecode.ISeq {
 						BlockSlot:   -1,
 						NumLocals:   2,
 						Locals:      []string{"message", "category"},
-						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2593}, {PC: 2, Line: 254}, {PC: 5, Line: 2594}, {PC: 9, Line: 254}},
-						FirstLine:   2593,
+						Lines:       []bytecode.LineEntry{{PC: 0, Line: 2623}, {PC: 2, Line: 259}, {PC: 5, Line: 2624}, {PC: 9, Line: 259}},
+						FirstLine:   2623,
 						Super:       "",
 					},
 				},
@@ -8073,8 +8090,8 @@ func embeddedPrelude() *bytecode.ISeq {
 				KwRestSlot:  -1,
 				BlockSlot:   -1,
 				NumLocals:   0,
-				Lines:       []bytecode.LineEntry{{PC: 0, Line: 2611}},
-				FirstLine:   2610,
+				Lines:       []bytecode.LineEntry{{PC: 0, Line: 2641}},
+				FirstLine:   2640,
 				Children: []*bytecode.ISeq{
 					&bytecode.ISeq{
 						Name:        "!~",
@@ -8089,7 +8106,7 @@ func embeddedPrelude() *bytecode.ISeq {
 						NumLocals:   1,
 						Locals:      []string{"other"},
 						Lines:       []bytecode.LineEntry{{PC: 0, Line: 109}},
-						FirstLine:   2611,
+						FirstLine:   2641,
 						Super:       "",
 					},
 				},
diff --git a/internal/vm/refinement_import.go b/internal/vm/refinement_import.go
index 419a8743..ba163ca0 100644
--- a/internal/vm/refinement_import.go
+++ b/internal/vm/refinement_import.go
@@ -90,7 +90,7 @@ func refinementImportMethods(vm *VM, self object.Value, args []object.Value, _ *
 	}
 	for _, mod := range mods {
 		if len(mod.includes) > 0 || len(mod.prepends) > 0 {
-			vm.rbWarn("warning: %s has ancestors, but Refinement#import_methods doesn't import their methods",
+			vm.rbWarnf("%s has ancestors, but Refinement#import_methods doesn't import their methods",
 				vm.moduleToSStr(mod))
 		}
 	}
diff --git a/internal/vm/regexp.go b/internal/vm/regexp.go
index 79f89b85..e01a57bb 100644
--- a/internal/vm/regexp.go
+++ b/internal/vm/regexp.go
@@ -1026,7 +1026,13 @@ func (vm *VM) regexpOptionFlags(v object.Value) string {
 		// Any other object is the legacy form: MRI warns (verbose) "expected true
 		// or false as ignorecase: <inspect>" without calling #to_int. A non-nil,
 		// non-false object is always truthy, so it selects IGNORECASE.
-		vm.rbWarn("warning: expected true or false as ignorecase: %s", vm.inspectStr(v))
+		// object.c ruby_4_0:3493 rb_bool_expected warns through rb_warning, not
+		// rb_warn, so a DEFAULT $VERBOSE stays silent. Measured on MRI 4.0.5:
+		// `ruby -e 'Regexp.new("a", Object.new)'` prints nothing, while
+		// `ruby -e '$VERBOSE=true; Regexp.new("a", Object.new)'` prints
+		// "-e:1: warning: expected true or false as ignorecase: #<Object:0x…>".
+		// This was rb_warn here, which only looked right while the gate was broken.
+		vm.rbWarningf("expected true or false as ignorecase: %s", vm.inspectStr(v))
 		return "i"
 	}
 }
@@ -1237,7 +1243,7 @@ func (vm *VM) checkSubjectEncoding(re *Regexp, v object.Value) {
 		return
 	}
 	if re.noEnc && strEnc != "ASCII-8BIT" && !sevenBit {
-		vm.rbWarn("warning: historical binary regexp match /.../n against %s string", strEnc)
+		vm.rbWarnf("historical binary regexp match /.../n against %s string", strEnc)
 	}
 }
 
diff --git a/internal/vm/require.go b/internal/vm/require.go
index 2363531e..3a63c832 100644
--- a/internal/vm/require.go
+++ b/internal/vm/require.go
@@ -373,13 +373,13 @@ func (vm *VM) requireLoadingKey(abs string) string {
 // warnCircularRequire emits MRI's circular-require warning. load_lock issues it
 // through rb_warning, not rb_warn, so it appears only in verbose mode ($VERBOSE
 // true) -- `require_internal(ec, fname, 1, RTEST(ruby_verbose))` passes the
-// verbose flag down as load_lock's `warn` argument. It goes to the current
-// $stderr so a reassigned $stderr (mspec's `complain` matcher) captures it.
+// verbose flag down as load_lock's `warn` argument. It reaches $stderr the way
+// every internal warning does — through Warning.warn, whose default body writes
+// there — so mspec's `complain` matcher captures it whether it replaced $stderr or
+// Warning.warn. The gate was reading vm.globals["$VERBOSE"] out of the map, which
+// is unset until a program assigns it.
 func (vm *VM) warnCircularRequire(path string) {
-	if v, ok := vm.globals["$VERBOSE"].(object.Bool); !ok || !bool(v) {
-		return
-	}
-	vm.curStderr().writeStr("warning: loading in progress, circular require considered harmful - " + path + "\n")
+	vm.rbWarning("loading in progress, circular require considered harmful - " + path)
 }
 
 // setISeqFile stamps path onto iseq and all of its nested children, so a method
diff --git a/internal/vm/struct.go b/internal/vm/struct.go
index 3dc8770d..15d09afa 100644
--- a/internal/vm/struct.go
+++ b/internal/vm/struct.go
@@ -132,7 +132,7 @@ func setupStruct(vm *VM) {
 				raise("NameError", "identifier %s needs to be constant", name)
 			}
 			if _, exists := base.consts[name]; exists {
-				vm.warnRedefineConst(base, name)
+				vm.warnStructRedefineConst(base, name)
 			}
 			vm.assignConstIn(base, name, sub)
 		}
@@ -808,8 +808,18 @@ func validConstName(s string) bool {
 	return true
 }
 
-// warnRedefineConst emits MRI's "already initialized constant" warning to
-// $stderr when Struct.new(name, …) overwrites an existing constant.
-func (vm *VM) warnRedefineConst(scope *RClass, name string) {
-	vm.send(vm.main, "warn", []object.Value{object.NewString("warning: already initialized constant " + scopedNameFor(scope, name))}, nil)
+// warnStructRedefineConst is struct.c's new_struct (ruby/ruby v3_4_0 struct.c:273)
+// — the ONE place in MRI that warns about a constant being taken over with a
+// different message and no companion line:
+//
+//	rb_warn("redefining constant %"PRIsVALUE"::%"PRIsVALUE, super, name);
+//
+// It is rb_warn, so it carries the file:lineno prefix and obeys $VERBOSE the same
+// way; it is NOT const_tbl_update's "already initialized constant …", because
+// new_struct removes the old constant itself (rb_mod_remove_const) before defining
+// the new one, so rb_const_set never sees a live entry to complain about. Measured
+// against MRI 4.0.5: `Struct.new("Dup1", :a); Struct.new("Dup1", :b)` prints
+// "-e:1: warning: redefining constant Struct::Dup1".
+func (vm *VM) warnStructRedefineConst(scope *RClass, name string) {
+	vm.rbWarnf("redefining constant %s::%s", vm.moduleToSStr(scope), name)
 }
diff --git a/internal/vm/struct_conformance_test.go b/internal/vm/struct_conformance_test.go
index 967cbce4..f4498480 100644
--- a/internal/vm/struct_conformance_test.go
+++ b/internal/vm/struct_conformance_test.go
@@ -232,11 +232,18 @@ func TestStructConformanceErrors(t *testing.T) {
 }
 
 // TestStructNamedRedefineWarns checks that Struct.new(name, …) overwriting an
-// existing constant emits the "already initialized constant" warning (to $stderr,
-// which the harness folds into the captured stream) and rebinds the constant.
+// existing constant warns and rebinds the constant. The wording is struct.c's own
+// (ruby_4_0 struct.c new_struct: rb_warn("redefining constant %s::%s")), NOT
+// const_tbl_update's "already initialized constant …", because new_struct removes
+// the old constant before defining the new one. Measured on MRI 4.0.5:
+//
+//	$ ruby -e 'Struct.new("Dup1", :a); Struct.new("Dup1", :b)'
+//	-e:1: warning: redefining constant Struct::Dup1
+//
+// This assertion used to name the other message, pinning rbgo's divergence.
 func TestStructNamedRedefineWarns(t *testing.T) {
 	out := eval(t, `Struct.new("Dup1", :a); Struct.new("Dup1", :b); p Struct::Dup1.members`)
-	if !strings.Contains(out, "already initialized constant Struct::Dup1") {
+	if !strings.Contains(out, "warning: redefining constant Struct::Dup1") {
 		t.Errorf("out=%q, want redefine warning", out)
 	}
 	if !strings.Contains(out, "[:b]") {
diff --git a/internal/vm/verbose_gate_wave45_test.go b/internal/vm/verbose_gate_wave45_test.go
new file mode 100644
index 00000000..f8c77648
--- /dev/null
+++ b/internal/vm/verbose_gate_wave45_test.go
@@ -0,0 +1,300 @@
+// Copyright (c) the go-embedded-ruby/ruby authors
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+package vm
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+
+	"github.com/go-embedded-ruby/ruby/internal/compiler"
+	"github.com/go-embedded-ruby/ruby/internal/object"
+	"github.com/go-ruby-parser/parser"
+)
+
+// warnProbeFile is the path runWarn stamps onto its ISeq. It has to be stamped:
+// a warning's position comes from the frame's ISeq, and so does the location
+// recordConstLoc stores for the "previous definition" line. A path-less ISeq —
+// which is what compiling a bare source string gives — records no location at
+// all, so the second line is correctly suppressed and the case cannot witness
+// it. Stamping a path is what `rbgo script.rb` and `rbgo -e` both do.
+const warnProbeFile = "wt45probe.rb"
+
+// runWarn compiles and runs src in one VM and returns everything it wrote,
+// newlines and all — warnings are the SUBJECT here, so nothing is trimmed and
+// nothing is filtered.
+func runWarn(t *testing.T, src string) string {
+	t.Helper()
+	prog, err := parser.Parse(src)
+	if err != nil {
+		t.Fatalf("parse: %v", err)
+	}
+	iseq, err := compiler.Compile(prog)
+	if err != nil {
+		t.Fatalf("compile: %v", err)
+	}
+	setISeqFile(iseq, warnProbeFile)
+	var buf bytes.Buffer
+	vm := New(&buf)
+	vm.SetScriptPath(warnProbeFile)
+	if _, err := vm.Run(iseq); err != nil {
+		t.Fatalf("run: %v", err)
+	}
+	return buf.String()
+}
+
+// $VERBOSE has three states and the two warning families split on them. This is
+// a WITNESS for the defect in #641: the UNSET rows. A fresh VM assigns $VERBOSE
+// nothing, MRI reads false there, and rb_warn must therefore speak. The gate used
+// to read vm.globals["$VERBOSE"] straight out of the map, where an unset slot is a
+// Go nil that object.IsNil accepts, so the unset rows were silent while the
+// $VERBOSE = false rows were not — one value with two representations, and the
+// gate read the one nobody writes.
+//
+// Verified against MRI 4.0.5: `ruby -e 'X=1; X=2'` warns, `ruby -W0 -e …` does
+// not, and `ruby -e 'p [1,2].inject(0, :+) { }'` warns only under -w.
+func TestVerboseGateThreeStates(t *testing.T) {
+	cases := []struct {
+		name        string
+		prologue    string
+		wantWarn    bool // rb_warn family (already initialized constant)
+		wantWarning bool // rb_warning family (Array.new with a block and no args)
+	}{
+		{"unset — MRI's default, reads false", "", true, false},
+		{"$VERBOSE = false", "$VERBOSE = false\n", true, false},
+		{"$VERBOSE = nil (-W0)", "$VERBOSE = nil\n", false, false},
+		{"$VERBOSE = true (-w)", "$VERBOSE = true\n", true, true},
+		{"$VERBOSE = 1 coerces to true", "$VERBOSE = 1\n", true, true},
+	}
+	for _, c := range cases {
+		gotWarn := strings.Contains(runWarn(t, c.prologue+"X = 1\nX = 2\n"), "already initialized constant X")
+		if gotWarn != c.wantWarn {
+			t.Errorf("%s: rb_warn fired=%v, want %v", c.name, gotWarn, c.wantWarn)
+		}
+		gotWarning := strings.Contains(runWarn(t, c.prologue+"Array.new { :blk }\n"), "given block not used")
+		if gotWarning != c.wantWarning {
+			t.Errorf("%s: rb_warning fired=%v, want %v", c.name, gotWarning, c.wantWarning)
+		}
+	}
+}
+
+// A redefined constant emits TWO lines, each with its own source position, and
+// the second one names the constant WITHOUT its module qualification. All four
+// expectations are MRI 4.0.5's, taken from `ruby -e` runs:
+//
+//	-e:1: warning: already initialized constant MM::K
+//	-e:1: warning: previous definition of K was here
+//
+// WITNESS for all three parts of #699 at once: the prefix, the second line, and
+// the gate that let neither be seen. Against the old code every row fails.
+func TestConstantRedefinitionEmitsBothLinesWithPositions(t *testing.T) {
+	cases := []struct{ name, src, want string }{
+		{"top level", "X = 1\nX = 2\n",
+			"wt45probe.rb:2: warning: already initialized constant X\n" +
+				"wt45probe.rb:1: warning: previous definition of X was here\n"},
+		{"qualified by the module, second line bare", "module MM\n  K = 1\n  K = 2\nend\n",
+			"wt45probe.rb:3: warning: already initialized constant MM::K\n" +
+				"wt45probe.rb:2: warning: previous definition of K was here\n"},
+		{"scoped assignment", "module MM\nend\nMM::K = 1\nMM::K = 2\n",
+			"wt45probe.rb:4: warning: already initialized constant MM::K\n" +
+				"wt45probe.rb:3: warning: previous definition of K was here\n"},
+		{"Module#const_set takes the same path", "Object.const_set(:Q, 1)\nObject.const_set(:Q, 2)\n",
+			"wt45probe.rb:2: warning: already initialized constant Q\n" +
+				"wt45probe.rb:1: warning: previous definition of Q was here\n"},
+		{"$VERBOSE = nil silences both", "$VERBOSE = nil\nX = 1\nX = 2\n", ""},
+	}
+	for _, c := range cases {
+		if got := runWarn(t, c.src); got != c.want {
+			t.Errorf("%s:\n got %q\nwant %q", c.name, got, c.want)
+		}
+	}
+}
+
+// The second line's position is the OLD entry's, so a constant first defined in
+// one place and overwritten in another produces two DIFFERENT positions. The
+// in-process harness compiles one ISeq, so the two lines share a path here and
+// the LINES are what differ; the cross-file case is the same code with a
+// different recorded file, which constLocs already stores per constant.
+//
+// This also pins that the location is read BEFORE the store: recordConstLoc
+// stamps the new site during the assignment, so reading it afterwards would
+// report line 2 twice.
+func TestPreviousDefinitionPointsAtTheOriginalSite(t *testing.T) {
+	got := runWarn(t, "Z = 1\n\n\n\nZ = 2\n")
+	want := "wt45probe.rb:5: warning: already initialized constant Z\n" +
+		"wt45probe.rb:1: warning: previous definition of Z was here\n"
+	if got != want {
+		t.Fatalf("got %q, want %q", got, want)
+	}
+}
+
+// A constant this VM defined natively has no recorded location, and MRI's
+// `if (!NIL_P(ce->file) && ce->line)` means the first line goes out ALONE. Object
+// is full of such constants; ARGV is one.
+func TestNativeConstantRedefinitionHasNoSecondLine(t *testing.T) {
+	got := runWarn(t, "ARGV = []\n")
+	if !strings.Contains(got, "already initialized constant ARGV") {
+		t.Fatalf("got %q, want the already-initialized line", got)
+	}
+	if strings.Contains(got, "previous definition") {
+		t.Fatalf("got %q, want NO second line for a natively defined constant", got)
+	}
+}
+
+// warningStringAt is err_vcatf's shape (error.c:125). The single caller today —
+// warnAlreadyInitialized — filters both degenerate shapes out at the call site,
+// exactly as MRI's `if (!NIL_P(ce->file) && ce->line)` does, so these two rows are
+// NOT reachable through it. This is a GUARD, not a witness: it pins the shape
+// err_vcatf gives the next caller that does not filter, and it is why the branches
+// exist at all rather than being asserted away.
+func TestWarningStringAtShapes(t *testing.T) {
+	cases := []struct {
+		file string
+		line int
+		want string
+	}{
+		{"a.rb", 7, "a.rb:7: warning: m\n"},
+		{"a.rb", 0, "a.rb: warning: m\n"}, // err_vcatf: `if (line)` guards the ":%d"
+		{"", 7, "warning: m\n"},           // err_vcatf: `if (file)` guards the whole location
+	}
+	for _, c := range cases {
+		if got := warningStringAt(c.file, c.line, "m"); got != c.want {
+			t.Errorf("warningStringAt(%q, %d): got %q, want %q", c.file, c.line, got, c.want)
+		}
+	}
+}
+
+// Struct.new(name, …) is the ONE place MRI words this differently: struct.c:273
+// warns "redefining constant Struct::Foo", with no companion line, because
+// new_struct removes the old constant itself before defining the new one.
+// Measured against MRI 4.0.5:
+//
+//	$ ruby -e 'Struct.new("Dup1", :a); Struct.new("Dup1", :b)'
+//	-e:1: warning: redefining constant Struct::Dup1
+//
+// WITNESS: the old code wrote "already initialized constant Struct::Dup1" through
+// Kernel#warn, with no prefix and no $VERBOSE gate, and a test asserted that text
+// — pinning our own divergence.
+func TestStructNamedRedefineUsesStructsOwnWording(t *testing.T) {
+	got := runWarn(t, "Struct.new(\"Dup1\", :a)\nStruct.new(\"Dup1\", :b)\n")
+	want := "wt45probe.rb:2: warning: redefining constant Struct::Dup1\n"
+	if got != want {
+		t.Fatalf("got %q, want %q", got, want)
+	}
+	if out := runWarn(t, "$VERBOSE = nil\nStruct.new(\"Dup2\", :a)\nStruct.new(\"Dup2\", :b)\n"); out != "" {
+		t.Fatalf("$VERBOSE = nil must silence it too: got %q", out)
+	}
+}
+
+// "given block not used" reaches every method MRI warns from, and only those.
+// enum.c and array.c use rb_warn for the value/pattern forms of count, index,
+// find_index, any?, all?, none? and one?, and rb_warning for Array#initialize
+// with no arguments and for inject's two-argument arm. Every row was measured on
+// MRI 4.0.5.
+//
+// WITNESS for the helper inconsistency: before this wave six of these were silent
+// at the default verbosity because rbgo did not emit them at all, and the one
+// helper that required $VERBOSE == true was chosen per call site rather than per
+// MRI function.
+func TestGivenBlockNotUsedMatchesMRIPerMethod(t *testing.T) {
+	const enumClass = "class WCE\n  include Enumerable\n  def each; yield 1; yield 2; end\nend\n"
+	cases := []struct {
+		name      string
+		src       string
+		wantWarn  bool // at the DEFAULT verbosity
+		wantUnder bool // under $VERBOSE = true
+	}{
+		{"Array#count(item) with a block", "[1, 2].count(1) { |x| x }\n", true, true},
+		{"Array#count with a block alone", "[1, 2].count { |x| x }\n", false, false},
+		{"Array#any?(pattern) with a block", "[1, 2].any?(Integer) { |x| x }\n", true, true},
+		{"Array#all?(pattern) with a block", "[1, 2].all?(Integer) { |x| x }\n", true, true},
+		{"Array#none?(pattern) with a block", "[1, 2].none?(Integer) { |x| x }\n", true, true},
+		{"Array#one?(pattern) with a block", "[1, 2].one?(Integer) { |x| x }\n", true, true},
+		{"Array#any? with a block alone", "[1, 2].any? { |x| x }\n", false, false},
+		{"Array#index(value) with a block", "[1].index(1) { }\n", true, true},
+		{"Array#rindex(value) with a block", "[1].rindex(1) { }\n", true, true},
+		{"Array#find_index(value) with a block", "[1].find_index(1) { }\n", true, true},
+		{"Hash#any?(pattern) with a block", "{ a: 1 }.any?(Array) { |x| x }\n", true, true},
+		{"Enumerable#count(item) with a block", enumClass + "WCE.new.count(1) { |x| x }\n", true, true},
+		{"Enumerable#find_index(value) with a block", enumClass + "WCE.new.find_index(1) { |x| x }\n", true, true},
+		{"Enumerable#one?(pattern) with a block", enumClass + "WCE.new.one?(Integer) { |x| x }\n", true, true},
+		// rb_warning, not rb_warn: the default verbosity stays quiet.
+		{"Array.new with no arguments and a block", "Array.new { :blk }\n", false, true},
+		{"Enumerable#inject(init, op) with a block", enumClass + "WCE.new.inject(0, :+) { |a, b| a }\n", false, true},
+		{"Enumerable#inject(init) with a block is the ordinary form", enumClass + "WCE.new.inject(0) { |a, b| a + b }\n", false, false},
+	}
+	for _, c := range cases {
+		got := strings.Contains(runWarn(t, c.src), "given block not used")
+		if got != c.wantWarn {
+			t.Errorf("%s at the default $VERBOSE: warned=%v, want %v", c.name, got, c.wantWarn)
+		}
+		gotV := strings.Contains(runWarn(t, "$VERBOSE = true\n"+c.src), "given block not used")
+		if gotV != c.wantUnder {
+			t.Errorf("%s under $VERBOSE = true: warned=%v, want %v", c.name, gotV, c.wantUnder)
+		}
+	}
+}
+
+// Every one of these lines carries the position of the frame that CALLED the
+// warning method, not of the prelude or of the native helper — error.c composes
+// it from rb_source_location, which is the current Ruby frame.
+func TestGivenBlockNotUsedCarriesTheCallersPosition(t *testing.T) {
+	got := runWarn(t, "\n\n[1, 2].count(1) { |x| x }\n")
+	want := "wt45probe.rb:3: warning: given block not used\n"
+	if got != want {
+		t.Fatalf("got %q, want %q", got, want)
+	}
+}
+
+// error.c's rb_write_warning_str is `rb_funcallv(Warning, :warn, str)`, so an
+// overridden Warning.warn sees every internal warning. #699's own eight-line probe
+// counted 3 on MRI 4.0.5 and 0 on rbgo; all three arrive here now — and none of them
+// reaches the real stderr. Measured byte-for-byte against MRI 4.0.5 on the same
+// file: `ruby /tmp/wt45probe.rb` and `rbgo /tmp/wt45probe.rb` now print the same
+// four lines.
+func TestOverriddenWarningWarnInterceptsInternalWarnings(t *testing.T) {
+	got := runWarn(t, `$seen = []
+module Warning
+  def self.warn(msg, category: nil); $seen << msg; end
+end
+[1, 2].fetch(5, 1) { |i| i }
+BAR = 1
+BAR = 2
+print "intercepted=", $seen.length, "\n"
+print $seen.join("")
+`)
+	const want = `intercepted=3
+wt45probe.rb:5: warning: block supersedes default value argument
+wt45probe.rb:7: warning: already initialized constant BAR
+wt45probe.rb:6: warning: previous definition of BAR was here
+`
+	if got != want {
+		t.Fatalf("got %q, want %q", got, want)
+	}
+}
+
+// warnEnabled / warningEnabled are the only two gates, so they are also the only
+// two places where an ASSIGNED $VERBOSE and an unset one can disagree. They may
+// not: a fresh VM must answer exactly as one that was handed MRI's default.
+func TestWarnGatesAgreeBetweenUnsetAndExplicitFalse(t *testing.T) {
+	var buf bytes.Buffer
+	unset := New(&buf)
+	explicit := New(&buf)
+	explicit.globals["$VERBOSE"] = object.False
+	if unset.warnEnabled() != explicit.warnEnabled() {
+		t.Errorf("warnEnabled: unset=%v explicit false=%v — one value, two answers",
+			unset.warnEnabled(), explicit.warnEnabled())
+	}
+	if unset.warningEnabled() != explicit.warningEnabled() {
+		t.Errorf("warningEnabled: unset=%v explicit false=%v",
+			unset.warningEnabled(), explicit.warningEnabled())
+	}
+	if !unset.warnEnabled() {
+		t.Error("an unset $VERBOSE must enable rb_warn — MRI starts it at false")
+	}
+	if unset.warningEnabled() {
+		t.Error("an unset $VERBOSE must NOT enable rb_warning — that needs true")
+	}
+}
diff --git a/internal/vm/vm.go b/internal/vm/vm.go
index 04c73b12..04b8af69 100644
--- a/internal/vm/vm.go
+++ b/internal/vm/vm.go
@@ -2955,16 +2955,33 @@ func (vm *VM) constTable(parent *RClass) map[string]object.Value {
 	return parent.consts
 }
 
-// warnAlreadyInitialized emits MRI's "already initialized constant" warning when
-// a syntactic constant assignment overwrites a value already in scope's own
-// table. variable.c's const_tbl_update (ruby/ruby v3_4_0:3658) warns through
-// rb_warn — so `$VERBOSE = nil` silences it, which is what ruby/spec's
-// suppress_warning relies on — and qualifies the name with the module unless
-// that module is Object. (struct.go's warnRedefineConst writes the same text
-// through Kernel#warn, which `$VERBOSE = nil` does not silence; the syntactic
-// assignment needs rb_warn's behaviour, hence the separate helper. MRI also
-// prefixes file:line and follows with "previous definition ... was here"; rbgo
-// carries no source map yet, so neither is emitted, as elsewhere in this VM.)
+// warnAlreadyInitialized is variable.c's const_tbl_update redefinition arm
+// (ruby/ruby v3_4_0 variable.c:3694-3706) in full. It warns when a constant
+// assignment overwrites a value already in scope's own table, and MRI emits TWO
+// lines there, not one:
+//
+//	-e:1: warning: already initialized constant X
+//	-e:1: warning: previous definition of X was here
+//
+// The first goes through rb_warn — so `$VERBOSE = nil` silences it, which is what
+// ruby/spec's suppress_warning relies on — and qualifies the name with the module
+// unless that module is Object. The second goes through rb_compile_warn with the
+// OLD entry's own ce->file / ce->line, so it points at the original definition and
+// not at the line doing the overwriting; when the two live in different files the
+// two lines carry different paths, which is measurable and is measured. Its name
+// is the BARE one (QUOTE_ID(id)), unqualified even when the first line is
+// qualified: MRI prints "already initialized constant MM::K" and then "previous
+// definition of K was here".
+//
+// MRI guards the second line with `if (!NIL_P(ce->file) && ce->line)`, so a
+// constant this VM defined natively — no Ruby frame, hence no recorded location —
+// gets the first line alone, exactly as in MRI.
+//
+// Both constant-assignment opcodes and Module#const_set come here; they went
+// through two helpers with two different behaviours before. Struct.new's named
+// form is the one genuine exception — struct.c:273 warns "redefining constant
+// Struct::Foo" instead, and with no second line — and it says so at its own call
+// site.
 func (vm *VM) warnAlreadyInitialized(scope *RClass, name string) {
 	if scope == nil {
 		scope = vm.cObject
@@ -2976,7 +2993,13 @@ func (vm *VM) warnAlreadyInitialized(scope *RClass, name string) {
 	// rb_class_name(klass) for every scope but Object, and an ANONYMOUS module
 	// renders as its "#<Module:0x…>" path there rather than dropping out of the
 	// message ("already initialized constant #<Module:0x…>::TEST").
-	vm.rbWarn("warning: already initialized constant %s", vm.constPathUnder(scope, name))
+	vm.rbWarnf("already initialized constant %s", vm.constPathUnder(scope, name))
+	// The location must be read BEFORE the assignment that follows overwrites it
+	// (recordConstLoc stamps the new site), which is why this helper runs ahead of
+	// the store rather than beside it.
+	if loc, ok := scope.constLocs[name]; ok && loc.file != "" && loc.line != 0 {
+		vm.rbCompileWarn(loc.file, loc.line, "previous definition of "+name+" was here")
+	}
 }
 
 // assignConst sets a bare constant assignment (`NAME = value`) into the current
diff --git a/internal/vm/wave24_lang_test.go b/internal/vm/wave24_lang_test.go
index 762fe2de..f353786a 100644
--- a/internal/vm/wave24_lang_test.go
+++ b/internal/vm/wave24_lang_test.go
@@ -166,15 +166,28 @@ p ::TOPC
 
 // Reassigning an already-initialized constant warns, qualified by the module
 // unless that module is Object, and `$VERBOSE = nil` silences it — MRI's
-// rb_warn behaviour. (rbgo leaves $VERBOSE unset, where MRI starts it at false,
-// so these set it explicitly to reach the warning at all.)
+// rb_warn behaviour. MRI emits TWO lines, both carrying a position: the
+// "already initialized" one at the overwriting site and "previous definition of
+// X was here" at the original. Measured on MRI 4.0.5:
+//
+//	$ ruby -e 'A = 1; A = 2'
+//	-e:1: warning: already initialized constant A
+//	-e:1: warning: previous definition of A was here
+//
+// These rows used to assert a bare "warning: …", which was rbgo's own divergence;
+// the $VERBOSE = false prologue is kept only so the silenced row below still
+// contrasts with them. They show ONE line, not two, because runSrcEnc compiles a
+// path-less ISeq: recordConstLoc stores nothing without a file, and MRI's
+// `if (!NIL_P(ce->file) && ce->line)` then suppresses the second line — the same
+// reason a natively defined constant gets one line. The two-line form is measured
+// against MRI in verbose_gate_wave45_test.go, which stamps a path.
 func TestAlreadyInitializedConstantWarning(t *testing.T) {
 	checkSrc(t, "toplevel constant", "$VERBOSE = false\nX = 1\nX = 2\np X\n",
-		"warning: already initialized constant X\n2")
+		"(rbgo):3: warning: already initialized constant X\n2")
 	checkSrc(t, "qualified constant", "$VERBOSE = false\nmodule M; end\nM::Y = 1\nM::Y = 2\np M::Y\n",
-		"warning: already initialized constant M::Y\n2")
+		"(rbgo):4: warning: already initialized constant M::Y\n2")
 	checkSrc(t, "inside a class body", "$VERBOSE = false\nclass K; Z = 1; Z = 2; end\np K::Z\n",
-		"warning: already initialized constant K::Z\n2")
+		"(rbgo):2: warning: already initialized constant K::Z\n2")
 	checkSrc(t, "silenced by $VERBOSE = nil", "$VERBOSE = nil\nX = 1\nX = 2\np X\n", "2")
 	checkSrc(t, "a first assignment does not warn", "$VERBOSE = false\nmodule M; end\nM::Q = 1\np M::Q\n", "1")
 }
@@ -301,6 +314,9 @@ func TestWarnAlreadyInitializedNilScope(t *testing.T) {
 	vm.globals["$VERBOSE"] = object.False
 	vm.cObject.consts["WAIN_TEST_CONST"] = object.IntValue(1)
 	vm.warnAlreadyInitialized(nil, "WAIN_TEST_CONST")
+	// No frame is on the stack (the helper is called directly), so warnUplevelPrefix
+	// falls back to the bare "warning: " — err_vcatf's `if (file)` arm — and there is
+	// no recorded location either, so no second line.
 	if got := buf.String(); got != "warning: already initialized constant WAIN_TEST_CONST\n" {
 		t.Fatalf("nil scope: got %q", got)
 	}
diff --git a/internal/vm/wave28_file_fd_open_test.go b/internal/vm/wave28_file_fd_open_test.go
index af61592a..bf5043ef 100644
--- a/internal/vm/wave28_file_fd_open_test.go
+++ b/internal/vm/wave28_file_fd_open_test.go
@@ -85,7 +85,7 @@ func TestWave28FileNewWarnsOnBlock(t *testing.T) {
 	dir := fdOpenScratch(t)
 	src := "Dir.chdir(" + rubyString(dir) + ")\n$VERBOSE = true\n" +
 		"$stderr = $stdout\nFile.new(\"f.txt\") { |f| 1 }\n"
-	const want = "warning: File::new() does not take block; use File::open() instead\n"
+	const want = "(rbgo):4: warning: File::new() does not take block; use File::open() instead\n"
 	if got := eval(t, src); got != want {
 		t.Errorf("got=%q\nwant=%q", got, want)
 	}
diff --git a/internal/vm/wave28_modreg_internal_test.go b/internal/vm/wave28_modreg_internal_test.go
index 176a67ab..da089143 100644
--- a/internal/vm/wave28_modreg_internal_test.go
+++ b/internal/vm/wave28_modreg_internal_test.go
@@ -406,7 +406,7 @@ func TestRefinementImportMethods(t *testing.T) {
 			M1 = Module.new
 			M2 = Module.new { include M1 }
 			R = Module.new { refine(String) { import_methods M2 } }
-			p :done`, "warning: M2 has ancestors, but Refinement#import_methods doesn't import their methods\n:done\n"},
+			p :done`, "(rbgo):5: warning: M2 has ancestors, but Refinement#import_methods doesn't import their methods\n:done\n"},
 		{"undefined_entries_are_skipped", `
 			su = Module.new do
 			  def gone; end
@@ -724,7 +724,7 @@ func TestRegexpPrepareEncoding(t *testing.T) {
 		{"historical_binary_warning", `
 		  $VERBOSE = true
 		  p(/a/n =~ "\xC3\xA9".dup.force_encoding("UTF-8"))`,
-			"warning: historical binary regexp match /.../n against UTF-8 string\nnil\n"},
+			"(rbgo):3: warning: historical binary regexp match /.../n against UTF-8 string\nnil\n"},
 		{"no_warning_for_binary_subject", `
 		  $VERBOSE = true
 		  p(/a/n =~ "\xC3\xA9".dup.force_encoding("BINARY"))`, "nil\n"},
diff --git a/internal/vm/wave31_consts_internal_test.go b/internal/vm/wave31_consts_internal_test.go
index 8fdf75e5..42da62be 100644
--- a/internal/vm/wave31_consts_internal_test.go
+++ b/internal/vm/wave31_consts_internal_test.go
@@ -33,7 +33,12 @@ p M.const_source_location(:NOPE)
 	// The file is empty because eval() compiles a source string with no path, so
 	// every location records line-only — which is exactly the shape that must
 	// read back as the EMPTY array rather than as ["", n].
-	want := "[]\n[]\n[]\n[]\nnil\n"
+	//
+	// Line 3's re-assignment of A also warns, which is variable.c's const_tbl_update
+	// doing its other job on the same code path this test exercises; there is no
+	// second "previous definition" line because the recorded location has no file,
+	// which is the very shape being asserted above (MRI's `!NIL_P(ce->file)` guard).
+	want := "[]\n(rbgo):3: warning: already initialized constant A\n[]\n[]\n[]\nnil\n"
 	if got := eval(t, src); got != want {
 		t.Errorf("got %q want %q", got, want)
 	}