From a3ed7f7574fd627ed6d260bb63b2e01cca5668af Mon Sep 17 00:00:00 2001 From: tannevaled Date: Sat, 31 Oct 2026 22:55:11 +0100 Subject: [PATCH] vm: Array#rfind, and it has to index the live array MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The last of the three Ruby 4.0 additions rbgo was missing. Of 31 surfaces ruby/spec gates behind `ruby_version_is "4.0"`, rbgo already answered 28; #846 added `Math.log1p`/`Math.expm1`, and this is `Array#rfind`. Array's own, not Enumerable's: MRI defines find, detect **and** rfind on `rb_cArray` itself (array.c at v4.0.9, lines 8916-8918), which is why `core/array/{find,detect,rfind}_spec.rb` all sit behind the 4.0 guard. ## ⛔ Why `to_a.reverse.find` and `reverse_each` are both wrong `core/array/rfind_spec.rb:81`: ```ruby ary = [4, 2, 1, 5, 1, 3] seen = [] ary.rfind { |x| seen << x; ary.clear; false } seen.should == [3] ``` **One element, not six.** `rb_ary_rfind` (array.c:2155) re-reads the length after every yield and clamps the index down to it: ```c idx = RARRAY_LEN(ary); while (idx--) { VALUE elem = RARRAY_AREF(ary, idx); if (RTEST(rb_yield(elem))) return elem; len = RARRAY_LEN(ary); idx = (idx >= len) ? len : idx; } ``` so a block that empties the receiver ends the walk immediately. Any snapshot — `reverse_each`, `to_a.reverse`, an index range computed up front — sees all six and **passes every other example in the file**. The implementation here walks the live array by index and carries that clamp, with the C quoted at the site. The clamp only ever lowers the index, so a block that grows the array does not revisit the tail already passed; that is a test too. ## Measured, with the control `core/array/rfind_spec.rb` on a private corpus at the pinned `SPEC_SHA`, shim at 4.0.9 (the whole file is behind the guard, so at 3.4.1 it yields nothing): | | `main` (3a3fb818) | this branch | |---|---|---| | `core/array/rfind_spec.rb` | `pass=1 fail=0 error=15` | **`pass=16 fail=0 error=0`** | ## ⛔ And that `pass=1` on main is a FALSE pass Accounting for it rather than rounding it off turned up something worth knowing. The 15 errors are 14 named `Array#rfind` examples plus the shared `:enumeratorized_with_unknown_size` block. The sixteenth — the one that "passes" without the method existing at all — is: ```ruby it "raises a NoMethodError if the ifnone argument does not respond to #call and no element is found" do -> { [1, 2, 3].rfind(42) { |x| false } }.should.raise(NoMethodError) end ``` On `main`, `[1,2,3].rfind(42)` raises NoMethodError **because `rfind` is undefined**, and the expectation is satisfied by the wrong exception. So the gate's total rises by 15, and the sixteenth example — which it already counted — becomes a pass for the right reason. One of the 16 was never conformance. This shape is not unique to rfind: `language/`+`core/` contain **150 `should.raise(NoMethodError)` expectations across 72 files** (an upper bound on candidates, not a count — most of them name a method that does exist and assert NoMethodError for another reason, such as a private call). Filed separately, because it means `BASELINE` can record passes that come from absence, and the only way to tell is to ask whether the receiver answers the method the describe block names. ## No regression - Full `internal/vm` suite green (237s, `-count=1`). - `core/array/find_spec.rb` **16/16** and `core/array/detect_spec.rb` **1/1** on `main` *and* on this branch — rbgo's Enumerable#find already satisfies Array's 4.0 specs for those, so they are 17 examples the version move will reveal as passing with no work at all. - `core/module/refine_spec.rb` is the only spec in `language/`+`core/` that reads `Array.instance_methods`, and it compares that list with the same list seen from inside a refinement rather than against a fixed count — so a new method changes both sides. Measured anyway: `pass=30 fail=5 error=3` on both binaries, identical. `gofmt` clean. The frozen prelude is regenerated (`go generate ./internal/vm`), and `prelude_frozen_test.go` is what would have caught forgetting to. ⚠ Note for whoever runs that generate next: it also runs `cmd/aotgen`, whose output is **not** gofmt-clean, so `go generate ./internal/vm` leaves `internal/vm/aot_e2e_gen_test.go` modified with pure formatting churn. The committed form is generated-then-gofmt'd; `gofmt -w` on it restores the committed bytes exactly. Not touched here, so this diff is prelude only. Co-Authored-By: Claude Opus 5 --- internal/vm/array_rfind_test.go | 83 ++ internal/vm/prelude.rb | 48 ++ internal/vm/prelude_frozen_gen.go | 1168 +++++++++++++++-------------- 3 files changed, 733 insertions(+), 566 deletions(-) create mode 100644 internal/vm/array_rfind_test.go diff --git a/internal/vm/array_rfind_test.go b/internal/vm/array_rfind_test.go new file mode 100644 index 00000000..62065af8 --- /dev/null +++ b/internal/vm/array_rfind_test.go @@ -0,0 +1,83 @@ +package vm_test + +import "testing" + +// Array#rfind, new in Ruby 4.0 (ruby/ruby array.c at v4.0.9: rb_ary_rfind, and +// rb_define_method(rb_cArray, "rfind", …) at line 8918 — Array's own, not +// Enumerable's, which is also why core/array/{find,detect,rfind}_spec.rb all +// sit behind a `ruby_version_is "4.0"` guard). +// +// The cases follow core/array/rfind_spec.rb. That file is entirely behind the +// 4.0 guard, so the conformance gate cannot see it while the shim resolves at +// 3.4.1; these assertions are what holds the behaviour until it can. +func TestArrayRfind(t *testing.T) { + checkCases(t, []runCase{ + // The last match, not the first. + {`p [1, 2, 3, 4, 5].rfind { |x| x % 2 == 0 }`, "4\n"}, + {`p [1, 2, 3, 4, 5, 6].rfind { |x| x < 5 }`, "4\n"}, + {`p [1, 2, 3].rfind { |x| false }`, "nil\n"}, + + // ⛔ Reverse order, and it STOPS at the first match from the end. A + // correct-looking implementation that found the last match by scanning + // forwards would satisfy the three cases above and fail both of these. + {`visited = [] +[1, 2, 3].rfind { |x| visited << x; false } +p visited`, "[3, 2, 1]\n"}, + {`visited = [] +[1, 2, 3, 4, 5].rfind { |x| visited << x; x == 3 } +p visited`, "[5, 4, 3]\n"}, + + // The ifnone proc: called when nothing matches, once, not at all when + // something matches, ignored when nil, and NoMethodError when it is not + // callable. + {`p [1, 2, 3].rfind(-> { "cheeseburgers" }) { |x| false }`, "\"cheeseburgers\"\n"}, + {`p [1, 2, 3].rfind(-> { raise "must not be called" }) { |x| x == 3 }`, "3\n"}, + {`times = 0 +fail_proc = -> { times += 1; raise if times > 1; "cheeseburgers" } +p [1, 2, 3].rfind(fail_proc) { |x| false } +p times`, "\"cheeseburgers\"\n1\n"}, + {`p [].rfind(-> { "yay" }) { |x| true }`, "\"yay\"\n"}, + {`p [1, 2, 3].rfind(nil) { |x| false }`, "nil\n"}, + {`begin + [1, 2, 3].rfind(42) { |x| false } +rescue NoMethodError + puts "NoMethodError" +end`, "NoMethodError\n"}, + + // An element is yielded whole; a two-parameter block destructures it, as + // any Ruby block does. + {`p [[1, 2], [3, 4, 5], [6, 7, 8, 9]].rfind { |e| e == [1, 2] }`, "[1, 2]\n"}, + {`seen = [] +[:a, :b].each_with_index.to_a.rfind { |x, i| seen << [x, i]; nil } +p seen`, "[[:b, 1], [:a, 0]]\n"}, + + // No block: an Enumerator, of unknown size, carrying the ifnone proc. + {`p [1, 2, 3].rfind.instance_of?(Enumerator)`, "true\n"}, + {`p [1, 2, 3].rfind.size`, "nil\n"}, + {`enum = [1, 2, 3].rfind(-> { "cheeseburgers" }) +p enum.each { |x| false }`, "\"cheeseburgers\"\n"}, + + // ⛔ THE CASE THAT RULES OUT `to_a.reverse.find` AND `reverse_each`. + // The size is re-read after every yield and the index clamped down to + // it, so a block that empties the receiver ends the walk after ONE + // element. core/array/rfind_spec.rb:81. A snapshot-based implementation + // sees all six and passes every other case in this file. + {`ary = [4, 2, 1, 5, 1, 3] +seen = [] +ary.rfind { |x| seen << x; ary.clear; false } +p seen`, "[3]\n"}, + + // The clamp only ever LOWERS the index, so a block that grows the array + // does not revisit the tail it has already passed. + {`ary = [1, 2, 3] +seen = [] +ary.rfind { |x| seen << x; ary.push(99) if seen.size == 1; false } +p seen`, "[3, 2, 1]\n"}, + + // find/detect still walk forwards: rfind is not an alias of either, and + // a mistake that aliased them would pass none of the reverse cases but + // is worth pinning from this side too. + {`p [1, 2, 3, 4].find { |x| x % 2 == 0 }`, "2\n"}, + {`p [1, 2, 3, 4].rfind { |x| x % 2 == 0 }`, "4\n"}, + }) +} diff --git a/internal/vm/prelude.rb b/internal/vm/prelude.rb index 933cb001..1c1eaa48 100644 --- a/internal/vm/prelude.rb +++ b/internal/vm/prelude.rb @@ -1054,6 +1054,54 @@ class Array def deconstruct self end + + # rfind(ifnone = nil): the LAST element for which the block is truthy, found by + # walking backwards. New in Ruby 4.0, and Array's own rather than Enumerable's: + # MRI defines find, detect and rfind on rb_cArray itself + # (array.c at v4.0.9, lines 8916-8918), which is also why + # core/array/{find,detect,rfind}_spec.rb all sit behind a 4.0 guard. + # + # ⛔ IT INDEXES THE LIVE ARRAY AND RE-READS THE SIZE AFTER EVERY YIELD. The + # obvious implementation, `reverse_each` or `to_a.reverse.find`, takes a + # snapshot and is wrong for a block that mutates the receiver — + # core/array/rfind_spec.rb:81 asserts exactly that case: + # + # ary = [4, 2, 1, 5, 1, 3] + # seen = [] + # ary.rfind { |x| seen << x; ary.clear; false } + # seen.should == [3] + # + # one element, not six. MRI's loop (rb_ary_rfind, array.c:2155) is + # + # idx = RARRAY_LEN(ary); + # while (idx--) { + # elem = RARRAY_AREF(ary, idx); + # if (RTEST(rb_yield(elem))) return elem; + # len = RARRAY_LEN(ary); + # idx = (idx >= len) ? len : idx; + # } + # + # and the clamp is the whole of that behaviour: after the block empties the + # array, idx is pulled down to the new length and the loop ends. A growing + # array is left alone, since the clamp only ever lowers idx. + def rfind(ifnone = nil) + # The { nil } block gives the enumerator an unknown size, which is what + # core/array/rfind_spec.rb's :enumeratorized_with_unknown_size requires, and + # passing ifnone through is what makes `[1,2,3].rfind(p).each { false }` + # return p.call. + return enum_for(:rfind, ifnone) { nil } unless block_given? + idx = size + while idx > 0 + idx -= 1 + elem = self[idx] + return elem if yield(elem) + len = size + idx = len if idx >= len + end + # nil is IGNORED rather than called, and a non-callable ifnone raises + # NoMethodError from the call itself — both asserted by the spec. + ifnone.nil? ? nil : ifnone.call + end end class Range diff --git a/internal/vm/prelude_frozen_gen.go b/internal/vm/prelude_frozen_gen.go index 5e715406..73e3693d 100644 --- a/internal/vm/prelude_frozen_gen.go +++ b/internal/vm/prelude_frozen_gen.go @@ -19,7 +19,7 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - 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: 2103}, {PC: 40, Line: 2145}, {PC: 42, Line: 2146}, {PC: 46, Line: 2211}, {PC: 48, Line: 2212}, {PC: 52, Line: 2321}, {PC: 54, Line: 2322}, {PC: 58, Line: 2423}, {PC: 60, Line: 2424}, {PC: 64, Line: 2481}, {PC: 66, Line: 2606}, {PC: 68, Line: 2664}}, + 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: 1107}, {PC: 18, Line: 1140}, {PC: 20, Line: 1155}, {PC: 22, Line: 1527}, {PC: 24, Line: 1747}, {PC: 26, Line: 1826}, {PC: 28, Line: 1857}, {PC: 30, Line: 1877}, {PC: 32, Line: 1917}, {PC: 34, Line: 1930}, {PC: 36, Line: 1970}, {PC: 38, Line: 2151}, {PC: 40, Line: 2193}, {PC: 42, Line: 2194}, {PC: 46, Line: 2259}, {PC: 48, Line: 2260}, {PC: 52, Line: 2369}, {PC: 54, Line: 2370}, {PC: 58, Line: 2471}, {PC: 60, Line: 2472}, {PC: 64, Line: 2529}, {PC: 66, Line: 2654}, {PC: 68, Line: 2712}}, FirstLine: 1, Children: []*bytecode.ISeq{ &bytecode.ISeq{ @@ -3063,15 +3063,15 @@ func embeddedPrelude() *bytecode.ISeq { }, &bytecode.ISeq{ Name: "", - Insns: []bytecode.Instr{{Op: 5}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 2}, {Op: 9}, {Op: 44, A: 2}, {Op: 53}}, - Names: []string{"Enumerable", "include", "deconstruct"}, + Insns: []bytecode.Instr{{Op: 5}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 2}, {Op: 9}, {Op: 44, A: 2}, {Op: 9}, {Op: 44, A: 3, B: 1}, {Op: 53}}, + Names: []string{"Enumerable", "include", "deconstruct", "rfind"}, NumRequired: 0, SplatIndex: -1, PostCount: 0, KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1051}, {PC: 4, Line: 1054}}, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1051}, {PC: 4, Line: 1054}, {PC: 6, Line: 1087}}, FirstLine: 1050, Children: []*bytecode.ISeq{ &bytecode.ISeq{ @@ -3087,6 +3087,42 @@ func embeddedPrelude() *bytecode.ISeq { FirstLine: 1054, Super: "", }, + &bytecode.ISeq{ + Name: "rfind", + Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 5}, {Op: 2}, {Op: 12}, {Op: 9}, {Op: 52}, {Op: 25}, {Op: 28, A: 14}, {Op: 5}, {Op: 1}, {Op: 11}, {Op: 30, B: 2, C: 1, Flags: 2}, {Op: 53}, {Op: 26, A: 15}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, Flags: 8}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 1, A: 1}, {Op: 19}, {Op: 28, A: 56}, {Op: 11, A: 1}, {Op: 1, A: 2}, {Op: 14}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 11, A: 1}, {Op: 30, A: 2, B: 1, Flags: 2}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 48, A: 1, Flags: 2}, {Op: 28, A: 40}, {Op: 11, A: 2}, {Op: 53}, {Op: 26, A: 41}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, Flags: 8}, {Op: 12, A: 3}, {Op: 9}, {Op: 11, A: 1}, {Op: 11, A: 3}, {Op: 21}, {Op: 28, A: 53}, {Op: 11, A: 3}, {Op: 12, A: 1}, {Op: 26, A: 54}, {Op: 2}, {Op: 9}, {Op: 26, A: 20}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 30, A: 3, Flags: 1}, {Op: 28, A: 63}, {Op: 2}, {Op: 26, A: 65}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 53}}, + Consts: []object.Value{ + object.Symbol("rfind"), + object.IntValue(0), + object.IntValue(1), + }, + Names: []string{"enum_for", "size", "[]", "nil?", "call"}, + Params: []string{"ifnone"}, + NumRequired: 0, + SplatIndex: -1, + PostCount: 0, + KwRestSlot: -1, + BlockSlot: -1, + NumLocals: 4, + Locals: []string{"ifnone", "idx", "elem", "len"}, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1087}, {PC: 2, Line: 259}, {PC: 5, Line: 1092}, {PC: 16, Line: 1093}, {PC: 20, Line: 1094}, {PC: 24, Line: 1095}, {PC: 29, Line: 109}, {PC: 34, Line: 1097}, {PC: 42, Line: 1098}, {PC: 46, Line: 1099}, {PC: 58, Line: 1103}, {PC: 61, Line: 259}}, + FirstLine: 1087, + Children: []*bytecode.ISeq{ + &bytecode.ISeq{ + Name: "block in rfind", + Insns: []bytecode.Instr{{Op: 2}, {Op: 53}}, + NumRequired: 0, + SplatIndex: -1, + PostCount: 0, + KwRestSlot: -1, + BlockSlot: -1, + NumLocals: 0, + Lines: []bytecode.LineEntry{{PC: 0, Line: 259}}, + FirstLine: 1092, + Super: "", + }, + }, + Super: "", + }, }, Super: "", }, @@ -3100,8 +3136,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1060}, {PC: 4, Line: 1067}, {PC: 6, Line: 1074}, {PC: 8, Line: 1084}}, - FirstLine: 1059, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1108}, {PC: 4, Line: 1115}, {PC: 6, Line: 1122}, {PC: 8, Line: 1132}}, + FirstLine: 1107, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "==", @@ -3115,8 +3151,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1068}, {PC: 9, Line: 1069}, {PC: 19, Line: 109}}, - FirstLine: 1067, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1116}, {PC: 9, Line: 1117}, {PC: 19, Line: 109}}, + FirstLine: 1115, Super: "", }, &bytecode.ISeq{ @@ -3131,8 +3167,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1075}, {PC: 9, Line: 1076}, {PC: 19, Line: 109}}, - FirstLine: 1074, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1123}, {PC: 9, Line: 1124}, {PC: 19, Line: 109}}, + FirstLine: 1122, Super: "", }, &bytecode.ISeq{ @@ -3146,7 +3182,7 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 0, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 1084, + FirstLine: 1132, Super: "", }, }, @@ -3162,8 +3198,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1093}, {PC: 4, Line: 1096}}, - FirstLine: 1092, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1141}, {PC: 4, Line: 1144}}, + FirstLine: 1140, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "deconstruct_keys", @@ -3177,7 +3213,7 @@ func embeddedPrelude() *bytecode.ISeq { NumLocals: 1, Locals: []string{"keys"}, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 1096, + FirstLine: 1144, Super: "", }, }, @@ -3199,8 +3235,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1156}, {PC: 4, Line: 1162}, {PC: 6, Line: 1171}, {PC: 10, Line: 1175}, {PC: 12, Line: 1183}, {PC: 16, Line: 1187}, {PC: 18, Line: 1193}, {PC: 20, Line: 1199}, {PC: 22, Line: 1203}, {PC: 24, Line: 1209}, {PC: 26, Line: 1214}, {PC: 28, Line: 1215}, {PC: 30, Line: 1219}, {PC: 32, Line: 1224}, {PC: 34, Line: 1228}, {PC: 36, Line: 1233}, {PC: 38, Line: 1237}, {PC: 40, Line: 1244}, {PC: 42, Line: 1250}, {PC: 44, Line: 1258}, {PC: 46, Line: 1272}, {PC: 48, Line: 1280}, {PC: 50, Line: 1285}, {PC: 52, Line: 1288}, {PC: 54, Line: 1293}, {PC: 56, Line: 1296}, {PC: 58, Line: 1301}, {PC: 60, Line: 1304}, {PC: 62, Line: 1309}, {PC: 64, Line: 1313}, {PC: 66, Line: 1324}, {PC: 68, Line: 1333}, {PC: 70, Line: 1337}, {PC: 72, Line: 1343}, {PC: 74, Line: 1351}, {PC: 76, Line: 1357}, {PC: 78, Line: 1363}, {PC: 80, Line: 1371}, {PC: 82, Line: 1377}, {PC: 84, Line: 1379}, {PC: 86, Line: 1388}, {PC: 88, Line: 1395}, {PC: 90, Line: 1399}, {PC: 92, Line: 1413}, {PC: 94, Line: 1422}, {PC: 96, Line: 1466}, {PC: 100, Line: 1472}, {PC: 102, Line: 1476}, {PC: 104, Line: 1487}, {PC: 106, Line: 1500}, {PC: 110, Line: 1503}, {PC: 112, Line: 1508}}, + FirstLine: 1155, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "__do_with_enum", @@ -3219,8 +3255,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"enum", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1115}, {PC: 4, Line: 1116}, {PC: 12, Line: 1118}, {PC: 16, Line: 1120}}, - FirstLine: 1114, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1163}, {PC: 4, Line: 1164}, {PC: 12, Line: 1166}, {PC: 16, Line: 1168}}, + FirstLine: 1162, Super: "", }, &bytecode.ISeq{ @@ -3235,8 +3271,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"enum", "block"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1175}, {PC: 2, Line: 259}, {PC: 5, Line: 1176}, {PC: 13, Line: 1177}, {PC: 15, Line: 1178}, {PC: 19, Line: 1180}}, + FirstLine: 1175, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in initialize", @@ -3250,8 +3286,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1130}}, - FirstLine: 1130, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1178}}, + FirstLine: 1178, Super: "", }, &bytecode.ISeq{ @@ -3266,8 +3302,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1132}}, - FirstLine: 1132, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1180}}, + FirstLine: 1180, Super: "", }, }, @@ -3287,8 +3323,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 0, NumLocals: 1, Locals: []string{"block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1140}, {PC: 10, Line: 1141}, {PC: 14, Line: 109}}, - FirstLine: 1139, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1188}, {PC: 10, Line: 1189}, {PC: 14, Line: 109}}, + FirstLine: 1187, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in each", @@ -3300,8 +3336,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1140}}, - FirstLine: 1140, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1188}}, + FirstLine: 1188, Super: "", }, }, @@ -3320,8 +3356,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1146}}, - FirstLine: 1145, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1194}}, + FirstLine: 1193, Super: "", }, &bytecode.ISeq{ @@ -3336,8 +3372,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1152}, {PC: 4, Line: 259}}, - FirstLine: 1151, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1200}, {PC: 4, Line: 259}}, + FirstLine: 1199, Super: "", }, &bytecode.ISeq{ @@ -3352,8 +3388,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1156}, {PC: 8, Line: 259}}, - FirstLine: 1155, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1204}, {PC: 8, Line: 259}}, + FirstLine: 1203, Super: "", }, &bytecode.ISeq{ @@ -3368,8 +3404,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"other", "n"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1162}, {PC: 4, Line: 1163}, {PC: 8, Line: 1164}}, - FirstLine: 1161, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1210}, {PC: 4, Line: 1211}, {PC: 8, Line: 1212}}, + FirstLine: 1209, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in |", @@ -3383,8 +3419,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1163}}, - FirstLine: 1163, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1211}}, + FirstLine: 1211, Super: "", }, }, @@ -3402,8 +3438,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"other", "n"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 5, Line: 1173}, {PC: 9, Line: 1174}}, - FirstLine: 1171, + Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 5, Line: 1221}, {PC: 9, Line: 1222}}, + FirstLine: 1219, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in &", @@ -3417,8 +3453,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1173}}, - FirstLine: 1173, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1221}}, + FirstLine: 1221, Super: "", }, }, @@ -3436,8 +3472,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"other", "n"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1181}, {PC: 4, Line: 1182}, {PC: 8, Line: 1183}}, - FirstLine: 1180, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1229}, {PC: 4, Line: 1230}, {PC: 8, Line: 1231}}, + FirstLine: 1228, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in -", @@ -3451,8 +3487,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1182}}, - FirstLine: 1182, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1230}}, + FirstLine: 1230, Super: "", }, }, @@ -3470,8 +3506,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"other", "n"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1191}, {PC: 9, Line: 1192}}, - FirstLine: 1189, + Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1239}, {PC: 9, Line: 1240}}, + FirstLine: 1237, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in ^", @@ -3485,8 +3521,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1191}}, - FirstLine: 1191, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1239}}, + FirstLine: 1239, Super: "", }, }, @@ -3504,8 +3540,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"enums"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1197}, {PC: 3, Line: 109}}, - FirstLine: 1196, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1245}, {PC: 3, Line: 109}}, + FirstLine: 1244, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in merge", @@ -3519,8 +3555,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"enum"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1197}}, - FirstLine: 1197, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1245}}, + FirstLine: 1245, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in merge", @@ -3534,8 +3570,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1197}}, - FirstLine: 1197, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1245}}, + FirstLine: 1245, Super: "", }, }, @@ -3556,8 +3592,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1203}, {PC: 4, Line: 109}}, - FirstLine: 1202, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1251}, {PC: 4, Line: 109}}, + FirstLine: 1250, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in subtract", @@ -3571,8 +3607,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1203}}, - FirstLine: 1203, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1251}}, + FirstLine: 1251, Super: "", }, }, @@ -3595,8 +3631,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1259}, {PC: 4, Line: 1260}, {PC: 9, Line: 1261}, {PC: 12, Line: 1263}, {PC: 30, Line: 1264}, {PC: 35, Line: 1265}, {PC: 39, Line: 109}}, + FirstLine: 1258, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in replace", @@ -3610,8 +3646,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1213}}, - FirstLine: 1213, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1261}}, + FirstLine: 1261, Super: "", }, &bytecode.ISeq{ @@ -3626,8 +3662,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1217}}, - FirstLine: 1217, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1265}}, + FirstLine: 1265, Super: "", }, }, @@ -3644,8 +3680,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"vals"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1225}, {PC: 4, Line: 1226}, {PC: 9, Line: 1227}, {PC: 12, Line: 109}}, - FirstLine: 1224, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1273}, {PC: 4, Line: 1274}, {PC: 9, Line: 1275}, {PC: 12, Line: 109}}, + FirstLine: 1272, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in reset", @@ -3659,8 +3695,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1227}}, - FirstLine: 1227, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1275}}, + FirstLine: 1275, Super: "", }, }, @@ -3681,8 +3717,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1233}, {PC: 12, Line: 1234}, {PC: 23, Line: 1235}}, - FirstLine: 1232, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1281}, {PC: 12, Line: 1282}, {PC: 23, Line: 1283}}, + FirstLine: 1280, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in subset?", @@ -3696,8 +3732,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1235}}, - FirstLine: 1235, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1283}}, + FirstLine: 1283, Super: "", }, }, @@ -3718,8 +3754,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1241}, {PC: 12, Line: 1242}, {PC: 23, Line: 1243}}, - FirstLine: 1240, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1289}, {PC: 12, Line: 1290}, {PC: 23, Line: 1291}}, + FirstLine: 1288, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in proper_subset?", @@ -3733,8 +3769,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1243}}, - FirstLine: 1243, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1291}}, + FirstLine: 1291, Super: "", }, }, @@ -3755,8 +3791,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1249}, {PC: 12, Line: 1250}, {PC: 23, Line: 1251}}, - FirstLine: 1248, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1297}, {PC: 12, Line: 1298}, {PC: 23, Line: 1299}}, + FirstLine: 1296, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in superset?", @@ -3770,8 +3806,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1251}}, - FirstLine: 1251, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1299}}, + FirstLine: 1299, Super: "", }, }, @@ -3792,8 +3828,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1257}, {PC: 12, Line: 1258}, {PC: 23, Line: 1259}}, - FirstLine: 1256, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1305}, {PC: 12, Line: 1306}, {PC: 23, Line: 1307}}, + FirstLine: 1304, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in proper_superset?", @@ -3807,8 +3843,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1259}}, - FirstLine: 1259, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1307}}, + FirstLine: 1307, Super: "", }, }, @@ -3831,8 +3867,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"other", ""}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1314}, {PC: 5, Line: 259}, {PC: 10, Line: 1315}, {PC: 22, Line: 1316}, {PC: 28, Line: 259}, {PC: 35, Line: 1317}, {PC: 41, Line: 259}, {PC: 43, Line: 109}, {PC: 49, Line: 259}}, + FirstLine: 1313, Super: "", }, &bytecode.ISeq{ @@ -3850,8 +3886,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1325}, {PC: 9, Line: 1326}, {PC: 19, Line: 1327}, {PC: 31, Line: 1328}, {PC: 36, Line: 1330}, {PC: 48, Line: 1331}}, + FirstLine: 1324, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in ==", @@ -3865,8 +3901,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1283}}, - FirstLine: 1283, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1331}}, + FirstLine: 1331, Super: "", }, }, @@ -3885,8 +3921,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1290}}, - FirstLine: 1289, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1338}}, + FirstLine: 1337, Super: "", }, &bytecode.ISeq{ @@ -3901,8 +3937,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1296}, {PC: 6, Line: 1297}, {PC: 9, Line: 1299}}, - FirstLine: 1295, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1344}, {PC: 6, Line: 1345}, {PC: 9, Line: 1347}}, + FirstLine: 1343, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in disjoint?", @@ -3916,8 +3952,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1297}}, - FirstLine: 1297, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1345}}, + FirstLine: 1345, Super: "", }, &bytecode.ISeq{ @@ -3932,8 +3968,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1299}}, - FirstLine: 1299, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1347}}, + FirstLine: 1347, Super: "", }, }, @@ -3951,8 +3987,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1304}}, - FirstLine: 1303, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1352}}, + FirstLine: 1351, Super: "", }, &bytecode.ISeq{ @@ -3969,8 +4005,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 0, NumLocals: 1, Locals: []string{"block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1310}, {PC: 10, Line: 1311}, {PC: 14, Line: 109}}, - FirstLine: 1309, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1358}, {PC: 10, Line: 1359}, {PC: 14, Line: 109}}, + FirstLine: 1357, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in delete_if", @@ -3982,8 +4018,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1310}}, - FirstLine: 1310, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1358}}, + FirstLine: 1358, Super: "", }, &bytecode.ISeq{ @@ -3998,8 +4034,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1311}}, - FirstLine: 1311, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1359}}, + FirstLine: 1359, Super: "", }, }, @@ -4019,8 +4055,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 0, NumLocals: 1, Locals: []string{"block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1316}, {PC: 10, Line: 1317}, {PC: 14, Line: 109}}, - FirstLine: 1315, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1364}, {PC: 10, Line: 1365}, {PC: 14, Line: 109}}, + FirstLine: 1363, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in keep_if", @@ -4032,8 +4068,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1316}}, - FirstLine: 1316, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1364}}, + FirstLine: 1364, Super: "", }, &bytecode.ISeq{ @@ -4048,8 +4084,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1317}}, - FirstLine: 1317, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1365}}, + FirstLine: 1365, Super: "", }, }, @@ -4069,8 +4105,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 0, NumLocals: 2, Locals: []string{"block", "n"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1372}, {PC: 10, Line: 1373}, {PC: 14, Line: 1374}, {PC: 18, Line: 1375}, {PC: 23, Line: 259}, {PC: 25, Line: 109}}, + FirstLine: 1371, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in select!", @@ -4082,8 +4118,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1324}}, - FirstLine: 1324, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1372}}, + FirstLine: 1372, Super: "", }, }, @@ -4103,8 +4139,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 0, NumLocals: 2, Locals: []string{"block", "n"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1380}, {PC: 10, Line: 1381}, {PC: 14, Line: 1382}, {PC: 18, Line: 1383}, {PC: 23, Line: 259}, {PC: 25, Line: 109}}, + FirstLine: 1379, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in reject!", @@ -4116,8 +4152,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1332}}, - FirstLine: 1332, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1380}}, + FirstLine: 1380, Super: "", }, }, @@ -4137,8 +4173,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 0, NumLocals: 2, Locals: []string{"block", "vals"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1389}, {PC: 10, Line: 1390}, {PC: 16, Line: 1391}, {PC: 20, Line: 1392}, {PC: 23, Line: 109}}, + FirstLine: 1388, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in map!", @@ -4150,8 +4186,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1341}}, - FirstLine: 1341, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1389}}, + FirstLine: 1389, Super: "", }, &bytecode.ISeq{ @@ -4166,8 +4202,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1344}}, - FirstLine: 1344, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1392}}, + FirstLine: 1392, Super: "", }, }, @@ -4187,8 +4223,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 0, NumLocals: 2, Locals: []string{"block", "h"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1352}, {PC: 10, Line: 1353}, {PC: 13, Line: 1354}, {PC: 16, Line: 1358}}, - FirstLine: 1351, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1400}, {PC: 10, Line: 1401}, {PC: 13, Line: 1402}, {PC: 16, Line: 1406}}, + FirstLine: 1399, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in classify", @@ -4200,8 +4236,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1352}}, - FirstLine: 1352, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1400}}, + FirstLine: 1400, Super: "", }, &bytecode.ISeq{ @@ -4216,8 +4252,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 5, Locals: []string{"o", "k", "", "", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1355}, {PC: 5, Line: 1356}, {PC: 17, Line: 109}}, - FirstLine: 1354, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1403}, {PC: 5, Line: 1404}, {PC: 17, Line: 109}}, + FirstLine: 1402, Super: "", }, }, @@ -4238,8 +4274,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 0, NumLocals: 1, Locals: []string{"func"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1366}, {PC: 10, Line: 1367}, {PC: 15, Line: 1368}, {PC: 19, Line: 109}}, - FirstLine: 1365, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1414}, {PC: 10, Line: 1415}, {PC: 15, Line: 1416}, {PC: 19, Line: 109}}, + FirstLine: 1413, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in divide", @@ -4251,8 +4287,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1366}}, - FirstLine: 1366, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1414}}, + FirstLine: 1414, Super: "", }, }, @@ -4272,8 +4308,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: 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1423}, {PC: 4, Line: 1424}, {PC: 8, Line: 1425}, {PC: 13, Line: 1426}, {PC: 16, Line: 1431}, {PC: 19, Line: 1432}, {PC: 24, Line: 1433}, {PC: 30, Line: 1434}, {PC: 36, Line: 1435}, {PC: 39, Line: 1436}, {PC: 42, Line: 259}, {PC: 45, Line: 1438}, {PC: 49, Line: 1463}, {PC: 52, Line: 109}}, + FirstLine: 1422, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in __divide_graph", @@ -4284,8 +4320,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1377}}, - FirstLine: 1377, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1425}}, + FirstLine: 1425, Super: "", }, &bytecode.ISeq{ @@ -4300,8 +4336,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"i"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1379}}, - FirstLine: 1378, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1427}}, + FirstLine: 1426, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in __divide_graph", @@ -4315,8 +4351,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"j"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1380}}, - FirstLine: 1379, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1428}}, + FirstLine: 1427, Super: "", }, }, @@ -4337,8 +4373,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 5, Locals: []string{"v", "", "", "", "comp"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1439}, {PC: 8, Line: 1440}, {PC: 16, Line: 1441}, {PC: 21, Line: 1442}, {PC: 25, Line: 1443}, {PC: 33, Line: 1444}, {PC: 38, Line: 1452}, {PC: 46, Line: 1453}, {PC: 49, Line: 1454}, {PC: 52, Line: 1460}}, + FirstLine: 1438, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in __divide_graph", @@ -4352,8 +4388,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"w", "", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1397}, {PC: 5, Line: 1398}, {PC: 9, Line: 1399}, {PC: 33, Line: 1401}}, - FirstLine: 1396, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1445}, {PC: 5, Line: 1446}, {PC: 9, Line: 1447}, {PC: 33, Line: 1449}}, + FirstLine: 1444, Super: "", }, &bytecode.ISeq{ @@ -4367,8 +4403,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"w", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1407}, {PC: 4, Line: 1408}, {PC: 12, Line: 1409}, {PC: 18, Line: 1410}}, - FirstLine: 1406, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1455}, {PC: 4, Line: 1456}, {PC: 12, Line: 1457}, {PC: 18, Line: 1458}}, + FirstLine: 1454, Super: "", }, }, @@ -4386,8 +4422,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1415}}, - FirstLine: 1415, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1463}}, + FirstLine: 1463, Super: "", }, &bytecode.ISeq{ @@ -4403,7 +4439,7 @@ func embeddedPrelude() *bytecode.ISeq { NumLocals: 1, Locals: []string{"c"}, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 1416, + FirstLine: 1464, Super: "", }, }, @@ -4420,7 +4456,7 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 0, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 1424, + FirstLine: 1472, Super: "", }, &bytecode.ISeq{ @@ -4433,8 +4469,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1429}, {PC: 3, Line: 1430}, {PC: 8, Line: 109}, {PC: 10, Line: 259}}, - FirstLine: 1428, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1477}, {PC: 3, Line: 1478}, {PC: 8, Line: 109}, {PC: 10, Line: 259}}, + FirstLine: 1476, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in flatten!", @@ -4448,8 +4484,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1429}}, - FirstLine: 1429, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1477}}, + FirstLine: 1477, Super: "", }, }, @@ -4467,8 +4503,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"other", "seen"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1439}, {PC: 5, Line: 1440}, {PC: 8, Line: 109}}, - FirstLine: 1439, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1487}, {PC: 5, Line: 1488}, {PC: 8, Line: 109}}, + FirstLine: 1487, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in flatten_merge", @@ -4485,8 +4521,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"o", ""}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1489}, {PC: 4, Line: 1490}, {PC: 16, Line: 1491}, {PC: 25, Line: 1492}, {PC: 30, Line: 1493}, {PC: 35, Line: 1495}}, + FirstLine: 1488, Super: "", }, }, @@ -4504,8 +4540,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"sep"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1455}, {PC: 2, Line: 259}, {PC: 5, Line: 1456}}, - FirstLine: 1455, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1503}, {PC: 2, Line: 259}, {PC: 5, Line: 1504}}, + FirstLine: 1503, Super: "", }, &bytecode.ISeq{ @@ -4518,7 +4554,7 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 0, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 1460, + FirstLine: 1508, Super: "", }, }, @@ -4534,8 +4570,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1531}, {PC: 2, Line: 1655}, {PC: 4, Line: 1712}, {PC: 6, Line: 1716}, {PC: 8, Line: 1722}, {PC: 10, Line: 1726}}, + FirstLine: 1527, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -4553,8 +4589,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1532}, {PC: 4, Line: 1534}, {PC: 7, Line: 1535}, {PC: 16, Line: 1539}, {PC: 18, Line: 1544}, {PC: 20, Line: 1554}, {PC: 24, Line: 1556}, {PC: 26, Line: 1564}, {PC: 28, Line: 1568}, {PC: 30, Line: 1574}, {PC: 32, Line: 1581}, {PC: 34, Line: 1585}, {PC: 36, Line: 1594}, {PC: 38, Line: 1602}, {PC: 40, Line: 1622}, {PC: 42, Line: 1628}, {PC: 44, Line: 1632}, {PC: 46, Line: 1636}, {PC: 49, Line: 1640}}, + FirstLine: 1531, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "correct?", @@ -4568,8 +4604,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"str"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1492}, {PC: 8, Line: 1493}}, - FirstLine: 1491, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1540}, {PC: 8, Line: 1541}}, + FirstLine: 1539, Super: "", }, &bytecode.ISeq{ @@ -4584,8 +4620,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"input"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1497}, {PC: 4, Line: 1498}, {PC: 9, Line: 259}, {PC: 11, Line: 1502}}, - FirstLine: 1496, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1545}, {PC: 4, Line: 1546}, {PC: 9, Line: 259}, {PC: 11, Line: 1550}}, + FirstLine: 1544, Super: "", }, &bytecode.ISeq{ @@ -4607,8 +4643,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"version"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1510}, {PC: 17, Line: 1512}, {PC: 25, Line: 1513}}, - FirstLine: 1508, + Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1558}, {PC: 17, Line: 1560}, {PC: 25, Line: 1561}}, + FirstLine: 1556, Super: "", }, &bytecode.ISeq{ @@ -4621,8 +4657,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1517}}, - FirstLine: 1516, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1565}}, + FirstLine: 1564, Super: "", }, &bytecode.ISeq{ @@ -4640,8 +4676,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1521}, {PC: 1, Line: 109}, {PC: 6, Line: 1521}}, - FirstLine: 1520, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1569}, {PC: 1, Line: 109}, {PC: 6, Line: 1569}}, + FirstLine: 1568, Super: "", }, &bytecode.ISeq{ @@ -4654,8 +4690,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1527}}, - FirstLine: 1526, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1575}}, + FirstLine: 1574, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in segments", @@ -4669,8 +4705,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"s"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1528}}, - FirstLine: 1527, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1576}}, + FirstLine: 1575, Super: "", }, }, @@ -4686,8 +4722,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1534}}, - FirstLine: 1533, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1582}}, + FirstLine: 1581, Super: "", }, &bytecode.ISeq{ @@ -4704,8 +4740,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"segs"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1586}, {PC: 4, Line: 109}, {PC: 9, Line: 1587}, {PC: 13, Line: 1588}, {PC: 31, Line: 109}}, + FirstLine: 1585, Super: "", }, &bytecode.ISeq{ @@ -4724,8 +4760,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"segs", ""}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1595}, {PC: 5, Line: 1596}, {PC: 23, Line: 1597}, {PC: 33, Line: 1598}, {PC: 45, Line: 109}}, + FirstLine: 1594, Super: "", }, &bytecode.ISeq{ @@ -4744,8 +4780,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: 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1604}, {PC: 9, Line: 259}, {PC: 14, Line: 1605}, {PC: 18, Line: 1606}, {PC: 22, Line: 1607}, {PC: 35, Line: 1608}, {PC: 38, Line: 1609}, {PC: 42, Line: 1610}, {PC: 47, Line: 1611}, {PC: 52, Line: 1613}, {PC: 60, Line: 1614}, {PC: 68, Line: 1615}, {PC: 74, Line: 1616}, {PC: 84, Line: 1617}, {PC: 92, Line: 1619}}, + FirstLine: 1602, Super: "", }, &bytecode.ISeq{ @@ -4763,8 +4799,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1576}, {PC: 14, Line: 109}}, - FirstLine: 1574, + Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1624}, {PC: 14, Line: 109}}, + FirstLine: 1622, Super: "", }, &bytecode.ISeq{ @@ -4779,8 +4815,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1581}}, - FirstLine: 1580, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1629}}, + FirstLine: 1628, Super: "", }, &bytecode.ISeq{ @@ -4793,8 +4829,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1585}}, - FirstLine: 1584, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1633}}, + FirstLine: 1632, Super: "", }, &bytecode.ISeq{ @@ -4813,8 +4849,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"l", "r"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1641}, {PC: 10, Line: 1642}, {PC: 24, Line: 1644}, {PC: 32, Line: 1646}, {PC: 34, Line: 1648}}, + FirstLine: 1640, Super: "", }, }, @@ -4842,8 +4878,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1656}, {PC: 24, Line: 1669}, {PC: 34, Line: 1671}, {PC: 36, Line: 1675}, {PC: 38, Line: 1679}, {PC: 42, Line: 1681}, {PC: 44, Line: 1689}, {PC: 46, Line: 1698}, {PC: 48, Line: 1702}, {PC: 50, Line: 1703}, {PC: 52, Line: 1705}}, + FirstLine: 1655, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in ", @@ -4856,8 +4892,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1609}}, - FirstLine: 1609, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1657}}, + FirstLine: 1657, Super: "", }, &bytecode.ISeq{ @@ -4871,8 +4907,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1610}}, - FirstLine: 1610, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1658}}, + FirstLine: 1658, Super: "", }, &bytecode.ISeq{ @@ -4886,8 +4922,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1611}}, - FirstLine: 1611, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1659}}, + FirstLine: 1659, Super: "", }, &bytecode.ISeq{ @@ -4901,8 +4937,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1612}}, - FirstLine: 1612, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1660}}, + FirstLine: 1660, Super: "", }, &bytecode.ISeq{ @@ -4916,8 +4952,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1613}}, - FirstLine: 1613, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1661}}, + FirstLine: 1661, Super: "", }, &bytecode.ISeq{ @@ -4931,8 +4967,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1614}}, - FirstLine: 1614, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1662}}, + FirstLine: 1662, Super: "", }, &bytecode.ISeq{ @@ -4947,8 +4983,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1615}}, - FirstLine: 1615, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1663}}, + FirstLine: 1663, Super: "", }, &bytecode.ISeq{ @@ -4963,8 +4999,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"input"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1624}}, - FirstLine: 1623, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1672}}, + FirstLine: 1671, Super: "", }, &bytecode.ISeq{ @@ -4980,8 +5016,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1628}}, - FirstLine: 1627, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1676}}, + FirstLine: 1675, Super: "", }, &bytecode.ISeq{ @@ -4999,8 +5035,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"reqs"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1634}, {PC: 4, Line: 1635}, {PC: 13, Line: 1636}}, - FirstLine: 1633, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1682}, {PC: 4, Line: 1683}, {PC: 13, Line: 1684}}, + FirstLine: 1681, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in initialize", @@ -5015,7 +5051,7 @@ func embeddedPrelude() *bytecode.ISeq { NumLocals: 1, Locals: []string{"r"}, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 1636, + FirstLine: 1684, Super: "", }, }, @@ -5040,8 +5076,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"obj", "m", "op"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1642}, {PC: 11, Line: 1643}, {PC: 17, Line: 1644}, {PC: 32, Line: 1645}, {PC: 41, Line: 1646}}, - FirstLine: 1641, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1690}, {PC: 11, Line: 1691}, {PC: 17, Line: 1692}, {PC: 32, Line: 1693}, {PC: 41, Line: 1694}}, + FirstLine: 1689, Super: "", }, &bytecode.ISeq{ @@ -5056,8 +5092,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"version"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1651}, {PC: 5, Line: 1652}}, - FirstLine: 1650, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1699}, {PC: 5, Line: 1700}}, + FirstLine: 1698, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in satisfied_by?", @@ -5071,8 +5107,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"op", "req"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1652}}, - FirstLine: 1652, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1700}}, + FirstLine: 1700, Super: "", }, }, @@ -5091,8 +5127,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1658}}, - FirstLine: 1657, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1706}}, + FirstLine: 1705, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in to_s", @@ -5109,8 +5145,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"op", "req"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1658}}, - FirstLine: 1658, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1706}}, + FirstLine: 1706, Super: "", }, }, @@ -5129,8 +5165,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1665}}, - FirstLine: 1664, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1713}}, + FirstLine: 1712, Super: "", }, &bytecode.ISeq{ @@ -5142,8 +5178,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1669}}, - FirstLine: 1668, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1717}}, + FirstLine: 1716, Super: "", }, &bytecode.ISeq{ @@ -5155,8 +5191,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1674}}, - FirstLine: 1674, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1722}}, + FirstLine: 1722, Super: "", }, &bytecode.ISeq{ @@ -5169,8 +5205,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1679}}, - FirstLine: 1678, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1727}}, + FirstLine: 1726, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "stubs", @@ -5181,8 +5217,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1680}}, - FirstLine: 1679, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1728}}, + FirstLine: 1727, Super: "", }, }, @@ -5201,8 +5237,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1748}, {PC: 2, Line: 1755}, {PC: 4, Line: 1759}, {PC: 6, Line: 1763}, {PC: 8, Line: 1767}, {PC: 10, Line: 1773}, {PC: 12, Line: 1777}, {PC: 14, Line: 1781}, {PC: 16, Line: 1785}, {PC: 18, Line: 1790}, {PC: 20, Line: 1802}, {PC: 22, Line: 1805}, {PC: 24, Line: 1807}, {PC: 26, Line: 1811}, {PC: 28, Line: 1814}}, + FirstLine: 1747, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -5216,8 +5252,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"hash"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1748}, {PC: 2, Line: 259}, {PC: 5, Line: 1749}, {PC: 8, Line: 1750}, {PC: 10, Line: 1751}}, + FirstLine: 1748, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in initialize", @@ -5231,8 +5267,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"k", "v", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1703}}, - FirstLine: 1703, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1751}}, + FirstLine: 1751, Super: "", }, }, @@ -5250,8 +5286,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"name"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1708}}, - FirstLine: 1707, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1756}}, + FirstLine: 1755, Super: "", }, &bytecode.ISeq{ @@ -5266,8 +5302,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"name", "value", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1712}}, - FirstLine: 1711, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1760}}, + FirstLine: 1759, Super: "", }, &bytecode.ISeq{ @@ -5280,8 +5316,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1716}}, - FirstLine: 1715, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1764}}, + FirstLine: 1763, Super: "", }, &bytecode.ISeq{ @@ -5297,8 +5333,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1720}, {PC: 10, Line: 1721}, {PC: 13, Line: 109}}, - FirstLine: 1719, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1768}, {PC: 10, Line: 1769}, {PC: 13, Line: 109}}, + FirstLine: 1767, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in each_pair", @@ -5311,8 +5347,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"k", "v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1721}}, - FirstLine: 1721, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1769}}, + FirstLine: 1769, Super: "", }, }, @@ -5328,8 +5364,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1726}}, - FirstLine: 1725, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1774}}, + FirstLine: 1773, Super: "", }, &bytecode.ISeq{ @@ -5344,8 +5380,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"names"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1730}}, - FirstLine: 1729, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1778}}, + FirstLine: 1777, Super: "", }, &bytecode.ISeq{ @@ -5360,8 +5396,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"name"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1734}}, - FirstLine: 1733, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1782}}, + FirstLine: 1781, Super: "", }, &bytecode.ISeq{ @@ -5379,8 +5415,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"name", "include_private", "n"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1737}, {PC: 5, Line: 1738}, {PC: 9, Line: 1739}}, - FirstLine: 1737, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1785}, {PC: 5, Line: 1786}, {PC: 9, Line: 1787}}, + FirstLine: 1785, Super: "", }, &bytecode.ISeq{ @@ -5403,8 +5439,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 4, Locals: []string{"name", "args", "n", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1743}, {PC: 4, Line: 1744}, {PC: 8, Line: 1745}, {PC: 26, Line: 1746}, {PC: 44, Line: 1748}, {PC: 48, Line: 1750}}, - FirstLine: 1742, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1791}, {PC: 4, Line: 1792}, {PC: 8, Line: 1793}, {PC: 26, Line: 1794}, {PC: 44, Line: 1796}, {PC: 48, Line: 1798}}, + FirstLine: 1790, Super: "", }, &bytecode.ISeq{ @@ -5419,8 +5455,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1755}, {PC: 9, Line: 259}}, - FirstLine: 1754, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1803}, {PC: 9, Line: 259}}, + FirstLine: 1802, Super: "", }, &bytecode.ISeq{ @@ -5435,8 +5471,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"name", "include_private"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1759}, {PC: 5, Line: 1760}}, - FirstLine: 1759, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1807}, {PC: 5, Line: 1808}}, + FirstLine: 1807, Super: "", }, &bytecode.ISeq{ @@ -5449,8 +5485,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1764}}, - FirstLine: 1763, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1812}}, + FirstLine: 1811, Super: "", }, }, @@ -5466,8 +5502,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1781}, {PC: 2, Line: 1789}, {PC: 4, Line: 1792}, {PC: 6, Line: 1798}}, - FirstLine: 1778, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1829}, {PC: 2, Line: 1837}, {PC: 4, Line: 1840}, {PC: 6, Line: 1846}}, + FirstLine: 1826, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "def_delegator", @@ -5481,8 +5517,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"accessor", "method", "ali"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1781}, {PC: 5, Line: 1782}, {PC: 9, Line: 1783}, {PC: 13, Line: 1787}}, - FirstLine: 1781, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1829}, {PC: 5, Line: 1830}, {PC: 9, Line: 1831}, {PC: 13, Line: 1835}}, + FirstLine: 1829, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in def_delegator", @@ -5496,8 +5532,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 3, Locals: []string{"args", "block", "target"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1784}, {PC: 1, Line: 109}, {PC: 6, Line: 1785}}, - FirstLine: 1783, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1832}, {PC: 1, Line: 109}, {PC: 6, Line: 1833}}, + FirstLine: 1831, Super: "", }, }, @@ -5515,8 +5551,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"accessor", "methods"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1793}}, - FirstLine: 1792, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1841}}, + FirstLine: 1840, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in def_delegators", @@ -5530,8 +5566,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"m"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1793}}, - FirstLine: 1793, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1841}}, + FirstLine: 1841, Super: "", }, }, @@ -5552,8 +5588,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"obj", "accessor"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1799}, {PC: 4, Line: 1800}, {PC: 9, Line: 1802}}, - FirstLine: 1798, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1847}, {PC: 4, Line: 1848}, {PC: 9, Line: 1850}}, + FirstLine: 1846, Super: "", }, }, @@ -5569,8 +5605,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1810}, {PC: 2, Line: 1818}, {PC: 4, Line: 1820}}, - FirstLine: 1809, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1858}, {PC: 2, Line: 1866}, {PC: 4, Line: 1868}}, + FirstLine: 1857, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "def_single_delegator", @@ -5584,8 +5620,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"accessor", "method", "ali"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1810}, {PC: 5, Line: 1811}, {PC: 9, Line: 1812}, {PC: 13, Line: 1816}}, - FirstLine: 1810, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1858}, {PC: 5, Line: 1859}, {PC: 9, Line: 1860}, {PC: 13, Line: 1864}}, + FirstLine: 1858, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in def_single_delegator", @@ -5599,8 +5635,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 3, Locals: []string{"args", "block", "target"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1813}, {PC: 1, Line: 109}, {PC: 6, Line: 1814}}, - FirstLine: 1812, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1861}, {PC: 1, Line: 109}, {PC: 6, Line: 1862}}, + FirstLine: 1860, Super: "", }, }, @@ -5618,8 +5654,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"accessor", "methods"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1821}}, - FirstLine: 1820, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1869}}, + FirstLine: 1868, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in def_single_delegators", @@ -5633,8 +5669,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"m"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1821}}, - FirstLine: 1821, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1869}}, + FirstLine: 1869, Super: "", }, }, @@ -5653,8 +5689,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1878}, {PC: 2, Line: 1884}, {PC: 4, Line: 1893}, {PC: 6, Line: 1897}, {PC: 8, Line: 1901}, {PC: 10, Line: 1906}, {PC: 12, Line: 1910}}, + FirstLine: 1877, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -5668,8 +5704,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"obj"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1831}}, - FirstLine: 1830, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1879}}, + FirstLine: 1878, Super: "", }, &bytecode.ISeq{ @@ -5684,8 +5720,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 2, NumLocals: 4, Locals: []string{"name", "args", "block", "target"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1837}, {PC: 4, Line: 1838}, {PC: 8, Line: 1839}, {PC: 19, Line: 1841}}, - FirstLine: 1836, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1885}, {PC: 4, Line: 1886}, {PC: 8, Line: 1887}, {PC: 19, Line: 1889}}, + FirstLine: 1884, Super: "", }, &bytecode.ISeq{ @@ -5700,8 +5736,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"name", "include_private"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1845}, {PC: 5, Line: 1846}}, - FirstLine: 1845, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1893}, {PC: 5, Line: 1894}}, + FirstLine: 1893, Super: "", }, &bytecode.ISeq{ @@ -5716,8 +5752,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"name", "include_private"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1849}, {PC: 5, Line: 1850}}, - FirstLine: 1849, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1897}, {PC: 5, Line: 1898}}, + FirstLine: 1897, Super: "", }, &bytecode.ISeq{ @@ -5732,8 +5768,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1854}, {PC: 1, Line: 109}, {PC: 9, Line: 1855}}, - FirstLine: 1853, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1902}, {PC: 1, Line: 109}, {PC: 9, Line: 1903}}, + FirstLine: 1901, Super: "", }, &bytecode.ISeq{ @@ -5750,8 +5786,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1859}, {PC: 3, Line: 109}}, - FirstLine: 1858, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1907}, {PC: 3, Line: 109}}, + FirstLine: 1906, Super: "", }, &bytecode.ISeq{ @@ -5770,8 +5806,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"_obj"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1863}, {PC: 3, Line: 109}}, - FirstLine: 1862, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1911}, {PC: 3, Line: 109}}, + FirstLine: 1910, Super: "", }, }, @@ -5787,8 +5823,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1870}, {PC: 2, Line: 1874}}, - FirstLine: 1869, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1918}, {PC: 2, Line: 1922}}, + FirstLine: 1917, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "__getobj__", @@ -5800,8 +5836,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1871}}, - FirstLine: 1870, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1919}}, + FirstLine: 1918, Super: "", }, &bytecode.ISeq{ @@ -5816,8 +5852,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"obj"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1875}}, - FirstLine: 1874, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1923}}, + FirstLine: 1922, Super: "", }, }, @@ -5860,8 +5896,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"superclass", "klass", "skip"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1931}, {PC: 5, Line: 1932}, {PC: 8, Line: 1950}, {PC: 34, Line: 1957}, {PC: 38, Line: 1963}}, + FirstLine: 1930, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in DelegateClass", @@ -5873,8 +5909,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1885}, {PC: 2, Line: 1889}}, - FirstLine: 1884, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1933}, {PC: 2, Line: 1937}}, + FirstLine: 1932, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "__getobj__", @@ -5886,8 +5922,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1886}}, - FirstLine: 1885, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1934}}, + FirstLine: 1933, Super: "", }, &bytecode.ISeq{ @@ -5902,8 +5938,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"obj"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1890}}, - FirstLine: 1889, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1938}}, + FirstLine: 1937, Super: "", }, }, @@ -5924,8 +5960,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"m"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1910}, {PC: 9, Line: 1911}}, - FirstLine: 1909, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1958}, {PC: 9, Line: 1959}}, + FirstLine: 1957, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in DelegateClass", @@ -5939,8 +5975,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"args", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1912}}, - FirstLine: 1911, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1960}}, + FirstLine: 1959, Super: "", }, }, @@ -5962,8 +5998,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - 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: 2002}, {PC: 37, Line: 2004}, {PC: 39, Line: 2012}, {PC: 41, Line: 2016}, {PC: 43, Line: 2019}, {PC: 45, Line: 2021}, {PC: 47, Line: 2025}, {PC: 49, Line: 2029}, {PC: 51, Line: 2036}, {PC: 53, Line: 2042}, {PC: 55, Line: 2049}, {PC: 57, Line: 2053}, {PC: 59, Line: 2061}, {PC: 61, Line: 2070}, {PC: 63, Line: 2074}, {PC: 65, Line: 2078}, {PC: 67, Line: 2082}, {PC: 69, Line: 2086}, {PC: 71, Line: 2090}, {PC: 73, Line: 2094}}, - FirstLine: 1922, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1971}, {PC: 4, Line: 1972}, {PC: 7, Line: 1974}, {PC: 9, Line: 1980}, {PC: 11, Line: 1983}, {PC: 13, Line: 1985}, {PC: 15, Line: 1989}, {PC: 17, Line: 1993}, {PC: 19, Line: 1998}, {PC: 21, Line: 2001}, {PC: 23, Line: 2003}, {PC: 25, Line: 2008}, {PC: 27, Line: 2018}, {PC: 29, Line: 2022}, {PC: 31, Line: 2026}, {PC: 33, Line: 2033}, {PC: 35, Line: 2050}, {PC: 37, Line: 2052}, {PC: 39, Line: 2060}, {PC: 41, Line: 2064}, {PC: 43, Line: 2067}, {PC: 45, Line: 2069}, {PC: 47, Line: 2073}, {PC: 49, Line: 2077}, {PC: 51, Line: 2084}, {PC: 53, Line: 2090}, {PC: 55, Line: 2097}, {PC: 57, Line: 2101}, {PC: 59, Line: 2109}, {PC: 61, Line: 2118}, {PC: 63, Line: 2122}, {PC: 65, Line: 2126}, {PC: 67, Line: 2130}, {PC: 69, Line: 2134}, {PC: 71, Line: 2138}, {PC: 73, Line: 2142}}, + FirstLine: 1970, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -5980,8 +6016,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"path"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1927}, {PC: 10, Line: 1928}, {PC: 22, Line: 1929}}, - FirstLine: 1926, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1975}, {PC: 10, Line: 1976}, {PC: 22, Line: 1977}}, + FirstLine: 1974, Super: "", }, &bytecode.ISeq{ @@ -5994,8 +6030,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1933}}, - FirstLine: 1932, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1981}}, + FirstLine: 1980, Super: "", }, &bytecode.ISeq{ @@ -6012,8 +6048,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: 1986}}, + FirstLine: 1985, Super: "", }, &bytecode.ISeq{ @@ -6026,8 +6062,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1942}}, - FirstLine: 1941, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1990}}, + FirstLine: 1989, Super: "", }, &bytecode.ISeq{ @@ -6040,8 +6076,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1946}, {PC: 3, Line: 1947}}, - FirstLine: 1945, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1994}, {PC: 3, Line: 1995}}, + FirstLine: 1993, Super: "", }, &bytecode.ISeq{ @@ -6056,8 +6092,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1951}}, - FirstLine: 1950, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1999}}, + FirstLine: 1998, Super: "", }, &bytecode.ISeq{ @@ -6072,8 +6108,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1956}, {PC: 5, Line: 259}, {PC: 10, Line: 1957}}, - FirstLine: 1955, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2004}, {PC: 5, Line: 259}, {PC: 10, Line: 2005}}, + FirstLine: 2003, Super: "", }, &bytecode.ISeq{ @@ -6086,8 +6122,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1961}}, - FirstLine: 1960, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2009}}, + FirstLine: 2008, Super: "", }, &bytecode.ISeq{ @@ -6100,8 +6136,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1971}}, - FirstLine: 1970, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2019}}, + FirstLine: 2018, Super: "", }, &bytecode.ISeq{ @@ -6114,8 +6150,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1975}}, - FirstLine: 1974, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2023}}, + FirstLine: 2022, Super: "", }, &bytecode.ISeq{ @@ -6128,8 +6164,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1979}}, - FirstLine: 1978, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2027}}, + FirstLine: 2026, Super: "", }, &bytecode.ISeq{ @@ -6144,8 +6180,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1986}, {PC: 12, Line: 1987}}, - FirstLine: 1985, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2034}, {PC: 12, Line: 2035}}, + FirstLine: 2033, Super: "", }, &bytecode.ISeq{ @@ -6160,8 +6196,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"args", "result"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 3, Line: 2006}, {PC: 6, Line: 2007}}, - FirstLine: 2004, + Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 3, Line: 2054}, {PC: 6, Line: 2055}}, + FirstLine: 2052, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in join", @@ -6174,8 +6210,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"a"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2006}}, - FirstLine: 2006, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2054}}, + FirstLine: 2054, Super: "", }, }, @@ -6196,8 +6232,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"suffix"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2012}, {PC: 5, Line: 2013}}, - FirstLine: 2012, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2060}, {PC: 5, Line: 2061}}, + FirstLine: 2060, Super: "", }, &bytecode.ISeq{ @@ -6210,8 +6246,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: 2065}}, + FirstLine: 2064, Super: "", }, &bytecode.ISeq{ @@ -6224,8 +6260,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2022}}, - FirstLine: 2021, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2070}}, + FirstLine: 2069, Super: "", }, &bytecode.ISeq{ @@ -6238,8 +6274,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2026}}, - FirstLine: 2025, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2074}}, + FirstLine: 2073, Super: "", }, &bytecode.ISeq{ @@ -6255,8 +6291,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2030}, {PC: 10, Line: 2031}}, - FirstLine: 2029, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2078}, {PC: 10, Line: 2079}}, + FirstLine: 2077, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in each_filename", @@ -6269,8 +6305,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"f"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2031}}, - FirstLine: 2031, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2079}}, + FirstLine: 2079, Super: "", }, }, @@ -6289,8 +6325,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2037}, {PC: 10, Line: 2038}, {PC: 15, Line: 109}}, - FirstLine: 2036, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2085}, {PC: 10, Line: 2086}, {PC: 15, Line: 109}}, + FirstLine: 2084, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in ascend", @@ -6304,8 +6340,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"p"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2038}}, - FirstLine: 2038, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2086}}, + FirstLine: 2086, Super: "", }, }, @@ -6324,8 +6360,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2043}, {PC: 10, Line: 2044}, {PC: 15, Line: 109}}, - FirstLine: 2042, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2091}, {PC: 10, Line: 2092}, {PC: 15, Line: 109}}, + FirstLine: 2090, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in descend", @@ -6339,8 +6375,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"p"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2044}}, - FirstLine: 2044, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2092}}, + FirstLine: 2092, Super: "", }, }, @@ -6356,8 +6392,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: 2098}}, + FirstLine: 2097, Super: "", }, &bytecode.ISeq{ @@ -6372,8 +6408,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"repl"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2054}}, - FirstLine: 2053, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2102}}, + FirstLine: 2101, Super: "", }, &bytecode.ISeq{ @@ -6388,8 +6424,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"base_directory"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2062}, {PC: 12, Line: 2063}}, - FirstLine: 2061, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2110}, {PC: 12, Line: 2111}}, + FirstLine: 2109, Super: "", }, &bytecode.ISeq{ @@ -6404,8 +6440,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"args", "opts"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2071}}, - FirstLine: 2070, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2119}}, + FirstLine: 2118, Super: "", }, &bytecode.ISeq{ @@ -6420,8 +6456,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"content", "args", "opts"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2075}}, - FirstLine: 2074, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2123}}, + FirstLine: 2122, Super: "", }, &bytecode.ISeq{ @@ -6436,8 +6472,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"args", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2079}}, - FirstLine: 2078, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2127}}, + FirstLine: 2126, Super: "", }, &bytecode.ISeq{ @@ -6450,8 +6486,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2083}}, - FirstLine: 2082, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2131}}, + FirstLine: 2130, Super: "", }, &bytecode.ISeq{ @@ -6464,8 +6500,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2087}}, - FirstLine: 2086, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2135}}, + FirstLine: 2134, Super: "", }, &bytecode.ISeq{ @@ -6478,8 +6514,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2091}}, - FirstLine: 2090, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2139}}, + FirstLine: 2138, Super: "", }, &bytecode.ISeq{ @@ -6494,8 +6530,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"args", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2095}}, - FirstLine: 2094, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2143}}, + FirstLine: 2142, Super: "", }, }, @@ -6511,8 +6547,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2105}, {PC: 2, Line: 2116}}, - FirstLine: 2103, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2153}, {PC: 2, Line: 2164}}, + FirstLine: 2151, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -6524,8 +6560,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2108}}, - FirstLine: 2105, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2156}}, + FirstLine: 2153, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "instance", @@ -6537,8 +6573,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2109}}, - FirstLine: 2108, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2157}}, + FirstLine: 2156, Super: "", }, }, @@ -6560,8 +6596,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"klass"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2117}, {PC: 4, Line: 2118}}, - FirstLine: 2116, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2165}, {PC: 4, Line: 2166}}, + FirstLine: 2164, Super: "", }, }, @@ -6583,8 +6619,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2148}, {PC: 5, Line: 2149}, {PC: 10, Line: 2155}, {PC: 12, Line: 2168}, {PC: 14, Line: 2175}, {PC: 16, Line: 2184}, {PC: 18, Line: 2188}, {PC: 21, Line: 2192}}, - FirstLine: 2146, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2196}, {PC: 5, Line: 2197}, {PC: 10, Line: 2203}, {PC: 12, Line: 2216}, {PC: 14, Line: 2223}, {PC: 16, Line: 2232}, {PC: 18, Line: 2236}, {PC: 21, Line: 2240}}, + FirstLine: 2194, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -6605,8 +6641,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"str", "trim_mode", "eoutvar"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2155}, {PC: 2, Line: 259}, {PC: 13, Line: 2157}, {PC: 16, Line: 2158}, {PC: 19, Line: 2162}}, - FirstLine: 2155, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2203}, {PC: 2, Line: 259}, {PC: 13, Line: 2205}, {PC: 16, Line: 2206}, {PC: 19, Line: 2210}}, + FirstLine: 2203, Super: "", }, &bytecode.ISeq{ @@ -6624,8 +6660,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"b"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2168}, {PC: 6, Line: 2169}}, - FirstLine: 2168, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2216}, {PC: 6, Line: 2217}}, + FirstLine: 2216, Super: "", }, &bytecode.ISeq{ @@ -6640,8 +6676,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"hash", "b"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2176}, {PC: 4, Line: 2177}, {PC: 7, Line: 2180}}, - FirstLine: 2175, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2224}, {PC: 4, Line: 2225}, {PC: 7, Line: 2228}}, + FirstLine: 2223, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in result_with_hash", @@ -6655,8 +6691,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"key", "value"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2178}}, - FirstLine: 2177, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2226}}, + FirstLine: 2225, Super: "", }, }, @@ -6674,8 +6710,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"b"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2184}, {PC: 6, Line: 2185}}, - FirstLine: 2184, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2232}, {PC: 6, Line: 2233}}, + FirstLine: 2232, Super: "", }, &bytecode.ISeq{ @@ -6687,8 +6723,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2193}}, - FirstLine: 2192, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2241}}, + FirstLine: 2240, Super: "", }, }, @@ -6704,8 +6740,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2213}, {PC: 2, Line: 2282}}, - FirstLine: 2212, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2261}, {PC: 2, Line: 2330}}, + FirstLine: 2260, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -6717,8 +6753,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2216}, {PC: 2, Line: 2223}, {PC: 4, Line: 2230}, {PC: 6, Line: 2239}, {PC: 8, Line: 2252}}, - FirstLine: 2213, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2264}, {PC: 2, Line: 2271}, {PC: 4, Line: 2278}, {PC: 6, Line: 2287}, {PC: 8, Line: 2300}}, + FirstLine: 2261, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -6733,8 +6769,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2217}, {PC: 4, Line: 2218}}, - FirstLine: 2216, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2265}, {PC: 4, Line: 2266}}, + FirstLine: 2264, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -6748,8 +6784,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2219}}, - FirstLine: 2218, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2267}}, + FirstLine: 2266, Super: "", }, }, @@ -6767,8 +6803,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2224}}, - FirstLine: 2223, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2272}}, + FirstLine: 2271, Super: "", }, &bytecode.ISeq{ @@ -6795,8 +6831,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"s"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2231}}, - FirstLine: 2230, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2279}}, + FirstLine: 2278, Super: "", }, &bytecode.ISeq{ @@ -6818,8 +6854,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"name", "value"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2240}, {PC: 14, Line: 2241}, {PC: 19, Line: 1}, {PC: 27, Line: 2242}, {PC: 32, Line: 1}, {PC: 44, Line: 2244}, {PC: 45, Line: 1}}, - FirstLine: 2239, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2288}, {PC: 14, Line: 2289}, {PC: 19, Line: 1}, {PC: 27, Line: 2290}, {PC: 32, Line: 1}, {PC: 44, Line: 2292}, {PC: 45, Line: 1}}, + FirstLine: 2287, Super: "", }, &bytecode.ISeq{ @@ -6837,8 +6873,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 5, Locals: []string{"base", "splats", "merged", "add", "out"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2253}, {PC: 3, Line: 2254}, {PC: 7, Line: 2266}, {PC: 10, Line: 2267}, {PC: 13, Line: 2269}, {PC: 17, Line: 2270}, {PC: 22, Line: 2273}}, - FirstLine: 2252, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2301}, {PC: 3, Line: 2302}, {PC: 7, Line: 2314}, {PC: 10, Line: 2315}, {PC: 13, Line: 2317}, {PC: 17, Line: 2318}, {PC: 22, Line: 2321}}, + FirstLine: 2300, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in render_attributes", @@ -6857,8 +6893,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 7, Locals: []string{"k", "v", "existing", "val", "", "", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2255}, {PC: 4, Line: 2256}, {PC: 8, Line: 2257}, {PC: 13, Line: 2258}, {PC: 24, Line: 2259}, {PC: 42, Line: 2261}, {PC: 50, Line: 2263}}, - FirstLine: 2254, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2303}, {PC: 4, Line: 2304}, {PC: 8, Line: 2305}, {PC: 13, Line: 2306}, {PC: 24, Line: 2307}, {PC: 42, Line: 2309}, {PC: 50, Line: 2311}}, + FirstLine: 2302, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in render_attributes", @@ -6874,8 +6910,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2259}}, - FirstLine: 2259, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2307}}, + FirstLine: 2307, Super: "", }, }, @@ -6893,8 +6929,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"k", "v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2266}}, - FirstLine: 2266, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2314}}, + FirstLine: 2314, Super: "", }, &bytecode.ISeq{ @@ -6909,8 +6945,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"h"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2267}}, - FirstLine: 2267, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2315}}, + FirstLine: 2315, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in render_attributes", @@ -6924,8 +6960,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"k", "v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2267}}, - FirstLine: 2267, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2315}}, + FirstLine: 2315, Super: "", }, }, @@ -6943,8 +6979,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"k"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2271}}, - FirstLine: 2270, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2319}}, + FirstLine: 2318, Super: "", }, }, @@ -6966,8 +7002,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2283}, {PC: 4, Line: 2287}, {PC: 6, Line: 2296}}, - FirstLine: 2282, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2331}, {PC: 4, Line: 2335}, {PC: 6, Line: 2344}}, + FirstLine: 2330, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -6981,8 +7017,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"template", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2287}, {PC: 2, Line: 259}, {PC: 5, Line: 2288}, {PC: 18, Line: 2289}}, - FirstLine: 2287, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2335}, {PC: 2, Line: 259}, {PC: 5, Line: 2336}, {PC: 18, Line: 2337}}, + FirstLine: 2335, Super: "", }, &bytecode.ISeq{ @@ -7001,8 +7037,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"_scope", "locals", "b"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2296}, {PC: 11, Line: 2297}, {PC: 14, Line: 2298}, {PC: 17, Line: 2299}}, - FirstLine: 2296, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2344}, {PC: 11, Line: 2345}, {PC: 14, Line: 2346}, {PC: 17, Line: 2347}}, + FirstLine: 2344, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in render", @@ -7016,8 +7052,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"k", "v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2298}}, - FirstLine: 2298, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2346}}, + FirstLine: 2346, Super: "", }, }, @@ -7039,8 +7075,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2323}, {PC: 2, Line: 2336}, {PC: 4, Line: 2376}}, - FirstLine: 2322, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2371}, {PC: 2, Line: 2384}, {PC: 4, Line: 2424}}, + FirstLine: 2370, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -7052,8 +7088,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2326}}, - FirstLine: 2323, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2374}}, + FirstLine: 2371, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "escape_html", @@ -7079,8 +7115,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"s"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2327}}, - FirstLine: 2326, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2375}}, + FirstLine: 2374, Super: "", }, }, @@ -7116,8 +7152,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2337}, {PC: 22, Line: 2341}}, - FirstLine: 2336, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2385}, {PC: 22, Line: 2389}}, + FirstLine: 2384, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "render", @@ -7134,8 +7170,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"h", "pairs", "out"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2342}, {PC: 3, Line: 2343}, {PC: 6, Line: 2358}, {PC: 10, Line: 2359}, {PC: 15, Line: 2369}}, - FirstLine: 2341, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2390}, {PC: 3, Line: 2391}, {PC: 6, Line: 2406}, {PC: 10, Line: 2407}, {PC: 15, Line: 2417}}, + FirstLine: 2389, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in render", @@ -7156,8 +7192,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 7, Locals: []string{"k", "v", "existing", "merged", "", "", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2344}, {PC: 4, Line: 2345}, {PC: 14, Line: 2346}, {PC: 21, Line: 2348}, {PC: 26, Line: 2349}, {PC: 42, Line: 2350}, {PC: 54, Line: 2352}, {PC: 59, Line: 2353}, {PC: 72, Line: 2355}}, - FirstLine: 2343, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2392}, {PC: 4, Line: 2393}, {PC: 14, Line: 2394}, {PC: 21, Line: 2396}, {PC: 26, Line: 2397}, {PC: 42, Line: 2398}, {PC: 54, Line: 2400}, {PC: 59, Line: 2401}, {PC: 72, Line: 2403}}, + FirstLine: 2391, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in render", @@ -7175,8 +7211,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"dk", "dv", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2346}}, - FirstLine: 2346, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2394}}, + FirstLine: 2394, Super: "", }, }, @@ -7200,8 +7236,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"k", "v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2360}, {PC: 5, Line: 2361}, {PC: 9, Line: 2362}, {PC: 27, Line: 2364}, {PC: 35, Line: 2366}, {PC: 37, Line: 1}}, - FirstLine: 2359, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2408}, {PC: 5, Line: 2409}, {PC: 9, Line: 2410}, {PC: 27, Line: 2412}, {PC: 35, Line: 2414}, {PC: 37, Line: 1}}, + FirstLine: 2407, Super: "", }, }, @@ -7223,8 +7259,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2377}, {PC: 4, Line: 2381}, {PC: 6, Line: 2389}}, - FirstLine: 2376, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2425}, {PC: 4, Line: 2429}, {PC: 6, Line: 2437}}, + FirstLine: 2424, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -7238,8 +7274,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"template", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2381}, {PC: 2, Line: 259}, {PC: 5, Line: 2382}, {PC: 18, Line: 2383}}, - FirstLine: 2381, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2429}, {PC: 2, Line: 259}, {PC: 5, Line: 2430}, {PC: 18, Line: 2431}}, + FirstLine: 2429, Super: "", }, &bytecode.ISeq{ @@ -7258,8 +7294,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"_scope", "locals", "b"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2389}, {PC: 11, Line: 2390}, {PC: 14, Line: 2391}, {PC: 17, Line: 2392}}, - FirstLine: 2389, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2437}, {PC: 11, Line: 2438}, {PC: 14, Line: 2439}, {PC: 17, Line: 2440}}, + FirstLine: 2437, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in render", @@ -7273,8 +7309,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"k", "v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2391}}, - FirstLine: 2391, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2439}}, + FirstLine: 2439, Super: "", }, }, @@ -7307,8 +7343,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2425}, {PC: 2, Line: 2446}, {PC: 4, Line: 2449}, {PC: 6, Line: 2452}, {PC: 8, Line: 2455}, {PC: 10, Line: 2458}, {PC: 12, Line: 2461}, {PC: 14, Line: 2465}}, - FirstLine: 2424, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2473}, {PC: 2, Line: 2494}, {PC: 4, Line: 2497}, {PC: 6, Line: 2500}, {PC: 8, Line: 2503}, {PC: 10, Line: 2506}, {PC: 12, Line: 2509}, {PC: 14, Line: 2513}}, + FirstLine: 2472, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -7323,8 +7359,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2426}, {PC: 4, Line: 2427}, {PC: 6, Line: 2434}, {PC: 8, Line: 2435}, {PC: 10, Line: 2436}, {PC: 12, Line: 2439}, {PC: 14, Line: 2440}}, - FirstLine: 2425, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2474}, {PC: 4, Line: 2475}, {PC: 6, Line: 2482}, {PC: 8, Line: 2483}, {PC: 10, Line: 2484}, {PC: 12, Line: 2487}, {PC: 14, Line: 2488}}, + FirstLine: 2473, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -7342,8 +7378,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"args"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2428}, {PC: 3, Line: 2432}}, - FirstLine: 2427, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2476}, {PC: 3, Line: 2480}}, + FirstLine: 2475, Super: "", }, &bytecode.ISeq{ @@ -7358,8 +7394,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2434}}, - FirstLine: 2434, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2482}}, + FirstLine: 2482, Super: "", }, &bytecode.ISeq{ @@ -7373,7 +7409,7 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 0, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 2435, + FirstLine: 2483, Super: "", }, &bytecode.ISeq{ @@ -7390,8 +7426,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2437}}, - FirstLine: 2436, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2485}}, + FirstLine: 2484, Super: "", }, &bytecode.ISeq{ @@ -7409,8 +7445,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"argv", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2441}, {PC: 9, Line: 2442}}, - FirstLine: 2440, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2489}, {PC: 9, Line: 2490}}, + FirstLine: 2488, Super: "", }, }, @@ -7426,8 +7462,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2447}}, - FirstLine: 2446, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2495}}, + FirstLine: 2494, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "reason", @@ -7441,8 +7477,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2447}}, - FirstLine: 2447, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2495}}, + FirstLine: 2495, Super: "", }, }, @@ -7458,8 +7494,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2450}}, - FirstLine: 2449, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2498}}, + FirstLine: 2497, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "reason", @@ -7473,8 +7509,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2450}}, - FirstLine: 2450, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2498}}, + FirstLine: 2498, Super: "", }, }, @@ -7490,8 +7526,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2453}}, - FirstLine: 2452, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2501}}, + FirstLine: 2500, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "reason", @@ -7505,8 +7541,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2453}}, - FirstLine: 2453, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2501}}, + FirstLine: 2501, Super: "", }, }, @@ -7522,8 +7558,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2456}}, - FirstLine: 2455, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2504}}, + FirstLine: 2503, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "reason", @@ -7537,8 +7573,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2456}}, - FirstLine: 2456, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2504}}, + FirstLine: 2504, Super: "", }, }, @@ -7554,8 +7590,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2459}}, - FirstLine: 2458, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2507}}, + FirstLine: 2506, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "reason", @@ -7569,8 +7605,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2459}}, - FirstLine: 2459, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2507}}, + FirstLine: 2507, Super: "", }, }, @@ -7586,8 +7622,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2462}}, - FirstLine: 2461, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2510}}, + FirstLine: 2509, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "reason", @@ -7601,8 +7637,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2462}}, - FirstLine: 2462, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2510}}, + FirstLine: 2510, Super: "", }, }, @@ -7624,8 +7660,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2482}, {PC: 4, Line: 2484}, {PC: 6, Line: 2505}, {PC: 8, Line: 2536}, {PC: 10, Line: 2542}, {PC: 12, Line: 2551}, {PC: 14, Line: 2566}, {PC: 16, Line: 2573}, {PC: 18, Line: 2577}, {PC: 20, Line: 2584}, {PC: 22, Line: 2586}, {PC: 24, Line: 2590}, {PC: 26, Line: 2594}}, - FirstLine: 2481, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2530}, {PC: 4, Line: 2532}, {PC: 6, Line: 2553}, {PC: 8, Line: 2584}, {PC: 10, Line: 2590}, {PC: 12, Line: 2599}, {PC: 14, Line: 2614}, {PC: 16, Line: 2621}, {PC: 18, Line: 2625}, {PC: 20, Line: 2632}, {PC: 22, Line: 2634}, {PC: 24, Line: 2638}, {PC: 26, Line: 2642}}, + FirstLine: 2529, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "counter", @@ -7641,8 +7677,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2485}}, - FirstLine: 2484, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2533}}, + FirstLine: 2532, Super: "", }, &bytecode.ISeq{ @@ -7667,8 +7703,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: 2505}, {PC: 7, Line: 259}, {PC: 15, Line: 2506}, {PC: 19, Line: 2507}, {PC: 36, Line: 2508}, {PC: 44, Line: 259}, {PC: 47, Line: 2510}, {PC: 50, Line: 2518}, {PC: 62, Line: 2519}, {PC: 65, Line: 2520}, {PC: 68, Line: 2521}, {PC: 76, Line: 2522}, {PC: 92, Line: 2523}, {PC: 94, Line: 2524}, {PC: 95, Line: 109}, {PC: 98, Line: 2527}, {PC: 101, Line: 2528}, {PC: 105, Line: 2527}, {PC: 108, Line: 2528}}, - FirstLine: 2505, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2553}, {PC: 7, Line: 259}, {PC: 15, Line: 2554}, {PC: 19, Line: 2555}, {PC: 36, Line: 2556}, {PC: 44, Line: 259}, {PC: 47, Line: 2558}, {PC: 50, Line: 2566}, {PC: 62, Line: 2567}, {PC: 65, Line: 2568}, {PC: 68, Line: 2569}, {PC: 76, Line: 2570}, {PC: 92, Line: 2571}, {PC: 94, Line: 2572}, {PC: 95, Line: 109}, {PC: 98, Line: 2575}, {PC: 101, Line: 2576}, {PC: 105, Line: 2575}, {PC: 108, Line: 2576}}, + FirstLine: 2553, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in initialize", @@ -7687,8 +7723,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"name", "candidate"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2511}, {PC: 25, Line: 2512}, {PC: 31, Line: 2513}, {PC: 36, Line: 2514}, {PC: 39, Line: 2515}}, - FirstLine: 2510, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2559}, {PC: 25, Line: 2560}, {PC: 31, Line: 2561}, {PC: 36, Line: 2562}, {PC: 39, Line: 2563}}, + FirstLine: 2558, Super: "", }, &bytecode.ISeq{ @@ -7706,8 +7742,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"k", "v", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2520}}, - FirstLine: 2520, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2568}}, + FirstLine: 2568, Super: "", }, }, @@ -7726,8 +7762,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2537}, {PC: 16, Line: 2538}, {PC: 19, Line: 2539}}, - FirstLine: 2536, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2585}, {PC: 16, Line: 2586}, {PC: 19, Line: 2587}}, + FirstLine: 2584, Super: "", }, &bytecode.ISeq{ @@ -7742,8 +7778,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"args", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2543}}, - FirstLine: 2542, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2591}}, + FirstLine: 2590, Super: "", }, &bytecode.ISeq{ @@ -7761,8 +7797,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 5, Locals: []string{"basename", "tmpdir", "opts", "fwd", "t"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2551}, {PC: 7, Line: 259}, {PC: 10, Line: 2552}, {PC: 13, Line: 2553}, {PC: 16, Line: 2554}, {PC: 32, Line: 2555}, {PC: 34, Line: 2556}, {PC: 35, Line: 2557}, {PC: 39, Line: 2559}, {PC: 42, Line: 2560}, {PC: 46, Line: 2559}, {PC: 49, Line: 2560}, {PC: 56, Line: 2563}}, - FirstLine: 2551, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2599}, {PC: 7, Line: 259}, {PC: 10, Line: 2600}, {PC: 13, Line: 2601}, {PC: 16, Line: 2602}, {PC: 32, Line: 2603}, {PC: 34, Line: 2604}, {PC: 35, Line: 2605}, {PC: 39, Line: 2607}, {PC: 42, Line: 2608}, {PC: 46, Line: 2607}, {PC: 49, Line: 2608}, {PC: 56, Line: 2611}}, + FirstLine: 2599, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in create", @@ -7779,8 +7815,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"k", "v", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2553}}, - FirstLine: 2553, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2601}}, + FirstLine: 2601, Super: "", }, }, @@ -7798,8 +7834,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"unlink_now"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2566}, {PC: 5, Line: 2567}, {PC: 17, Line: 2568}, {PC: 20, Line: 2569}, {PC: 27, Line: 259}}, - FirstLine: 2566, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2614}, {PC: 5, Line: 2615}, {PC: 17, Line: 2616}, {PC: 20, Line: 2617}, {PC: 27, Line: 259}}, + FirstLine: 2614, Super: "", }, &bytecode.ISeq{ @@ -7812,8 +7848,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2574}}, - FirstLine: 2573, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2622}}, + FirstLine: 2621, Super: "", }, &bytecode.ISeq{ @@ -7826,8 +7862,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2578}, {PC: 8, Line: 2579}, {PC: 14, Line: 259}}, - FirstLine: 2577, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2626}, {PC: 8, Line: 2627}, {PC: 14, Line: 259}}, + FirstLine: 2625, Super: "", }, &bytecode.ISeq{ @@ -7845,8 +7881,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"mode"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2587}}, - FirstLine: 2586, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2635}}, + FirstLine: 2634, Super: "", }, &bytecode.ISeq{ @@ -7861,8 +7897,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"name", "include_private"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2590}, {PC: 5, Line: 2591}}, - FirstLine: 2590, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2638}, {PC: 5, Line: 2639}}, + FirstLine: 2638, Super: "", }, &bytecode.ISeq{ @@ -7877,8 +7913,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 2, NumLocals: 3, Locals: []string{"name", "args", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2595}, {PC: 8, Line: 2596}, {PC: 19, Line: 2598}}, - FirstLine: 2594, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2643}, {PC: 8, Line: 2644}, {PC: 19, Line: 2646}}, + FirstLine: 2642, Super: "", }, }, @@ -7900,8 +7936,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2607}, {PC: 11, Line: 109}, {PC: 14, Line: 2647}, {PC: 16, Line: 2651}, {PC: 17, Line: 109}}, - FirstLine: 2606, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2655}, {PC: 11, Line: 109}, {PC: 14, Line: 2695}, {PC: 16, Line: 2699}, {PC: 17, Line: 109}}, + FirstLine: 2654, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -7913,8 +7949,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2617}, {PC: 2, Line: 2629}, {PC: 4, Line: 2640}}, - FirstLine: 2614, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2665}, {PC: 2, Line: 2677}, {PC: 4, Line: 2688}}, + FirstLine: 2662, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "[]", @@ -7934,8 +7970,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"category"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2618}, {PC: 5, Line: 2619}, {PC: 17, Line: 2621}, {PC: 22, Line: 2622}, {PC: 33, Line: 2624}}, - FirstLine: 2617, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2666}, {PC: 5, Line: 2667}, {PC: 17, Line: 2669}, {PC: 22, Line: 2670}, {PC: 33, Line: 2672}}, + FirstLine: 2665, Super: "", }, &bytecode.ISeq{ @@ -7956,8 +7992,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"category", "flag", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2630}, {PC: 5, Line: 2631}, {PC: 17, Line: 2633}, {PC: 22, Line: 2634}, {PC: 33, Line: 2636}}, - FirstLine: 2629, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2678}, {PC: 5, Line: 2679}, {PC: 17, Line: 2681}, {PC: 22, Line: 2682}, {PC: 33, Line: 2684}}, + FirstLine: 2677, Super: "", }, &bytecode.ISeq{ @@ -7970,8 +8006,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2641}}, - FirstLine: 2640, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2689}}, + FirstLine: 2688, Super: "", }, }, @@ -7991,8 +8027,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"message", "category"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2647}, {PC: 2, Line: 259}, {PC: 5, Line: 2648}, {PC: 9, Line: 259}}, - FirstLine: 2647, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2695}, {PC: 2, Line: 259}, {PC: 5, Line: 2696}, {PC: 9, Line: 259}}, + FirstLine: 2695, Super: "", }, }, @@ -8008,8 +8044,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2665}}, - FirstLine: 2664, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2713}}, + FirstLine: 2712, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "!~", @@ -8024,7 +8060,7 @@ func embeddedPrelude() *bytecode.ISeq { NumLocals: 1, Locals: []string{"other"}, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 2665, + FirstLine: 2713, Super: "", }, },