Skip to content

Instantly share code, notes, and snippets.

@knaeckeKami

knaeckeKami/gist:bc202626e87171616e629606d55e9e28

Created January 15, 2023 00:24
Show Gist options
  • Save knaeckeKami/bc202626e87171616e629606d55e9e28 to your computer and use it in GitHub Desktop.
Save knaeckeKami/bc202626e87171616e629606d55e9e28 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
gistfile1.txt
Info: Compiling with sound null safety.
../../runtime/vm/compiler/backend/flow_graph_compiler.cc: 737: error: expected: !is_optimizing() || !instr->HasUnmatchedInputRepresentations()
version=3.0.0-75.0.dev (dev) (Thu Dec 29 16:50:26 2022 -0800) on "macos_arm64"
pid=72359, thread=-1, isolate_group=isolate(0x13902c800), isolate=(nil)(0x0)
os=macos, arch=arm64, comp=no, sim=no
isolate_instructions=0, vm_instructions=0
pc 0x0000000104819440 fp 0x000000016b738e20 Cr_z_armv8_crc32_little+0x113f54
pc 0x00000001046f3168 fp 0x000000016b738e40 std::__2::align(unsigned long, unsigned long, void*&, unsigned long&)+0x7344
pc 0x000000010495dccc fp 0x000000016b739000 std::__2::__call_once(unsigned long volatile&, void*, void (*)(void*))+0x6eab0
pc 0x000000010495d378 fp 0x000000016b739030 std::__2::__call_once(unsigned long volatile&, void*, void (*)(void*))+0x6e15c
pc 0x0000000104a0c3d0 fp 0x000000016b739040 std::__2::__call_once(unsigned long volatile&, void*, void (*)(void*))+0x11d1b4
pc 0x0000000104a0b2c4 fp 0x000000016b739100 std::__2::__call_once(unsigned long volatile&, void*, void (*)(void*))+0x11c0a8
pc 0x0000000104924cdc fp 0x000000016b739830 std::__2::__call_once(unsigned long volatile&, void*, void (*)(void*))+0x35ac0
pc 0x00000001049253ec fp 0x000000016b739f00 std::__2::__call_once(unsigned long volatile&, void*, void (*)(void*))+0x361d0
pc 0x0000000104920c94 fp 0x000000016b739fd0 std::__2::__call_once(unsigned long volatile&, void*, void (*)(void*))+0x31a78
pc 0x000000010491ea9c fp 0x000000016b73a090 std::__2::__call_once(unsigned long volatile&, void*, void (*)(void*))+0x2f880
pc 0x000000010491953c fp 0x000000016b73a0e0 std::__2::__call_once(unsigned long volatile&, void*, void (*)(void*))+0x2a320
pc 0x00000001049154f0 fp 0x000000016b73a840 std::__2::__call_once(unsigned long volatile&, void*, void (*)(void*))+0x262d4
pc 0x000000010491422c fp 0x000000016b73ace0 std::__2::__call_once(unsigned long volatile&, void*, void (*)(void*))+0x25010
pc 0x0000000104aa34a4 fp 0x000000016b73ae10 Dart_Precompile+0x1c8
pc 0x00000001046ec8ac fp 0x000000016b73afc0 std::__2::align(unsigned long, unsigned long, void*&, unsigned long&)+0xa88
pc 0x000000018cbc3e50 fp 0x000000016b73b2b0 start+0x9f0
-- End of DumpStackTrace
=== Crash occurred when compiling package:barbecue/src/text_render.dart_::_Render|render in AOT mode in GenerateCode pass
=== When compiling block B88[target]:694 ParallelMove ? <- ?, ? <- ?, ? <- ?
=== When compiling instruction v1776 <- UnboxInt64:1012([non-speculative], v32 T{_Smi}) [0, 576460752303423487] T{int}
*** BEGIN CFG
GenerateCode
==== package:barbecue/src/text_render.dart_::_Render|render (RegularFunction)
0: B0[graph]:0 {
v0 <- Constant(#null) T{Null?}
v5 <- Constant(#1) [1, 1] T{_Smi}
v8 <- Constant(#0) [0, 0] T{_Smi}
v11 <- Constant(#4) [4, 4] T{_Smi}
v14 <- Constant(#border) T{_OneByteString}
v19 <- Constant(#TypeArguments: (H1bd5ead4) [Type: Cell] [Type: TextLayout]) T{TypeArguments}
v20 <- Constant(#_ImmutableList len:0) T{_ImmutableList}
v25 <- Constant(#true) T{bool}
v26 <- Constant(#TypeArguments: (H28c6315d) [Type: int]) T{TypeArguments}
v49 <- Constant(#Function '<anonymous closure>': static.) T{Function}
v53 <- Constant(#Function '<anonymous closure>': static.) T{Function}
v69 <- Constant(#Function '<anonymous closure>': static.) T{Function}
v73 <- Constant(#Function '<anonymous closure>': static.) T{Function}
v156 <- Constant(#Function '<anonymous closure>': static.) T{Function}
v308 <- Constant(#false) T{bool}
v413 <- Constant(#Function '<anonymous closure>': static.) T{Function}
v416 <- Constant(#Closure: (int, int) => int from Function '_plus@18294472': static.) T{_Closure}
v423 <- Constant(#Function '<anonymous closure>': static.) T{Function}
v451 <- Constant(#Function '<anonymous closure>': static.) T{Function}
v459 <- Constant(#Function '<anonymous closure>': static.) T{Function}
v567 <- Constant(#5) [5, 5] T{_Smi}
v743 <- Constant(#TypeParameter: X0; bound: Object?) T{_TypeParameter}
v2634 <- UnboxedConstant(#0 int64) [0, 0] T{_Smi}
v2635 <- UnboxedConstant(#1 int64) [1, 1] T{_Smi}
v2651 <- Constant(#Type: int) T{_Type}
}
2: B1[function entry]:2 {
v2 <- SpecialParameter(ArgDescriptor) T{_ImmutableList}
}
4: ParallelMove ? <- ?
4: v4 <- LoadField(v2 . ArgumentsDescriptor.count {final}) [0, 4611686018427387903] T{_Smi}
6: v6 <- BinarySmiOp:4(- [tr], v4, v5) [-1, 4611686018427387902] T{_Smi}
8: v7 <- LoadIndexedUnsafe(fp[v6 + 16]) T{Table}
9: ParallelMove ? <- ?
10: v13 <- LoadIndexed(v2, v11) T{*?}
12: Branch if StrictCompare:16(===, v13, v14) goto (2, 3)
14: B2[target]:20
16: v569 <- LoadIndexed(v2, v567) T{*?}
18: v570 <- BinarySmiOp:10(- [tr], v4, v569) [-4611686018427387903, 4611686018427387903] T{_Smi}
20: v571 <- LoadIndexedUnsafe(fp[v570 + 8]) T{TextBorder??}
22: ParallelMove ? <- ? goto:26 B5
24: B3[target]:22
26: ParallelMove ? <- ? goto:28 B5
28: B5[join]:24 pred(B2, B3) {
v15 <- phi(v571, v0) alive T{TextBorder?}
}
30: CheckStackOverflow:34(stack=0, loop=0)
32: Branch if StrictCompare:38(===, v15, v0) goto (6, 7)
34: B6[target]:42
36: v1252 <- LoadStaticField:4(DEFAULT, CallsInitializer) T{TextBorder}
37: ParallelMove r0 <- r0
38: ParallelMove ? <- ? goto:50 B8
40: B7[target]:46
42: ParallelMove ? <- ? goto:52 B8
44: B8[join]:48 pred(B6, B7) {
v17 <- phi(v1252, v15 T{TextBorder}) alive T{TextBorder}
} ParallelMove ? <- ?
45: ParallelMove ? <- ?
46: PushArgument(v19)
48: PushArgument(v20)
50: v21 <- StaticCall:54( Map._fromLiteral@0150898<0> v19, v20) T{*?}
51: ParallelMove ? <- ?, ? <- ?
52: ParallelMove ? <- ?
52: v1243 <- LoadField:4(v7 . positionedCells, CallsInitializer) T{_GrowableList}
53: ParallelMove ? <- ?
54: v1248 <- LoadField(v1243 . :type_arguments {final}) T{TypeArguments}
55: ParallelMove ? <- ?
56: v1615 <- LoadField(v1243 . GrowableObjectArray.length) [0, 576460752303423487] T{_Smi}
58: v1717 <- UnboxInt64([non-speculative], v1615) [0, 576460752303423487] T{int}
59: ParallelMove ? <- ?
60: ParallelMove ? <- ? goto:84 B11
62: B11[join]:82 pred(B8, B557) {
v2082 <- phi(v2634, v1234) alive [-9223372036854775808, 9223372036854775807] int64 T{int}
}
63: ParallelMove ? <- ?
64: CheckStackOverflow:88(stack=0, loop=1)
66: v3950 <- LoadClassId(<non-smi> v1243)
68: PushArgument(v1243)
69: ParallelMove r0 <- r0
70: v1223 <- DispatchTableCall( cid=v3950 Iterable.length<0>, v1243) T{int}
71: ParallelMove r0 <- r0
72: v1719 <- UnboxInt64([non-speculative], v1223 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
73: ParallelMove ? <- ?
74: Branch if EqualityCompare(v1717 T{int} != v1719 T{int}) T{bool} goto (560, 561)
76: B560[target]:24 ParallelMove r0 <- S-6
78: v1236 <- AllocateObject:26(cls=ConcurrentModificationError, <not-aliased>) T{ConcurrentModificationError}
79: ParallelMove r0 <- r0, r3 <- S-6
80: StoreField(v1236 . modifiedObject = v1243, NoStoreBarrier)
81: ParallelMove r0 <- r0
82: Throw:32(v1236)
84: B561[target]:34 ParallelMove ? <- ?, ? <- ?
86: Branch if RelationalOp(>=, v2082 T{int}, v1719 T{int}) T{bool} goto (10, 9)
88: B10[target]:46 ParallelMove ? <- ?, ? <- ?
90: v16 <- AllocateContext:36(num_variables=8) T{Context}
91: ParallelMove ? <- ?, ? <- ?
92: ParallelMove ? <- ?
92: StoreField(v16 . layouts = v21, NoStoreBarrier)
93: ParallelMove ? <- ?
94: v27 <- LoadField(v7 . columnCount) T{int??}
95: ParallelMove ? <- ?
96: CheckNull:92(v27, CastError) [-9223372036854775808, 9223372036854775807] T{int?}
98: v1720 <- UnboxInt64([non-speculative], v27 T{int?}) [-9223372036854775808, 9223372036854775807] T{int}
100: PushArgument(v26)
102: PushArgument(v1720)
104: PushArgument(v5)
106: v28 <- StaticCall:94( _List@0150898.filled<0> v26, v1720, v5, result_type = T{_List}) T{_List}
107: ParallelMove r0 <- r0, ? <- ?, ? <- ?
108: ParallelMove ? <- ?
108: StoreField(v16 . columnWidths = v28)
109: ParallelMove ? <- ?
110: v29 <- LoadField(v7 . columnCount) T{int??}
112: CheckNull:98(v29, CastError) [-9223372036854775808, 9223372036854775807] T{int?}
114: v1721 <- UnboxInt64([non-speculative], v29 T{int?}) [-9223372036854775808, 9223372036854775807] T{int}
116: v30 <- BinaryInt64Op(+ [tr], v1721, v2635) [-9223372036854775808, 9223372036854775807] T{int}
117: ParallelMove ? <- ?
118: PushArgument(v26)
120: PushArgument(v30)
122: PushArgument(v8)
124: v31 <- StaticCall:102( _List@0150898.filled<0> v26, v30, v8, result_type = T{_List}) T{_List}
125: ParallelMove r0 <- r0, ? <- ?, ? <- ?
126: ParallelMove ? <- ?
126: StoreField(v16 . columnBorderWidths = v31)
127: ParallelMove ? <- ?
128: v32 <- LoadField(v7 . rowCount {final}) [-9223372036854775808, 9223372036854775807] T{int}
129: ParallelMove ? <- ?
130: PushArgument(v26)
132: PushArgument(v32)
134: PushArgument(v5)
136: v33 <- StaticCall:106( _List@0150898.filled<0> v26, v32, v5, result_type = T{_List}) T{_List}
137: ParallelMove r0 <- r0, ? <- ?, ? <- ?
138: ParallelMove ? <- ?
138: StoreField(v16 . rowHeights = v33)
139: ParallelMove ? <- ?
140: v35 <- BinaryInt64Op(+ [tr], v32 T{int}, v2635) [-9223372036854775808, 9223372036854775807] T{int}
141: ParallelMove ? <- ?
142: PushArgument(v26)
144: PushArgument(v35)
146: PushArgument(v8)
148: v36 <- StaticCall:112( _List@0150898.filled<0> v26, v35, v8, result_type = T{_List}) T{_List}
149: ParallelMove r0 <- r0, ? <- ?, ? <- ?
150: ParallelMove ? <- ?
150: StoreField(v16 . rowBorderHeights = v36)
151: ParallelMove ? <- ?
152: v1200 <- LoadField:4(v7 . positionedCells, CallsInitializer) T{_GrowableList}
153: ParallelMove ? <- ?
154: v1205 <- LoadField(v1200 . :type_arguments {final}) T{TypeArguments}
155: ParallelMove ? <- ?
156: v1606 <- LoadField(v1200 . GrowableObjectArray.length) [0, 576460752303423487] T{_Smi}
158: v1722 <- UnboxInt64([non-speculative], v1606) [0, 576460752303423487] T{int}
159: ParallelMove ? <- ?, ? <- ?
160: v1907 <- UnboxInt64:664([non-speculative], v27 T{_Smi}) [-9223372036854775808, 9223372036854775807] T{int}
161: ParallelMove ? <- ?
162: v525 <- LoadField:664(v7 . tableStyle {final}) T{TableStyle}
163: ParallelMove ? <- ?
164: v526 <- LoadField:664(v525 . border {final}) T{bool}
165: ParallelMove ? <- ?
166: ParallelMove ? <- ?, ? <- ? goto:664 B86
168: B86[join]:662 pred(B10, B85) {
v2104 <- phi(v2634, v1191) alive [-9223372036854775808, 9223372036854775807] int64 T{int}
} ParallelMove ? <- ?, ? <- ?
169: ParallelMove ? <- ?
170: CheckStackOverflow:668(stack=0, loop=1)
172: v3951 <- LoadClassId(<non-smi> v1200)
174: PushArgument(v1200)
175: ParallelMove r0 <- r0
176: v1180 <- DispatchTableCall( cid=v3951 Iterable.length<0>, v1200) T{int}
177: ParallelMove r0 <- r0
178: v1724 <- UnboxInt64([non-speculative], v1180 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
179: ParallelMove ? <- ?
180: Branch if EqualityCompare(v1722 T{int} != v1724 T{int}) T{bool} goto (545, 546)
182: B545[target]:24 ParallelMove r0 <- S-22
184: v1193 <- AllocateObject:26(cls=ConcurrentModificationError, <not-aliased>) T{ConcurrentModificationError}
185: ParallelMove r0 <- r0, r3 <- S-22
186: StoreField(v1193 . modifiedObject = v1200, NoStoreBarrier)
187: ParallelMove r0 <- r0
188: Throw:32(v1193)
190: B546[target]:34 ParallelMove ? <- ?, ? <- ?
192: Branch if RelationalOp(>=, v2104 T{int}, v1724 T{int}) T{bool} goto (13, 12)
194: B13[target]:46 ParallelMove ? <- ?, ? <- ?
196: v1110 <- LoadField:4(v7 . positionedCells, CallsInitializer) T{_GrowableList}
197: ParallelMove ? <- ?, ? <- ?, ? <- ?
198: v50 <- AllocateClosure:672(v49, v0) T{_Closure}
199: ParallelMove r0 <- r0
200: PushArgument(v1110)
202: PushArgument(v50)
204: v51 <- StaticCall:674( where<0> v1110, v50, using unchecked entrypoint, result_type = T{WhereIterable}) T{WhereIterable}
205: ParallelMove r0 <- r0
206: PushArgument(v51)
208: v52 <- StaticCall:676( toList<0> v51, using unchecked entrypoint, result_type = T{*}) T{*?}
209: ParallelMove ? <- ?, ? <- ?, r0 <- r0
210: ParallelMove ? <- ?
210: v54 <- AllocateClosure:678(v53, v0) T{_Closure}
211: ParallelMove r0 <- r0
212: PushArgument(v52)
214: PushArgument(v54)
216: StaticCall:680( sort<0> v52, v54, using unchecked entrypoint, result_type = T{??})
217: ParallelMove ? <- ?
218: v3952 <- LoadClassId(<non-smi> v52)
220: PushArgument(v52)
221: ParallelMove ? <- ?
222: v55 <- DispatchTableCall( cid=v3952 Iterable.iterator<0>, v52) T{*?}
223: ParallelMove ? <- ?, ? <- ?
224: ParallelMove ? <- ?
224: v1744 <- UnboxInt64:860([non-speculative], v27 T{_Smi}) [-9223372036854775808, 9223372036854775807] T{int}
225: ParallelMove ? <- ?
226: ParallelMove ? <- ? goto:860 B104
228: B104[join]:858 pred(B13, B103) ParallelMove ? <- ?
230: CheckStackOverflow:864(stack=0, loop=1)
232: v3953 <- LoadClassId(<non-smi> v55 T{*?})
234: PushArgument(v55 T{*?})
235: ParallelMove r0 <- r0
236: v67 <- DispatchTableCall( cid=v3953 Iterator.moveNext<0>, v55 T{*?}) T{bool}
237: ParallelMove r0 <- r0
238: Branch if StrictCompare:688(===, v67, v25) goto (87, 88)
240: B87[target]:692 ParallelMove ? <- ?, ? <- ?
242: v3954 <- LoadClassId(<non-smi> v55 T{*})
244: PushArgument(v55 T{*})
245: ParallelMove r0 <- r0
246: v441 <- DispatchTableCall( cid=v3954 Iterator.current<0>, v55 T{*}) T{*?}
247: ParallelMove r0 <- r0
248: v442 <- LoadField(v441 T{PositionedCell} . columnIndex {final}) [-9223372036854775808, 9223372036854775807] T{int}
249: ParallelMove ? <- ?
250: v443 <- LoadField(v441 T{PositionedCell} . cell {final}) T{Cell}
252: PushArgument(v21 T{Map<Cell, TextLayout>?})
254: PushArgument(v443)
256: v1103 <- StaticCall:10( _getValueOrData@3220832<0> v21 T{Map<Cell, TextLayout>?}, v443, using unchecked entrypoint, result_type = T{*?}) T{Object??}
257: ParallelMove ? <- ?, ? <- ?
258: v1467 <- LoadField(v21 T{Map<Cell, TextLayout>?} . LinkedHashBase.data) T{_List}
260: Branch if StrictCompare:14(===, v1467, v1103) goto (513, 514)
262: B513[target]:18
264: ParallelMove ? <- ? goto:24 B515
266: B514[target]:20
268: ParallelMove ? <- ? goto:26 B515
270: B515[join]:22 pred(B513, B514) {
v1105 <- phi(v0, v1103) alive T{Object??}
} ParallelMove ? <- ?
272: CheckNull:704(v1105 T{SimpleLayout?}, CastError) T{SimpleLayout}
274: PushArgument(v1105 T{SimpleLayout})
276: v446 <- StaticCall:708( measureWidth<0> v1105 T{SimpleLayout}, using unchecked entrypoint, result_type = T{int}) [-9223372036854775808, 9223372036854775807] T{int}
277: ParallelMove r0 <- r0
278: ParallelMove ? <- ?
278: PushArgument(v26)
280: PushArgument(v2634)
282: v447 <- StaticCall:710( _GrowableList@0150898.<0> v26, v2634, result_type = T{_GrowableList}) T{_GrowableList}
283: ParallelMove ? <- ?, ? <- ?
284: ParallelMove ? <- ?
284: v449 <- BinaryInt64Op:732(+ [tr], v442, v2635) [-9223372036854775808, 9223372036854775807] T{int}
285: ParallelMove ? <- ?
286: ParallelMove ? <- ? goto:732 B91
288: B91[join]:730 pred(B506, B515) {
v448 <- phi(v489, v442) alive [-9223372036854775808, 9223372036854775807] int64 T{int}
}
289: ParallelMove ? <- ?
290: CheckStackOverflow:736(stack=0, loop=2)
292: Branch if RelationalOp(<, v448, v449) T{bool} goto (89, 90)
294: B89[target]:722
296: v1456 <- LoadField(v447 . GrowableObjectArray.length) [0, 576460752303423487] T{_Smi}
297: ParallelMove ? <- ?
298: v1461 <- LoadField(v447 . GrowableObjectArray.data) T{_List}
300: v1462 <- LoadField(v1461 . Array.length {final}) [0, 576460752303423487] T{_Smi}
302: Branch if StrictCompare(===, v1456, v1462) T{bool} goto (504, 505)
304: B504[target]:24
306: PushArgument(v447)
308: StaticCall:26( _growToNextCapacity@0150898<0> v447, using unchecked entrypoint, result_type = T{??})
310: ParallelMove goto:32 B506
312: B505[target]:28
314: ParallelMove goto:34 B506
316: B506[join]:30 pred(B504, B505) ParallelMove ? <- ?, ? <- ?, ? <- ?
318: v1727 <- UnboxInt64([non-speculative], v1456) [0, 576460752303423487] T{int}
320: v1093 <- BinaryInt64Op(+ [tr], v1727 T{_Smi}, v2635) [1, 576460752303423488] T{int}
322: v1728 <- BoxInt64(v1093) [1, 576460752303423488] T{_Smi}
324: StoreField(v447 . GrowableObjectArray.length = v1728, NoStoreBarrier)
325: ParallelMove r0 <- r0, ? <- ?
326: GenericCheckBound:40(v1093 T{_Smi}, v1727 T{_Smi}) [-4611686018427387904, 4611686018427387903] T{_Smi}
328: v1096 <- LoadField(v447 . GrowableObjectArray.data) T{_List}
330: v1725 <- BoxInt64(v448 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
331: ParallelMove ? <- ?, r0 <- r0
332: StoreIndexed:40(v1096, v1727 T{_Smi}, v1725 T{int})
334: v489 <- BinaryInt64Op(+ [tr], v448, v2635) [-9223372036854775808, 9223372036854775807] T{int}
336: ParallelMove r3 <- r3, ? <- ?, ? <- ?, ? <- ? goto:734 B91
338: B90[target]:724 ParallelMove ? <- ?
339: ParallelMove ? <- ?, ? <- ?
340: v452 <- AllocateClosure:738(v451, v16) T{_Closure}
341: ParallelMove r0 <- r0
342: PushArgument(v26)
344: PushArgument(v447)
346: PushArgument(v452)
348: v453 <- StaticCall:740( map<1> v26, v447, v452, using unchecked entrypoint, result_type = T{MappedListIterable}) T{MappedListIterable}
349: ParallelMove r0 <- r0
350: PushArgument(v26)
352: PushArgument(v453)
354: PushArgument(v8)
356: PushArgument(v416)
358: v454 <- StaticCall:742( fold<1> v26, v453, v8, v416, using unchecked entrypoint, result_type = T{int}) [-9223372036854775808, 9223372036854775807] T{int}
359: ParallelMove r0 <- r0
360: ParallelMove ? <- ?
360: PushArgument(v26)
362: PushArgument(v2634)
364: v455 <- StaticCall:744( _GrowableList@0150898.<0> v26, v2634, result_type = T{_GrowableList}) T{_GrowableList}
365: ParallelMove r0 <- r0
366: ParallelMove ? <- ?
366: ParallelMove ? <- ? goto:766 B94
368: B94[join]:764 pred(B90, B497) {
v456 <- phi(v442, v488) alive [-9223372036854775808, 9223372036854775807] int64 T{int}
} ParallelMove ? <- ?
369: ParallelMove ? <- ?
370: CheckStackOverflow:770(stack=2, loop=2)
372: Branch if RelationalOp(<, v456, v449 T{int}) T{bool} goto (92, 93)
374: B92[target]:756
376: v1445 <- LoadField(v455 . GrowableObjectArray.length) [0, 576460752303423487] T{_Smi}
377: ParallelMove ? <- ?
378: v1450 <- LoadField(v455 . GrowableObjectArray.data) T{_List}
380: v1451 <- LoadField(v1450 . Array.length {final}) [0, 576460752303423487] T{_Smi}
382: Branch if StrictCompare(===, v1445, v1451) T{bool} goto (495, 496)
384: B495[target]:24
386: PushArgument(v455)
388: StaticCall:26( _growToNextCapacity@0150898<0> v455, using unchecked entrypoint, result_type = T{??})
390: ParallelMove goto:32 B497
392: B496[target]:28
394: ParallelMove goto:34 B497
396: B497[join]:30 pred(B495, B496) ParallelMove ? <- ?, ? <- ?, ? <- ?
398: v1734 <- UnboxInt64([non-speculative], v1445) [0, 576460752303423487] T{int}
400: v1078 <- BinaryInt64Op(+ [tr], v1734 T{_Smi}, v2635) [1, 576460752303423488] T{int}
402: v1735 <- BoxInt64(v1078) [1, 576460752303423488] T{_Smi}
404: StoreField(v455 . GrowableObjectArray.length = v1735, NoStoreBarrier)
405: ParallelMove r0 <- r0, ? <- ?
406: GenericCheckBound:40(v1078 T{_Smi}, v1734 T{_Smi}) [-4611686018427387904, 4611686018427387903] T{_Smi}
408: v1081 <- LoadField(v455 . GrowableObjectArray.data) T{_List}
410: v1732 <- BoxInt64(v456 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
411: ParallelMove ? <- ?, r0 <- r0
412: StoreIndexed:40(v1081, v1734 T{_Smi}, v1732 T{int})
414: v488 <- BinaryInt64Op(+ [tr], v456, v2635) [-9223372036854775808, 9223372036854775807] T{int}
416: ParallelMove ? <- ?, ? <- ? goto:768 B94
418: B93[target]:758 ParallelMove ? <- ?, ? <- ?, ? <- ?
419: ParallelMove ? <- ?, ? <- ?
420: v460 <- AllocateClosure:772(v459, v16) T{_Closure}
421: ParallelMove r0 <- r0
422: PushArgument(v26)
424: PushArgument(v455)
426: PushArgument(v460)
428: v461 <- StaticCall:774( map<1> v26, v455, v460, using unchecked entrypoint, result_type = T{MappedListIterable}) T{MappedListIterable}
429: ParallelMove r0 <- r0
430: PushArgument(v26)
432: PushArgument(v461)
434: PushArgument(v8)
436: PushArgument(v416)
438: v462 <- StaticCall:776( fold<1> v26, v461, v8, v416, using unchecked entrypoint, result_type = T{int}) [-9223372036854775808, 9223372036854775807] T{int}
439: ParallelMove ? <- ?, ? <- ?
440: v1731 <- UnboxInt64([non-speculative], v454) [-9223372036854775808, 9223372036854775807] T{int}
442: v1738 <- UnboxInt64([non-speculative], v462) [-9223372036854775808, 9223372036854775807] T{int}
444: v463 <- BinaryInt64Op(+ [tr], v1731 T{int}, v1738 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
445: ParallelMove ? <- ?
446: v464 <- BinaryInt64Op(- [tr], v446, v463) [-9223372036854775808, 9223372036854775807] T{int}
448: Branch if RelationalOp(>, v464, v2634) T{bool} goto (95, 102)
450: B95[target]:790 ParallelMove ? <- ?
452: v473 <- BinaryInt64Op(- [tr], v464, v464 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
454: v1066 <- LoadField:844(v447 . GrowableObjectArray.length) [0, 576460752303423487] T{_Smi}
456: v1739 <- UnboxInt64:844([non-speculative], v1066) [0, 576460752303423487] T{int}
458: v593 <- LoadField:844(v447 . GrowableObjectArray.data) T{_List}
460: v487 <- BinaryInt64Op:844(+ [tr], v464 T{int}, v2635) [-9223372036854775808, 9223372036854775807] T{int}
462: ParallelMove ? <- ?, ? <- ? goto:844 B101
464: B101[join]:842 pred(B95, B100) {
v475 <- phi(v2634, v486) alive [-9223372036854775808, 9223372036854775807] int64 T{int}
}
466: CheckStackOverflow:848(stack=0, loop=2)
468: Branch if RelationalOp(<, v475, v1739 T{_Smi}) T{bool} goto (96, 97)
470: B96[target]:808
472: v2636 <- LoadIndexed(v593, v475 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
474: Branch if RelationalOp(<, v475 T{int}, v473) T{bool} goto (98, 99)
476: B98[target]:824
478: ParallelMove ? <- ? goto:832 B100
480: B99[target]:828
482: ParallelMove ? <- ? goto:834 B100
484: B100[join]:830 pred(B98, B99) {
v481 <- phi(v487, v464 T{int}) alive [-9223372036854775808, 9223372036854775807] int64 T{int}
}
486: v1743 <- UnboxInt64([non-speculative], v2636 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
487: ParallelMove ? <- ?, ? <- ?
488: GenericCheckBound:836(v1744 T{_Smi}, v1743 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
490: v2637 <- LoadIndexed(v28, v1743 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
492: v1746 <- UnboxInt64([non-speculative], v2637 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
494: v484 <- BinaryInt64Op(+ [tr], v1746 T{int}, v481) [-9223372036854775808, 9223372036854775807] T{int}
496: v1747 <- BoxInt64(v484 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
497: ParallelMove ? <- ?, r0 <- r0
498: StoreIndexed:840(v28, v1743 T{int}, v1747 T{int})
500: v486 <- BinaryInt64Op(+ [tr], v475 T{int}, v2635) [-9223372036854775808, 9223372036854775807] T{int}
502: ParallelMove ? <- ? goto:846 B101
504: B97[target]:810
506: ParallelMove goto:854 B103
508: B102[target]:850 ParallelMove ? <- ?
510: ParallelMove goto:856 B103
512: B103[join]:852 pred(B97, B102)
514: ParallelMove ? <- ?, ? <- ?, ? <- ?, ? <- ? goto:862 B104
516: B88[target]:694 ParallelMove ? <- ?, ? <- ?, ? <- ?
518: v1061 <- LoadField:4(v7 . positionedCells, CallsInitializer) T{_GrowableList}
519: ParallelMove ? <- ?, ? <- ?, ? <- ?
520: v70 <- AllocateClosure:868(v69, v0) T{_Closure}
521: ParallelMove r0 <- r0
522: PushArgument(v1061)
524: PushArgument(v70)
526: v71 <- StaticCall:870( where<0> v1061, v70, using unchecked entrypoint, result_type = T{WhereIterable}) T{WhereIterable}
527: ParallelMove r0 <- r0
528: PushArgument(v71)
530: v72 <- StaticCall:872( toList<0> v71, using unchecked entrypoint, result_type = T{*}) T{*?}
531: ParallelMove ? <- ?, ? <- ?, r0 <- r0
532: ParallelMove ? <- ?
532: v74 <- AllocateClosure:874(v73, v0) T{_Closure}
533: ParallelMove r0 <- r0
534: PushArgument(v72)
536: PushArgument(v74)
538: StaticCall:876( sort<0> v72, v74, using unchecked entrypoint, result_type = T{??})
539: ParallelMove ? <- ?
540: v3955 <- LoadClassId(<non-smi> v72)
542: PushArgument(v72)
543: ParallelMove ? <- ?
544: v75 <- DispatchTableCall( cid=v3955 Iterable.iterator<0>, v72) T{*?}
545: ParallelMove ? <- ?, ? <- ?
546: ParallelMove ? <- ?
546: v1776 <- UnboxInt64:1012([non-speculative], v32 T{_Smi}) [0, 576460752303423487] T{int}
547: ParallelMove S-25 <- r3
548: ParallelMove r5 <- S-15 goto:1012 B116
550: B116[join]:1010 pred(B88, B115) ParallelMove r4 <- S-7
552: CheckStackOverflow:1016(stack=0, loop=1)
554: v3956 <- LoadClassId(<non-smi> v75 T{*?})
556: PushArgument(v75 T{*?})
557: ParallelMove r0 <- r0
558: v85 <- DispatchTableCall( cid=v3956 Iterator.moveNext<0>, v75 T{*?}) T{bool}
559: ParallelMove r0 <- r0
560: Branch if StrictCompare:884(===, v85, v25) goto (105, 106)
562: B105[target]:888 ParallelMove r2 <- S-7, r1 <- S-24
564: v3957 <- LoadClassId(<non-smi> v75 T{*})
566: PushArgument(v75 T{*})
567: ParallelMove r0 <- r0
568: v403 <- DispatchTableCall( cid=v3957 Iterator.current<0>, v75 T{*}) T{*?}
569: ParallelMove r0 <- r0
570: v404 <- LoadField(v403 T{PositionedCell} . rowIndex {final}) [-9223372036854775808, 9223372036854775807] T{int}
571: ParallelMove S-26 <- r1
572: v405 <- LoadField(v403 T{PositionedCell} . cell {final}) T{Cell}
574: PushArgument(v21 T{Map<Cell, TextLayout>?})
576: PushArgument(v405)
578: v1054 <- StaticCall:10( _getValueOrData@3220832<0> v21 T{Map<Cell, TextLayout>?}, v405, using unchecked entrypoint, result_type = T{*?}) T{Object??}
579: ParallelMove r1 <- r0, r0 <- S-7
580: v1440 <- LoadField(v21 T{Map<Cell, TextLayout>?} . LinkedHashBase.data) T{_List}
582: Branch if StrictCompare:14(===, v1440, v1054) goto (487, 488)
584: B487[target]:18
586: ParallelMove r2 <- C goto:24 B489
588: B488[target]:20
590: ParallelMove r2 <- r1 goto:26 B489
592: B489[join]:22 pred(B487, B488) {
v1056 <- phi(v0, v1054) alive T{Object??}
} ParallelMove r1 <- S-26
594: CheckNull:900(v1056 T{SimpleLayout?}, CastError) T{SimpleLayout}
596: PushArgument(v1056 T{SimpleLayout})
598: v408 <- StaticCall:904( measureHeight<0> v1056 T{SimpleLayout}, using unchecked entrypoint, result_type = T{int}) [-9223372036854775808, 9223372036854775807] T{int}
599: ParallelMove r0 <- r0
600: ParallelMove S-27 <- r0
600: PushArgument(v26)
602: PushArgument(v2634)
604: v409 <- StaticCall:906( _GrowableList@0150898.<0> v26, v2634, result_type = T{_GrowableList}) T{_GrowableList}
605: ParallelMove r1 <- r0, r0 <- S-26
606: ParallelMove S-31 <- r1
606: v411 <- BinaryInt64Op:928(+ [tr], v404, v2635) [-9223372036854775808, 9223372036854775807] T{int}
607: ParallelMove S-29 <- r2
608: ParallelMove r0 <- r0 goto:928 B109
610: B109[join]:926 pred(B480, B489) {
v410 <- phi(v440, v404) alive [-9223372036854775808, 9223372036854775807] int64 T{int}
}
611: ParallelMove S-26 <- r0
612: CheckStackOverflow:932(stack=0, loop=2)
614: Branch if RelationalOp(<, v410, v411) T{bool} goto (107, 108)
616: B107[target]:918
618: v1429 <- LoadField(v409 . GrowableObjectArray.length) [0, 576460752303423487] T{_Smi}
619: ParallelMove S-28 <- r3
620: v1434 <- LoadField(v409 . GrowableObjectArray.data) T{_List}
622: v1435 <- LoadField(v1434 . Array.length {final}) [0, 576460752303423487] T{_Smi}
624: Branch if StrictCompare(===, v1429, v1435) T{bool} goto (478, 479)
626: B478[target]:24
628: PushArgument(v409)
630: StaticCall:26( _growToNextCapacity@0150898<0> v409, using unchecked entrypoint, result_type = T{??})
632: ParallelMove goto:32 B480
634: B479[target]:28
636: ParallelMove goto:34 B480
638: B480[join]:30 pred(B478, B479) ParallelMove r3 <- S-31, r2 <- S-26, r0 <- S-28
640: v1752 <- UnboxInt64([non-speculative], v1429) [0, 576460752303423487] T{int}
642: v1044 <- BinaryInt64Op(+ [tr], v1752 T{_Smi}, v2635) [1, 576460752303423488] T{int}
644: v1753 <- BoxInt64(v1044) [1, 576460752303423488] T{_Smi}
646: StoreField(v409 . GrowableObjectArray.length = v1753, NoStoreBarrier)
647: ParallelMove r0 <- r0, r1 <- r4
648: GenericCheckBound:40(v1044 T{_Smi}, v1752 T{_Smi}) [-4611686018427387904, 4611686018427387903] T{_Smi}
650: v1047 <- LoadField(v409 . GrowableObjectArray.data) T{_List}
652: v1750 <- BoxInt64(v410 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
653: ParallelMove r1 <- r5, r0 <- r0
654: StoreIndexed:40(v1047, v1752 T{_Smi}, v1750 T{int})
656: v440 <- BinaryInt64Op(+ [tr], v410, v2635) [-9223372036854775808, 9223372036854775807] T{int}
658: ParallelMove r0 <- r0, r1 <- r3, r2 <- S-29 goto:930 B109
660: B108[target]:920 ParallelMove r3 <- r1
661: ParallelMove r1 <- C, r2 <- S-9
662: v414 <- AllocateClosure:934(v413, v16) T{_Closure}
663: ParallelMove r0 <- r0
664: PushArgument(v26)
666: PushArgument(v409)
668: PushArgument(v414)
670: v415 <- StaticCall:936( map<1> v26, v409, v414, using unchecked entrypoint, result_type = T{MappedListIterable}) T{MappedListIterable}
671: ParallelMove r0 <- r0
672: PushArgument(v26)
674: PushArgument(v415)
676: PushArgument(v8)
678: PushArgument(v416)
680: v417 <- StaticCall:938( fold<1> v26, v415, v8, v416, using unchecked entrypoint, result_type = T{int}) [-9223372036854775808, 9223372036854775807] T{int}
681: ParallelMove r0 <- r0
682: ParallelMove S-28 <- r0
682: PushArgument(v26)
684: PushArgument(v2634)
686: v418 <- StaticCall:940( _GrowableList@0150898.<0> v26, v2634, result_type = T{_GrowableList}) T{_GrowableList}
687: ParallelMove r0 <- r0
688: ParallelMove S-33 <- r0
688: ParallelMove r2 <- S-29 goto:964 B112
690: B112[join]:962 pred(B108, B471) {
v420 <- phi(v411 T{int}, v439) alive [-9223372036854775808, 9223372036854775807] int64 T{int}
} ParallelMove r1 <- S-29
691: ParallelMove S-26 <- r2
692: CheckStackOverflow:968(stack=2, loop=2)
694: Branch if RelationalOp(<, v420, v411 T{int}) T{bool} goto (110, 111)
696: B110[target]:954
698: v1418 <- LoadField(v418 . GrowableObjectArray.length) [0, 576460752303423487] T{_Smi}
699: ParallelMove S-32 <- r3
700: v1423 <- LoadField(v418 . GrowableObjectArray.data) T{_List}
702: v1424 <- LoadField(v1423 . Array.length {final}) [0, 576460752303423487] T{_Smi}
704: Branch if StrictCompare(===, v1418, v1424) T{bool} goto (469, 470)
706: B469[target]:24
708: PushArgument(v418)
710: StaticCall:26( _growToNextCapacity@0150898<0> v418, using unchecked entrypoint, result_type = T{??})
712: ParallelMove goto:32 B471
714: B470[target]:28
716: ParallelMove goto:34 B471
718: B471[join]:30 pred(B469, B470) ParallelMove r3 <- S-33, r2 <- S-26, r0 <- S-32
720: v1759 <- UnboxInt64([non-speculative], v1418) [0, 576460752303423487] T{int}
722: v1029 <- BinaryInt64Op(+ [tr], v1759 T{_Smi}, v2635) [1, 576460752303423488] T{int}
724: v1760 <- BoxInt64(v1029) [1, 576460752303423488] T{_Smi}
726: StoreField(v418 . GrowableObjectArray.length = v1760, NoStoreBarrier)
727: ParallelMove r0 <- r0, r1 <- r4
728: GenericCheckBound:40(v1029 T{_Smi}, v1759 T{_Smi}) [-4611686018427387904, 4611686018427387903] T{_Smi}
730: v1032 <- LoadField(v418 . GrowableObjectArray.data) T{_List}
732: v1757 <- BoxInt64(v420 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
733: ParallelMove r1 <- r5, r0 <- r0
734: StoreIndexed:40(v1032, v1759 T{_Smi}, v1757 T{int})
736: v439 <- BinaryInt64Op(+ [tr], v420, v2635) [-9223372036854775808, 9223372036854775807] T{int}
738: ParallelMove r2 <- r0, r0 <- r3 goto:966 B112
740: B111[target]:956 ParallelMove r4 <- S-27, r0 <- S-28, r3 <- r0
741: ParallelMove r1 <- C, r2 <- S-9
742: v424 <- AllocateClosure:970(v423, v16) T{_Closure}
743: ParallelMove r0 <- r0
744: PushArgument(v26)
746: PushArgument(v418)
748: PushArgument(v424)
750: v425 <- StaticCall:972( map<1> v26, v418, v424, using unchecked entrypoint, result_type = T{MappedListIterable}) T{MappedListIterable}
751: ParallelMove r0 <- r0
752: PushArgument(v26)
754: PushArgument(v425)
756: PushArgument(v8)
758: PushArgument(v416)
760: v426 <- StaticCall:974( fold<1> v26, v425, v8, v416, using unchecked entrypoint, result_type = T{int}) [-9223372036854775808, 9223372036854775807] T{int}
761: ParallelMove r1 <- r0, r0 <- S-28
762: v1756 <- UnboxInt64([non-speculative], v417) [-9223372036854775808, 9223372036854775807] T{int}
764: v1763 <- UnboxInt64([non-speculative], v426) [-9223372036854775808, 9223372036854775807] T{int}
766: v427 <- BinaryInt64Op(+ [tr], v1756 T{int}, v1763 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
767: ParallelMove r0 <- S-27
768: v428 <- BinaryInt64Op(- [tr], v408, v427) [-9223372036854775808, 9223372036854775807] T{int}
770: Branch if RelationalOp(>, v428, v2634) T{bool} goto (113, 114)
772: B113[target]:988 ParallelMove r0 <- S-31
774: v435 <- BinaryInt64Op(- [tr], v428, v428 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
776: v1413 <- LoadField(v409 . GrowableObjectArray.length) [0, 576460752303423487] T{_Smi}
778: v1767 <- UnboxInt64:56([non-speculative], v1413) [0, 576460752303423487] T{int}
780: v1016 <- LoadField:56(v409 . GrowableObjectArray.data) T{_List}
782: v1556 <- BinaryInt64Op:56(+ [tr], v428 T{int}, v2635) [-9223372036854775808, 9223372036854775807] T{int}
784: ParallelMove r9 <- C, r8 <- C, r7 <- S-15 goto:56 B465
786: B465[join]:54 pred(B113, B464) {
v1003 <- phi(v2634, v1012) alive [-9223372036854775808, 9223372036854775807] int64 T{int}
v2970 <- phi(v2634, v1554 T{int}) alive [-9223372036854775808, 9223372036854775807] int64 T{int}
}
788: CheckStackOverflow:60(stack=0, loop=1)
790: Branch if RelationalOp(<, v1003, v1767 T{_Smi}) T{bool} goto (461, 462)
792: B461[target]:22
794: v2638 <- LoadIndexed(v1016, v1003 T{int}) T{*?}
796: Branch if RelationalOp(<, v2970 T{int}, v435 T{int}) T{bool} goto (663, 664)
798: B663[target]:18
800: ParallelMove r10 <- r6 goto:26 B464
802: B664[target]:22
804: ParallelMove r10 <- r2 goto:28 B464
806: B464[join]:24 pred(B663, B664) {
v1545 <- phi(v1556 T{int}, v428 T{int}) alive [-9223372036854775808, 9223372036854775807] int64 T{int}
}
808: v1771 <- UnboxInt64([non-speculative], v2638 T{*?}) [-9223372036854775808, 9223372036854775807] T{int}
809: ParallelMove r0 <- S-25, r1 <- r11
810: GenericCheckBound:30(v1776 T{_Smi}, v1771) [-9223372036854775808, 9223372036854775807] T{int}
812: v2639 <- LoadIndexed(v33, v1771 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
814: v1778 <- UnboxInt64([non-speculative], v2639 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
816: v1549 <- BinaryInt64Op(+ [tr], v1778 T{int}, v1545 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
818: v1780 <- BoxInt64(v1549 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
819: ParallelMove r1 <- r7, r0 <- r0
820: StoreIndexed:34(v33, v1771 T{int}, v1780 T{int})
822: v1554 <- BinaryInt64Op(+ [tr], v2970 T{int}, v2635) [-9223372036854775808, 9223372036854775807] T{int}
824: v1012 <- BinaryInt64Op(+ [tr], v1003 T{int}, v2635) [-9223372036854775808, 9223372036854775807] T{int}
826: ParallelMove r9 <- r1, r8 <- r0 goto:58 B465
828: B462[target]:24
830: ParallelMove goto:1006 B115
832: B114[target]:1002 ParallelMove r7 <- S-15
834: ParallelMove goto:1008 B115
836: B115[join]:1004 pred(B114, B462)
838: ParallelMove r1 <- S-12, r5 <- r7, r2 <- S-24, r3 <- S-25 goto:1014 B116
840: B106[target]:890 ParallelMove r2 <- S-9, r1 <- S-8, r7 <- S-15
842: v1785 <- UnboxInt64([non-speculative], v27 T{_Smi}) [-9223372036854775808, 9223372036854775807] T{int}
843: ParallelMove S-26 <- r0
844: v88 <- BinaryInt64Op(+ [tr], v1785 T{_Smi}, v2635) [-9223372036854775808, 9223372036854775807] T{int}
845: ParallelMove S-25 <- r1
846: PushArgument(v26)
848: PushArgument(v88)
850: PushArgument(v8)
852: v89 <- StaticCall:1022( _List@0150898.filled<0> v26, v88, v8, result_type = T{_List}) T{_List}
853: ParallelMove r0 <- r0, r1 <- r0, r2 <- S-9
854: ParallelMove S-24 <- r1
854: StoreField(v16 . tableLefts = v89)
856: PushArgument(v26)
857: ParallelMove r0 <- S-26
858: PushArgument(v1785 T{_Smi})
860: v92 <- StaticCall:1026( Iterable.generate<0> v26, v1785 T{_Smi}, result_type = T{*}) T{*?}
861: ParallelMove r0 <- r0
862: v3958 <- LoadClassId(<non-smi> v92)
864: PushArgument(v92)
865: ParallelMove r0 <- r1
866: v93 <- DispatchTableCall( cid=v3958 Iterable.iterator<0>, v92) T{*?}
867: ParallelMove r1 <- r0
868: ParallelMove S-28 <- r1
868: ParallelMove r4 <- C, r2 <- S-11, r3 <- S-13 goto:1056 B119
870: B119[join]:1054 pred(B106, B117) {
v94 <- phi(v2634, v402) alive [-9223372036854775808, 9223372036854775807] int64 T{int}
}
871: ParallelMove S-27 <- r4
872: CheckStackOverflow:1060(stack=0, loop=1)
874: v3959 <- LoadClassId(<non-smi> v93 T{*?})
876: PushArgument(v93 T{*?})
877: ParallelMove r0 <- r0
878: v95 <- DispatchTableCall( cid=v3959 Iterator.moveNext<0>, v93 T{*?}) T{bool}
879: ParallelMove r0 <- r0
880: Branch if StrictCompare:1034(===, v95, v25) goto (117, 118)
882: B117[target]:1038 ParallelMove r2 <- S-11, r3 <- S-13, r1 <- S-28, r4 <- S-27
884: v3960 <- LoadClassId(<non-smi> v93 T{*})
886: PushArgument(v93 T{*})
887: ParallelMove r0 <- r0
888: v395 <- DispatchTableCall( cid=v3960 Iterator.current<0>, v93 T{*}) T{*?}
889: ParallelMove r0 <- r0
890: v1791 <- UnboxInt64([non-speculative], v395 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
891: ParallelMove r0 <- S-25, r1 <- r2
892: GenericCheckBound:1044(v88 T{_Smi}, v1791 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
893: ParallelMove r3 <- S-27
894: v1788 <- BoxInt64(v94) [-9223372036854775808, 9223372036854775807] T{int}
895: ParallelMove r1 <- S-24, r0 <- r0
896: StoreIndexed:1044(v89, v1791 T{int}, v1788 T{int})
897: ParallelMove r0 <- S-26, r1 <- r2
898: GenericCheckBound:1046(v1785 T{_Smi}, v1791 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
899: ParallelMove r5 <- S-11
900: v2640 <- LoadIndexed(v28, v1791 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
901: ParallelMove r0 <- S-10, r1 <- r2
902: GenericCheckBound:1048(v30 T{_Smi}, v1791 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
903: ParallelMove r6 <- S-13
904: v2641 <- LoadIndexed(v31, v1791 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
906: v1796 <- UnboxInt64([non-speculative], v2640 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
908: v1799 <- UnboxInt64([non-speculative], v2641 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
910: v401 <- BinaryInt64Op(+ [tr], v1796 T{int}, v1799 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
912: v402 <- BinaryInt64Op(+ [tr], v94, v401) [-9223372036854775808, 9223372036854775807] T{int}
914: ParallelMove r4 <- r4, r2 <- r5, r3 <- r6, r1 <- S-28 goto:1058 B119
916: B118[target]:1040 ParallelMove r2 <- S-9, r6 <- S-13, r5 <- S-12, r3 <- S-27, r4 <- S-26
917: ParallelMove r0 <- S-25, r1 <- r4
918: GenericCheckBound:1064(v88 T{_Smi}, v1785 T{_Smi}) [-4611686018427387904, 4611686018427387903] T{_Smi}
920: v1787 <- BoxInt64(v94) [-9223372036854775808, 9223372036854775807] T{int}
921: ParallelMove r1 <- S-24, r0 <- r0
922: StoreIndexed:1064(v89, v1785 T{_Smi}, v1787 T{int})
923: ParallelMove r0 <- S-10, r1 <- r4
924: GenericCheckBound:1068(v30 T{_Smi}, v1785 T{_Smi}) [-4611686018427387904, 4611686018427387903] T{_Smi}
926: v2642 <- LoadIndexed(v31, v1785 T{_Smi}) [-9223372036854775808, 9223372036854775807] T{int}
928: v1806 <- UnboxInt64([non-speculative], v2642 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
930: v103 <- BinaryInt64Op(+ [tr], v94, v1806 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
931: ParallelMove S-29 <- r0
932: v106 <- BinaryInt64Op(+ [tr], v32 T{_Smi}, v2635) [-9223372036854775808, 9223372036854775807] T{int}
933: ParallelMove S-26 <- r1
934: PushArgument(v26)
936: PushArgument(v106)
938: PushArgument(v8)
940: v107 <- StaticCall:1076( _List@0150898.filled<0> v26, v106, v8, result_type = T{_List}) T{_List}
941: ParallelMove r0 <- r0, r1 <- r0, r2 <- S-9
942: ParallelMove S-28 <- r1
942: StoreField(v16 . tableTops = v107)
944: PushArgument(v26)
945: ParallelMove r0 <- S-12
946: PushArgument(v32 T{_Smi})
948: v110 <- StaticCall:1080( Iterable.generate<0> v26, v32 T{_Smi}, result_type = T{*}) T{*?}
949: ParallelMove r0 <- r0
950: v3961 <- LoadClassId(<non-smi> v110)
952: PushArgument(v110)
953: ParallelMove r0 <- r1
954: v111 <- DispatchTableCall( cid=v3961 Iterable.iterator<0>, v110) T{*?}
955: ParallelMove r1 <- r0
956: ParallelMove S-31 <- r1
956: ParallelMove r4 <- C, r2 <- S-15, r3 <- S-23 goto:1110 B122
958: B122[join]:1108 pred(B118, B120) {
v112 <- phi(v2634, v394) alive [-9223372036854775808, 9223372036854775807] int64 T{int}
}
959: ParallelMove S-27 <- r4
960: CheckStackOverflow:1114(stack=0, loop=1)
962: v3962 <- LoadClassId(<non-smi> v111 T{*?})
964: PushArgument(v111 T{*?})
965: ParallelMove r0 <- r0
966: v113 <- DispatchTableCall( cid=v3962 Iterator.moveNext<0>, v111 T{*?}) T{bool}
967: ParallelMove r0 <- r0
968: Branch if StrictCompare:1088(===, v113, v25) goto (120, 121)
970: B120[target]:1092 ParallelMove r2 <- S-15, r3 <- S-23, r1 <- S-31, r4 <- S-27
972: v3963 <- LoadClassId(<non-smi> v111 T{*})
974: PushArgument(v111 T{*})
975: ParallelMove r0 <- r0
976: v387 <- DispatchTableCall( cid=v3963 Iterator.current<0>, v111 T{*}) T{*?}
977: ParallelMove r0 <- r0
978: v1814 <- UnboxInt64([non-speculative], v387 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
979: ParallelMove r0 <- S-26, r1 <- r2
980: GenericCheckBound:1098(v106 T{_Smi}, v1814 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
981: ParallelMove r3 <- S-27
982: v1811 <- BoxInt64(v112) [-9223372036854775808, 9223372036854775807] T{int}
983: ParallelMove r1 <- S-28, r0 <- r0
984: StoreIndexed:1098(v107, v1814 T{int}, v1811 T{int})
985: ParallelMove r0 <- S-12, r1 <- r2
986: GenericCheckBound:1100(v32 T{_Smi}, v1814 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
987: ParallelMove r6 <- S-15
988: v2643 <- LoadIndexed(v33, v1814 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
989: ParallelMove r0 <- S-14, r1 <- r2
990: GenericCheckBound:1102(v35 T{_Smi}, v1814 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
991: ParallelMove r5 <- S-23
992: v2644 <- LoadIndexed(v36, v1814 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
994: v1819 <- UnboxInt64([non-speculative], v2643 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
996: v1822 <- UnboxInt64([non-speculative], v2644 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
998: v393 <- BinaryInt64Op(+ [tr], v1819 T{int}, v1822 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
1000: v394 <- BinaryInt64Op(+ [tr], v112, v393) [-9223372036854775808, 9223372036854775807] T{int}
1002: ParallelMove r4 <- r4, r2 <- r6, r3 <- r5, r1 <- S-31 goto:1112 B122
1004: B121[target]:1094 ParallelMove r2 <- S-9, r9 <- S-2, r4 <- S-12, r8 <- S-14, r5 <- S-23, r6 <- S-29, r3 <- S-27, r7 <- S-18
1005: ParallelMove r0 <- S-26, r1 <- r4
1006: GenericCheckBound:1118(v106 T{_Smi}, v32 T{_Smi}) [-4611686018427387904, 4611686018427387903] T{_Smi}
1008: v1810 <- BoxInt64(v112) [-9223372036854775808, 9223372036854775807] T{int}
1009: ParallelMove r1 <- S-28, r0 <- r0
1010: StoreIndexed:1118(v107, v32 T{_Smi}, v1810 T{int})
1011: ParallelMove r0 <- r8, r1 <- r4
1012: GenericCheckBound:1122(v35 T{_Smi}, v32 T{_Smi}) [-4611686018427387904, 4611686018427387903] T{_Smi}
1014: v2645 <- LoadIndexed(v36, v32 T{_Smi}) [-9223372036854775808, 9223372036854775807] T{int}
1016: v1829 <- UnboxInt64([non-speculative], v2645 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
1018: v121 <- BinaryInt64Op(+ [tr], v112, v1829 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
1019: ParallelMove S-30 <- r10
1020: v1807 <- BoxInt64(v103) [-9223372036854775808, 9223372036854775807] T{int}
1021: ParallelMove r0 <- r0
1022: ParallelMove S-31 <- r0
1022: v122 <- AllocateObject:1126(cls=TextSurface) T{TextSurface}
1023: ParallelMove r0 <- r0
1024: ParallelMove S-32 <- r0
1024: PushArgument(v122)
1026: PushArgument(v1807 T{int})
1027: ParallelMove r1 <- S-30
1028: PushArgument(v121)
1030: StaticCall:1128( TextSurface.<0> v122, v1807 T{int}, v121)
1031: ParallelMove r0 <- S-32, r2 <- S-9
1032: StoreField(v16 . surface = v122)
1034: PushArgument(v26)
1035: ParallelMove r0 <- S-14
1036: PushArgument(v35 T{int})
1038: v125 <- StaticCall:1134( Iterable.generate<0> v26, v35 T{int}, result_type = T{*}) T{*?}
1039: ParallelMove r0 <- r0
1040: v3964 <- LoadClassId(<non-smi> v125)
1042: PushArgument(v125)
1043: ParallelMove r0 <- r1
1044: v126 <- DispatchTableCall( cid=v3964 Iterable.iterator<0>, v125) T{*?}
1045: ParallelMove r1 <- r0, r7 <- S-18
1046: ParallelMove S-36 <- r1
1046: v255 <- LoadField:2408(v525 . border {final}) T{bool}
1047: ParallelMove r8 <- S-2, S-35 <- r2
1048: v262 <- LoadField:2408(v17 . horizontal {final}) T{String}
1049: ParallelMove S-34 <- r3
1050: v289 <- LoadField:2408(v17 . vertical {final}) T{String}
1051: ParallelMove S-33 <- r4
1052: v903 <- LoadField:2408(v17 . characters {final}) T{StringCharacters}
1053: ParallelMove S-31 <- r5
1054: ParallelMove goto:2408 B316
1056: B316[join]:2406 pred(B121, B126) ParallelMove r11 <- S-1, r9 <- S-13, r7 <- S-12, r6 <- S-23, r10 <- S-24, r8 <- S-28
1058: CheckStackOverflow:2412(stack=0, loop=1)
1060: v3965 <- LoadClassId(<non-smi> v126 T{*?})
1062: PushArgument(v126 T{*?})
1063: ParallelMove r0 <- r0
1064: v154 <- DispatchTableCall( cid=v3965 Iterator.moveNext<0>, v126 T{*?}) T{bool}
1065: ParallelMove r0 <- r0
1066: Branch if StrictCompare:1142(===, v154, v25) goto (123, 124)
1068: B123[target]:1146 ParallelMove r3 <- S-1, r2 <- S-28, r1 <- S-36
1070: v3966 <- LoadClassId(<non-smi> v126 T{*})
1072: PushArgument(v126 T{*})
1073: ParallelMove r0 <- r0
1074: v160 <- DispatchTableCall( cid=v3966 Iterator.current<0>, v126 T{*}) T{*?}
1075: ParallelMove r2 <- r0
1076: ParallelMove S-38 <- r2
1076: v1842 <- UnboxInt64([non-speculative], v160 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
1077: ParallelMove r0 <- S-26, r1 <- r3, S-27 <- r3
1078: GenericCheckBound:1152(v106 T{_Smi}, v1842 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
1079: ParallelMove r0 <- S-28
1080: v2646 <- LoadIndexed(v107, v1842 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
1081: ParallelMove r4 <- S-1, S-37 <- r1
1082: v163 <- LoadField(v7 . columnCount) T{int??}
1084: CheckNull:1156(v163, CastError) [-9223372036854775808, 9223372036854775807] T{int?}
1086: v1846 <- UnboxInt64([non-speculative], v163 T{int?}) [-9223372036854775808, 9223372036854775807] T{int}
1088: v164 <- BinaryInt64Op(+ [tr], v1846, v2635) [-9223372036854775808, 9223372036854775807] T{int}
1090: PushArgument(v26)
1092: PushArgument(v164)
1094: v165 <- StaticCall:1160( Iterable.generate<0> v26, v164, result_type = T{*}) T{*?}
1095: ParallelMove r0 <- r0
1096: v3967 <- LoadClassId(<non-smi> v165)
1098: PushArgument(v165)
1099: ParallelMove r0 <- r1
1100: v166 <- DispatchTableCall( cid=v3967 Iterable.iterator<0>, v165) T{*?}
1101: ParallelMove r3 <- r0, r2 <- S-27
1102: ParallelMove S-40 <- r3
1102: v204 <- BinaryInt64Op:2400(- [tr], v1842 T{int}, v2635) [-9223372036854775808, 9223372036854775807] T{int}
1104: v1859 <- BoxInt64:2400(v204) [-9223372036854775808, 9223372036854775807] T{int}
1105: ParallelMove r4 <- r0, r1 <- S-37
1106: ParallelMove S-39 <- r4
1106: v1845 <- UnboxInt64:2400([non-speculative], v2646 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
1107: ParallelMove S-29 <- r5
1108: ParallelMove goto:2400 B315
1110: B315[join]:2398 pred(B123, B314) ParallelMove r7 <- S-1, r11 <- S-13, r10 <- S-12, r9 <- S-23, r12 <- S-24, r6 <- S-28, r8 <- S-35
1112: CheckStackOverflow:2404(stack=0, loop=2)
1114: v3968 <- LoadClassId(<non-smi> v166 T{*?})
1116: PushArgument(v166 T{*?})
1117: ParallelMove r0 <- r0
1118: v191 <- DispatchTableCall( cid=v3968 Iterator.moveNext<0>, v166 T{*?}) T{bool}
1119: ParallelMove r0 <- r0
1120: Branch if StrictCompare:1168(===, v191, v25) goto (125, 126)
1122: B125[target]:1172 ParallelMove r1 <- S-40
1124: v3969 <- LoadClassId(<non-smi> v166 T{*})
1126: PushArgument(v166 T{*})
1127: ParallelMove r0 <- r0
1128: v192 <- DispatchTableCall( cid=v3969 Iterator.current<0>, v166 T{*}) T{*?}
1129: ParallelMove r0 <- r0
1130: ParallelMove S-41 <- r0
1130: v1858 <- UnboxInt64([non-speculative], v192 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
1131: ParallelMove S-30 <- r1
1132: PushArgument(v7)
1134: PushArgument(v160 T{int})
1136: PushArgument(v1858 T{int})
1138: v193 <- StaticCall:1178( getOrNull<0> v7, v160 T{int}, v1858 T{int}, using unchecked entrypoint, result_type = T{PositionedCell?}) T{PositionedCell?}
1139: ParallelMove r0 <- r0
1140: Branch if StrictCompare:1180(===, v193, v0) goto (127, 128)
1142: B127[target]:1184
1144: ParallelMove r1 <- C goto:1192 B129
1146: B128[target]:1186
1148: v194 <- LoadField(v193 T{PositionedCell} . cell {final}) T{Cell}
1150: ParallelMove r1 <- r1 goto:1194 B129
1152: B129[join]:1190 pred(B127, B128) {
v195 <- phi(v0, v194) alive T{Cell?}
}
1153: ParallelMove S-44 <- r1
1154: Branch if StrictCompare:1196(===, v193, v0) goto (130, 131)
1156: B130[target]:1200
1158: ParallelMove r2 <- C goto:1208 B132
1160: B131[target]:1202
1162: v196 <- LoadField(v193 T{PositionedCell} . canonicalStyle {final}) T{CellStyle}
1164: ParallelMove r2 <- r2 goto:1210 B132
1166: B132[join]:1206 pred(B130, B131) {
v197 <- phi(v0, v196) alive T{CellStyle?}
} ParallelMove r0 <- S-30
1167: ParallelMove S-43 <- r2
1168: v198 <- BinaryInt64Op(- [tr], v1858 T{int}, v2635) [-9223372036854775808, 9223372036854775807] T{int}
1169: ParallelMove S-42 <- r3
1170: PushArgument(v7)
1172: PushArgument(v160 T{int})
1174: PushArgument(v198)
1176: v199 <- StaticCall:1214( getOrNull<0> v7, v160 T{int}, v198, using unchecked entrypoint, result_type = T{PositionedCell?}) T{PositionedCell?}
1177: ParallelMove r0 <- r0
1178: Branch if StrictCompare:1216(===, v199, v0) goto (133, 134)
1180: B133[target]:1220
1182: ParallelMove r1 <- C goto:1228 B135
1184: B134[target]:1222
1186: v200 <- LoadField(v199 T{PositionedCell} . cell {final}) T{Cell}
1188: ParallelMove r1 <- r1 goto:1230 B135
1190: B135[join]:1226 pred(B133, B134) {
v201 <- phi(v0, v200) alive T{Cell?}
}
1191: ParallelMove S-46 <- r1
1192: Branch if StrictCompare:1232(===, v199, v0) goto (136, 137)
1194: B136[target]:1236
1196: ParallelMove r2 <- C goto:1244 B138
1198: B137[target]:1238
1200: v202 <- LoadField(v199 T{PositionedCell} . canonicalStyle {final}) T{CellStyle}
1202: ParallelMove r2 <- r2 goto:1246 B138
1204: B138[join]:1242 pred(B136, B137) {
v203 <- phi(v0, v202) alive T{CellStyle?}
} ParallelMove r0 <- S-30
1205: ParallelMove S-45 <- r2
1206: PushArgument(v7)
1208: PushArgument(v1859 T{int})
1210: PushArgument(v1858 T{int})
1212: v205 <- StaticCall:1250( getOrNull<0> v7, v1859 T{int}, v1858 T{int}, using unchecked entrypoint, result_type = T{PositionedCell?}) T{PositionedCell?}
1213: ParallelMove r0 <- r0
1214: Branch if StrictCompare:1252(===, v205, v0) goto (139, 140)
1216: B139[target]:1256
1218: ParallelMove r2 <- C goto:1264 B141
1220: B140[target]:1258
1222: v206 <- LoadField(v205 T{PositionedCell} . cell {final}) T{Cell}
1224: ParallelMove r2 <- r1 goto:1266 B141
1226: B141[join]:1262 pred(B139, B140) {
v207 <- phi(v0, v206) alive T{Cell?}
}
1227: ParallelMove S-53 <- r2
1228: Branch if StrictCompare:1268(===, v205, v0) goto (142, 143)
1230: B142[target]:1272
1232: ParallelMove r8 <- C goto:1280 B144
1234: B143[target]:1274
1236: v208 <- LoadField(v205 T{PositionedCell} . canonicalStyle {final}) T{CellStyle}
1238: ParallelMove r8 <- r1 goto:1282 B144
1240: B144[join]:1278 pred(B142, B143) {
v209 <- phi(v0, v208) alive T{CellStyle?}
} ParallelMove r6 <- S-13, r5 <- S-23, r7 <- S-24, r4 <- S-27, r3 <- S-30
1241: ParallelMove r0 <- S-25, r1 <- r3, S-52 <- r8
1242: GenericCheckBound:1284(v88 T{_Smi}, v1858 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
1244: v2647 <- LoadIndexed(v89, v1858 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
1245: ParallelMove r0 <- S-14, r1 <- r4, S-51 <- r9
1246: GenericCheckBound:1286(v35 T{_Smi}, v1842 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
1248: v2648 <- LoadIndexed(v36, v1842 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
1250: v1868 <- UnboxInt64([non-speculative], v2648 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
1251: ParallelMove S-50 <- r10
1252: v214 <- EqualityCompare(v1868 T{int} != v2634) T{bool}
1253: ParallelMove r0 <- S-10, r1 <- r3, S-49 <- r11
1254: GenericCheckBound:1292(v30 T{_Smi}, v1858 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
1256: v2649 <- LoadIndexed(v31, v1858 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
1258: v1872 <- UnboxInt64([non-speculative], v2649 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
1259: ParallelMove S-48 <- r1
1260: v218 <- EqualityCompare(v1872 T{int} != v2634) T{bool}
1261: ParallelMove S-47 <- r0
1262: Branch if StrictCompare:1300(===, v214, v25) goto (145, 252)
1264: B145[target]:1310
1266: Branch if StrictCompare:1306(===, v218, v25) goto (146, 253)
1268: B146[target]:1312 ParallelMove r12 <- S-42
1270: PushArgument(v7)
1272: PushArgument(v1859 T{int})
1274: PushArgument(v198 T{int})
1276: v301 <- StaticCall:1318( getOrNull<0> v7, v1859 T{int}, v198 T{int}, using unchecked entrypoint, result_type = T{PositionedCell?}) T{PositionedCell?}
1277: ParallelMove r0 <- r0
1278: Branch if StrictCompare:1320(===, v301, v0) goto (147, 148)
1280: B147[target]:1324
1282: ParallelMove r1 <- C goto:1332 B149
1284: B148[target]:1326
1286: v302 <- LoadField(v301 T{PositionedCell} . cell {final}) T{Cell}
1288: ParallelMove r1 <- r1 goto:1334 B149
1290: B149[join]:1330 pred(B147, B148) {
v303 <- phi(v0, v302) alive T{Cell?}
}
1292: Branch if StrictCompare:1336(===, v301, v0) goto (150, 151)
1294: B150[target]:1340
1296: ParallelMove r2 <- C goto:1348 B152
1298: B151[target]:1342
1300: v304 <- LoadField(v301 T{PositionedCell} . canonicalStyle {final}) T{CellStyle}
1302: ParallelMove r2 <- r2 goto:1350 B152
1304: B152[join]:1346 pred(B150, B151) {
v305 <- phi(v0, v304) alive T{CellStyle?}
} ParallelMove r0 <- S-53
1306: Branch if StrictCompare:1354(!==, v303, v207) goto (154, 172)
1308: B154[target]:1358
1310: Branch if StrictCompare:1360(===, v305, v0) goto (705, 156)
1312: B705[target]:1364
1314: ParallelMove goto:1408 B161
1316: B156[target]:1366
1318: v372 <- LoadField(v305 T{CellStyle} . borderRight {final}) T{bool?}
1320: Branch if StrictCompare(===, v372, v25) goto (169, 707)
1322: B169[target]:1464
1324: ParallelMove r3 <- S-52 goto:1466 B168
1326: B707[target]:1408
1328: ParallelMove goto:1408 B161
1330: B161[join]:1408 pred(B705, B707) ParallelMove r3 <- S-52
1332: Branch if StrictCompare:1384(===, v209, v0) goto (709, 159)
1334: B709[target]:1388
1336: ParallelMove goto:1410 B162
1338: B159[target]:1390
1340: v375 <- LoadField(v209 T{CellStyle} . borderLeft {final}) T{bool?}
1342: Branch if StrictCompare(===, v375, v25) goto (170, 711)
1344: B170[target]:1468
1346: ParallelMove goto:1470 B168
1348: B168[join]:1462 pred(B169, B170)
1350: ParallelMove r9 <- C, r7 <- S-1, r6 <- S-41, r4 <- S-27, r5 <- S-30 goto:1472 B153
1352: B711[target]:1410
1354: ParallelMove goto:1410 B162
1356: B162[join]:1410 pred(B709, B711) ParallelMove r4 <- S-27
1358: Branch if RelationalOp(>, v1842 T{int}, v2634) T{bool} goto (164, 173)
1360: B164[target]:1440 ParallelMove r5 <- S-30
1362: Branch if EqualityCompare(v1858 T{int} == v2634) T{bool} goto (166, 163)
1364: B166[target]:1444
1366: ParallelMove r7 <- S-1, r6 <- S-41 goto:1446 B165
1368: B163[target]:1438 ParallelMove r7 <- S-1, r6 <- S-41
1370: v380 <- LoadField(v7 . columnCount) T{int??}
1372: Branch if EqualityCompare(v192 T{int} == v380) T{bool} goto (167, 174)
1374: B167[target]:1448
1376: ParallelMove goto:1450 B165
1378: B165[join]:1442 pred(B166, B167)
1380: ParallelMove r9 <- S-35 goto:1460 B153
1382: B174[target]:1484
1384: ParallelMove goto:1486 B171
1386: B173[target]:1480 ParallelMove r7 <- S-1, r6 <- S-41, r5 <- S-30
1388: ParallelMove goto:1482 B171
1390: B172[target]:1476 ParallelMove r7 <- S-1, r6 <- S-41, r3 <- S-52, r4 <- S-27, r5 <- S-30
1392: ParallelMove goto:1478 B171
1394: B171[join]:1474 pred(B172, B173, B174)
1396: ParallelMove r9 <- C goto:1488 B153
1398: B153[join]:1352 pred(B165, B168, B171) {
v309 <- phi(v255, v25, v308) alive T{bool}
} ParallelMove r8 <- S-46
1400: Branch if StrictCompare:1492(!==, v303, v201) goto (176, 194)
1402: B176[target]:1496
1404: Branch if StrictCompare:1498(===, v305, v0) goto (713, 178)
1406: B713[target]:1502
1408: ParallelMove goto:1546 B183
1410: B178[target]:1504
1412: v357 <- LoadField(v305 T{CellStyle} . borderBottom {final}) T{bool?}
1414: Branch if StrictCompare(===, v357, v25) goto (191, 715)
1416: B191[target]:1602
1418: ParallelMove r1 <- S-45 goto:1604 B190
1420: B715[target]:1546
1422: ParallelMove goto:1546 B183
1424: B183[join]:1546 pred(B713, B715) ParallelMove r1 <- S-45
1426: Branch if StrictCompare:1522(===, v203, v0) goto (717, 181)
1428: B717[target]:1526
1430: ParallelMove goto:1548 B184
1432: B181[target]:1528
1434: v360 <- LoadField(v203 T{CellStyle} . borderTop {final}) T{bool?}
1436: Branch if StrictCompare(===, v360, v25) goto (192, 719)
1438: B192[target]:1606
1440: ParallelMove goto:1608 B190
1442: B190[join]:1600 pred(B191, B192)
1444: ParallelMove r11 <- C, r2 <- S-12 goto:1610 B175
1446: B719[target]:1548
1448: ParallelMove goto:1548 B184
1450: B184[join]:1548 pred(B717, B719)
1452: Branch if RelationalOp(>, v1858 T{int}, v2634) T{bool} goto (186, 195)
1454: B186[target]:1578
1456: Branch if EqualityCompare(v1842 T{int} == v2634) T{bool} goto (188, 185)
1458: B188[target]:1582
1460: ParallelMove r2 <- S-12 goto:1584 B187
1462: B185[target]:1576 ParallelMove r2 <- S-12
1464: Branch if EqualityCompare(v1842 T{int} == v32 T{int}) T{bool} goto (189, 196)
1466: B189[target]:1586
1468: ParallelMove goto:1588 B187
1470: B187[join]:1580 pred(B188, B189)
1472: ParallelMove r11 <- S-35 goto:1598 B175
1474: B196[target]:1622
1476: ParallelMove goto:1624 B193
1478: B195[target]:1618 ParallelMove r2 <- S-12
1480: ParallelMove goto:1620 B193
1482: B194[target]:1614 ParallelMove r2 <- S-12, r1 <- S-45
1484: ParallelMove goto:1616 B193
1486: B193[join]:1612 pred(B194, B195, B196)
1488: ParallelMove r11 <- C goto:1626 B175
1490: B175[join]:1490 pred(B187, B190, B193) {
v313 <- phi(v255, v25, v308) alive T{bool}
} ParallelMove r10 <- S-44
1492: Branch if StrictCompare:1630(!==, v201, v195) goto (198, 216)
1494: B198[target]:1634
1496: Branch if StrictCompare:1636(===, v203, v0) goto (721, 200)
1498: B721[target]:1640
1500: ParallelMove goto:1684 B205
1502: B200[target]:1642
1504: v341 <- LoadField(v203 T{CellStyle} . borderRight {final}) T{bool?}
1506: Branch if StrictCompare(===, v341, v25) goto (213, 723)
1508: B213[target]:1742
1510: ParallelMove r12 <- S-43 goto:1744 B212
1512: B723[target]:1684
1514: ParallelMove goto:1684 B205
1516: B205[join]:1684 pred(B721, B723) ParallelMove r12 <- S-43
1518: Branch if StrictCompare:1660(===, v197, v0) goto (725, 203)
1520: B725[target]:1664
1522: ParallelMove goto:1686 B206
1524: B203[target]:1666
1526: v344 <- LoadField(v197 T{CellStyle} . borderLeft {final}) T{bool?}
1528: Branch if StrictCompare(===, v344, v25) goto (214, 727)
1530: B214[target]:1746
1532: ParallelMove goto:1748 B212
1534: B212[join]:1740 pred(B213, B214)
1536: ParallelMove r13 <- C goto:1750 B197
1538: B727[target]:1686
1540: ParallelMove goto:1686 B206
1542: B206[join]:1686 pred(B725, B727)
1544: Branch if RelationalOp(<, v1842 T{int}, v32 T{int}) T{bool} goto (208, 217)
1546: B208[target]:1718
1548: Branch if EqualityCompare(v1858 T{int} == v2634) T{bool} goto (210, 207)
1550: B210[target]:1722
1552: ParallelMove goto:1724 B209
1554: B207[target]:1716
1556: v350 <- LoadField(v7 . columnCount) T{int??}
1558: Branch if EqualityCompare(v192 T{int} == v350) T{bool} goto (211, 218)
1560: B211[target]:1726
1562: ParallelMove goto:1728 B209
1564: B209[join]:1720 pred(B210, B211)
1566: ParallelMove r13 <- S-35 goto:1738 B197
1568: B218[target]:1762
1570: ParallelMove goto:1764 B215
1572: B217[target]:1758
1574: ParallelMove goto:1760 B215
1576: B216[target]:1754 ParallelMove r12 <- S-43
1578: ParallelMove goto:1756 B215
1580: B215[join]:1752 pred(B216, B217, B218)
1582: ParallelMove r13 <- C goto:1766 B197
1584: B197[join]:1628 pred(B209, B212, B215) {
v317 <- phi(v255, v25, v308) alive T{bool}
}
1586: Branch if StrictCompare:1770(!==, v207, v195) goto (220, 238)
1588: B220[target]:1774
1590: Branch if StrictCompare:1776(===, v209, v0) goto (729, 222)
1592: B729[target]:1780
1594: ParallelMove goto:1824 B227
1596: B222[target]:1782
1598: v325 <- LoadField(v209 T{CellStyle} . borderBottom {final}) T{bool?}
1600: Branch if StrictCompare(===, v325, v25) goto (235, 731)
1602: B235[target]:1884
1604: ParallelMove goto:1886 B234
1606: B731[target]:1824
1608: ParallelMove goto:1824 B227
1610: B227[join]:1824 pred(B729, B731)
1612: Branch if StrictCompare:1800(===, v197, v0) goto (733, 225)
1614: B733[target]:1804
1616: ParallelMove goto:1826 B228
1618: B225[target]:1806
1620: v328 <- LoadField(v197 T{CellStyle} . borderTop {final}) T{bool?}
1622: Branch if StrictCompare(===, v328, v25) goto (236, 735)
1624: B236[target]:1888
1626: ParallelMove goto:1890 B234
1628: B234[join]:1882 pred(B235, B236)
1630: ParallelMove r14 <- C goto:1892 B219
1632: B735[target]:1826
1634: ParallelMove goto:1826 B228
1636: B228[join]:1826 pred(B733, B735)
1638: v331 <- LoadField(v7 . columnCount) T{int??}
1640: CheckNull:1830(v331, CastError) [-9223372036854775808, 9223372036854775807] T{int?}
1642: v1874 <- UnboxInt64([non-speculative], v331 T{int?}) [-9223372036854775808, 9223372036854775807] T{int}
1644: Branch if RelationalOp(<, v1858 T{int}, v1874) T{bool} goto (230, 239)
1646: B230[target]:1860
1648: Branch if EqualityCompare(v1842 T{int} == v2634) T{bool} goto (232, 229)
1650: B232[target]:1864
1652: ParallelMove goto:1866 B231
1654: B229[target]:1858
1656: Branch if EqualityCompare(v1842 T{int} == v32 T{int}) T{bool} goto (233, 240)
1658: B233[target]:1868
1660: ParallelMove goto:1870 B231
1662: B231[join]:1862 pred(B232, B233)
1664: ParallelMove r14 <- S-35 goto:1880 B219
1666: B240[target]:1904
1668: ParallelMove goto:1906 B237
1670: B239[target]:1900
1672: ParallelMove goto:1902 B237
1674: B238[target]:1896
1676: ParallelMove goto:1898 B237
1678: B237[join]:1894 pred(B238, B239, B240)
1680: ParallelMove r14 <- C goto:1908 B219
1682: B219[join]:1768 pred(B231, B234, B237) {
v321 <- phi(v255, v25, v308) alive T{bool}
}
1684: Branch if StrictCompare:1912(===, v309, v25) goto (245, 241)
1686: B245[target]:1942
1688: ParallelMove goto:1944 B432
1690: B241[target]:1922
1692: Branch if StrictCompare:1918(===, v313, v25) goto (246, 242)
1694: B246[target]:1946
1696: ParallelMove goto:1948 B432
1698: B242[target]:1930
1700: Branch if StrictCompare:1926(===, v317, v25) goto (247, 243)
1702: B247[target]:1950
1704: ParallelMove goto:1952 B432
1706: B243[target]:1938
1708: Branch if StrictCompare:1934(===, v321, v25) goto (248, 249)
1710: B248[target]:1954
1712: ParallelMove goto:1956 B432
1714: B432[join]:1940 pred(B245, B246, B247, B248) ParallelMove r19 <- S-51
1716: v1632 <- IfThenElse(===, v317, v25 ? 1 : 0) [0, 1] T{_Smi}
1718: v1631 <- IfThenElse(===, v309, v25 ? 2 : 0) [0, 2] T{_Smi}
1720: v1875 <- UnboxInt64([non-speculative], v1631) [0, 2] T{int}
1722: v1876 <- UnboxInt64([non-speculative], v1632) [0, 1] T{int}
1724: v908 <- BinaryInt64Op(| [tr], v1876 T{_Smi}, v1875 T{_Smi}) [0, 3] T{int}
1726: v1630 <- IfThenElse(===, v321, v25 ? 4 : 0) [0, 4] T{_Smi}
1728: v1877 <- UnboxInt64([non-speculative], v1630) [0, 4] T{int}
1730: v910 <- BinaryInt64Op(| [tr], v908 T{int}, v1877 T{_Smi}) [0, 7] T{int}
1732: v1629 <- IfThenElse(===, v313, v25 ? 8 : 0) [0, 8] T{_Smi}
1734: v1878 <- UnboxInt64([non-speculative], v1629) [0, 8] T{int}
1736: v912 <- BinaryInt64Op(| [tr], v910 T{int}, v1878 T{_Smi}) [0, 15] T{int}
1738: PushArgument(v903)
1740: PushArgument(v912 T{int})
1742: v913 <- StaticCall:82( elementAt<0> v903, v912 T{int}, using unchecked entrypoint, result_type = T{*}) T{String}
1743: ParallelMove r0 <- r0
1744: PushArgument(v0)
1746: PushArgument(v913 T{String})
1748: v930 <- StaticCall:10( Characters.<0> v0, v913 T{String}, result_type = T{StringCharacters}) T{StringCharacters}
1749: ParallelMove r1 <- r0, r0 <- S-51
1750: v1862 <- UnboxInt64([non-speculative], v2647 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
1752: PushArgument(v122)
1754: PushArgument(v2646 T{int})
1756: PushArgument(v1862 T{int})
1758: PushArgument(v930)
1760: StaticCall:12( setCharacter<0> v122, v2646 T{int}, v1862 T{int}, v930, using unchecked entrypoint, result_type = T{??})
1762: ParallelMove goto:1966 B250
1764: B249[target]:1962
1766: ParallelMove goto:1968 B250
1768: B250[join]:1964 pred(B249, B432)
1770: ParallelMove goto:1982 B254
1772: B253[target]:1976
1774: ParallelMove goto:1978 B251
1776: B252[target]:1972
1778: ParallelMove goto:1974 B251
1780: B251[join]:1970 pred(B252, B253)
1782: ParallelMove goto:1984 B254
1784: B254[join]:1980 pred(B250, B251) ParallelMove r0 <- S-47
1786: Branch if StrictCompare:1988(===, v218, v25) goto (255, 280)
1788: B255[target]:1996 ParallelMove r2 <- S-44, r0 <- S-46
1790: Branch if StrictCompare:1992(!==, v201, v195) goto (268, 281)
1792: B268[target]:2092 ParallelMove r0 <- S-45
1794: Branch if StrictCompare:1998(===, v203, v0) goto (737, 257)
1796: B737[target]:2002
1798: ParallelMove goto:2046 B262
1800: B257[target]:2004
1802: v272 <- LoadField(v203 T{CellStyle} . borderRight {final}) T{bool?}
1804: Branch if StrictCompare(===, v272, v25) goto (270, 739)
1806: B270[target]:2096
1808: ParallelMove r5 <- S-1, r3 <- S-43, r6 <- S-35, r4 <- S-30 goto:2098 B269
1810: B739[target]:2046
1812: ParallelMove goto:2046 B262
1814: B262[join]:2046 pred(B737, B739) ParallelMove r3 <- S-43
1816: Branch if StrictCompare:2022(===, v197, v0) goto (741, 260)
1818: B741[target]:2026
1820: ParallelMove goto:2090 B267
1822: B260[target]:2028
1824: v275 <- LoadField(v197 T{CellStyle} . borderLeft {final}) T{bool?}
1826: Branch if StrictCompare(===, v275, v25) goto (271, 743)
1828: B271[target]:2100
1830: ParallelMove r5 <- S-1, r6 <- S-35, r4 <- S-30 goto:2102 B269
1832: B743[target]:2090
1834: ParallelMove goto:2090 B267
1836: B267[join]:2090 pred(B741, B743) ParallelMove r4 <- S-30
1838: Branch if EqualityCompare(v1858 T{int} == v2634) T{bool} goto (265, 263)
1840: B265[target]:2082
1842: ParallelMove r5 <- S-1 goto:2084 B264
1844: B263[target]:2066 ParallelMove r5 <- S-1, r0 <- S-41
1846: v279 <- LoadField(v7 . columnCount) T{int??}
1848: Branch if EqualityCompare(v192 T{int} == v279) T{bool} goto (266, 282)
1850: B266[target]:2086
1852: ParallelMove goto:2088 B264
1854: B264[join]:2080 pred(B265, B266) ParallelMove r6 <- S-35
1856: Branch if StrictCompare:2076(===, v255, v25) goto (272, 283)
1858: B272[target]:2104
1860: ParallelMove goto:2106 B269
1862: B269[join]:2094 pred(B270, B271, B272) ParallelMove r10 <- S-28, r7 <- S-27, r9 <- S-29, r8 <- S-50
1864: v287 <- BinaryInt64Op(+ [tr], v1842 T{int}, v2635) [-9223372036854775808, 9223372036854775807] T{int}
1865: ParallelMove r0 <- S-26, r1 <- r11
1866: GenericCheckBound:2110(v106 T{_Smi}, v287) [-9223372036854775808, 9223372036854775807] T{int}
1868: v2650 <- LoadIndexed(v107, v287 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
1869: ParallelMove S-41 <- r0
1870: v1593 <- LoadStaticField:4(_emptyList@0150898, CallsInitializer) T{_List}
1871: ParallelMove r1 <- C, r0 <- r0
1872: ParallelMove S-45 <- r0
1872: v1391 <- AllocateObject:10(cls=_GrowableList, v26) T{_GrowableList}
1873: ParallelMove r2 <- r0, r0 <- S-45
1874: ParallelMove S-46 <- r2
1874: StoreField(v1391 . GrowableObjectArray.data = v1593, NoStoreBarrier)
1876: StoreField(v1391 . GrowableObjectArray.length = v8, NoStoreBarrier)
1877: ParallelMove r3 <- S-29, r1 <- S-50
1878: v291 <- BinaryInt64Op(+ [tr], v1845 T{int}, v1868 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
1879: ParallelMove r1 <- S-41
1880: v1881 <- UnboxInt64:2136([non-speculative], v2650 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
1881: ParallelMove S-54 <- r5
1882: ParallelMove r6 <- r4, r4 <- C, r0 <- r0 goto:2136 B275
1884: B275[join]:2134 pred(B269, B406) {
v292 <- phi(v291, v298) alive [-9223372036854775808, 9223372036854775807] int64 T{int}
v2451 <- phi(v2634, v872 T{int}) alive [-9223372036854775808, 9223372036854775807] int64 T{int}
v2450 <- phi(v1593, v875) alive T{_List}
}
1885: ParallelMove S-42 <- r6, S-50 <- r4
1886: CheckStackOverflow:2140(stack=0, loop=3)
1888: Branch if RelationalOp(<, v292, v1881 T{int}) T{bool} goto (273, 274)
1890: B273[target]:2126
1892: v1377 <- LoadField(v2450 . Array.length {final}) [0, 576460752303423487] T{_Smi}
1894: v3941 <- BoxInt64(v2451 T{_Smi})
1895: ParallelMove r0 <- r0
1896: Branch if StrictCompare(===, v3941 T{_Smi}, v1377) T{bool} goto (404, 405)
1898: B404[target]:24
1900: PushArgument(v1391)
1902: StaticCall:26( _growToNextCapacity@0150898<0> v1391, using unchecked entrypoint, result_type = T{??})
1904: ParallelMove goto:32 B406
1906: B405[target]:28
1908: ParallelMove goto:34 B406
1910: B406[join]:30 pred(B404, B405) ParallelMove r4 <- S-42, r2 <- S-46, r3 <- S-50
1912: v872 <- BinaryInt64Op(+ [tr], v2451 T{_Smi}, v2635) [-9223372036854775808, 9223372036854775807] T{int}
1914: v1885 <- BoxInt64(v872) [-9223372036854775808, 9223372036854775807] T{int}
1915: ParallelMove r0 <- r0
1916: StoreField(v1391 . GrowableObjectArray.length = v1885 T{int}, NoStoreBarrier)
1917: ParallelMove r0 <- r5, r1 <- r3
1918: GenericCheckBound:40(v872 T{_Smi}, v2451 T{_Smi}) [-4611686018427387904, 4611686018427387903] T{_Smi}
1920: v875 <- LoadField(v1391 . GrowableObjectArray.data) T{_List}
1922: v1882 <- BoxInt64(v292 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
1923: ParallelMove r1 <- r7, r0 <- r0
1924: StoreIndexed:40(v875, v2451 T{_Smi}, v1882 T{int})
1926: v298 <- BinaryInt64Op(+ [tr], v292, v2635) [-9223372036854775808, 9223372036854775807] T{int}
1928: ParallelMove r6 <- r6, r4 <- r5, r0 <- r7, r3 <- S-29, r5 <- S-54 goto:2138 B275
1930: B274[target]:2128 ParallelMove r3 <- r4, r1 <- S-51
1932: v1863 <- UnboxInt64:2162([non-speculative], v2647 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
1933: ParallelMove S-54 <- r4
1934: ParallelMove r5 <- C goto:2162 B278
1936: B278[join]:2160 pred(B274, B390) {
v2495 <- phi(v2634, v850) alive [-9223372036854775808, 9223372036854775807] int64 T{int}
}
1937: ParallelMove S-42 <- r5
1938: CheckStackOverflow:2166(stack=0, loop=3)
1940: v3970 <- LoadClassId(<non-smi> v1391)
1942: PushArgument(v1391)
1943: ParallelMove r0 <- r0
1944: v839 <- DispatchTableCall( cid=v3970 Iterable.length<0>, v1391) T{int}
1945: ParallelMove r0 <- r0
1946: v1890 <- UnboxInt64([non-speculative], v839 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
1947: ParallelMove r2 <- S-50
1948: Branch if EqualityCompare(v2451 T{int} != v1890 T{int}) T{bool} goto (395, 396)
1950: B395[target]:24 ParallelMove r0 <- S-46
1952: v852 <- AllocateObject:26(cls=ConcurrentModificationError, <not-aliased>) T{ConcurrentModificationError}
1953: ParallelMove r0 <- r0, r3 <- S-46
1954: StoreField(v852 . modifiedObject = v1391, NoStoreBarrier)
1955: ParallelMove r0 <- r0
1956: Throw:32(v852)
1958: B396[target]:34 ParallelMove r3 <- S-46, r4 <- S-42
1960: Branch if RelationalOp(>=, v2495 T{int}, v1890 T{int}) T{bool} goto (277, 276)
1962: B277[target]:46
1964: ParallelMove goto:2188 B284
1966: B276[target]:52
1968: v3971 <- LoadClassId(<non-smi> v1391)
1970: PushArgument(v1391)
1972: PushArgument(v2495 T{int})
1973: ParallelMove r0 <- r0
1974: v847 <- DispatchTableCall( cid=v3971 Iterable.elementAt<0>, v1391, v2495 T{int}) T{*?}
1975: ParallelMove r3 <- r0, r0 <- S-42
1976: ParallelMove S-41 <- r3
1976: v850 <- BinaryInt64Op(+ [tr], v2495 T{int}, v2635) [-9223372036854775808, 9223372036854775807] T{int}
1977: ParallelMove S-55 <- r5
1978: Branch if StrictCompare:12(===, v847 T{X0??}, v0) goto (388, 389)
1980: B388[target]:16
1981: ParallelMove r0 <- r3, r2 <- C, r1 <- C
1982: t0 <- AssertAssignable:18(v847 T{X0??}, v2651, ' in type cast', instantiator_type_args(v0), function_type_args(v0)) [-9223372036854775808, 9223372036854775807] T{int}
1984: ParallelMove goto:24 B390
1986: B389[target]:20
1988: ParallelMove goto:26 B390
1990: B390[join]:22 pred(B388, B389) ParallelMove r0 <- S-54
1992: PushArgument(v0)
1994: PushArgument(v289 T{String})
1996: v833 <- StaticCall:10( Characters.<0> v0, v289 T{String}, result_type = T{StringCharacters}) T{StringCharacters}
1997: ParallelMove r0 <- r0
1998: PushArgument(v122)
2000: PushArgument(v847 T{X0?})
2001: ParallelMove r1 <- S-54
2002: PushArgument(v1863 T{int})
2004: PushArgument(v833)
2006: StaticCall:12( setCharacter<0> v122, v847 T{X0?}, v1863 T{int}, v833, using unchecked entrypoint, result_type = T{??})
2008: ParallelMove r5 <- S-55, r2 <- S-46, r4 <- S-54, r3 <- S-50, r1 <- S-51 goto:2164 B278
2010: B283[target]:2182
2012: ParallelMove goto:2184 B279
2014: B282[target]:2178
2016: ParallelMove goto:2180 B279
2018: B281[target]:2174
2020: ParallelMove goto:2176 B279
2022: B280[target]:2170
2024: ParallelMove goto:2172 B279
2026: B279[join]:2168 pred(B280, B281, B282, B283)
2028: ParallelMove goto:2190 B284
2030: B284[join]:2186 pred(B277, B279) ParallelMove r0 <- S-49
2032: Branch if StrictCompare:2194(===, v214, v25) goto (285, 310)
2034: B285[target]:2202 ParallelMove r0 <- S-44, r1 <- S-53
2036: Branch if StrictCompare:2198(!==, v207, v195) goto (298, 311)
2038: B298[target]:2298 ParallelMove r0 <- S-52
2040: Branch if StrictCompare:2204(===, v209, v0) goto (749, 287)
2042: B749[target]:2208
2044: ParallelMove goto:2252 B292
2046: B287[target]:2210
2048: v245 <- LoadField(v209 T{CellStyle} . borderBottom {final}) T{bool?}
2050: Branch if StrictCompare(===, v245, v25) goto (300, 751)
2052: B300[target]:2302
2054: ParallelMove r3 <- S-12, r4 <- S-35, r2 <- S-27 goto:2304 B299
2056: B751[target]:2252
2058: ParallelMove goto:2252 B292
2060: B292[join]:2252 pred(B749, B751) ParallelMove r0 <- S-43
2062: Branch if StrictCompare:2228(===, v197, v0) goto (753, 290)
2064: B753[target]:2232
2066: ParallelMove goto:2296 B297
2068: B290[target]:2234
2070: v248 <- LoadField(v197 T{CellStyle} . borderTop {final}) T{bool?}
2072: Branch if StrictCompare(===, v248, v25) goto (301, 755)
2074: B301[target]:2306
2076: ParallelMove r3 <- S-12, r4 <- S-35, r2 <- S-27 goto:2308 B299
2078: B755[target]:2296
2080: ParallelMove goto:2296 B297
2082: B297[join]:2296 pred(B753, B755) ParallelMove r2 <- S-27
2084: Branch if EqualityCompare(v1842 T{int} == v2634) T{bool} goto (295, 293)
2086: B295[target]:2288
2088: ParallelMove r3 <- S-12 goto:2290 B294
2090: B293[target]:2272 ParallelMove r3 <- S-12
2092: Branch if EqualityCompare(v1842 T{int} == v32 T{int}) T{bool} goto (296, 312)
2094: B296[target]:2292
2096: ParallelMove goto:2294 B294
2098: B294[join]:2286 pred(B295, B296) ParallelMove r4 <- S-35
2100: Branch if StrictCompare:2282(===, v255, v25) goto (302, 313)
2102: B302[target]:2310
2104: ParallelMove goto:2312 B299
2106: B299[join]:2300 pred(B300, B301, B302) ParallelMove r6 <- S-24, r0 <- S-30, r7 <- S-48, r5 <- S-51
2108: v260 <- BinaryInt64Op(+ [tr], v1858 T{int}, v2635) [-9223372036854775808, 9223372036854775807] T{int}
2109: ParallelMove r0 <- S-25, r1 <- r8
2110: GenericCheckBound:2316(v88 T{_Smi}, v260) [-9223372036854775808, 9223372036854775807] T{int}
2112: v2652 <- LoadIndexed(v89, v260 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
2113: ParallelMove S-41 <- r0
2114: v1581 <- LoadStaticField:4(_emptyList@0150898, CallsInitializer) T{_List}
2115: ParallelMove r1 <- C, r0 <- r0
2116: ParallelMove S-43 <- r0
2116: v1335 <- AllocateObject:10(cls=_GrowableList, v26) T{_GrowableList}
2117: ParallelMove r2 <- r0, r0 <- S-43
2118: ParallelMove S-44 <- r2
2118: StoreField(v1335 . GrowableObjectArray.data = v1581, NoStoreBarrier)
2120: StoreField(v1335 . GrowableObjectArray.length = v8, NoStoreBarrier)
2121: ParallelMove r1 <- S-51
2122: v1864 <- UnboxInt64([non-speculative], v2647 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
2123: ParallelMove r1 <- S-48
2124: v264 <- BinaryInt64Op(+ [tr], v1864 T{int}, v1872 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
2125: ParallelMove r1 <- S-41
2126: v1893 <- UnboxInt64:2342([non-speculative], v2652 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
2127: ParallelMove S-48 <- r3
2128: ParallelMove r5 <- r4, r4 <- C, r0 <- r0 goto:2342 B305
2130: B305[join]:2340 pred(B299, B373) {
v265 <- phi(v264, v271) alive [-9223372036854775808, 9223372036854775807] int64 T{int}
v2540 <- phi(v2634, v793 T{int}) alive [-9223372036854775808, 9223372036854775807] int64 T{int}
v2539 <- phi(v1581, v796) alive T{_List}
}
2131: ParallelMove S-30 <- r5, S-42 <- r4
2132: CheckStackOverflow:2346(stack=0, loop=3)
2134: Branch if RelationalOp(<, v265, v1893 T{int}) T{bool} goto (303, 304)
2136: B303[target]:2332
2138: v1321 <- LoadField(v2539 . Array.length {final}) [0, 576460752303423487] T{_Smi}
2140: v3945 <- BoxInt64(v2540 T{_Smi})
2141: ParallelMove r0 <- r0
2142: Branch if StrictCompare(===, v3945 T{_Smi}, v1321) T{bool} goto (371, 372)
2144: B371[target]:24
2146: PushArgument(v1335)
2148: StaticCall:26( _growToNextCapacity@0150898<0> v1335, using unchecked entrypoint, result_type = T{??})
2150: ParallelMove goto:32 B373
2152: B372[target]:28
2154: ParallelMove goto:34 B373
2156: B373[join]:30 pred(B371, B372) ParallelMove r4 <- S-30, r2 <- S-44, r3 <- S-42
2158: v793 <- BinaryInt64Op(+ [tr], v2540 T{_Smi}, v2635) [-9223372036854775808, 9223372036854775807] T{int}
2160: v1897 <- BoxInt64(v793) [-9223372036854775808, 9223372036854775807] T{int}
2161: ParallelMove r0 <- r0
2162: StoreField(v1335 . GrowableObjectArray.length = v1897 T{int}, NoStoreBarrier)
2163: ParallelMove r0 <- r6, r1 <- r3
2164: GenericCheckBound:40(v793 T{_Smi}, v2540 T{_Smi}) [-4611686018427387904, 4611686018427387903] T{_Smi}
2166: v796 <- LoadField(v1335 . GrowableObjectArray.data) T{_List}
2168: v1894 <- BoxInt64(v265 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
2169: ParallelMove r1 <- r7, r0 <- r0
2170: StoreIndexed:40(v796, v2540 T{_Smi}, v1894 T{int})
2172: v271 <- BinaryInt64Op(+ [tr], v265, v2635) [-9223372036854775808, 9223372036854775807] T{int}
2174: ParallelMove r5 <- r5, r4 <- r6, r0 <- r7, r3 <- S-48 goto:2344 B305
2176: B304[target]:2334 ParallelMove r3 <- r4
2178: ParallelMove r1 <- C goto:2368 B308
2180: B308[join]:2366 pred(B304, B357) {
v2584 <- phi(v2634, v771) alive [-9223372036854775808, 9223372036854775807] int64 T{int}
}
2181: ParallelMove S-30 <- r1
2182: CheckStackOverflow:2372(stack=0, loop=3)
2184: v3972 <- LoadClassId(<non-smi> v1335)
2186: PushArgument(v1335)
2187: ParallelMove r0 <- r0
2188: v760 <- DispatchTableCall( cid=v3972 Iterable.length<0>, v1335) T{int}
2189: ParallelMove r0 <- r0
2190: v1902 <- UnboxInt64([non-speculative], v760 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
2191: ParallelMove r2 <- S-42
2192: Branch if EqualityCompare(v2540 T{int} != v1902 T{int}) T{bool} goto (362, 363)
2194: B362[target]:24 ParallelMove r0 <- S-44
2196: v773 <- AllocateObject:26(cls=ConcurrentModificationError, <not-aliased>) T{ConcurrentModificationError}
2197: ParallelMove r0 <- r0, r3 <- S-44
2198: StoreField(v773 . modifiedObject = v1335, NoStoreBarrier)
2199: ParallelMove r0 <- r0
2200: Throw:32(v773)
2202: B363[target]:34 ParallelMove r3 <- S-44, r4 <- S-30
2204: Branch if RelationalOp(>=, v2584 T{int}, v1902 T{int}) T{bool} goto (307, 306)
2206: B307[target]:46
2208: ParallelMove goto:2394 B314
2210: B306[target]:52
2212: v3973 <- LoadClassId(<non-smi> v1335)
2214: PushArgument(v1335)
2216: PushArgument(v2584 T{int})
2217: ParallelMove r0 <- r0
2218: v768 <- DispatchTableCall( cid=v3973 Iterable.elementAt<0>, v1335, v2584 T{int}) T{*?}
2219: ParallelMove r3 <- r0, r0 <- S-30
2220: ParallelMove S-41 <- r3
2220: v771 <- BinaryInt64Op(+ [tr], v2584 T{int}, v2635) [-9223372036854775808, 9223372036854775807] T{int}
2221: ParallelMove S-48 <- r4
2222: Branch if StrictCompare:12(===, v768 T{X0??}, v0) goto (355, 356)
2224: B355[target]:16
2225: ParallelMove r0 <- r3, r2 <- C, r1 <- C
2226: t0 <- AssertAssignable:18(v768 T{X0??}, v2651, ' in type cast', instantiator_type_args(v0), function_type_args(v0)) [-9223372036854775808, 9223372036854775807] T{int}
2228: ParallelMove goto:24 B357
2230: B356[target]:20
2232: ParallelMove goto:26 B357
2234: B357[join]:22 pred(B355, B356) ParallelMove r0 <- S-41
2236: PushArgument(v0)
2238: PushArgument(v262 T{String})
2240: v754 <- StaticCall:10( Characters.<0> v0, v262 T{String}, result_type = T{StringCharacters}) T{StringCharacters}
2241: ParallelMove r1 <- r0, r0 <- S-41
2242: v1903 <- UnboxInt64([non-speculative], v768 T{X0?}) [-9223372036854775808, 9223372036854775807] T{int}
2244: PushArgument(v122)
2246: PushArgument(v2646 T{int})
2248: PushArgument(v1903)
2250: PushArgument(v754)
2252: StaticCall:12( setCharacter<0> v122, v2646 T{int}, v1903, v754, using unchecked entrypoint, result_type = T{??})
2254: ParallelMove r1 <- S-48, r2 <- S-44, r3 <- S-42 goto:2370 B308
2256: B313[target]:2388
2258: ParallelMove goto:2390 B309
2260: B312[target]:2384
2262: ParallelMove goto:2386 B309
2264: B311[target]:2380
2266: ParallelMove goto:2382 B309
2268: B310[target]:2376
2270: ParallelMove goto:2378 B309
2272: B309[join]:2374 pred(B310, B311, B312, B313)
2274: ParallelMove goto:2396 B314
2276: B314[join]:2392 pred(B307, B309)
2278: ParallelMove r3 <- S-40, r2 <- S-27, r5 <- S-29, r4 <- S-39, r1 <- S-37 goto:2402 B315
2280: B126[target]:1174
2282: ParallelMove r1 <- S-36, r2 <- S-35, r3 <- S-34, r4 <- S-33, r5 <- S-31 goto:2410 B316
2284: B124[target]:1148 ParallelMove r10 <- S-1
2286: v708 <- LoadField:4(v7 . positionedCells, CallsInitializer) T{_GrowableList}
2287: ParallelMove r1 <- C, r2 <- S-9, S-24 <- r0
2288: v157 <- AllocateClosure:2416(v156, v16) T{_Closure}
2289: ParallelMove r3 <- r0, r2 <- S-24
2290: ParallelMove S-31 <- r3
2290: v1280 <- LoadField(v708 . GrowableObjectArray.length) [0, 576460752303423487] T{_Smi}
2291: ParallelMove S-28 <- r4
2292: v3947 <- UnboxInt64([non-speculative], v1280)
2294: ParallelMove r5 <- C, r0 <- r0 goto:56 B351
2296: B351[join]:54 pred(B124, B350) {
v717 <- phi(v2634, v726) alive [-9223372036854775808, 9223372036854775807] int64 T{int}
v2633 <- phi(v3947 T{_Smi}, v3949 T{_Smi}) alive [0, 576460752303423487] int64 T{_Smi}
}
2297: ParallelMove S-25 <- r5
2298: CheckStackOverflow:60(stack=0, loop=1)
2300: Branch if RelationalOp(<, v717, v2633) T{bool} goto (347, 348)
2302: B347[target]:22
2303: ParallelMove r0 <- r0, r1 <- r5
2304: GenericCheckBound:28(v2633, v717) [-9223372036854775808, 9223372036854775807] T{int}
2306: v730 <- LoadField(v708 . GrowableObjectArray.data) T{_List}
2308: v2653 <- LoadIndexed(v730, v717 T{int}) T{*?}
2310: PushArgument(v157)
2312: PushArgument(v2653 T{*?})
2313: ParallelMove r0 <- r3
2314: v722 <- ClosureCall:32( closure=v157<0>, v157, v2653 T{*?}) T{*?}
2315: ParallelMove r0 <- S-24
2316: v1270 <- LoadField(v708 . GrowableObjectArray.length) [0, 576460752303423487] T{_Smi}
2317: ParallelMove r2 <- S-28
2318: Branch if StrictCompare(!==, v1270, v1280) T{bool} goto (349, 350)
2320: B349[target]:44
2322: v727 <- AllocateObject:46(cls=ConcurrentModificationError, <not-aliased>) T{ConcurrentModificationError}
2323: ParallelMove r1 <- r0, r0 <- S-24
2324: StoreField(v727 . modifiedObject = v708, NoStoreBarrier)
2325: ParallelMove r0 <- r1
2326: Throw:50(v727)
2328: B350[target]:52 ParallelMove r3 <- S-25
2330: v726 <- BinaryInt64Op(+ [tr], v717 T{int}, v2635) [-9223372036854775808, 9223372036854775807] T{int}
2332: v3949 <- UnboxInt64([non-speculative], v1270)
2334: ParallelMove r5 <- r5, r0 <- r3, r3 <- S-31, r2 <- r0, r4 <- r2 goto:58 B351
2336: B348[target]:24
2338: PushArgument(v122)
2340: v159 <- StaticCall:2420( toString<0> v122, using unchecked entrypoint, result_type = T{*}) T{String}
2341: ParallelMove r0 <- r0
2342: Return:2422(v159)
2344: B12[target]:52 ParallelMove r10 <- S-1, r8 <- S-2, r1 <- S-8, r5 <- S-11, r6 <- S-15, r7 <- S-18
2346: v3974 <- LoadClassId(<non-smi> v1200)
2348: PushArgument(v1200)
2350: PushArgument(v2104 T{int})
2351: ParallelMove r0 <- r0
2352: v1188 <- DispatchTableCall( cid=v3974 Iterable.elementAt<0>, v1200, v2104 T{int}) T{*?}
2353: ParallelMove r3 <- r0, r0 <- S-16
2354: ParallelMove S-24 <- r3
2354: v1191 <- BinaryInt64Op(+ [tr], v2104 T{int}, v2635) [-9223372036854775808, 9223372036854775807] T{int}
2355: ParallelMove S-25 <- r14
2356: Branch if StrictCompare:12(===, v1188 T{X0??}, v0) goto (535, 536)
2358: B535[target]:16
2359: ParallelMove r0 <- r3, r2 <- S-21, r1 <- C
2360: t0 <- AssertAssignable:18(v1188 T{X0??}, v743, ' in type cast', instantiator_type_args(v1205), function_type_args(v0)) T{X0?}
2362: ParallelMove goto:24 B537
2364: B536[target]:20
2366: ParallelMove goto:26 B537
2368: B537[join]:22 pred(B535, B536) ParallelMove r1 <- S-7, r0 <- S-24
2370: v491 <- LoadField(v1188 T{PositionedCell} . rowIndex {final}) [-9223372036854775808, 9223372036854775807] T{int}
2371: ParallelMove S-26 <- r2
2372: v492 <- LoadField(v1188 T{PositionedCell} . columnIndex {final}) [-9223372036854775808, 9223372036854775807] T{int}
2373: ParallelMove S-16 <- r3
2374: v493 <- LoadField(v1188 T{PositionedCell} . cell {final}) T{Cell}
2376: v494 <- LoadField(v1188 T{PositionedCell} . canonicalStyle {final}) T{CellStyle}
2377: ParallelMove S-28 <- r5
2378: PushArgument(v21 T{Map<Cell, TextLayout>?})
2380: PushArgument(v493)
2382: v1172 <- StaticCall:10( _getValueOrData@3220832<0> v21 T{Map<Cell, TextLayout>?}, v493, using unchecked entrypoint, result_type = T{*?}) T{Object??}
2383: ParallelMove r0 <- r0, r2 <- S-7
2384: v1472 <- LoadField(v21 T{Map<Cell, TextLayout>?} . LinkedHashBase.data) T{_List}
2386: Branch if StrictCompare:14(===, v1472, v1172) goto (540, 541)
2388: B540[target]:18
2390: ParallelMove r5 <- C goto:24 B14
2392: B541[target]:20
2394: ParallelMove r5 <- r0 goto:26 B14
2396: B14[join]:22 pred(B540, B541) {
v1174 <- phi(v0, v1172) alive T{Object??}
} ParallelMove r4 <- S-11, r3 <- S-16
2397: ParallelMove S-31 <- r5
2398: CheckNull:142(v1174 T{SimpleLayout?}, CastError) T{SimpleLayout}
2399: ParallelMove r0 <- S-19, r1 <- r3
2400: GenericCheckBound:156(v1907 T{_Smi}, v492) [-9223372036854775808, 9223372036854775807] T{int}
2402: v2654 <- LoadIndexed(v28, v492 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
2403: ParallelMove S-24 <- r0
2404: PushArgument(v1174 T{SimpleLayout})
2406: v559 <- StaticCall:158( measureWidth<0> v1174 T{SimpleLayout}, using unchecked entrypoint, result_type = T{int}) [-9223372036854775808, 9223372036854775807] T{int}
2407: ParallelMove r2 <- r0, r0 <- S-24
2408: v1909 <- UnboxInt64([non-speculative], v2654 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
2410: Branch if RelationalOp(>, v559, v1909 T{int}) T{bool} goto (15, 16)
2412: B15[target]:168 ParallelMove r3 <- S-16
2414: v1910 <- BoxInt64(v559) [-9223372036854775808, 9223372036854775807] T{int}
2415: ParallelMove r1 <- S-11, r0 <- r0
2416: StoreIndexed:170(v28, v492 T{int}, v1910 T{int})
2418: ParallelMove goto:176 B20
2420: B16[target]:172 ParallelMove r3 <- S-16
2422: ParallelMove goto:178 B20
2424: B20[join]:174 pred(B15, B16) ParallelMove r4 <- S-15, r2 <- S-26
2425: ParallelMove r0 <- S-12, r1 <- r2
2426: GenericCheckBound:200(v32 T{_Smi}, v491) [-9223372036854775808, 9223372036854775807] T{int}
2428: v2655 <- LoadIndexed(v33, v491 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
2429: ParallelMove S-24 <- r0
2430: PushArgument(v1174 T{SimpleLayout})
2432: v554 <- StaticCall:202( measureHeight<0> v1174 T{SimpleLayout}, using unchecked entrypoint, result_type = T{int}) [-9223372036854775808, 9223372036854775807] T{int}
2433: ParallelMove r2 <- r0, r0 <- S-24
2434: v1915 <- UnboxInt64([non-speculative], v2655 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
2436: Branch if RelationalOp(>, v554, v1915 T{int}) T{bool} goto (21, 22)
2438: B21[target]:212 ParallelMove r3 <- S-26
2440: v1916 <- BoxInt64(v554) [-9223372036854775808, 9223372036854775807] T{int}
2441: ParallelMove r1 <- S-15, r0 <- r0
2442: StoreIndexed:214(v33, v491 T{int}, v1916 T{int})
2444: ParallelMove goto:220 B25
2446: B22[target]:216 ParallelMove r3 <- S-26
2448: ParallelMove goto:222 B25
2450: B25[join]:218 pred(B21, B22) ParallelMove r2 <- S-16
2452: Branch if EqualityCompare(v492 T{int} == v2634) T{bool} goto (26, 28)
2454: B26[target]:252 ParallelMove r4 <- S-17
2456: Branch if StrictCompare:248(===, v526, v25) goto (32, 29)
2458: B32[target]:298
2460: ParallelMove r5 <- S-28 goto:300 B34
2462: B29[target]:270
2464: ParallelMove goto:272 B27
2466: B28[target]:266 ParallelMove r4 <- S-17
2468: ParallelMove goto:268 B27
2470: B27[join]:264 pred(B28, B29) ParallelMove r5 <- S-28
2472: v502 <- LoadField(v494 . borderLeft {final}) T{bool?}
2474: Branch if StrictCompare(===, v502, v25) T{bool} goto (33, 37)
2476: B33[target]:302
2478: ParallelMove goto:304 B34
2480: B34[join]:296 pred(B32, B33) ParallelMove r6 <- S-13
2481: ParallelMove r0 <- S-10, r1 <- r2
2482: GenericCheckBound:316(v30 T{_Smi}, v492 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
2484: StoreIndexed:316(v31, v492 T{int}, v5, NoStoreBarrier)
2486: ParallelMove goto:330 B40
2488: B37[target]:320 ParallelMove r6 <- S-13
2490: ParallelMove goto:332 B40
2492: B40[join]:328 pred(B34, B37) ParallelMove r7 <- S-1
2494: v504 <- BinaryInt64Op(+ [tr], v492 T{int}, v2635) [-9223372036854775808, 9223372036854775807] T{int}
2496: v505 <- LoadField(v7 . columnCount) T{int??}
2498: v1921 <- BoxInt64(v504) [-9223372036854775808, 9223372036854775807] T{int}
2499: ParallelMove r0 <- r0
2500: Branch if EqualityCompare(v1921 T{int} == v505) T{bool} goto (41, 43)
2502: B41[target]:358
2504: Branch if StrictCompare:354(===, v526, v25) goto (47, 44)
2506: B47[target]:410
2508: ParallelMove goto:412 B49
2510: B44[target]:376
2512: ParallelMove goto:378 B42
2514: B43[target]:372
2516: ParallelMove goto:374 B42
2518: B42[join]:370 pred(B43, B44)
2520: v507 <- LoadField(v494 . borderRight {final}) T{bool?}
2522: Branch if StrictCompare(===, v507, v25) T{bool} goto (48, 52)
2524: B48[target]:414
2526: ParallelMove goto:416 B49
2528: B49[join]:408 pred(B47, B48)
2530: CheckNull:384(v505 T{int??}, CastError) [-9223372036854775808, 9223372036854775807] T{int?}
2531: ParallelMove r0 <- S-10, r1 <- r8
2532: GenericCheckBound:430(v30 T{_Smi}, v504 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
2534: StoreIndexed:430(v31, v504 T{int}, v5, NoStoreBarrier)
2536: ParallelMove goto:444 B55
2538: B52[target]:434
2540: ParallelMove goto:446 B55
2542: B55[join]:442 pred(B49, B52)
2544: Branch if EqualityCompare(v491 T{int} == v2634) T{bool} goto (56, 58)
2546: B56[target]:468
2548: Branch if StrictCompare:464(===, v526, v25) goto (62, 59)
2550: B62[target]:514
2552: ParallelMove goto:516 B64
2554: B59[target]:486
2556: ParallelMove goto:488 B57
2558: B58[target]:482
2560: ParallelMove goto:484 B57
2562: B57[join]:480 pred(B58, B59)
2564: v510 <- LoadField(v494 . borderTop {final}) T{bool?}
2566: Branch if StrictCompare(===, v510, v25) T{bool} goto (63, 67)
2568: B63[target]:518
2570: ParallelMove goto:520 B64
2572: B64[join]:512 pred(B62, B63) ParallelMove r2 <- S-23
2573: ParallelMove r0 <- S-14, r1 <- r3
2574: GenericCheckBound:532(v35 T{_Smi}, v491 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
2576: StoreIndexed:532(v36, v491 T{int}, v5, NoStoreBarrier)
2578: ParallelMove goto:546 B70
2580: B67[target]:536 ParallelMove r2 <- S-23
2582: ParallelMove goto:548 B70
2584: B70[join]:544 pred(B64, B67) ParallelMove r8 <- S-12
2586: v512 <- BinaryInt64Op(+ [tr], v491 T{int}, v2635) [-9223372036854775808, 9223372036854775807] T{int}
2588: Branch if EqualityCompare(v512 == v32 T{int}) T{bool} goto (71, 73)
2590: B71[target]:574
2592: Branch if StrictCompare:570(===, v526, v25) goto (77, 74)
2594: B77[target]:624
2596: ParallelMove goto:626 B79
2598: B74[target]:592
2600: ParallelMove goto:594 B72
2602: B73[target]:588
2604: ParallelMove goto:590 B72
2606: B72[join]:586 pred(B73, B74)
2608: v515 <- LoadField(v494 . borderBottom {final}) T{bool?}
2610: Branch if StrictCompare(===, v515, v25) T{bool} goto (78, 82)
2612: B78[target]:628
2614: ParallelMove goto:630 B79
2616: B79[join]:622 pred(B77, B78)
2617: ParallelMove r0 <- S-14, r1 <- r9
2618: GenericCheckBound:644(v35 T{_Smi}, v512 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
2620: StoreIndexed:644(v36, v512 T{int}, v5, NoStoreBarrier)
2622: ParallelMove goto:658 B85
2624: B82[target]:648
2626: ParallelMove goto:660 B85
2628: B85[join]:656 pred(B79, B82)
2630: ParallelMove r14 <- S-25, r3 <- r7, r2 <- S-9, r7 <- S-8, r11 <- r8, r1 <- r2, r9 <- S-18, r10 <- r4, r4 <- S-22, r5 <- S-21, r6 <- S-20, r8 <- S-19 goto:666 B86
2632: B9[target]:52 ParallelMove r7 <- S-1
2634: v3975 <- LoadClassId(<non-smi> v1243)
2636: PushArgument(v1243)
2638: PushArgument(v2082 T{int})
2639: ParallelMove r0 <- r0
2640: v1231 <- DispatchTableCall( cid=v3975 Iterable.elementAt<0>, v1243, v2082 T{int}) T{*?}
2641: ParallelMove r3 <- r0, r0 <- S-3
2642: ParallelMove S-8 <- r3
2642: v1234 <- BinaryInt64Op(+ [tr], v2082 T{int}, v2635) [-9223372036854775808, 9223372036854775807] T{int}
2643: ParallelMove S-10 <- r6
2644: Branch if StrictCompare:12(===, v1231 T{X0??}, v0) goto (555, 556)
2646: B555[target]:16
2647: ParallelMove r0 <- r3, r2 <- S-5, r1 <- C
2648: t0 <- AssertAssignable:18(v1231 T{X0??}, v743, ' in type cast', instantiator_type_args(v1248), function_type_args(v0)) T{X0?}
2650: ParallelMove goto:24 B557
2652: B556[target]:20
2654: ParallelMove goto:26 B557
2656: B557[join]:22 pred(B555, B556) ParallelMove r0 <- S-8
2658: v563 <- LoadField(v1231 T{PositionedCell} . cell {final}) T{Cell}
2659: ParallelMove S-9 <- r1
2660: PushArgument(v1231 T{PositionedCell})
2662: v1259 <- StaticCall:10( _simpleLayoutFactory@18294472<0> v1231 T{PositionedCell}) T{SimpleLayout}
2663: ParallelMove r0 <- r0
2664: PushArgument(v21)
2666: PushArgument(v563)
2668: PushArgument(v1259)
2670: StaticCall:80( []=<0> v21, v563, v1259, using unchecked entrypoint, result_type = T{??})
2672: ParallelMove r6 <- S-10, r1 <- S-1, r2 <- S-7, r3 <- S-6, r4 <- S-5, r5 <- S-4 goto:86 B11
*** END CFG
Error: AOT compilation failed
Generating AOT snapshot failed!
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment