diff --git a/internal/vm/crash_hardening_test.go b/internal/vm/crash_hardening_test.go index 4a07e7d1..21d8ecc2 100644 --- a/internal/vm/crash_hardening_test.go +++ b/internal/vm/crash_hardening_test.go @@ -112,6 +112,52 @@ func TestRecursiveStructureInspect(t *testing.T) { } } +// ⛔ `(1..).to_set` DID NOT CRASH — IT NEVER CAME BACK, which is worse. +// +// Measured on main: `rbgo -e '(1..).to_set'` had to be killed (`timeout 6` → +// exit 124). Enumerable#to_set enumerated the endless range forever, allocating +// as it went. One expression from any untrusted Ruby an embedding host +// evaluates, and the host is gone — and unlike a stack overflow there is +// nothing to recover from, because nothing faults. +// +// Every other member of the family was already guarded (`to_a`, `last`, `max`, +// `size`), which is how this one hid: `Range#to_set` is new in Ruby 4.0, so +// there was no 3.4-era guard to copy, and its spec sits behind a +// `ruby_version_is "4.0"` block the gate cannot reach at 3.4.1. The sweep +// recorded `core/range/to_set_spec.rb` as "failed to load" — it had not failed, +// the per-file TIMEOUT had killed it. +// +// The message is MRI's, character for character (range.c at v4.0.9, +// `range_to_set`), and core/range/to_set_spec.rb:22 asserts it. +// +// There is no timeout in this test and there does not need to be one: if the +// guard goes away, `go test` hangs here instead of failing, which is itself the +// signal — and the four rows below it are what keep the guard from being +// "fixed" into refusing a bounded range. +func TestEndlessRangeToSetRaisesInsteadOfHanging(t *testing.T) { + cases := []struct{ src, want string }{ + {`begin; (1..).to_set; rescue => e; puts "#{e.class}: #{e.message}"; end`, + "RangeError: cannot convert endless range to a set\n"}, + {`begin; (1...).to_set; rescue => e; puts "#{e.class}: #{e.message}"; end`, + "RangeError: cannot convert endless range to a set\n"}, + + // Bounded ranges are untouched, with and without a block. + {`p (1..4).to_set`, "Set[1, 2, 3, 4]\n"}, + {`p (1...4).to_set`, "Set[1, 2, 3]\n"}, + {`p (1..3).to_set { |x| x * x }`, "Set[1, 4, 9]\n"}, + + // A beginless range still fails the way it did, from the iteration + // rather than from this guard: the check is on `end`, not on either end. + {`begin; (..0).to_set; rescue => e; puts "#{e.class}: #{e.message}"; end`, + "TypeError: can't iterate from NilClass\n"}, + } + for _, c := range cases { + if got := eval(t, c.src); got != c.want { + t.Errorf("src=%q\n got=%q\nwant=%q", c.src, got, c.want) + } + } +} + // ⛔ THE FIVE TYPES THE TEST ABOVE DID NOT COVER, each of which killed the // process. // diff --git a/internal/vm/prelude.rb b/internal/vm/prelude.rb index 1c1eaa48..585da1ff 100644 --- a/internal/vm/prelude.rb +++ b/internal/vm/prelude.rb @@ -1107,6 +1107,44 @@ def rfind(ifnone = nil) class Range include Enumerable + # ⛔ to_set REFUSES AN ENDLESS RANGE, because otherwise it hangs. + # + # `(1..).to_set` enumerated forever through Enumerable#to_set, allocating as + # it went: measured on main, `rbgo -e '(1..).to_set'` had to be killed + # (`timeout 6` → exit 124). One expression, from any untrusted Ruby an + # embedding host evaluates, and the host never comes back — the same threat + # model as the repr recursion fixed in #852, and worse, because there is no + # stack to overflow and so nothing to recover from. + # + # Every OTHER member of this family was already guarded, which is how this one + # hid: `(1..).to_a` raises "cannot convert endless range to an array", + # `(1..).last` and `(1..).max` each raise, `(1..).size` answers Infinity. + # `Range#to_set` is **new in Ruby 4.0**, so there was no 3.4-era guard to copy + # — and its spec sits behind a `ruby_version_is "4.0"` block, so the gate + # cannot see it while the shim resolves at 3.4.1 (#799). The sweep recorded the + # file as "failed to load"; it had not failed, it had been killed by the + # per-file TIMEOUT. + # + # MRI's own, range.c at v4.0.9: + # + # static VALUE + # range_to_set(int argc, VALUE *argv, VALUE range) + # { + # if (NIL_P(RANGE_END(range))) { + # rb_raise(rb_eRangeError, "cannot convert endless range to a set"); + # } + # return rb_call_super(argc, argv); + # } + # + # The message is asserted character for character by + # core/range/to_set_spec.rb:22. Unconditional rather than version-gated: no + # spec asserts the old behaviour — nothing can assert a hang — so the only + # thing a version gate would preserve is the way to wedge the interpreter. + def to_set(klass = Set, *args, &block) + raise RangeError, "cannot convert endless range to a set" if self.end.nil? + super + end + # Range#== is true when other is a Range (or subclass) with == begin, == end # and the same exclude_end? flag, dispatching #== on the endpoints so that # custom Comparable endpoints and Range subclasses compare by value (MRI's diff --git a/internal/vm/prelude_frozen_gen.go b/internal/vm/prelude_frozen_gen.go index 73e3693d..f1820d94 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: 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}}, + 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: 1178}, {PC: 20, Line: 1193}, {PC: 22, Line: 1565}, {PC: 24, Line: 1785}, {PC: 26, Line: 1864}, {PC: 28, Line: 1895}, {PC: 30, Line: 1915}, {PC: 32, Line: 1955}, {PC: 34, Line: 1968}, {PC: 36, Line: 2008}, {PC: 38, Line: 2189}, {PC: 40, Line: 2231}, {PC: 42, Line: 2232}, {PC: 46, Line: 2297}, {PC: 48, Line: 2298}, {PC: 52, Line: 2407}, {PC: 54, Line: 2408}, {PC: 58, Line: 2509}, {PC: 60, Line: 2510}, {PC: 64, Line: 2567}, {PC: 66, Line: 2692}, {PC: 68, Line: 2750}}, FirstLine: 1, Children: []*bytecode.ISeq{ &bytecode.ISeq{ @@ -3128,17 +3128,36 @@ 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: 9}, {Op: 44, A: 3, B: 1}, {Op: 9}, {Op: 44, A: 4, B: 2}, {Op: 53}}, - Names: []string{"Enumerable", "include", "==", "eql?", "hash"}, + Insns: []bytecode.Instr{{Op: 5}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 2}, {Op: 9}, {Op: 44, A: 2}, {Op: 9}, {Op: 44, A: 3, B: 1}, {Op: 9}, {Op: 44, A: 4, B: 2}, {Op: 9}, {Op: 44, A: 5, B: 3}, {Op: 53}}, + Names: []string{"Enumerable", "include", "to_set", "==", "eql?", "hash"}, NumRequired: 0, SplatIndex: -1, PostCount: 0, KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1108}, {PC: 4, Line: 1115}, {PC: 6, Line: 1122}, {PC: 8, Line: 1132}}, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1108}, {PC: 4, Line: 1143}, {PC: 6, Line: 1153}, {PC: 8, Line: 1160}, {PC: 10, Line: 1170}}, FirstLine: 1107, Children: []*bytecode.ISeq{ + &bytecode.ISeq{ + Name: "to_set", + Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 5}, {Op: 33}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 30, A: 1}, {Op: 30, A: 2, Flags: 1}, {Op: 28, A: 14}, {Op: 5}, {Op: 33, A: 3}, {Op: 1}, {Op: 30, A: 4, B: 2, Flags: 2}, {Op: 26, A: 15}, {Op: 2}, {Op: 9}, {Op: 47, B: 1}, {Op: 53}}, + Consts: []object.Value{ + object.FString("cannot convert endless range to a set", ""), + }, + Names: []string{"Set", "end", "nil?", "RangeError", "raise"}, + Params: []string{"klass", "args"}, + NumRequired: 0, + SplatIndex: 1, + PostCount: 0, + KwRestSlot: -1, + BlockSlot: 2, + NumLocals: 3, + Locals: []string{"klass", "args", "block"}, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1143}, {PC: 5, Line: 109}, {PC: 16, Line: 1145}}, + FirstLine: 1143, + Super: "", + }, &bytecode.ISeq{ Name: "==", Insns: []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 28, A: 7}, {Op: 3}, {Op: 53}, {Op: 26, A: 8}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 33, A: 1}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 25}, {Op: 28, A: 17}, {Op: 4}, {Op: 53}, {Op: 26, A: 18}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 3}, {Op: 11}, {Op: 30, A: 3, Flags: 1}, {Op: 22}, {Op: 10}, {Op: 28, A: 32}, {Op: 9}, {Op: 5}, {Op: 30, A: 4}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 22}, {Op: 10}, {Op: 28, A: 40}, {Op: 9}, {Op: 5}, {Op: 30, A: 5}, {Op: 11}, {Op: 30, A: 5, Flags: 1}, {Op: 22}, {Op: 53}}, @@ -3151,8 +3170,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1116}, {PC: 9, Line: 1117}, {PC: 19, Line: 109}}, - FirstLine: 1115, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1154}, {PC: 9, Line: 1155}, {PC: 19, Line: 109}}, + FirstLine: 1153, Super: "", }, &bytecode.ISeq{ @@ -3167,8 +3186,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1123}, {PC: 9, Line: 1124}, {PC: 19, Line: 109}}, - FirstLine: 1122, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1161}, {PC: 9, Line: 1162}, {PC: 19, Line: 109}}, + FirstLine: 1160, Super: "", }, &bytecode.ISeq{ @@ -3182,7 +3201,7 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 0, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 1132, + FirstLine: 1170, Super: "", }, }, @@ -3198,8 +3217,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1141}, {PC: 4, Line: 1144}}, - FirstLine: 1140, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1179}, {PC: 4, Line: 1182}}, + FirstLine: 1178, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "deconstruct_keys", @@ -3213,7 +3232,7 @@ func embeddedPrelude() *bytecode.ISeq { NumLocals: 1, Locals: []string{"keys"}, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 1144, + FirstLine: 1182, Super: "", }, }, @@ -3235,8 +3254,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1194}, {PC: 4, Line: 1200}, {PC: 6, Line: 1209}, {PC: 10, Line: 1213}, {PC: 12, Line: 1221}, {PC: 16, Line: 1225}, {PC: 18, Line: 1231}, {PC: 20, Line: 1237}, {PC: 22, Line: 1241}, {PC: 24, Line: 1247}, {PC: 26, Line: 1252}, {PC: 28, Line: 1253}, {PC: 30, Line: 1257}, {PC: 32, Line: 1262}, {PC: 34, Line: 1266}, {PC: 36, Line: 1271}, {PC: 38, Line: 1275}, {PC: 40, Line: 1282}, {PC: 42, Line: 1288}, {PC: 44, Line: 1296}, {PC: 46, Line: 1310}, {PC: 48, Line: 1318}, {PC: 50, Line: 1323}, {PC: 52, Line: 1326}, {PC: 54, Line: 1331}, {PC: 56, Line: 1334}, {PC: 58, Line: 1339}, {PC: 60, Line: 1342}, {PC: 62, Line: 1347}, {PC: 64, Line: 1351}, {PC: 66, Line: 1362}, {PC: 68, Line: 1371}, {PC: 70, Line: 1375}, {PC: 72, Line: 1381}, {PC: 74, Line: 1389}, {PC: 76, Line: 1395}, {PC: 78, Line: 1401}, {PC: 80, Line: 1409}, {PC: 82, Line: 1415}, {PC: 84, Line: 1417}, {PC: 86, Line: 1426}, {PC: 88, Line: 1433}, {PC: 90, Line: 1437}, {PC: 92, Line: 1451}, {PC: 94, Line: 1460}, {PC: 96, Line: 1504}, {PC: 100, Line: 1510}, {PC: 102, Line: 1514}, {PC: 104, Line: 1525}, {PC: 106, Line: 1538}, {PC: 110, Line: 1541}, {PC: 112, Line: 1546}}, + FirstLine: 1193, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "__do_with_enum", @@ -3255,8 +3274,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"enum", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1163}, {PC: 4, Line: 1164}, {PC: 12, Line: 1166}, {PC: 16, Line: 1168}}, - FirstLine: 1162, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1201}, {PC: 4, Line: 1202}, {PC: 12, Line: 1204}, {PC: 16, Line: 1206}}, + FirstLine: 1200, Super: "", }, &bytecode.ISeq{ @@ -3271,8 +3290,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"enum", "block"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1213}, {PC: 2, Line: 259}, {PC: 5, Line: 1214}, {PC: 13, Line: 1215}, {PC: 15, Line: 1216}, {PC: 19, Line: 1218}}, + FirstLine: 1213, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in initialize", @@ -3286,8 +3305,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1178}}, - FirstLine: 1178, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1216}}, + FirstLine: 1216, Super: "", }, &bytecode.ISeq{ @@ -3302,8 +3321,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1180}}, - FirstLine: 1180, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1218}}, + FirstLine: 1218, Super: "", }, }, @@ -3323,8 +3342,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 0, NumLocals: 1, Locals: []string{"block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1188}, {PC: 10, Line: 1189}, {PC: 14, Line: 109}}, - FirstLine: 1187, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1226}, {PC: 10, Line: 1227}, {PC: 14, Line: 109}}, + FirstLine: 1225, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in each", @@ -3336,8 +3355,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1188}}, - FirstLine: 1188, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1226}}, + FirstLine: 1226, Super: "", }, }, @@ -3356,8 +3375,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1194}}, - FirstLine: 1193, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1232}}, + FirstLine: 1231, Super: "", }, &bytecode.ISeq{ @@ -3372,8 +3391,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1200}, {PC: 4, Line: 259}}, - FirstLine: 1199, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1238}, {PC: 4, Line: 259}}, + FirstLine: 1237, Super: "", }, &bytecode.ISeq{ @@ -3388,8 +3407,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1204}, {PC: 8, Line: 259}}, - FirstLine: 1203, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1242}, {PC: 8, Line: 259}}, + FirstLine: 1241, Super: "", }, &bytecode.ISeq{ @@ -3404,8 +3423,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"other", "n"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1210}, {PC: 4, Line: 1211}, {PC: 8, Line: 1212}}, - FirstLine: 1209, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1248}, {PC: 4, Line: 1249}, {PC: 8, Line: 1250}}, + FirstLine: 1247, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in |", @@ -3419,8 +3438,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1211}}, - FirstLine: 1211, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1249}}, + FirstLine: 1249, Super: "", }, }, @@ -3438,8 +3457,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"other", "n"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 5, Line: 1221}, {PC: 9, Line: 1222}}, - FirstLine: 1219, + Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 5, Line: 1259}, {PC: 9, Line: 1260}}, + FirstLine: 1257, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in &", @@ -3453,8 +3472,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1221}}, - FirstLine: 1221, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1259}}, + FirstLine: 1259, Super: "", }, }, @@ -3472,8 +3491,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"other", "n"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1229}, {PC: 4, Line: 1230}, {PC: 8, Line: 1231}}, - FirstLine: 1228, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1267}, {PC: 4, Line: 1268}, {PC: 8, Line: 1269}}, + FirstLine: 1266, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in -", @@ -3487,8 +3506,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1230}}, - FirstLine: 1230, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1268}}, + FirstLine: 1268, Super: "", }, }, @@ -3506,8 +3525,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"other", "n"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1239}, {PC: 9, Line: 1240}}, - FirstLine: 1237, + Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1277}, {PC: 9, Line: 1278}}, + FirstLine: 1275, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in ^", @@ -3521,8 +3540,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1239}}, - FirstLine: 1239, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1277}}, + FirstLine: 1277, Super: "", }, }, @@ -3540,8 +3559,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"enums"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1245}, {PC: 3, Line: 109}}, - FirstLine: 1244, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1283}, {PC: 3, Line: 109}}, + FirstLine: 1282, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in merge", @@ -3555,8 +3574,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"enum"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1245}}, - FirstLine: 1245, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1283}}, + FirstLine: 1283, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in merge", @@ -3570,8 +3589,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1245}}, - FirstLine: 1245, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1283}}, + FirstLine: 1283, Super: "", }, }, @@ -3592,8 +3611,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1251}, {PC: 4, Line: 109}}, - FirstLine: 1250, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1289}, {PC: 4, Line: 109}}, + FirstLine: 1288, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in subtract", @@ -3607,8 +3626,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: 1289}}, + FirstLine: 1289, Super: "", }, }, @@ -3631,8 +3650,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1297}, {PC: 4, Line: 1298}, {PC: 9, Line: 1299}, {PC: 12, Line: 1301}, {PC: 30, Line: 1302}, {PC: 35, Line: 1303}, {PC: 39, Line: 109}}, + FirstLine: 1296, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in replace", @@ -3646,8 +3665,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1261}}, - FirstLine: 1261, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1299}}, + FirstLine: 1299, Super: "", }, &bytecode.ISeq{ @@ -3662,8 +3681,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1265}}, - FirstLine: 1265, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1303}}, + FirstLine: 1303, Super: "", }, }, @@ -3680,8 +3699,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"vals"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1273}, {PC: 4, Line: 1274}, {PC: 9, Line: 1275}, {PC: 12, Line: 109}}, - FirstLine: 1272, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1311}, {PC: 4, Line: 1312}, {PC: 9, Line: 1313}, {PC: 12, Line: 109}}, + FirstLine: 1310, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in reset", @@ -3695,8 +3714,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1275}}, - FirstLine: 1275, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1313}}, + FirstLine: 1313, Super: "", }, }, @@ -3717,8 +3736,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1281}, {PC: 12, Line: 1282}, {PC: 23, Line: 1283}}, - FirstLine: 1280, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1319}, {PC: 12, Line: 1320}, {PC: 23, Line: 1321}}, + FirstLine: 1318, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in subset?", @@ -3732,8 +3751,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: 1321}}, + FirstLine: 1321, Super: "", }, }, @@ -3754,8 +3773,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1289}, {PC: 12, Line: 1290}, {PC: 23, Line: 1291}}, - FirstLine: 1288, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1327}, {PC: 12, Line: 1328}, {PC: 23, Line: 1329}}, + FirstLine: 1326, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in proper_subset?", @@ -3769,8 +3788,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1291}}, - FirstLine: 1291, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1329}}, + FirstLine: 1329, Super: "", }, }, @@ -3791,8 +3810,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1297}, {PC: 12, Line: 1298}, {PC: 23, Line: 1299}}, - FirstLine: 1296, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1335}, {PC: 12, Line: 1336}, {PC: 23, Line: 1337}}, + FirstLine: 1334, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in superset?", @@ -3806,8 +3825,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: 1337}}, + FirstLine: 1337, Super: "", }, }, @@ -3828,8 +3847,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1305}, {PC: 12, Line: 1306}, {PC: 23, Line: 1307}}, - FirstLine: 1304, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1343}, {PC: 12, Line: 1344}, {PC: 23, Line: 1345}}, + FirstLine: 1342, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in proper_superset?", @@ -3843,8 +3862,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1307}}, - FirstLine: 1307, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1345}}, + FirstLine: 1345, Super: "", }, }, @@ -3867,8 +3886,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"other", ""}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1352}, {PC: 5, Line: 259}, {PC: 10, Line: 1353}, {PC: 22, Line: 1354}, {PC: 28, Line: 259}, {PC: 35, Line: 1355}, {PC: 41, Line: 259}, {PC: 43, Line: 109}, {PC: 49, Line: 259}}, + FirstLine: 1351, Super: "", }, &bytecode.ISeq{ @@ -3886,8 +3905,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1363}, {PC: 9, Line: 1364}, {PC: 19, Line: 1365}, {PC: 31, Line: 1366}, {PC: 36, Line: 1368}, {PC: 48, Line: 1369}}, + FirstLine: 1362, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in ==", @@ -3901,8 +3920,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1331}}, - FirstLine: 1331, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1369}}, + FirstLine: 1369, Super: "", }, }, @@ -3921,8 +3940,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1338}}, - FirstLine: 1337, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1376}}, + FirstLine: 1375, Super: "", }, &bytecode.ISeq{ @@ -3937,8 +3956,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1344}, {PC: 6, Line: 1345}, {PC: 9, Line: 1347}}, - FirstLine: 1343, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1382}, {PC: 6, Line: 1383}, {PC: 9, Line: 1385}}, + FirstLine: 1381, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in disjoint?", @@ -3952,8 +3971,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1345}}, - FirstLine: 1345, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1383}}, + FirstLine: 1383, Super: "", }, &bytecode.ISeq{ @@ -3968,8 +3987,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1347}}, - FirstLine: 1347, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1385}}, + FirstLine: 1385, Super: "", }, }, @@ -3987,8 +4006,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1352}}, - FirstLine: 1351, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1390}}, + FirstLine: 1389, Super: "", }, &bytecode.ISeq{ @@ -4005,8 +4024,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 0, NumLocals: 1, Locals: []string{"block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1358}, {PC: 10, Line: 1359}, {PC: 14, Line: 109}}, - FirstLine: 1357, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1396}, {PC: 10, Line: 1397}, {PC: 14, Line: 109}}, + FirstLine: 1395, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in delete_if", @@ -4018,8 +4037,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1358}}, - FirstLine: 1358, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1396}}, + FirstLine: 1396, Super: "", }, &bytecode.ISeq{ @@ -4034,8 +4053,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1359}}, - FirstLine: 1359, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1397}}, + FirstLine: 1397, Super: "", }, }, @@ -4055,8 +4074,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 0, NumLocals: 1, Locals: []string{"block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1364}, {PC: 10, Line: 1365}, {PC: 14, Line: 109}}, - FirstLine: 1363, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1402}, {PC: 10, Line: 1403}, {PC: 14, Line: 109}}, + FirstLine: 1401, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in keep_if", @@ -4068,8 +4087,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1364}}, - FirstLine: 1364, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1402}}, + FirstLine: 1402, Super: "", }, &bytecode.ISeq{ @@ -4084,8 +4103,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1365}}, - FirstLine: 1365, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1403}}, + FirstLine: 1403, Super: "", }, }, @@ -4105,8 +4124,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 0, NumLocals: 2, Locals: []string{"block", "n"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1410}, {PC: 10, Line: 1411}, {PC: 14, Line: 1412}, {PC: 18, Line: 1413}, {PC: 23, Line: 259}, {PC: 25, Line: 109}}, + FirstLine: 1409, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in select!", @@ -4118,8 +4137,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1372}}, - FirstLine: 1372, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1410}}, + FirstLine: 1410, Super: "", }, }, @@ -4139,8 +4158,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 0, NumLocals: 2, Locals: []string{"block", "n"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1418}, {PC: 10, Line: 1419}, {PC: 14, Line: 1420}, {PC: 18, Line: 1421}, {PC: 23, Line: 259}, {PC: 25, Line: 109}}, + FirstLine: 1417, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in reject!", @@ -4152,8 +4171,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1380}}, - FirstLine: 1380, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1418}}, + FirstLine: 1418, Super: "", }, }, @@ -4173,8 +4192,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 0, NumLocals: 2, Locals: []string{"block", "vals"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1427}, {PC: 10, Line: 1428}, {PC: 16, Line: 1429}, {PC: 20, Line: 1430}, {PC: 23, Line: 109}}, + FirstLine: 1426, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in map!", @@ -4186,8 +4205,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1389}}, - FirstLine: 1389, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1427}}, + FirstLine: 1427, Super: "", }, &bytecode.ISeq{ @@ -4202,8 +4221,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1392}}, - FirstLine: 1392, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1430}}, + FirstLine: 1430, Super: "", }, }, @@ -4223,8 +4242,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 0, NumLocals: 2, Locals: []string{"block", "h"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1400}, {PC: 10, Line: 1401}, {PC: 13, Line: 1402}, {PC: 16, Line: 1406}}, - FirstLine: 1399, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1438}, {PC: 10, Line: 1439}, {PC: 13, Line: 1440}, {PC: 16, Line: 1444}}, + FirstLine: 1437, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in classify", @@ -4236,8 +4255,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1400}}, - FirstLine: 1400, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1438}}, + FirstLine: 1438, Super: "", }, &bytecode.ISeq{ @@ -4252,8 +4271,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 5, Locals: []string{"o", "k", "", "", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1403}, {PC: 5, Line: 1404}, {PC: 17, Line: 109}}, - FirstLine: 1402, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1441}, {PC: 5, Line: 1442}, {PC: 17, Line: 109}}, + FirstLine: 1440, Super: "", }, }, @@ -4274,8 +4293,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 0, NumLocals: 1, Locals: []string{"func"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1414}, {PC: 10, Line: 1415}, {PC: 15, Line: 1416}, {PC: 19, Line: 109}}, - FirstLine: 1413, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1452}, {PC: 10, Line: 1453}, {PC: 15, Line: 1454}, {PC: 19, Line: 109}}, + FirstLine: 1451, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in divide", @@ -4287,8 +4306,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1414}}, - FirstLine: 1414, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1452}}, + FirstLine: 1452, Super: "", }, }, @@ -4308,8 +4327,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: 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1461}, {PC: 4, Line: 1462}, {PC: 8, Line: 1463}, {PC: 13, Line: 1464}, {PC: 16, Line: 1469}, {PC: 19, Line: 1470}, {PC: 24, Line: 1471}, {PC: 30, Line: 1472}, {PC: 36, Line: 1473}, {PC: 39, Line: 1474}, {PC: 42, Line: 259}, {PC: 45, Line: 1476}, {PC: 49, Line: 1501}, {PC: 52, Line: 109}}, + FirstLine: 1460, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in __divide_graph", @@ -4320,8 +4339,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1425}}, - FirstLine: 1425, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1463}}, + FirstLine: 1463, Super: "", }, &bytecode.ISeq{ @@ -4336,8 +4355,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"i"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1427}}, - FirstLine: 1426, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1465}}, + FirstLine: 1464, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in __divide_graph", @@ -4351,8 +4370,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"j"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1428}}, - FirstLine: 1427, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1466}}, + FirstLine: 1465, Super: "", }, }, @@ -4373,8 +4392,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 5, Locals: []string{"v", "", "", "", "comp"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1477}, {PC: 8, Line: 1478}, {PC: 16, Line: 1479}, {PC: 21, Line: 1480}, {PC: 25, Line: 1481}, {PC: 33, Line: 1482}, {PC: 38, Line: 1490}, {PC: 46, Line: 1491}, {PC: 49, Line: 1492}, {PC: 52, Line: 1498}}, + FirstLine: 1476, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in __divide_graph", @@ -4388,8 +4407,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"w", "", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1445}, {PC: 5, Line: 1446}, {PC: 9, Line: 1447}, {PC: 33, Line: 1449}}, - FirstLine: 1444, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1483}, {PC: 5, Line: 1484}, {PC: 9, Line: 1485}, {PC: 33, Line: 1487}}, + FirstLine: 1482, Super: "", }, &bytecode.ISeq{ @@ -4403,8 +4422,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"w", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1455}, {PC: 4, Line: 1456}, {PC: 12, Line: 1457}, {PC: 18, Line: 1458}}, - FirstLine: 1454, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1493}, {PC: 4, Line: 1494}, {PC: 12, Line: 1495}, {PC: 18, Line: 1496}}, + FirstLine: 1492, Super: "", }, }, @@ -4422,8 +4441,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1463}}, - FirstLine: 1463, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1501}}, + FirstLine: 1501, Super: "", }, &bytecode.ISeq{ @@ -4439,7 +4458,7 @@ func embeddedPrelude() *bytecode.ISeq { NumLocals: 1, Locals: []string{"c"}, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 1464, + FirstLine: 1502, Super: "", }, }, @@ -4456,7 +4475,7 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 0, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 1472, + FirstLine: 1510, Super: "", }, &bytecode.ISeq{ @@ -4469,8 +4488,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1477}, {PC: 3, Line: 1478}, {PC: 8, Line: 109}, {PC: 10, Line: 259}}, - FirstLine: 1476, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1515}, {PC: 3, Line: 1516}, {PC: 8, Line: 109}, {PC: 10, Line: 259}}, + FirstLine: 1514, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in flatten!", @@ -4484,8 +4503,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1477}}, - FirstLine: 1477, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1515}}, + FirstLine: 1515, Super: "", }, }, @@ -4503,8 +4522,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"other", "seen"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1487}, {PC: 5, Line: 1488}, {PC: 8, Line: 109}}, - FirstLine: 1487, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1525}, {PC: 5, Line: 1526}, {PC: 8, Line: 109}}, + FirstLine: 1525, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in flatten_merge", @@ -4521,8 +4540,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"o", ""}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1527}, {PC: 4, Line: 1528}, {PC: 16, Line: 1529}, {PC: 25, Line: 1530}, {PC: 30, Line: 1531}, {PC: 35, Line: 1533}}, + FirstLine: 1526, Super: "", }, }, @@ -4540,8 +4559,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"sep"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1503}, {PC: 2, Line: 259}, {PC: 5, Line: 1504}}, - FirstLine: 1503, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1541}, {PC: 2, Line: 259}, {PC: 5, Line: 1542}}, + FirstLine: 1541, Super: "", }, &bytecode.ISeq{ @@ -4554,7 +4573,7 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 0, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 1508, + FirstLine: 1546, Super: "", }, }, @@ -4570,8 +4589,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1569}, {PC: 2, Line: 1693}, {PC: 4, Line: 1750}, {PC: 6, Line: 1754}, {PC: 8, Line: 1760}, {PC: 10, Line: 1764}}, + FirstLine: 1565, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -4589,8 +4608,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1570}, {PC: 4, Line: 1572}, {PC: 7, Line: 1573}, {PC: 16, Line: 1577}, {PC: 18, Line: 1582}, {PC: 20, Line: 1592}, {PC: 24, Line: 1594}, {PC: 26, Line: 1602}, {PC: 28, Line: 1606}, {PC: 30, Line: 1612}, {PC: 32, Line: 1619}, {PC: 34, Line: 1623}, {PC: 36, Line: 1632}, {PC: 38, Line: 1640}, {PC: 40, Line: 1660}, {PC: 42, Line: 1666}, {PC: 44, Line: 1670}, {PC: 46, Line: 1674}, {PC: 49, Line: 1678}}, + FirstLine: 1569, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "correct?", @@ -4604,8 +4623,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"str"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1540}, {PC: 8, Line: 1541}}, - FirstLine: 1539, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1578}, {PC: 8, Line: 1579}}, + FirstLine: 1577, Super: "", }, &bytecode.ISeq{ @@ -4620,8 +4639,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"input"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1545}, {PC: 4, Line: 1546}, {PC: 9, Line: 259}, {PC: 11, Line: 1550}}, - FirstLine: 1544, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1583}, {PC: 4, Line: 1584}, {PC: 9, Line: 259}, {PC: 11, Line: 1588}}, + FirstLine: 1582, Super: "", }, &bytecode.ISeq{ @@ -4643,8 +4662,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"version"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1558}, {PC: 17, Line: 1560}, {PC: 25, Line: 1561}}, - FirstLine: 1556, + Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1596}, {PC: 17, Line: 1598}, {PC: 25, Line: 1599}}, + FirstLine: 1594, Super: "", }, &bytecode.ISeq{ @@ -4657,8 +4676,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1565}}, - FirstLine: 1564, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1603}}, + FirstLine: 1602, Super: "", }, &bytecode.ISeq{ @@ -4676,8 +4695,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1569}, {PC: 1, Line: 109}, {PC: 6, Line: 1569}}, - FirstLine: 1568, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1607}, {PC: 1, Line: 109}, {PC: 6, Line: 1607}}, + FirstLine: 1606, Super: "", }, &bytecode.ISeq{ @@ -4690,8 +4709,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1575}}, - FirstLine: 1574, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1613}}, + FirstLine: 1612, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in segments", @@ -4705,8 +4724,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"s"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1576}}, - FirstLine: 1575, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1614}}, + FirstLine: 1613, Super: "", }, }, @@ -4722,8 +4741,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1582}}, - FirstLine: 1581, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1620}}, + FirstLine: 1619, Super: "", }, &bytecode.ISeq{ @@ -4740,8 +4759,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"segs"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1624}, {PC: 4, Line: 109}, {PC: 9, Line: 1625}, {PC: 13, Line: 1626}, {PC: 31, Line: 109}}, + FirstLine: 1623, Super: "", }, &bytecode.ISeq{ @@ -4760,8 +4779,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"segs", ""}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1633}, {PC: 5, Line: 1634}, {PC: 23, Line: 1635}, {PC: 33, Line: 1636}, {PC: 45, Line: 109}}, + FirstLine: 1632, Super: "", }, &bytecode.ISeq{ @@ -4780,8 +4799,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: 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1642}, {PC: 9, Line: 259}, {PC: 14, Line: 1643}, {PC: 18, Line: 1644}, {PC: 22, Line: 1645}, {PC: 35, Line: 1646}, {PC: 38, Line: 1647}, {PC: 42, Line: 1648}, {PC: 47, Line: 1649}, {PC: 52, Line: 1651}, {PC: 60, Line: 1652}, {PC: 68, Line: 1653}, {PC: 74, Line: 1654}, {PC: 84, Line: 1655}, {PC: 92, Line: 1657}}, + FirstLine: 1640, Super: "", }, &bytecode.ISeq{ @@ -4799,8 +4818,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1624}, {PC: 14, Line: 109}}, - FirstLine: 1622, + Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1662}, {PC: 14, Line: 109}}, + FirstLine: 1660, Super: "", }, &bytecode.ISeq{ @@ -4815,8 +4834,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1629}}, - FirstLine: 1628, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1667}}, + FirstLine: 1666, Super: "", }, &bytecode.ISeq{ @@ -4829,8 +4848,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1633}}, - FirstLine: 1632, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1671}}, + FirstLine: 1670, Super: "", }, &bytecode.ISeq{ @@ -4849,8 +4868,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"l", "r"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1679}, {PC: 10, Line: 1680}, {PC: 24, Line: 1682}, {PC: 32, Line: 1684}, {PC: 34, Line: 1686}}, + FirstLine: 1678, Super: "", }, }, @@ -4878,8 +4897,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1694}, {PC: 24, Line: 1707}, {PC: 34, Line: 1709}, {PC: 36, Line: 1713}, {PC: 38, Line: 1717}, {PC: 42, Line: 1719}, {PC: 44, Line: 1727}, {PC: 46, Line: 1736}, {PC: 48, Line: 1740}, {PC: 50, Line: 1741}, {PC: 52, Line: 1743}}, + FirstLine: 1693, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in ", @@ -4892,8 +4911,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1657}}, - FirstLine: 1657, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1695}}, + FirstLine: 1695, Super: "", }, &bytecode.ISeq{ @@ -4907,8 +4926,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1658}}, - FirstLine: 1658, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1696}}, + FirstLine: 1696, Super: "", }, &bytecode.ISeq{ @@ -4922,8 +4941,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1659}}, - FirstLine: 1659, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1697}}, + FirstLine: 1697, Super: "", }, &bytecode.ISeq{ @@ -4937,8 +4956,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1660}}, - FirstLine: 1660, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1698}}, + FirstLine: 1698, Super: "", }, &bytecode.ISeq{ @@ -4952,8 +4971,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1661}}, - FirstLine: 1661, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1699}}, + FirstLine: 1699, Super: "", }, &bytecode.ISeq{ @@ -4967,8 +4986,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1662}}, - FirstLine: 1662, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1700}}, + FirstLine: 1700, Super: "", }, &bytecode.ISeq{ @@ -4983,8 +5002,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1663}}, - FirstLine: 1663, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1701}}, + FirstLine: 1701, Super: "", }, &bytecode.ISeq{ @@ -4999,8 +5018,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"input"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1672}}, - FirstLine: 1671, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1710}}, + FirstLine: 1709, Super: "", }, &bytecode.ISeq{ @@ -5016,8 +5035,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1676}}, - FirstLine: 1675, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1714}}, + FirstLine: 1713, Super: "", }, &bytecode.ISeq{ @@ -5035,8 +5054,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"reqs"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1682}, {PC: 4, Line: 1683}, {PC: 13, Line: 1684}}, - FirstLine: 1681, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1720}, {PC: 4, Line: 1721}, {PC: 13, Line: 1722}}, + FirstLine: 1719, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in initialize", @@ -5051,7 +5070,7 @@ func embeddedPrelude() *bytecode.ISeq { NumLocals: 1, Locals: []string{"r"}, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 1684, + FirstLine: 1722, Super: "", }, }, @@ -5076,8 +5095,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"obj", "m", "op"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1728}, {PC: 11, Line: 1729}, {PC: 17, Line: 1730}, {PC: 32, Line: 1731}, {PC: 41, Line: 1732}}, + FirstLine: 1727, Super: "", }, &bytecode.ISeq{ @@ -5092,8 +5111,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"version"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1699}, {PC: 5, Line: 1700}}, - FirstLine: 1698, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1737}, {PC: 5, Line: 1738}}, + FirstLine: 1736, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in satisfied_by?", @@ -5107,8 +5126,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"op", "req"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1700}}, - FirstLine: 1700, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1738}}, + FirstLine: 1738, Super: "", }, }, @@ -5127,8 +5146,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1706}}, - FirstLine: 1705, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1744}}, + FirstLine: 1743, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in to_s", @@ -5145,8 +5164,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"op", "req"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1706}}, - FirstLine: 1706, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1744}}, + FirstLine: 1744, Super: "", }, }, @@ -5165,8 +5184,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1713}}, - FirstLine: 1712, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1751}}, + FirstLine: 1750, Super: "", }, &bytecode.ISeq{ @@ -5178,8 +5197,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1717}}, - FirstLine: 1716, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1755}}, + FirstLine: 1754, Super: "", }, &bytecode.ISeq{ @@ -5191,8 +5210,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1722}}, - FirstLine: 1722, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1760}}, + FirstLine: 1760, Super: "", }, &bytecode.ISeq{ @@ -5205,8 +5224,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1727}}, - FirstLine: 1726, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1765}}, + FirstLine: 1764, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "stubs", @@ -5217,8 +5236,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1728}}, - FirstLine: 1727, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1766}}, + FirstLine: 1765, Super: "", }, }, @@ -5237,8 +5256,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1786}, {PC: 2, Line: 1793}, {PC: 4, Line: 1797}, {PC: 6, Line: 1801}, {PC: 8, Line: 1805}, {PC: 10, Line: 1811}, {PC: 12, Line: 1815}, {PC: 14, Line: 1819}, {PC: 16, Line: 1823}, {PC: 18, Line: 1828}, {PC: 20, Line: 1840}, {PC: 22, Line: 1843}, {PC: 24, Line: 1845}, {PC: 26, Line: 1849}, {PC: 28, Line: 1852}}, + FirstLine: 1785, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -5252,8 +5271,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"hash"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1786}, {PC: 2, Line: 259}, {PC: 5, Line: 1787}, {PC: 8, Line: 1788}, {PC: 10, Line: 1789}}, + FirstLine: 1786, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in initialize", @@ -5267,8 +5286,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"k", "v", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1751}}, - FirstLine: 1751, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1789}}, + FirstLine: 1789, Super: "", }, }, @@ -5286,8 +5305,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"name"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1756}}, - FirstLine: 1755, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1794}}, + FirstLine: 1793, Super: "", }, &bytecode.ISeq{ @@ -5302,8 +5321,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"name", "value", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1760}}, - FirstLine: 1759, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1798}}, + FirstLine: 1797, Super: "", }, &bytecode.ISeq{ @@ -5316,8 +5335,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: 1802}}, + FirstLine: 1801, Super: "", }, &bytecode.ISeq{ @@ -5333,8 +5352,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1768}, {PC: 10, Line: 1769}, {PC: 13, Line: 109}}, - FirstLine: 1767, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1806}, {PC: 10, Line: 1807}, {PC: 13, Line: 109}}, + FirstLine: 1805, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in each_pair", @@ -5347,8 +5366,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"k", "v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1769}}, - FirstLine: 1769, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1807}}, + FirstLine: 1807, Super: "", }, }, @@ -5364,8 +5383,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1774}}, - FirstLine: 1773, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1812}}, + FirstLine: 1811, Super: "", }, &bytecode.ISeq{ @@ -5380,8 +5399,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"names"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1778}}, - FirstLine: 1777, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1816}}, + FirstLine: 1815, Super: "", }, &bytecode.ISeq{ @@ -5396,8 +5415,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"name"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1782}}, - FirstLine: 1781, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1820}}, + FirstLine: 1819, Super: "", }, &bytecode.ISeq{ @@ -5415,8 +5434,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"name", "include_private", "n"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1785}, {PC: 5, Line: 1786}, {PC: 9, Line: 1787}}, - FirstLine: 1785, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1823}, {PC: 5, Line: 1824}, {PC: 9, Line: 1825}}, + FirstLine: 1823, Super: "", }, &bytecode.ISeq{ @@ -5439,8 +5458,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 4, Locals: []string{"name", "args", "n", ""}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1829}, {PC: 4, Line: 1830}, {PC: 8, Line: 1831}, {PC: 26, Line: 1832}, {PC: 44, Line: 1834}, {PC: 48, Line: 1836}}, + FirstLine: 1828, Super: "", }, &bytecode.ISeq{ @@ -5455,8 +5474,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1803}, {PC: 9, Line: 259}}, - FirstLine: 1802, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1841}, {PC: 9, Line: 259}}, + FirstLine: 1840, Super: "", }, &bytecode.ISeq{ @@ -5471,8 +5490,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"name", "include_private"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1807}, {PC: 5, Line: 1808}}, - FirstLine: 1807, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1845}, {PC: 5, Line: 1846}}, + FirstLine: 1845, Super: "", }, &bytecode.ISeq{ @@ -5485,8 +5504,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1812}}, - FirstLine: 1811, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1850}}, + FirstLine: 1849, Super: "", }, }, @@ -5502,8 +5521,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1829}, {PC: 2, Line: 1837}, {PC: 4, Line: 1840}, {PC: 6, Line: 1846}}, - FirstLine: 1826, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1867}, {PC: 2, Line: 1875}, {PC: 4, Line: 1878}, {PC: 6, Line: 1884}}, + FirstLine: 1864, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "def_delegator", @@ -5517,8 +5536,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"accessor", "method", "ali"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1829}, {PC: 5, Line: 1830}, {PC: 9, Line: 1831}, {PC: 13, Line: 1835}}, - FirstLine: 1829, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1867}, {PC: 5, Line: 1868}, {PC: 9, Line: 1869}, {PC: 13, Line: 1873}}, + FirstLine: 1867, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in def_delegator", @@ -5532,8 +5551,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 3, Locals: []string{"args", "block", "target"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1832}, {PC: 1, Line: 109}, {PC: 6, Line: 1833}}, - FirstLine: 1831, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1870}, {PC: 1, Line: 109}, {PC: 6, Line: 1871}}, + FirstLine: 1869, Super: "", }, }, @@ -5551,8 +5570,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"accessor", "methods"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1841}}, - FirstLine: 1840, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1879}}, + FirstLine: 1878, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in def_delegators", @@ -5566,8 +5585,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"m"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1841}}, - FirstLine: 1841, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1879}}, + FirstLine: 1879, Super: "", }, }, @@ -5588,8 +5607,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"obj", "accessor"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1847}, {PC: 4, Line: 1848}, {PC: 9, Line: 1850}}, - FirstLine: 1846, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1885}, {PC: 4, Line: 1886}, {PC: 9, Line: 1888}}, + FirstLine: 1884, Super: "", }, }, @@ -5605,8 +5624,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1858}, {PC: 2, Line: 1866}, {PC: 4, Line: 1868}}, - FirstLine: 1857, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1896}, {PC: 2, Line: 1904}, {PC: 4, Line: 1906}}, + FirstLine: 1895, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "def_single_delegator", @@ -5620,8 +5639,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"accessor", "method", "ali"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1858}, {PC: 5, Line: 1859}, {PC: 9, Line: 1860}, {PC: 13, Line: 1864}}, - FirstLine: 1858, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1896}, {PC: 5, Line: 1897}, {PC: 9, Line: 1898}, {PC: 13, Line: 1902}}, + FirstLine: 1896, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in def_single_delegator", @@ -5635,8 +5654,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 3, Locals: []string{"args", "block", "target"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1861}, {PC: 1, Line: 109}, {PC: 6, Line: 1862}}, - FirstLine: 1860, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1899}, {PC: 1, Line: 109}, {PC: 6, Line: 1900}}, + FirstLine: 1898, Super: "", }, }, @@ -5654,8 +5673,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"accessor", "methods"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1869}}, - FirstLine: 1868, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1907}}, + FirstLine: 1906, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in def_single_delegators", @@ -5669,8 +5688,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"m"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1869}}, - FirstLine: 1869, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1907}}, + FirstLine: 1907, Super: "", }, }, @@ -5689,8 +5708,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1916}, {PC: 2, Line: 1922}, {PC: 4, Line: 1931}, {PC: 6, Line: 1935}, {PC: 8, Line: 1939}, {PC: 10, Line: 1944}, {PC: 12, Line: 1948}}, + FirstLine: 1915, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -5704,8 +5723,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"obj"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1879}}, - FirstLine: 1878, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1917}}, + FirstLine: 1916, Super: "", }, &bytecode.ISeq{ @@ -5720,8 +5739,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 2, NumLocals: 4, Locals: []string{"name", "args", "block", "target"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1885}, {PC: 4, Line: 1886}, {PC: 8, Line: 1887}, {PC: 19, Line: 1889}}, - FirstLine: 1884, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1923}, {PC: 4, Line: 1924}, {PC: 8, Line: 1925}, {PC: 19, Line: 1927}}, + FirstLine: 1922, Super: "", }, &bytecode.ISeq{ @@ -5736,8 +5755,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"name", "include_private"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1893}, {PC: 5, Line: 1894}}, - FirstLine: 1893, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1931}, {PC: 5, Line: 1932}}, + FirstLine: 1931, Super: "", }, &bytecode.ISeq{ @@ -5752,8 +5771,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"name", "include_private"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1897}, {PC: 5, Line: 1898}}, - FirstLine: 1897, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1935}, {PC: 5, Line: 1936}}, + FirstLine: 1935, Super: "", }, &bytecode.ISeq{ @@ -5768,8 +5787,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1902}, {PC: 1, Line: 109}, {PC: 9, Line: 1903}}, - FirstLine: 1901, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1940}, {PC: 1, Line: 109}, {PC: 9, Line: 1941}}, + FirstLine: 1939, Super: "", }, &bytecode.ISeq{ @@ -5786,8 +5805,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1907}, {PC: 3, Line: 109}}, - FirstLine: 1906, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1945}, {PC: 3, Line: 109}}, + FirstLine: 1944, Super: "", }, &bytecode.ISeq{ @@ -5806,8 +5825,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"_obj"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1911}, {PC: 3, Line: 109}}, - FirstLine: 1910, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1949}, {PC: 3, Line: 109}}, + FirstLine: 1948, Super: "", }, }, @@ -5823,8 +5842,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1918}, {PC: 2, Line: 1922}}, - FirstLine: 1917, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1956}, {PC: 2, Line: 1960}}, + FirstLine: 1955, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "__getobj__", @@ -5836,8 +5855,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1919}}, - FirstLine: 1918, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1957}}, + FirstLine: 1956, Super: "", }, &bytecode.ISeq{ @@ -5852,8 +5871,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"obj"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1923}}, - FirstLine: 1922, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1961}}, + FirstLine: 1960, Super: "", }, }, @@ -5896,8 +5915,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"superclass", "klass", "skip"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1969}, {PC: 5, Line: 1970}, {PC: 8, Line: 1988}, {PC: 34, Line: 1995}, {PC: 38, Line: 2001}}, + FirstLine: 1968, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in DelegateClass", @@ -5909,8 +5928,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1933}, {PC: 2, Line: 1937}}, - FirstLine: 1932, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1971}, {PC: 2, Line: 1975}}, + FirstLine: 1970, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "__getobj__", @@ -5922,8 +5941,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1934}}, - FirstLine: 1933, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1972}}, + FirstLine: 1971, Super: "", }, &bytecode.ISeq{ @@ -5938,8 +5957,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"obj"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1938}}, - FirstLine: 1937, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1976}}, + FirstLine: 1975, Super: "", }, }, @@ -5960,8 +5979,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"m"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1958}, {PC: 9, Line: 1959}}, - FirstLine: 1957, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1996}, {PC: 9, Line: 1997}}, + FirstLine: 1995, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in DelegateClass", @@ -5975,8 +5994,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"args", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1960}}, - FirstLine: 1959, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1998}}, + FirstLine: 1997, Super: "", }, }, @@ -5998,8 +6017,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2009}, {PC: 4, Line: 2010}, {PC: 7, Line: 2012}, {PC: 9, Line: 2018}, {PC: 11, Line: 2021}, {PC: 13, Line: 2023}, {PC: 15, Line: 2027}, {PC: 17, Line: 2031}, {PC: 19, Line: 2036}, {PC: 21, Line: 2039}, {PC: 23, Line: 2041}, {PC: 25, Line: 2046}, {PC: 27, Line: 2056}, {PC: 29, Line: 2060}, {PC: 31, Line: 2064}, {PC: 33, Line: 2071}, {PC: 35, Line: 2088}, {PC: 37, Line: 2090}, {PC: 39, Line: 2098}, {PC: 41, Line: 2102}, {PC: 43, Line: 2105}, {PC: 45, Line: 2107}, {PC: 47, Line: 2111}, {PC: 49, Line: 2115}, {PC: 51, Line: 2122}, {PC: 53, Line: 2128}, {PC: 55, Line: 2135}, {PC: 57, Line: 2139}, {PC: 59, Line: 2147}, {PC: 61, Line: 2156}, {PC: 63, Line: 2160}, {PC: 65, Line: 2164}, {PC: 67, Line: 2168}, {PC: 69, Line: 2172}, {PC: 71, Line: 2176}, {PC: 73, Line: 2180}}, + FirstLine: 2008, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -6016,8 +6035,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"path"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1975}, {PC: 10, Line: 1976}, {PC: 22, Line: 1977}}, - FirstLine: 1974, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2013}, {PC: 10, Line: 2014}, {PC: 22, Line: 2015}}, + FirstLine: 2012, Super: "", }, &bytecode.ISeq{ @@ -6030,8 +6049,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1981}}, - FirstLine: 1980, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2019}}, + FirstLine: 2018, Super: "", }, &bytecode.ISeq{ @@ -6048,8 +6067,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1986}}, - FirstLine: 1985, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2024}}, + FirstLine: 2023, Super: "", }, &bytecode.ISeq{ @@ -6062,8 +6081,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1990}}, - FirstLine: 1989, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2028}}, + FirstLine: 2027, Super: "", }, &bytecode.ISeq{ @@ -6076,8 +6095,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1994}, {PC: 3, Line: 1995}}, - FirstLine: 1993, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2032}, {PC: 3, Line: 2033}}, + FirstLine: 2031, Super: "", }, &bytecode.ISeq{ @@ -6092,8 +6111,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1999}}, - FirstLine: 1998, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2037}}, + FirstLine: 2036, Super: "", }, &bytecode.ISeq{ @@ -6108,8 +6127,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2004}, {PC: 5, Line: 259}, {PC: 10, Line: 2005}}, - FirstLine: 2003, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2042}, {PC: 5, Line: 259}, {PC: 10, Line: 2043}}, + FirstLine: 2041, Super: "", }, &bytecode.ISeq{ @@ -6122,8 +6141,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2009}}, - FirstLine: 2008, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2047}}, + FirstLine: 2046, Super: "", }, &bytecode.ISeq{ @@ -6136,8 +6155,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2019}}, - FirstLine: 2018, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2057}}, + FirstLine: 2056, Super: "", }, &bytecode.ISeq{ @@ -6150,8 +6169,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2023}}, - FirstLine: 2022, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2061}}, + FirstLine: 2060, Super: "", }, &bytecode.ISeq{ @@ -6164,8 +6183,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2027}}, - FirstLine: 2026, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2065}}, + FirstLine: 2064, Super: "", }, &bytecode.ISeq{ @@ -6180,8 +6199,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2034}, {PC: 12, Line: 2035}}, - FirstLine: 2033, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2072}, {PC: 12, Line: 2073}}, + FirstLine: 2071, Super: "", }, &bytecode.ISeq{ @@ -6196,8 +6215,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"args", "result"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 3, Line: 2054}, {PC: 6, Line: 2055}}, - FirstLine: 2052, + Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 3, Line: 2092}, {PC: 6, Line: 2093}}, + FirstLine: 2090, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in join", @@ -6210,8 +6229,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"a"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2054}}, - FirstLine: 2054, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2092}}, + FirstLine: 2092, Super: "", }, }, @@ -6232,8 +6251,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"suffix"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2060}, {PC: 5, Line: 2061}}, - FirstLine: 2060, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2098}, {PC: 5, Line: 2099}}, + FirstLine: 2098, Super: "", }, &bytecode.ISeq{ @@ -6246,8 +6265,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2065}}, - FirstLine: 2064, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2103}}, + FirstLine: 2102, Super: "", }, &bytecode.ISeq{ @@ -6260,8 +6279,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2070}}, - FirstLine: 2069, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2108}}, + FirstLine: 2107, Super: "", }, &bytecode.ISeq{ @@ -6274,8 +6293,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2074}}, - FirstLine: 2073, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2112}}, + FirstLine: 2111, Super: "", }, &bytecode.ISeq{ @@ -6291,8 +6310,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2078}, {PC: 10, Line: 2079}}, - FirstLine: 2077, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2116}, {PC: 10, Line: 2117}}, + FirstLine: 2115, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in each_filename", @@ -6305,8 +6324,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"f"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2079}}, - FirstLine: 2079, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2117}}, + FirstLine: 2117, Super: "", }, }, @@ -6325,8 +6344,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2085}, {PC: 10, Line: 2086}, {PC: 15, Line: 109}}, - FirstLine: 2084, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2123}, {PC: 10, Line: 2124}, {PC: 15, Line: 109}}, + FirstLine: 2122, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in ascend", @@ -6340,8 +6359,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"p"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2086}}, - FirstLine: 2086, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2124}}, + FirstLine: 2124, Super: "", }, }, @@ -6360,8 +6379,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2091}, {PC: 10, Line: 2092}, {PC: 15, Line: 109}}, - FirstLine: 2090, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2129}, {PC: 10, Line: 2130}, {PC: 15, Line: 109}}, + FirstLine: 2128, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in descend", @@ -6375,8 +6394,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"p"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2092}}, - FirstLine: 2092, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2130}}, + FirstLine: 2130, Super: "", }, }, @@ -6392,8 +6411,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2098}}, - FirstLine: 2097, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2136}}, + FirstLine: 2135, Super: "", }, &bytecode.ISeq{ @@ -6408,8 +6427,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"repl"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2102}}, - FirstLine: 2101, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2140}}, + FirstLine: 2139, Super: "", }, &bytecode.ISeq{ @@ -6424,8 +6443,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"base_directory"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2110}, {PC: 12, Line: 2111}}, - FirstLine: 2109, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2148}, {PC: 12, Line: 2149}}, + FirstLine: 2147, Super: "", }, &bytecode.ISeq{ @@ -6440,8 +6459,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"args", "opts"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2119}}, - FirstLine: 2118, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2157}}, + FirstLine: 2156, Super: "", }, &bytecode.ISeq{ @@ -6456,8 +6475,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"content", "args", "opts"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2123}}, - FirstLine: 2122, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2161}}, + FirstLine: 2160, Super: "", }, &bytecode.ISeq{ @@ -6472,8 +6491,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"args", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2127}}, - FirstLine: 2126, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2165}}, + FirstLine: 2164, Super: "", }, &bytecode.ISeq{ @@ -6486,8 +6505,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2131}}, - FirstLine: 2130, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2169}}, + FirstLine: 2168, Super: "", }, &bytecode.ISeq{ @@ -6500,8 +6519,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2135}}, - FirstLine: 2134, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2173}}, + FirstLine: 2172, Super: "", }, &bytecode.ISeq{ @@ -6514,8 +6533,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2139}}, - FirstLine: 2138, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2177}}, + FirstLine: 2176, Super: "", }, &bytecode.ISeq{ @@ -6530,8 +6549,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"args", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2143}}, - FirstLine: 2142, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2181}}, + FirstLine: 2180, Super: "", }, }, @@ -6547,8 +6566,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2153}, {PC: 2, Line: 2164}}, - FirstLine: 2151, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2191}, {PC: 2, Line: 2202}}, + FirstLine: 2189, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -6560,8 +6579,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2156}}, - FirstLine: 2153, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2194}}, + FirstLine: 2191, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "instance", @@ -6573,8 +6592,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2157}}, - FirstLine: 2156, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2195}}, + FirstLine: 2194, Super: "", }, }, @@ -6596,8 +6615,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"klass"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2165}, {PC: 4, Line: 2166}}, - FirstLine: 2164, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2203}, {PC: 4, Line: 2204}}, + FirstLine: 2202, Super: "", }, }, @@ -6619,8 +6638,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2234}, {PC: 5, Line: 2235}, {PC: 10, Line: 2241}, {PC: 12, Line: 2254}, {PC: 14, Line: 2261}, {PC: 16, Line: 2270}, {PC: 18, Line: 2274}, {PC: 21, Line: 2278}}, + FirstLine: 2232, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -6641,8 +6660,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"str", "trim_mode", "eoutvar"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2241}, {PC: 2, Line: 259}, {PC: 13, Line: 2243}, {PC: 16, Line: 2244}, {PC: 19, Line: 2248}}, + FirstLine: 2241, Super: "", }, &bytecode.ISeq{ @@ -6660,8 +6679,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"b"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2216}, {PC: 6, Line: 2217}}, - FirstLine: 2216, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2254}, {PC: 6, Line: 2255}}, + FirstLine: 2254, Super: "", }, &bytecode.ISeq{ @@ -6676,8 +6695,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"hash", "b"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2224}, {PC: 4, Line: 2225}, {PC: 7, Line: 2228}}, - FirstLine: 2223, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2262}, {PC: 4, Line: 2263}, {PC: 7, Line: 2266}}, + FirstLine: 2261, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in result_with_hash", @@ -6691,8 +6710,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"key", "value"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2226}}, - FirstLine: 2225, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2264}}, + FirstLine: 2263, Super: "", }, }, @@ -6710,8 +6729,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"b"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2232}, {PC: 6, Line: 2233}}, - FirstLine: 2232, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2270}, {PC: 6, Line: 2271}}, + FirstLine: 2270, Super: "", }, &bytecode.ISeq{ @@ -6723,8 +6742,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2241}}, - FirstLine: 2240, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2279}}, + FirstLine: 2278, Super: "", }, }, @@ -6740,8 +6759,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2261}, {PC: 2, Line: 2330}}, - FirstLine: 2260, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2299}, {PC: 2, Line: 2368}}, + FirstLine: 2298, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -6753,8 +6772,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2302}, {PC: 2, Line: 2309}, {PC: 4, Line: 2316}, {PC: 6, Line: 2325}, {PC: 8, Line: 2338}}, + FirstLine: 2299, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -6769,8 +6788,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2265}, {PC: 4, Line: 2266}}, - FirstLine: 2264, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2303}, {PC: 4, Line: 2304}}, + FirstLine: 2302, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -6784,8 +6803,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2267}}, - FirstLine: 2266, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2305}}, + FirstLine: 2304, Super: "", }, }, @@ -6803,8 +6822,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2272}}, - FirstLine: 2271, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2310}}, + FirstLine: 2309, Super: "", }, &bytecode.ISeq{ @@ -6831,8 +6850,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"s"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2279}}, - FirstLine: 2278, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2317}}, + FirstLine: 2316, Super: "", }, &bytecode.ISeq{ @@ -6854,8 +6873,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"name", "value"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2326}, {PC: 14, Line: 2327}, {PC: 19, Line: 1}, {PC: 27, Line: 2328}, {PC: 32, Line: 1}, {PC: 44, Line: 2330}, {PC: 45, Line: 1}}, + FirstLine: 2325, Super: "", }, &bytecode.ISeq{ @@ -6873,8 +6892,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 5, Locals: []string{"base", "splats", "merged", "add", "out"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2339}, {PC: 3, Line: 2340}, {PC: 7, Line: 2352}, {PC: 10, Line: 2353}, {PC: 13, Line: 2355}, {PC: 17, Line: 2356}, {PC: 22, Line: 2359}}, + FirstLine: 2338, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in render_attributes", @@ -6893,8 +6912,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 7, Locals: []string{"k", "v", "existing", "val", "", "", ""}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2341}, {PC: 4, Line: 2342}, {PC: 8, Line: 2343}, {PC: 13, Line: 2344}, {PC: 24, Line: 2345}, {PC: 42, Line: 2347}, {PC: 50, Line: 2349}}, + FirstLine: 2340, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in render_attributes", @@ -6910,8 +6929,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2307}}, - FirstLine: 2307, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2345}}, + FirstLine: 2345, Super: "", }, }, @@ -6929,8 +6948,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"k", "v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2314}}, - FirstLine: 2314, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2352}}, + FirstLine: 2352, Super: "", }, &bytecode.ISeq{ @@ -6945,8 +6964,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"h"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2315}}, - FirstLine: 2315, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2353}}, + FirstLine: 2353, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in render_attributes", @@ -6960,8 +6979,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"k", "v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2315}}, - FirstLine: 2315, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2353}}, + FirstLine: 2353, Super: "", }, }, @@ -6979,8 +6998,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"k"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2319}}, - FirstLine: 2318, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2357}}, + FirstLine: 2356, Super: "", }, }, @@ -7002,8 +7021,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2331}, {PC: 4, Line: 2335}, {PC: 6, Line: 2344}}, - FirstLine: 2330, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2369}, {PC: 4, Line: 2373}, {PC: 6, Line: 2382}}, + FirstLine: 2368, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -7017,8 +7036,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"template", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2335}, {PC: 2, Line: 259}, {PC: 5, Line: 2336}, {PC: 18, Line: 2337}}, - FirstLine: 2335, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2373}, {PC: 2, Line: 259}, {PC: 5, Line: 2374}, {PC: 18, Line: 2375}}, + FirstLine: 2373, Super: "", }, &bytecode.ISeq{ @@ -7037,8 +7056,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"_scope", "locals", "b"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2344}, {PC: 11, Line: 2345}, {PC: 14, Line: 2346}, {PC: 17, Line: 2347}}, - FirstLine: 2344, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2382}, {PC: 11, Line: 2383}, {PC: 14, Line: 2384}, {PC: 17, Line: 2385}}, + FirstLine: 2382, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in render", @@ -7052,8 +7071,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"k", "v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2346}}, - FirstLine: 2346, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2384}}, + FirstLine: 2384, Super: "", }, }, @@ -7075,8 +7094,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2371}, {PC: 2, Line: 2384}, {PC: 4, Line: 2424}}, - FirstLine: 2370, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2409}, {PC: 2, Line: 2422}, {PC: 4, Line: 2462}}, + FirstLine: 2408, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -7088,8 +7107,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2374}}, - FirstLine: 2371, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2412}}, + FirstLine: 2409, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "escape_html", @@ -7115,8 +7134,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"s"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2375}}, - FirstLine: 2374, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2413}}, + FirstLine: 2412, Super: "", }, }, @@ -7152,8 +7171,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2385}, {PC: 22, Line: 2389}}, - FirstLine: 2384, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2423}, {PC: 22, Line: 2427}}, + FirstLine: 2422, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "render", @@ -7170,8 +7189,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"h", "pairs", "out"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2428}, {PC: 3, Line: 2429}, {PC: 6, Line: 2444}, {PC: 10, Line: 2445}, {PC: 15, Line: 2455}}, + FirstLine: 2427, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in render", @@ -7192,8 +7211,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 7, Locals: []string{"k", "v", "existing", "merged", "", "", ""}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2430}, {PC: 4, Line: 2431}, {PC: 14, Line: 2432}, {PC: 21, Line: 2434}, {PC: 26, Line: 2435}, {PC: 42, Line: 2436}, {PC: 54, Line: 2438}, {PC: 59, Line: 2439}, {PC: 72, Line: 2441}}, + FirstLine: 2429, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in render", @@ -7211,8 +7230,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"dk", "dv", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2394}}, - FirstLine: 2394, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2432}}, + FirstLine: 2432, Super: "", }, }, @@ -7236,8 +7255,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"k", "v"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2446}, {PC: 5, Line: 2447}, {PC: 9, Line: 2448}, {PC: 27, Line: 2450}, {PC: 35, Line: 2452}, {PC: 37, Line: 1}}, + FirstLine: 2445, Super: "", }, }, @@ -7259,8 +7278,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2425}, {PC: 4, Line: 2429}, {PC: 6, Line: 2437}}, - FirstLine: 2424, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2463}, {PC: 4, Line: 2467}, {PC: 6, Line: 2475}}, + FirstLine: 2462, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -7274,8 +7293,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"template", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2429}, {PC: 2, Line: 259}, {PC: 5, Line: 2430}, {PC: 18, Line: 2431}}, - FirstLine: 2429, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2467}, {PC: 2, Line: 259}, {PC: 5, Line: 2468}, {PC: 18, Line: 2469}}, + FirstLine: 2467, Super: "", }, &bytecode.ISeq{ @@ -7294,8 +7313,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"_scope", "locals", "b"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2437}, {PC: 11, Line: 2438}, {PC: 14, Line: 2439}, {PC: 17, Line: 2440}}, - FirstLine: 2437, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2475}, {PC: 11, Line: 2476}, {PC: 14, Line: 2477}, {PC: 17, Line: 2478}}, + FirstLine: 2475, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in render", @@ -7309,8 +7328,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"k", "v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2439}}, - FirstLine: 2439, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2477}}, + FirstLine: 2477, Super: "", }, }, @@ -7343,8 +7362,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2511}, {PC: 2, Line: 2532}, {PC: 4, Line: 2535}, {PC: 6, Line: 2538}, {PC: 8, Line: 2541}, {PC: 10, Line: 2544}, {PC: 12, Line: 2547}, {PC: 14, Line: 2551}}, + FirstLine: 2510, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -7359,8 +7378,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2512}, {PC: 4, Line: 2513}, {PC: 6, Line: 2520}, {PC: 8, Line: 2521}, {PC: 10, Line: 2522}, {PC: 12, Line: 2525}, {PC: 14, Line: 2526}}, + FirstLine: 2511, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -7378,8 +7397,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"args"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2476}, {PC: 3, Line: 2480}}, - FirstLine: 2475, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2514}, {PC: 3, Line: 2518}}, + FirstLine: 2513, Super: "", }, &bytecode.ISeq{ @@ -7394,8 +7413,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2482}}, - FirstLine: 2482, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2520}}, + FirstLine: 2520, Super: "", }, &bytecode.ISeq{ @@ -7409,7 +7428,7 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 0, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 2483, + FirstLine: 2521, Super: "", }, &bytecode.ISeq{ @@ -7426,8 +7445,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: 2523}}, + FirstLine: 2522, Super: "", }, &bytecode.ISeq{ @@ -7445,8 +7464,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"argv", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2489}, {PC: 9, Line: 2490}}, - FirstLine: 2488, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2527}, {PC: 9, Line: 2528}}, + FirstLine: 2526, Super: "", }, }, @@ -7462,8 +7481,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2495}}, - FirstLine: 2494, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2533}}, + FirstLine: 2532, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "reason", @@ -7477,8 +7496,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2495}}, - FirstLine: 2495, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2533}}, + FirstLine: 2533, Super: "", }, }, @@ -7494,8 +7513,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2498}}, - FirstLine: 2497, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2536}}, + FirstLine: 2535, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "reason", @@ -7509,8 +7528,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2498}}, - FirstLine: 2498, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2536}}, + FirstLine: 2536, Super: "", }, }, @@ -7526,8 +7545,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2501}}, - FirstLine: 2500, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2539}}, + FirstLine: 2538, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "reason", @@ -7541,8 +7560,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2501}}, - FirstLine: 2501, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2539}}, + FirstLine: 2539, Super: "", }, }, @@ -7558,8 +7577,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2504}}, - FirstLine: 2503, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2542}}, + FirstLine: 2541, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "reason", @@ -7573,8 +7592,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2504}}, - FirstLine: 2504, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2542}}, + FirstLine: 2542, Super: "", }, }, @@ -7590,8 +7609,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2507}}, - FirstLine: 2506, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2545}}, + FirstLine: 2544, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "reason", @@ -7605,8 +7624,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2507}}, - FirstLine: 2507, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2545}}, + FirstLine: 2545, Super: "", }, }, @@ -7622,8 +7641,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2510}}, - FirstLine: 2509, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2548}}, + FirstLine: 2547, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "reason", @@ -7637,8 +7656,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2510}}, - FirstLine: 2510, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2548}}, + FirstLine: 2548, Super: "", }, }, @@ -7660,8 +7679,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2568}, {PC: 4, Line: 2570}, {PC: 6, Line: 2591}, {PC: 8, Line: 2622}, {PC: 10, Line: 2628}, {PC: 12, Line: 2637}, {PC: 14, Line: 2652}, {PC: 16, Line: 2659}, {PC: 18, Line: 2663}, {PC: 20, Line: 2670}, {PC: 22, Line: 2672}, {PC: 24, Line: 2676}, {PC: 26, Line: 2680}}, + FirstLine: 2567, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "counter", @@ -7677,8 +7696,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2533}}, - FirstLine: 2532, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2571}}, + FirstLine: 2570, Super: "", }, &bytecode.ISeq{ @@ -7703,8 +7722,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: 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2591}, {PC: 7, Line: 259}, {PC: 15, Line: 2592}, {PC: 19, Line: 2593}, {PC: 36, Line: 2594}, {PC: 44, Line: 259}, {PC: 47, Line: 2596}, {PC: 50, Line: 2604}, {PC: 62, Line: 2605}, {PC: 65, Line: 2606}, {PC: 68, Line: 2607}, {PC: 76, Line: 2608}, {PC: 92, Line: 2609}, {PC: 94, Line: 2610}, {PC: 95, Line: 109}, {PC: 98, Line: 2613}, {PC: 101, Line: 2614}, {PC: 105, Line: 2613}, {PC: 108, Line: 2614}}, + FirstLine: 2591, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in initialize", @@ -7723,8 +7742,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"name", "candidate"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2597}, {PC: 25, Line: 2598}, {PC: 31, Line: 2599}, {PC: 36, Line: 2600}, {PC: 39, Line: 2601}}, + FirstLine: 2596, Super: "", }, &bytecode.ISeq{ @@ -7742,8 +7761,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"k", "v", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2568}}, - FirstLine: 2568, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2606}}, + FirstLine: 2606, Super: "", }, }, @@ -7762,8 +7781,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2585}, {PC: 16, Line: 2586}, {PC: 19, Line: 2587}}, - FirstLine: 2584, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2623}, {PC: 16, Line: 2624}, {PC: 19, Line: 2625}}, + FirstLine: 2622, Super: "", }, &bytecode.ISeq{ @@ -7778,8 +7797,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"args", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2591}}, - FirstLine: 2590, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2629}}, + FirstLine: 2628, Super: "", }, &bytecode.ISeq{ @@ -7797,8 +7816,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 5, Locals: []string{"basename", "tmpdir", "opts", "fwd", "t"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2637}, {PC: 7, Line: 259}, {PC: 10, Line: 2638}, {PC: 13, Line: 2639}, {PC: 16, Line: 2640}, {PC: 32, Line: 2641}, {PC: 34, Line: 2642}, {PC: 35, Line: 2643}, {PC: 39, Line: 2645}, {PC: 42, Line: 2646}, {PC: 46, Line: 2645}, {PC: 49, Line: 2646}, {PC: 56, Line: 2649}}, + FirstLine: 2637, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in create", @@ -7815,8 +7834,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"k", "v", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2601}}, - FirstLine: 2601, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2639}}, + FirstLine: 2639, Super: "", }, }, @@ -7834,8 +7853,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"unlink_now"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2652}, {PC: 5, Line: 2653}, {PC: 17, Line: 2654}, {PC: 20, Line: 2655}, {PC: 27, Line: 259}}, + FirstLine: 2652, Super: "", }, &bytecode.ISeq{ @@ -7848,8 +7867,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2622}}, - FirstLine: 2621, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2660}}, + FirstLine: 2659, Super: "", }, &bytecode.ISeq{ @@ -7862,8 +7881,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2626}, {PC: 8, Line: 2627}, {PC: 14, Line: 259}}, - FirstLine: 2625, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2664}, {PC: 8, Line: 2665}, {PC: 14, Line: 259}}, + FirstLine: 2663, Super: "", }, &bytecode.ISeq{ @@ -7881,8 +7900,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"mode"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2635}}, - FirstLine: 2634, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2673}}, + FirstLine: 2672, Super: "", }, &bytecode.ISeq{ @@ -7897,8 +7916,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"name", "include_private"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2638}, {PC: 5, Line: 2639}}, - FirstLine: 2638, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2676}, {PC: 5, Line: 2677}}, + FirstLine: 2676, Super: "", }, &bytecode.ISeq{ @@ -7913,8 +7932,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 2, NumLocals: 3, Locals: []string{"name", "args", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2643}, {PC: 8, Line: 2644}, {PC: 19, Line: 2646}}, - FirstLine: 2642, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2681}, {PC: 8, Line: 2682}, {PC: 19, Line: 2684}}, + FirstLine: 2680, Super: "", }, }, @@ -7936,8 +7955,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2693}, {PC: 11, Line: 109}, {PC: 14, Line: 2733}, {PC: 16, Line: 2737}, {PC: 17, Line: 109}}, + FirstLine: 2692, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -7949,8 +7968,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2665}, {PC: 2, Line: 2677}, {PC: 4, Line: 2688}}, - FirstLine: 2662, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2703}, {PC: 2, Line: 2715}, {PC: 4, Line: 2726}}, + FirstLine: 2700, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "[]", @@ -7970,8 +7989,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"category"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2704}, {PC: 5, Line: 2705}, {PC: 17, Line: 2707}, {PC: 22, Line: 2708}, {PC: 33, Line: 2710}}, + FirstLine: 2703, Super: "", }, &bytecode.ISeq{ @@ -7992,8 +8011,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"category", "flag", ""}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2716}, {PC: 5, Line: 2717}, {PC: 17, Line: 2719}, {PC: 22, Line: 2720}, {PC: 33, Line: 2722}}, + FirstLine: 2715, Super: "", }, &bytecode.ISeq{ @@ -8006,8 +8025,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2689}}, - FirstLine: 2688, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2727}}, + FirstLine: 2726, Super: "", }, }, @@ -8027,8 +8046,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"message", "category"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2695}, {PC: 2, Line: 259}, {PC: 5, Line: 2696}, {PC: 9, Line: 259}}, - FirstLine: 2695, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2733}, {PC: 2, Line: 259}, {PC: 5, Line: 2734}, {PC: 9, Line: 259}}, + FirstLine: 2733, Super: "", }, }, @@ -8044,8 +8063,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2713}}, - FirstLine: 2712, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2751}}, + FirstLine: 2750, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "!~", @@ -8060,7 +8079,7 @@ func embeddedPrelude() *bytecode.ISeq { NumLocals: 1, Locals: []string{"other"}, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 2713, + FirstLine: 2751, Super: "", }, },