Type computation trace for core_int__parse

linux_type_computation.txt

reaching type to v5 <- StaticCall:12( _lastNonWhitespace@0150898<0> v2, using unchecked entrypoint, result_type = T{int}) T{int} for v2 is T{_StringBase}
reaching type to v8 <- BinaryInt64Op(+ [tr], v5, v7) T{int} for v5 is T{int}
reaching type to v8 <- BinaryInt64Op(+ [tr], v5, v7) T{int} for v7 is T{_Smi}
reaching type to v11 <- EqualityCompare(v8 == v10) T{bool} for v8 is T{int}
reaching type to v11 <- EqualityCompare(v8 == v10) T{bool} for v10 is T{_Smi}
reaching type to AssertBoolean:18(v11) for v11 is T{bool}
reaching type to Branch if StrictCompare:20(===, v11, v13) goto (3, 4) for v11 is T{bool}
reaching type to Branch if StrictCompare:20(===, v11, v13) goto (3, 4) for v13 is T{bool}
reaching type to v14 <- StaticCall:36( _firstNonWhitespace@0150898<0> v2, using unchecked entrypoint, result_type = T{int}) T{int} for v2 is T{_StringBase}
reaching type to v16 <- InstanceCall:38( codeUnitAt<0>, v2, v14 IC[0: ], result_type = T{_Smi}) T{_Smi} for v2 is T{_StringBase}
reaching type to v16 <- InstanceCall:38( codeUnitAt<0>, v2, v14 IC[0: ], result_type = T{_Smi}) T{_Smi} for v14 is T{int}
reaching type to v19 <- EqualityCompare(v16 == v18) T{bool} for v16 is T{_Smi}
reaching type to v19 <- EqualityCompare(v16 == v18) T{bool} for v18 is T{_Smi}
reaching type to AssertBoolean:44(v19) for v19 is T{bool}
reaching type to Branch if StrictCompare:46(===, v19, v13) goto (7, 5) for v19 is T{bool}
reaching type to Branch if StrictCompare:46(===, v19, v13) goto (7, 5) for v13 is T{bool}
reaching type to v22 <- EqualityCompare(v16 == v21) T{bool} for v16 is T{_Smi}
reaching type to v22 <- EqualityCompare(v16 == v21) T{bool} for v21 is T{_Smi}
reaching type to AssertBoolean:52(v22) for v22 is T{bool}
reaching type to Branch if StrictCompare:54(===, v22, v13) goto (8, 11) for v22 is T{bool}
reaching type to Branch if StrictCompare:54(===, v22, v13) goto (8, 11) for v13 is T{bool}
reaching type to v24 <- phi(v69, v14) alive T{int?} for v14 is T{int}
reaching type to v26 <- phi(v73, v16) alive T{int?} for v16 is T{_Smi}
reaching type to v28 <- phi(v67, v7) alive T{int?} for v7 is T{_Smi}
reaching type to Branch if StrictCompare:102(===, v3, v0, with number check) goto (13, 23) for v3 is T{_Smi?}
reaching type to Branch if StrictCompare:102(===, v3, v0, with number check) goto (13, 23) for v0 is T{Null?}
reaching type to v81 <- Redefinition(v3 ^ T{_Smi}) for v3 is T{_Smi?}
reaching type to v30 <- phi(v42, v81) alive T{int?} for v81 is T{_Smi}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) for v2 is T{_StringBase}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) for v30 is T{int?}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) for v24 is T{int?}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) for v8 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) for v28 is T{int?}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) for v34 is T{bool}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) for v4 is T{*?}
reaching type to Return:204(v35) for v35 is T{int?}
reaching type to v38 <- StrictCompare(===, v26, v37) T{bool} for v26 is T{int?}
reaching type to v38 <- StrictCompare(===, v26, v37) T{bool} for v37 is T{_Smi}
reaching type to AssertBoolean:112(v38) for v38 is T{bool}
reaching type to Branch if StrictCompare:114(===, v38, v13) goto (14, 21) for v38 is T{bool}
reaching type to Branch if StrictCompare:114(===, v38, v13) goto (14, 21) for v13 is T{bool}
reaching type to v30 <- phi(v42, v81) alive T{int?} for v42 is T{_Smi}
reaching type to CheckNull:120(v24, NoSuchMethodError) for v24 is T{int?}
reaching type to v43 <- BinaryInt64Op(+ [tr], v83 T{int}, v7) T{int} for v83 is T{int}
reaching type to v43 <- BinaryInt64Op(+ [tr], v83 T{int}, v7) T{int} for v7 is T{_Smi}
reaching type to v45 <- EqualityCompare(v43 == v8) T{bool} for v43 is T{int}
reaching type to v45 <- EqualityCompare(v43 == v8) T{bool} for v8 is T{int}
reaching type to AssertBoolean:124(v45) for v45 is T{bool}
reaching type to Branch if StrictCompare:126(===, v45, v13) goto (15, 16) for v45 is T{bool}
reaching type to Branch if StrictCompare:126(===, v45, v13) goto (15, 16) for v13 is T{bool}
reaching type to v47 <- InstanceCall:138( codeUnitAt<0>, v2, v43 IC[0: ], result_type = T{_Smi}) T{_Smi} for v2 is T{_StringBase}
reaching type to v47 <- InstanceCall:138( codeUnitAt<0>, v2, v43 IC[0: ], result_type = T{_Smi}) T{_Smi} for v43 is T{int}
reaching type to v50 <- BinaryInt64Op(| [tr], v47, v49) T{int} for v47 is T{_Smi}
reaching type to v50 <- BinaryInt64Op(| [tr], v47, v49) T{int} for v49 is T{_Smi}
reaching type to v53 <- EqualityCompare(v50 == v52) T{bool} for v50 is T{int}
reaching type to v53 <- EqualityCompare(v50 == v52) T{bool} for v52 is T{_Smi}
reaching type to AssertBoolean:144(v53) for v53 is T{bool}
reaching type to Branch if StrictCompare:146(===, v53, v13) goto (17, 20) for v53 is T{bool}
reaching type to Branch if StrictCompare:146(===, v53, v13) goto (17, 20) for v13 is T{bool}
reaching type to v55 <- BinaryInt64Op(+ [tr], v43, v7) T{int} for v43 is T{int}
reaching type to v55 <- BinaryInt64Op(+ [tr], v43, v7) T{int} for v7 is T{_Smi}
reaching type to v57 <- EqualityCompare(v55 == v8) T{bool} for v55 is T{int}
reaching type to v57 <- EqualityCompare(v55 == v8) T{bool} for v8 is T{int}
reaching type to AssertBoolean:156(v57) for v57 is T{bool}
reaching type to Branch if StrictCompare:158(===, v57, v13) goto (18, 19) for v57 is T{bool}
reaching type to Branch if StrictCompare:158(===, v57, v13) goto (18, 19) for v13 is T{bool}
reaching type to CheckNull:172(v28, NoSuchMethodError) for v28 is T{int?}
reaching type to v60 <- RelationalOp(>, v85 T{int}, v10) T{bool} for v85 is T{int}
reaching type to v60 <- RelationalOp(>, v85 T{int}, v10) T{bool} for v10 is T{_Smi}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85, v60, v4, result_type = T{int?}) for v2 is T{_StringBase}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85, v60, v4, result_type = T{int?}) for v59 is T{_Smi}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85, v60, v4, result_type = T{int?}) for v55 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85, v60, v4, result_type = T{int?}) for v8 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) for v85 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) for v60 is T{bool}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) for v4 is T{*?}
reaching type to Return:178(v62) for v62 is T{int?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) for v4 is T{*?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) for v2 is T{_StringBase}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) for v55 is T{int}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) for v0 is T{Null?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) for v0 is T{Null?}
reaching type to Return:168(v64) for v64 is T{int?}
reaching type to Return:134(v10) for v10 is T{_Smi}
reaching type to v67 <- BinaryInt64Op(- [tr], v66, v16) T{int} for v66 is T{_Smi}
reaching type to v67 <- BinaryInt64Op(- [tr], v66, v16) T{int} for v16 is T{_Smi}
reaching type to v69 <- BinaryInt64Op(+ [tr], v14, v7) T{int} for v14 is T{int}
reaching type to v69 <- BinaryInt64Op(+ [tr], v14, v7) T{int} for v7 is T{_Smi}
reaching type to v71 <- EqualityCompare(v69 == v8) T{bool} for v69 is T{int}
reaching type to v71 <- EqualityCompare(v69 == v8) T{bool} for v8 is T{int}
reaching type to AssertBoolean:76(v71) for v71 is T{bool}
reaching type to Branch if StrictCompare:78(===, v71, v13) goto (9, 10) for v71 is T{bool}
reaching type to Branch if StrictCompare:78(===, v71, v13) goto (9, 10) for v13 is T{bool}
reaching type to v73 <- InstanceCall:92( codeUnitAt<0>, v2, v69 IC[0: ], result_type = T{_Smi}) for v2 is T{_StringBase}
reaching type to v73 <- InstanceCall:92( codeUnitAt<0>, v2, v69 IC[0: ], result_type = T{_Smi}) for v69 is T{int}
reaching type to v24 <- phi(v69, v14) alive T{int?} for v69 is T{int}
reaching type to v26 <- phi(v73, v16) alive T{int?} for v73 is T{_Smi}
reaching type to v28 <- phi(v67, v7) alive T{int?} for v67 is T{int}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) for v4 is T{*?}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) for v2 is T{_StringBase}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) for v8 is T{int}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) for v3 is T{_Smi?}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) for v0 is T{Null?}
reaching type to Return:88(v75) for v75 is T{int?}
reaching type to v77 <- StaticCall:26( get:length<0> v2, recognized_kind = StringBaseLength, result_type = T{_Smi}) for v2 is T{_StringBase}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v77, v3, v0, result_type = T{int?}) for v4 is T{*?}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v77, v3, v0, result_type = T{int?}) for v2 is T{_StringBase}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v77, v3, v0, result_type = T{int?}) for v77 is T{_Smi}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v77, v3, v0, result_type = T{int?}) for v3 is T{_Smi?}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v77, v3, v0, result_type = T{int?}) for v0 is T{Null?}
reaching type to Return:32(v79) for v79 is T{int?}
recomputing type of v30: T{}
  phi 30 input 0: v42 has reaching type T{_Smi}
  phi 30 input 1: v81 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v35: T{int?}
recomputing type of v28: T{}
  phi 28 input 0: v67 has reaching type T{int}
  phi 28 input 1: v7 has reaching type T{_Smi}
  ... new type T{int}
recomputing type of v35: T{int?}
recomputing type of v85: T{int}
  ... new type T{int}
recomputing type of v60: T{bool}
recomputing type of v62: T{int?}
recomputing type of v26: T{}
  phi 26 input 0: v73 has reaching type T{_Smi}
  phi 26 input 1: v16 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v38: T{bool}
recomputing type of v24: T{}
  phi 24 input 0: v69 has reaching type T{int}
  phi 24 input 1: v14 has reaching type T{int}
  ... new type T{int}
recomputing type of v35: T{int?}
recomputing type of v83: T{int}
reaching type to v5 <- StaticCall:12( _lastNonWhitespace@0150898<0> v2, using unchecked entrypoint, result_type = T{int}) T{int} for v2 is T{_StringBase}
reaching type to v8 <- BinaryInt64Op(+ [tr], v5, v7) T{int} for v5 is T{int}
reaching type to v8 <- BinaryInt64Op(+ [tr], v5, v7) T{int} for v7 is T{_Smi}
reaching type to v11 <- EqualityCompare(v8 == v10) T{bool} for v8 is T{int}
reaching type to v11 <- EqualityCompare(v8 == v10) T{bool} for v10 is T{_Smi}
reaching type to AssertBoolean:18(v11) for v11 is T{bool}
reaching type to Branch if StrictCompare:20(===, v11, v13) goto (3, 4) for v11 is T{bool}
reaching type to Branch if StrictCompare:20(===, v11, v13) goto (3, 4) for v13 is T{bool}
reaching type to v14 <- StaticCall:36( _firstNonWhitespace@0150898<0> v2, using unchecked entrypoint, result_type = T{int}) T{int} for v2 is T{_StringBase}
reaching type to v16 <- PolymorphicInstanceCall:38( codeUnitAt<0>, v2, v14 Targets[4: _OneByteString@0150898 cid 79 cnt:1 trgt:'_OneByteString@0150898.codeUnitAt' | _TwoByteString@0150898 cid 80 cnt:1 trgt:'_TwoByteString@0150898.codeUnitAt' | _ExternalOneByteString@0150898 cid 81 cnt:1 trgt:'_ExternalOneByteString@0150898.codeUnitAt' | _ExternalTwoByteString@0150898 cid 82 cnt:1 trgt:'_ExternalTwoByteString@0150898.codeUnitAt'] COMPLETE) T{_Smi} for v2 is T{_StringBase}
reaching type to v16 <- PolymorphicInstanceCall:38( codeUnitAt<0>, v2, v14 Targets[4: _OneByteString@0150898 cid 79 cnt:1 trgt:'_OneByteString@0150898.codeUnitAt' | _TwoByteString@0150898 cid 80 cnt:1 trgt:'_TwoByteString@0150898.codeUnitAt' | _ExternalOneByteString@0150898 cid 81 cnt:1 trgt:'_ExternalOneByteString@0150898.codeUnitAt' | _ExternalTwoByteString@0150898 cid 82 cnt:1 trgt:'_ExternalTwoByteString@0150898.codeUnitAt'] COMPLETE) T{_Smi} for v14 is T{int}
reaching type to v19 <- EqualityCompare(v16 == v18) T{bool} for v16 is T{_Smi}
reaching type to v19 <- EqualityCompare(v16 == v18) T{bool} for v18 is T{_Smi}
reaching type to AssertBoolean:44(v19) for v19 is T{bool}
reaching type to Branch if StrictCompare:46(===, v19, v13) goto (7, 5) for v19 is T{bool}
reaching type to Branch if StrictCompare:46(===, v19, v13) goto (7, 5) for v13 is T{bool}
reaching type to v22 <- EqualityCompare(v16 == v21) T{bool} for v16 is T{_Smi}
reaching type to v22 <- EqualityCompare(v16 == v21) T{bool} for v21 is T{_Smi}
reaching type to AssertBoolean:52(v22) for v22 is T{bool}
reaching type to Branch if StrictCompare:54(===, v22, v13) goto (8, 11) for v22 is T{bool}
reaching type to Branch if StrictCompare:54(===, v22, v13) goto (8, 11) for v13 is T{bool}
reaching type to v24 <- phi(v69, v14) alive T{int} for v14 is T{int}
reaching type to v26 <- phi(v73, v16) alive T{_Smi} for v16 is T{_Smi}
reaching type to v28 <- phi(v67, v7) alive T{int} for v7 is T{_Smi}
reaching type to Branch if StrictCompare:102(===, v3, v0, with number check) goto (13, 23) for v3 is T{_Smi?}
reaching type to Branch if StrictCompare:102(===, v3, v0, with number check) goto (13, 23) for v0 is T{Null?}
reaching type to v81 <- Redefinition(v3 ^ T{_Smi}) T{_Smi} for v3 is T{_Smi?}
reaching type to v30 <- phi(v42, v81) alive T{_Smi} for v81 is T{_Smi}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v30 is T{_Smi}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v24 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v8 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v28 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v34 is T{bool}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to Return:204(v35) for v35 is T{int?}
reaching type to v38 <- StrictCompare(===, v26, v37) T{bool} for v26 is T{_Smi}
reaching type to v38 <- StrictCompare(===, v26, v37) T{bool} for v37 is T{_Smi}
reaching type to AssertBoolean:112(v38) for v38 is T{bool}
reaching type to Branch if StrictCompare:114(===, v38, v13) goto (14, 21) for v38 is T{bool}
reaching type to Branch if StrictCompare:114(===, v38, v13) goto (14, 21) for v13 is T{bool}
reaching type to v30 <- phi(v42, v81) alive T{_Smi} for v42 is T{_Smi}
reaching type to v83 <- CheckNull:120(v24, NoSuchMethodError) T{int} for v24 is T{int}
reaching type to v43 <- BinaryInt64Op(+ [tr], v83 T{int}, v7) T{int} for v83 is T{int}
reaching type to v43 <- BinaryInt64Op(+ [tr], v83 T{int}, v7) T{int} for v7 is T{_Smi}
reaching type to v45 <- EqualityCompare(v43 == v8) T{bool} for v43 is T{int}
reaching type to v45 <- EqualityCompare(v43 == v8) T{bool} for v8 is T{int}
reaching type to AssertBoolean:124(v45) for v45 is T{bool}
reaching type to Branch if StrictCompare:126(===, v45, v13) goto (15, 16) for v45 is T{bool}
reaching type to Branch if StrictCompare:126(===, v45, v13) goto (15, 16) for v13 is T{bool}
reaching type to v47 <- PolymorphicInstanceCall:138( codeUnitAt<0>, v2, v43 Targets[4: _OneByteString@0150898 cid 79 cnt:1 trgt:'_OneByteString@0150898.codeUnitAt' | _TwoByteString@0150898 cid 80 cnt:1 trgt:'_TwoByteString@0150898.codeUnitAt' | _ExternalOneByteString@0150898 cid 81 cnt:1 trgt:'_ExternalOneByteString@0150898.codeUnitAt' | _ExternalTwoByteString@0150898 cid 82 cnt:1 trgt:'_ExternalTwoByteString@0150898.codeUnitAt'] COMPLETE) T{_Smi} for v2 is T{_StringBase}
reaching type to v47 <- PolymorphicInstanceCall:138( codeUnitAt<0>, v2, v43 Targets[4: _OneByteString@0150898 cid 79 cnt:1 trgt:'_OneByteString@0150898.codeUnitAt' | _TwoByteString@0150898 cid 80 cnt:1 trgt:'_TwoByteString@0150898.codeUnitAt' | _ExternalOneByteString@0150898 cid 81 cnt:1 trgt:'_ExternalOneByteString@0150898.codeUnitAt' | _ExternalTwoByteString@0150898 cid 82 cnt:1 trgt:'_ExternalTwoByteString@0150898.codeUnitAt'] COMPLETE) T{_Smi} for v43 is T{int}
reaching type to v50 <- BinaryInt64Op(| [tr], v47, v49) T{int} for v47 is T{_Smi}
reaching type to v50 <- BinaryInt64Op(| [tr], v47, v49) T{int} for v49 is T{_Smi}
reaching type to v53 <- EqualityCompare(v50 == v52) T{bool} for v50 is T{int}
reaching type to v53 <- EqualityCompare(v50 == v52) T{bool} for v52 is T{_Smi}
reaching type to AssertBoolean:144(v53) for v53 is T{bool}
reaching type to Branch if StrictCompare:146(===, v53, v13) goto (17, 20) for v53 is T{bool}
reaching type to Branch if StrictCompare:146(===, v53, v13) goto (17, 20) for v13 is T{bool}
reaching type to v55 <- BinaryInt64Op(+ [tr], v43, v7) T{int} for v43 is T{int}
reaching type to v55 <- BinaryInt64Op(+ [tr], v43, v7) T{int} for v7 is T{_Smi}
reaching type to v57 <- EqualityCompare(v55 == v8) T{bool} for v55 is T{int}
reaching type to v57 <- EqualityCompare(v55 == v8) T{bool} for v8 is T{int}
reaching type to AssertBoolean:156(v57) for v57 is T{bool}
reaching type to Branch if StrictCompare:158(===, v57, v13) goto (18, 19) for v57 is T{bool}
reaching type to Branch if StrictCompare:158(===, v57, v13) goto (18, 19) for v13 is T{bool}
reaching type to v85 <- CheckNull:172(v28, NoSuchMethodError) T{int} for v28 is T{int}
reaching type to v60 <- RelationalOp(>, v85 T{int}, v10) T{bool} for v85 is T{int}
reaching type to v60 <- RelationalOp(>, v85 T{int}, v10) T{bool} for v10 is T{_Smi}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v59 is T{_Smi}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v55 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v8 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v85 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v60 is T{bool}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to Return:178(v62) for v62 is T{int?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) T{int?} for v55 is T{int}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:168(v64) for v64 is T{int?}
reaching type to Return:134(v10) for v10 is T{_Smi}
reaching type to v67 <- BinaryInt64Op(- [tr], v66, v16) T{int} for v66 is T{_Smi}
reaching type to v67 <- BinaryInt64Op(- [tr], v66, v16) T{int} for v16 is T{_Smi}
reaching type to v69 <- BinaryInt64Op(+ [tr], v14, v7) T{int} for v14 is T{int}
reaching type to v69 <- BinaryInt64Op(+ [tr], v14, v7) T{int} for v7 is T{_Smi}
reaching type to v71 <- EqualityCompare(v69 == v8) T{bool} for v69 is T{int}
reaching type to v71 <- EqualityCompare(v69 == v8) T{bool} for v8 is T{int}
reaching type to AssertBoolean:76(v71) for v71 is T{bool}
reaching type to Branch if StrictCompare:78(===, v71, v13) goto (9, 10) for v71 is T{bool}
reaching type to Branch if StrictCompare:78(===, v71, v13) goto (9, 10) for v13 is T{bool}
reaching type to v73 <- PolymorphicInstanceCall:92( codeUnitAt<0>, v2, v69 Targets[4: _OneByteString@0150898 cid 79 cnt:1 trgt:'_OneByteString@0150898.codeUnitAt' | _TwoByteString@0150898 cid 80 cnt:1 trgt:'_TwoByteString@0150898.codeUnitAt' | _ExternalOneByteString@0150898 cid 81 cnt:1 trgt:'_ExternalOneByteString@0150898.codeUnitAt' | _ExternalTwoByteString@0150898 cid 82 cnt:1 trgt:'_ExternalTwoByteString@0150898.codeUnitAt'] COMPLETE) T{_Smi} for v2 is T{_StringBase}
reaching type to v73 <- PolymorphicInstanceCall:92( codeUnitAt<0>, v2, v69 Targets[4: _OneByteString@0150898 cid 79 cnt:1 trgt:'_OneByteString@0150898.codeUnitAt' | _TwoByteString@0150898 cid 80 cnt:1 trgt:'_TwoByteString@0150898.codeUnitAt' | _ExternalOneByteString@0150898 cid 81 cnt:1 trgt:'_ExternalOneByteString@0150898.codeUnitAt' | _ExternalTwoByteString@0150898 cid 82 cnt:1 trgt:'_ExternalTwoByteString@0150898.codeUnitAt'] COMPLETE) T{_Smi} for v69 is T{int}
reaching type to v24 <- phi(v69, v14) alive T{int} for v69 is T{int}
reaching type to v26 <- phi(v73, v16) alive T{_Smi} for v73 is T{_Smi}
reaching type to v28 <- phi(v67, v7) alive T{int} for v67 is T{int}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) T{int?} for v8 is T{int}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) T{int?} for v3 is T{_Smi?}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:88(v75) for v75 is T{int?}
reaching type to v77 <- StaticCall:26( get:length<0> v2, recognized_kind = StringBaseLength, result_type = T{_Smi}) T{_Smi} for v2 is T{_StringBase}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v77, v3, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v77, v3, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v77, v3, v0, result_type = T{int?}) T{int?} for v77 is T{_Smi}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v77, v3, v0, result_type = T{int?}) T{int?} for v3 is T{_Smi?}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v77, v3, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:32(v79) for v79 is T{int?}
recomputing type of v30: T{}
  phi 30 input 0: v42 has reaching type T{_Smi}
  phi 30 input 1: v81 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v35: T{int?}
recomputing type of v28: T{}
  phi 28 input 0: v67 has reaching type T{int}
  phi 28 input 1: v7 has reaching type T{_Smi}
  ... new type T{int}
recomputing type of v35: T{int?}
recomputing type of v85: T{int}
recomputing type of v26: T{}
  phi 26 input 0: v73 has reaching type T{_Smi}
  phi 26 input 1: v16 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v38: T{bool}
recomputing type of v24: T{}
  phi 24 input 0: v69 has reaching type T{int}
  phi 24 input 1: v14 has reaching type T{int}
  ... new type T{int}
recomputing type of v35: T{int?}
recomputing type of v83: T{int}
reaching type to v243 <- BinaryInt64Op(- [tr], v230, v242) T{int} for v230 is T{_Smi}
reaching type to v243 <- BinaryInt64Op(- [tr], v230, v242) T{int} for v242 is T{_Smi}
reaching type to v246 <- BinaryInt64Op(* [tr], v243, v245) T{int} for v243 is T{int}
reaching type to v246 <- BinaryInt64Op(* [tr], v243, v245) T{int} for v245 is T{_Smi}
reaching type to AssertBoolean:18(v248) for v248 is T{bool?}
reaching type to Branch if StrictCompare:20(===, v248, v250) goto (54, 55) for v248 is T{bool?}
reaching type to Branch if StrictCompare:20(===, v248, v250) goto (54, 55) for v250 is T{bool}
reaching type to v252 <- phi(v242, v251) alive T{*?} for v251 is T{_Smi}
reaching type to v254 <- StaticCall:34( +<0> v246, v252, using unchecked entrypoint, recognized_kind = Integer_add, result_type = T{int}) T{num} for v246 is T{int}
reaching type to v254 <- StaticCall:34( +<0> v246, v252, using unchecked entrypoint, recognized_kind = Integer_add, result_type = T{int}) T{num} for v252 is T{*?}
reaching type to v257 <- StaticCall:36( []<0> v256, v254, recognized_kind = ImmutableArrayGetIndexed) T{*?} for v256 is T{_ImmutableList}
reaching type to v257 <- StaticCall:36( []<0> v256, v254, recognized_kind = ImmutableArrayGetIndexed) T{*?} for v254 is T{num}
reaching type to v259 <- BinaryInt64Op(- [tr], v234, v232) T{int} for v234 is T{int}
reaching type to v259 <- BinaryInt64Op(- [tr], v234, v232) T{int} for v232 is T{int}
reaching type to v261 <- StaticCall:40( <=<0> v259, v257, using unchecked entrypoint, recognized_kind = Integer_lessEqualThan, result_type = T{bool}) for v259 is T{int}
reaching type to v261 <- StaticCall:40( <=<0> v259, v257, using unchecked entrypoint, recognized_kind = Integer_lessEqualThan, result_type = T{bool}) for v257 is T{*?}
reaching type to AssertBoolean:42(v261) for v261 is T{bool}
reaching type to Branch if StrictCompare:44(===, v261, v250) goto (57, 60) for v261 is T{bool}
reaching type to Branch if StrictCompare:44(===, v261, v250) goto (57, 60) for v250 is T{bool}
reaching type to v263 <- phi(v259, v389) alive T{int?} for v259 is T{int}
reaching type to v265 <- StaticCall:76( >=<0> v263, v257, using unchecked entrypoint, recognized_kind = Integer_greaterEqualThan, result_type = T{bool}) for v263 is T{int?}
reaching type to v265 <- StaticCall:76( >=<0> v263, v257, using unchecked entrypoint, recognized_kind = Integer_greaterEqualThan, result_type = T{bool}) for v257 is T{*?}
reaching type to AssertBoolean:78(v265) for v265 is T{bool}
reaching type to Branch if StrictCompare:80(===, v265, v250) goto (61, 63) for v265 is T{bool}
reaching type to Branch if StrictCompare:80(===, v265, v250) goto (61, 63) for v250 is T{bool}
reaching type to CheckNull:100(v263, NoSuchMethodError) for v263 is T{int?}
reaching type to v267 <- RelationalOp(>, v431 T{int}, v251) T{bool} for v431 is T{int}
reaching type to v267 <- RelationalOp(>, v431 T{int}, v251) T{bool} for v251 is T{_Smi}
reaching type to AssertBoolean:102(v267) for v267 is T{bool}
reaching type to Branch if StrictCompare:104(===, v267, v250) goto (64, 67) for v267 is T{bool}
reaching type to Branch if StrictCompare:104(===, v267, v250) goto (64, 67) for v250 is T{bool}
reaching type to v269 <- phi(v381, v232) alive T{int?} for v232 is T{int}
reaching type to v271 <- phi(v385, v251) alive for v251 is T{_Smi}
reaching type to v397 <- Redefinition(v254 ^ T{int}) T{int} for v254 is T{num}
reaching type to v278 <- BinaryInt64Op(+ [tr], v397, v277) T{int} for v397 is T{int}
reaching type to v278 <- BinaryInt64Op(+ [tr], v397, v277) T{int} for v277 is T{_Smi}
reaching type to v280 <- StaticCall:142( []<0> v256, v278, recognized_kind = ImmutableArrayGetIndexed) T{*?} for v256 is T{_ImmutableList}
reaching type to v280 <- StaticCall:142( []<0> v256, v278, recognized_kind = ImmutableArrayGetIndexed) T{*?} for v278 is T{int}
reaching type to v282 <- ShiftInt64Op(<< [tr], v397, v277) T{int} for v397 is T{int}
reaching type to v282 <- ShiftInt64Op(<< [tr], v397, v277) T{int} for v277 is T{_Smi}
reaching type to CheckNull:152(v284, NoSuchMethodError) for v284 is T{_Int64List?}
reaching type to v399 <- LoadField(v433 T{_Int64List} . TypedDataBase.length {final}) for v433 is T{_Int64List}
reaching type to v401 <- GenericCheckBound:154(v399, v282) for v399 is T{_Smi}
reaching type to v401 <- GenericCheckBound:154(v399, v282) for v282 is T{int}
reaching type to v403 <- LoadIndexed(v433 T{_Int64List}, v401) T{int} for v433 is T{_Int64List}
reaching type to v403 <- LoadIndexed(v433 T{_Int64List}, v401) T{int} for v401 is T{int}
reaching type to v288 <- EqualityCompare(v403 == v251) T{bool} for v403 is T{int}
reaching type to v288 <- EqualityCompare(v403 == v251) T{bool} for v251 is T{_Smi}
reaching type to AssertBoolean:158(v288) for v288 is T{bool}
reaching type to Branch if StrictCompare:160(===, v288, v250) goto (69, 70) for v288 is T{bool}
reaching type to Branch if StrictCompare:160(===, v288, v250) goto (69, 70) for v250 is T{bool}
reaching type to v290 <- phi(v379, v403) alive T{int?} for v403 is T{int}
reaching type to v294 <- BinaryInt64Op(+ [tr], v282, v277) T{int} for v282 is T{int}
reaching type to v294 <- BinaryInt64Op(+ [tr], v282, v277) T{int} for v277 is T{_Smi}
reaching type to CheckNull:180(v292, NoSuchMethodError) for v292 is T{_Int64List?}
reaching type to v405 <- LoadField(v435 T{_Int64List} . TypedDataBase.length {final}) for v435 is T{_Int64List}
reaching type to v407 <- GenericCheckBound:182(v405, v294) for v405 is T{_Smi}
reaching type to v407 <- GenericCheckBound:182(v405, v294) for v294 is T{int}
reaching type to v409 <- LoadIndexed(v435 T{_Int64List}, v407) T{int} for v435 is T{_Int64List}
reaching type to v409 <- LoadIndexed(v435 T{_Int64List}, v407) T{int} for v407 is T{int}
reaching type to v298 <- StaticCall:184( +<0> v269, v257, using unchecked entrypoint, recognized_kind = Integer_add, result_type = T{int}) for v269 is T{int?}
reaching type to v298 <- StaticCall:184( +<0> v269, v257, using unchecked entrypoint, recognized_kind = Integer_add, result_type = T{int}) for v257 is T{*?}
reaching type to v300 <- phi(v269, v304) alive T{int?} for v269 is T{int?}
reaching type to v302 <- phi(v271, v332) alive T{int?} for v271 is T{}
reaching type to v304 <- phi(v298, v429) alive T{int?} for v298 is T{num}
reaching type to v308 <- StaticCall:186( _parseBlock@0150898<0> v228, v230, v300, v304, result_type = T{_Smi?}) T{_Smi?} for v228 is T{_StringBase}
reaching type to v308 <- StaticCall:186( _parseBlock@0150898<0> v228, v230, v300, v304, result_type = T{_Smi?}) T{_Smi?} for v230 is T{_Smi}
reaching type to v308 <- StaticCall:186( _parseBlock@0150898<0> v228, v230, v300, v304, result_type = T{_Smi?}) T{_Smi?} for v300 is T{int?}
reaching type to v308 <- StaticCall:186( _parseBlock@0150898<0> v228, v230, v300, v304, result_type = T{_Smi?}) T{_Smi?} for v304 is T{int?}
reaching type to Branch if StrictCompare:188(===, v308, v219, with number check) goto (72, 73) for v308 is T{_Smi?}
reaching type to Branch if StrictCompare:188(===, v308, v219, with number check) goto (72, 73) for v219 is T{Null?}
reaching type to v437 <- Redefinition(v308 ^ T{_Smi}) for v308 is T{_Smi?}
reaching type to CheckNull:202(v302, NoSuchMethodError) for v302 is T{int?}
reaching type to CheckNull:202(v290, NoSuchMethodError) for v290 is T{int?}
reaching type to v310 <- RelationalOp(>=, v439 T{int}, v441 T{int?}) T{bool} for v439 is T{int}
reaching type to v310 <- RelationalOp(>=, v439 T{int}, v441 T{int}) T{bool} for v441 is T{int}
reaching type to AssertBoolean:204(v310) for v310 is T{bool}
reaching type to Branch if StrictCompare:206(===, v310, v250) goto (74, 95) for v310 is T{bool}
reaching type to Branch if StrictCompare:206(===, v310, v250) goto (74, 95) for v250 is T{bool}
reaching type to CheckNull:368(v439 T{int}, NoSuchMethodError) for v439 is T{int}
reaching type to v312 <- RelationalOp(<=, v439 T{int}, v409) T{bool} for v439 is T{int}
reaching type to v312 <- RelationalOp(<=, v439 T{int}, v409) T{bool} for v409 is T{int}
reaching type to AssertBoolean:370(v312) for v312 is T{bool}
reaching type to Branch if StrictCompare:372(===, v312, v250) goto (96, 102) for v312 is T{bool}
reaching type to Branch if StrictCompare:372(===, v312, v250) goto (96, 102) for v250 is T{bool}
reaching type to CheckNull:378(v439 T{int}, NoSuchMethodError) for v439 is T{int}
reaching type to v314 <- RelationalOp(<, v439 T{int}, v409) T{bool} for v439 is T{int}
reaching type to v314 <- RelationalOp(<, v439 T{int}, v409) T{bool} for v409 is T{int}
reaching type to AssertBoolean:380(v314) for v314 is T{bool}
reaching type to Branch if StrictCompare:382(===, v314, v250) goto (99, 97) for v314 is T{bool}
reaching type to Branch if StrictCompare:382(===, v314, v250) goto (99, 97) for v250 is T{bool}
reaching type to v319 <- BinaryInt64Op(+ [tr], v282, v318) T{int} for v282 is T{int}
reaching type to v319 <- BinaryInt64Op(+ [tr], v282, v318) T{int} for v318 is T{_Smi}
reaching type to CheckNull:390(v316, NoSuchMethodError) for v316 is T{_Int64List?}
reaching type to v421 <- LoadField(v443 T{_Int64List} . TypedDataBase.length {final}) for v443 is T{_Int64List}
reaching type to v423 <- GenericCheckBound:392(v421, v319) for v421 is T{_Smi}
reaching type to v423 <- GenericCheckBound:392(v421, v319) for v319 is T{int}
reaching type to v425 <- LoadIndexed(v443 T{_Int64List}, v423) T{int} for v443 is T{_Int64List}
reaching type to v425 <- LoadIndexed(v443 T{_Int64List}, v423) T{int} for v423 is T{int}
reaching type to CheckNull:394(v437, NoSuchMethodError) for v437 is T{_Smi}
reaching type to v323 <- RelationalOp(>, v437, v425) T{bool} for v437 is T{_Smi}
reaching type to v323 <- RelationalOp(>, v437, v425) T{bool} for v425 is T{int}
reaching type to AssertBoolean:396(v323) for v323 is T{bool}
reaching type to Branch if StrictCompare:398(===, v323, v250) goto (100, 101) for v323 is T{bool}
reaching type to Branch if StrictCompare:398(===, v323, v250) goto (100, 101) for v250 is T{bool}
reaching type to v326 <- StaticCall:414( _throwFormatException@0150898<0> v240, v228, v219, v230, v325, result_type = T{int?}) for v240 is T{*?}
reaching type to v326 <- StaticCall:414( _throwFormatException@0150898<0> v240, v228, v219, v230, v325, result_type = T{int?}) for v228 is T{_StringBase}
reaching type to v326 <- StaticCall:414( _throwFormatException@0150898<0> v240, v228, v219, v230, v325, result_type = T{int?}) for v219 is T{Null?}
reaching type to v326 <- StaticCall:414( _throwFormatException@0150898<0> v240, v228, v219, v230, v325, result_type = T{int?}) for v230 is T{_Smi}
reaching type to v326 <- StaticCall:414( _throwFormatException@0150898<0> v240, v228, v219, v230, v325, result_type = T{int?}) for v325 is T{_OneByteString}
reaching type to Return:418(v326) for v326 is T{int?}
reaching type to v328 <- StaticCall:436( *<0> v439 T{int}, v280, using unchecked entrypoint, recognized_kind = Integer_mul, result_type = T{int}) T{num} for v439 is T{int}
reaching type to v328 <- StaticCall:436( *<0> v439 T{int}, v280, using unchecked entrypoint, recognized_kind = Integer_mul, result_type = T{int}) T{num} for v280 is T{*?}
reaching type to CheckNull:438(v437, NoSuchMethodError) for v437 is T{_Smi}
reaching type to v330 <- BinaryInt64Op(* [tr], v236, v437 T{_Smi?}) T{int} for v236 is T{int}
reaching type to v330 <- BinaryInt64Op(* [tr], v236, v437) T{int} for v437 is T{_Smi}
reaching type to v427 <- Redefinition(v328 ^ T{int}) T{int} for v328 is T{num}
reaching type to v332 <- BinaryInt64Op(+ [tr], v427, v330) T{int} for v427 is T{int}
reaching type to v332 <- BinaryInt64Op(+ [tr], v427, v330) T{int} for v330 is T{int}
reaching type to CheckNull:444(v304, NoSuchMethodError) for v304 is T{int?}
reaching type to v334 <- StaticCall:446( +<0> v445 T{int}, v257, using unchecked entrypoint, recognized_kind = Integer_add, result_type = T{int}) T{num} for v445 is T{int}
reaching type to v334 <- StaticCall:446( +<0> v445 T{int}, v257, using unchecked entrypoint, recognized_kind = Integer_add, result_type = T{int}) T{num} for v257 is T{*?}
reaching type to v429 <- Redefinition(v334 ^ T{int}) T{int} for v334 is T{num}
reaching type to v336 <- RelationalOp(<=, v429, v234) T{bool} for v429 is T{int}
reaching type to v336 <- RelationalOp(<=, v429, v234) T{bool} for v234 is T{int}
reaching type to AssertBoolean:450(v336) for v336 is T{bool}
reaching type to Branch if StrictCompare:452(===, v336, v250) goto (106, 107) for v336 is T{bool}
reaching type to Branch if StrictCompare:452(===, v336, v250) goto (106, 107) for v250 is T{bool}
reaching type to Return:470(v332) for v332 is T{int}
reaching type to v300 <- phi(v269, v445 T{int}) alive T{int?} for v445 is T{int}
reaching type to v302 <- phi(v271, v332) alive T{int?} for v332 is T{int}
reaching type to v304 <- phi(v298, v429) alive T{int?} for v429 is T{int}
reaching type to CheckNull:212(v439 T{int}, NoSuchMethodError) for v439 is T{int}
reaching type to CheckNull:212(v441 T{int}, NoSuchMethodError) for v441 is T{int}
reaching type to v338 <- RelationalOp(>, v439 T{int}, v441 T{int?}) T{bool} for v439 is T{int}
reaching type to v338 <- RelationalOp(>, v439 T{int}, v441 T{int}) T{bool} for v441 is T{int}
reaching type to AssertBoolean:214(v338) for v338 is T{bool}
reaching type to Branch if StrictCompare:216(===, v338, v250) goto (77, 75) for v338 is T{bool}
reaching type to Branch if StrictCompare:216(===, v338, v250) goto (77, 75) for v250 is T{bool}
reaching type to v342 <- BinaryInt64Op(+ [tr], v282, v242) T{int} for v282 is T{int}
reaching type to v342 <- BinaryInt64Op(+ [tr], v282, v242) T{int} for v242 is T{_Smi}
reaching type to CheckNull:224(v340, NoSuchMethodError) for v340 is T{_Int64List?}
reaching type to v411 <- LoadField(v447 T{_Int64List} . TypedDataBase.length {final}) for v447 is T{_Int64List}
reaching type to v413 <- GenericCheckBound:226(v411, v342) for v411 is T{_Smi}
reaching type to v413 <- GenericCheckBound:226(v411, v342) for v342 is T{int}
reaching type to v415 <- LoadIndexed(v447 T{_Int64List}, v413) T{int} for v447 is T{_Int64List}
reaching type to v415 <- LoadIndexed(v447 T{_Int64List}, v413) T{int} for v413 is T{int}
reaching type to CheckNull:228(v437, NoSuchMethodError) for v437 is T{_Smi}
reaching type to v346 <- RelationalOp(>, v437, v415) T{bool} for v437 is T{_Smi}
reaching type to v346 <- RelationalOp(>, v437, v415) T{bool} for v415 is T{int}
reaching type to AssertBoolean:230(v346) for v346 is T{bool}
reaching type to Branch if StrictCompare:232(===, v346, v250) goto (78, 94) for v346 is T{bool}
reaching type to Branch if StrictCompare:232(===, v346, v250) goto (78, 94) for v250 is T{bool}
reaching type to AssertBoolean:250(v348) for v348 is T{bool?}
reaching type to Branch if StrictCompare:252(===, v348, v250) goto (79, 80) for v348 is T{bool?}
reaching type to Branch if StrictCompare:252(===, v348, v250) goto (79, 80) for v250 is T{bool}
reaching type to v350 <- phi(v277, v251) alive T{*?} for v251 is T{_Smi}
reaching type to AssertBoolean:268(v238) for v238 is T{bool}
reaching type to Branch if StrictCompare:270(===, v238, v250) goto (84, 90) for v238 is T{bool}
reaching type to Branch if StrictCompare:270(===, v238, v250) goto (84, 90) for v250 is T{bool}
reaching type to v353 <- StaticCall:358( _throwFormatException@0150898<0> v240, v228, v219, v230, v352, result_type = T{int?}) for v240 is T{*?}
reaching type to v353 <- StaticCall:358( _throwFormatException@0150898<0> v240, v228, v219, v230, v352, result_type = T{int?}) for v228 is T{_StringBase}
reaching type to v353 <- StaticCall:358( _throwFormatException@0150898<0> v240, v228, v219, v230, v352, result_type = T{int?}) for v219 is T{Null?}
reaching type to v353 <- StaticCall:358( _throwFormatException@0150898<0> v240, v228, v219, v230, v352, result_type = T{int?}) for v230 is T{_Smi}
reaching type to v353 <- StaticCall:358( _throwFormatException@0150898<0> v240, v228, v219, v230, v352, result_type = T{int?}) for v352 is T{_OneByteString}
reaching type to Return:362(v353) for v353 is T{int?}
reaching type to v356 <- StaticCall:274( []<0> v355, v350, recognized_kind = ImmutableArrayGetIndexed) T{*?} for v355 is T{_ImmutableList}
reaching type to v356 <- StaticCall:274( []<0> v355, v350, recognized_kind = ImmutableArrayGetIndexed) T{*?} for v350 is T{*?}
reaching type to v358 <- StaticCall:276( >=<0> v439 T{int}, v356, using unchecked entrypoint, recognized_kind = Integer_greaterEqualThan, result_type = T{bool}) for v439 is T{int}
reaching type to v358 <- StaticCall:276( >=<0> v439 T{int}, v356, using unchecked entrypoint, recognized_kind = Integer_greaterEqualThan, result_type = T{bool}) for v356 is T{*?}
reaching type to AssertBoolean:278(v358) for v358 is T{bool}
reaching type to Branch if StrictCompare:280(===, v358, v250) goto (83, 86) for v358 is T{bool}
reaching type to Branch if StrictCompare:280(===, v358, v250) goto (83, 86) for v250 is T{bool}
reaching type to v360 <- StaticCall:310( +<0> v304, v257, using unchecked entrypoint, recognized_kind = Integer_add, result_type = T{int}) T{num} for v304 is T{int?}
reaching type to v360 <- StaticCall:310( +<0> v304, v257, using unchecked entrypoint, recognized_kind = Integer_add, result_type = T{int}) T{num} for v257 is T{*?}
reaching type to v417 <- Redefinition(v360 ^ T{int}) T{int} for v360 is T{num}
reaching type to v362 <- RelationalOp(>, v417, v234) T{bool} for v417 is T{int}
reaching type to v362 <- RelationalOp(>, v417, v234) T{bool} for v234 is T{int}
reaching type to AssertBoolean:314(v362) for v362 is T{bool}
reaching type to Branch if StrictCompare:316(===, v362, v250) goto (88, 93) for v362 is T{bool}
reaching type to Branch if StrictCompare:316(===, v362, v250) goto (88, 93) for v250 is T{bool}
reaching type to v364 <- StaticCall:332( *<0> v439 T{int}, v280, using unchecked entrypoint, recognized_kind = Integer_mul, result_type = T{int}) T{num} for v439 is T{int}
reaching type to v364 <- StaticCall:332( *<0> v439 T{int}, v280, using unchecked entrypoint, recognized_kind = Integer_mul, result_type = T{int}) T{num} for v280 is T{*?}
reaching type to v419 <- Redefinition(v364 ^ T{int}) T{int} for v364 is T{num}
reaching type to CheckNull:334(v437, NoSuchMethodError) for v437 is T{_Smi}
reaching type to v366 <- BinaryInt64Op(+ [tr], v419, v437 T{_Smi?}) T{int} for v419 is T{int}
reaching type to v366 <- BinaryInt64Op(+ [tr], v419, v437) T{int} for v437 is T{_Smi}
reaching type to Return:338(v366) for v366 is T{int}
reaching type to v368 <- StaticCall:284( []<0> v355, v350, recognized_kind = ImmutableArrayGetIndexed) T{*?} for v355 is T{_ImmutableList}
reaching type to v368 <- StaticCall:284( []<0> v355, v350, recognized_kind = ImmutableArrayGetIndexed) T{*?} for v350 is T{*?}
reaching type to v370 <- StaticCall:286( ><0> v439 T{int}, v368, using unchecked entrypoint, recognized_kind = Integer_greaterThan, result_type = T{bool}) for v439 is T{int}
reaching type to v370 <- StaticCall:286( ><0> v439 T{int}, v368, using unchecked entrypoint, recognized_kind = Integer_greaterThan, result_type = T{bool}) for v368 is T{*?}
reaching type to AssertBoolean:288(v370) for v370 is T{bool}
reaching type to Branch if StrictCompare:290(===, v370, v250) goto (91, 82) for v370 is T{bool}
reaching type to Branch if StrictCompare:290(===, v370, v250) goto (91, 82) for v250 is T{bool}
reaching type to v373 <- StaticCall:294( []<0> v372, v350, recognized_kind = ImmutableArrayGetIndexed) T{*?} for v372 is T{_ImmutableList}
reaching type to v373 <- StaticCall:294( []<0> v372, v350, recognized_kind = ImmutableArrayGetIndexed) T{*?} for v350 is T{*?}
reaching type to v375 <- StaticCall:296( ><0> v437, v373, using unchecked entrypoint, recognized_kind = Integer_greaterThan, result_type = T{bool}) for v437 is T{_Smi}
reaching type to v375 <- StaticCall:296( ><0> v437, v373, using unchecked entrypoint, recognized_kind = Integer_greaterThan, result_type = T{bool}) for v373 is T{*?}
reaching type to AssertBoolean:298(v375) for v375 is T{bool}
reaching type to Branch if StrictCompare:300(===, v375, v250) goto (92, 87) for v375 is T{bool}
reaching type to Branch if StrictCompare:300(===, v375, v250) goto (92, 87) for v250 is T{bool}
reaching type to v350 <- phi(v277, v251) alive T{*?} for v277 is T{_Smi}
reaching type to v377 <- StaticCall:194( _throwFormatException@0150898<0> v240, v228, v300, v230, v219, result_type = T{int?}) for v240 is T{*?}
reaching type to v377 <- StaticCall:194( _throwFormatException@0150898<0> v240, v228, v300, v230, v219, result_type = T{int?}) for v228 is T{_StringBase}
reaching type to v377 <- StaticCall:194( _throwFormatException@0150898<0> v240, v228, v300, v230, v219, result_type = T{int?}) for v300 is T{int?}
reaching type to v377 <- StaticCall:194( _throwFormatException@0150898<0> v240, v228, v300, v230, v219, result_type = T{int?}) for v230 is T{_Smi}
reaching type to v377 <- StaticCall:194( _throwFormatException@0150898<0> v240, v228, v300, v230, v219, result_type = T{int?}) for v219 is T{Null?}
reaching type to Return:198(v377) for v377 is T{int?}
reaching type to v379 <- StaticCall:166( _initInt64OverflowLimits@0150898<0> v282, v280, result_type = T{int?}) for v282 is T{int}
reaching type to v379 <- StaticCall:166( _initInt64OverflowLimits@0150898<0> v282, v280, result_type = T{int?}) for v280 is T{*?}
reaching type to v290 <- phi(v379, v403) alive T{int?} for v379 is T{int?}
reaching type to CheckNull:110(v431 T{int}, NoSuchMethodError) for v431 is T{int}
reaching type to v381 <- BinaryInt64Op(+ [tr], v232, v431 T{int?}) T{int} for v232 is T{int}
reaching type to v381 <- BinaryInt64Op(+ [tr], v232, v431 T{int}) T{int} for v431 is T{int}
reaching type to v383 <- StaticCall:112( _parseBlock@0150898<0> v228, v230, v232, v381, result_type = T{_Smi?}) T{_Smi?} for v228 is T{_StringBase}
reaching type to v383 <- StaticCall:112( _parseBlock@0150898<0> v228, v230, v232, v381, result_type = T{_Smi?}) T{_Smi?} for v230 is T{_Smi}
reaching type to v383 <- StaticCall:112( _parseBlock@0150898<0> v228, v230, v232, v381, result_type = T{_Smi?}) T{_Smi?} for v232 is T{int}
reaching type to v383 <- StaticCall:112( _parseBlock@0150898<0> v228, v230, v232, v381, result_type = T{_Smi?}) T{_Smi?} for v381 is T{int}
reaching type to Branch if StrictCompare:114(===, v383, v219, with number check) goto (65, 66) for v383 is T{_Smi?}
reaching type to Branch if StrictCompare:114(===, v383, v219, with number check) goto (65, 66) for v219 is T{Null?}
reaching type to v449 <- Redefinition(v383 ^ T{_Smi}) for v383 is T{_Smi?}
reaching type to CheckNull:128(v449, NoSuchMethodError) for v449 is T{_Smi}
reaching type to v385 <- BinaryInt64Op(* [tr], v236, v449 T{_Smi?}) T{int} for v236 is T{int}
reaching type to v385 <- BinaryInt64Op(* [tr], v236, v449) T{int} for v449 is T{_Smi}
reaching type to v269 <- phi(v381, v232) alive T{int?} for v381 is T{int}
reaching type to v271 <- phi(v385, v251) alive T{} for v385 is T{int}
reaching type to v387 <- StaticCall:120( _throwFormatException@0150898<0> v240, v228, v232, v230, v219, result_type = T{int?}) for v240 is T{*?}
reaching type to v387 <- StaticCall:120( _throwFormatException@0150898<0> v240, v228, v232, v230, v219, result_type = T{int?}) for v228 is T{_StringBase}
reaching type to v387 <- StaticCall:120( _throwFormatException@0150898<0> v240, v228, v232, v230, v219, result_type = T{int?}) for v232 is T{int}
reaching type to v387 <- StaticCall:120( _throwFormatException@0150898<0> v240, v228, v232, v230, v219, result_type = T{int?}) for v230 is T{_Smi}
reaching type to v387 <- StaticCall:120( _throwFormatException@0150898<0> v240, v228, v232, v230, v219, result_type = T{int?}) for v219 is T{Null?}
reaching type to Return:124(v387) for v387 is T{int?}
reaching type to v389 <- StaticCall:84( -<0> v263, v257, using unchecked entrypoint, recognized_kind = Integer_sub, result_type = T{int}) for v263 is T{int?}
reaching type to v389 <- StaticCall:84( -<0> v263, v257, using unchecked entrypoint, recognized_kind = Integer_sub, result_type = T{int}) for v257 is T{*?}
reaching type to v263 <- phi(v259, v389) alive T{int?} for v389 is T{num}
reaching type to v391 <- StaticCall:50( _parseBlock@0150898<0> v228, v230, v232, v234, result_type = T{_Smi?}) T{_Smi?} for v228 is T{_StringBase}
reaching type to v391 <- StaticCall:50( _parseBlock@0150898<0> v228, v230, v232, v234, result_type = T{_Smi?}) T{_Smi?} for v230 is T{_Smi}
reaching type to v391 <- StaticCall:50( _parseBlock@0150898<0> v228, v230, v232, v234, result_type = T{_Smi?}) T{_Smi?} for v232 is T{int}
reaching type to v391 <- StaticCall:50( _parseBlock@0150898<0> v228, v230, v232, v234, result_type = T{_Smi?}) T{_Smi?} for v234 is T{int}
reaching type to Branch if StrictCompare:52(===, v391, v219, with number check) goto (58, 59) for v391 is T{_Smi?}
reaching type to Branch if StrictCompare:52(===, v391, v219, with number check) goto (58, 59) for v219 is T{Null?}
reaching type to v451 <- Redefinition(v391 ^ T{_Smi}) for v391 is T{_Smi?}
reaching type to CheckNull:66(v451, NoSuchMethodError) for v451 is T{_Smi}
reaching type to v393 <- BinaryInt64Op(* [tr], v236, v451 T{_Smi?}) T{int} for v236 is T{int}
reaching type to v393 <- BinaryInt64Op(* [tr], v236, v451) T{int} for v451 is T{_Smi}
reaching type to Return:70(v393) for v393 is T{int}
reaching type to v395 <- StaticCall:58( _throwFormatException@0150898<0> v240, v228, v232, v230, v219, result_type = T{int?}) for v240 is T{*?}
reaching type to v395 <- StaticCall:58( _throwFormatException@0150898<0> v240, v228, v232, v230, v219, result_type = T{int?}) for v228 is T{_StringBase}
reaching type to v395 <- StaticCall:58( _throwFormatException@0150898<0> v240, v228, v232, v230, v219, result_type = T{int?}) for v232 is T{int}
reaching type to v395 <- StaticCall:58( _throwFormatException@0150898<0> v240, v228, v232, v230, v219, result_type = T{int?}) for v230 is T{_Smi}
reaching type to v395 <- StaticCall:58( _throwFormatException@0150898<0> v240, v228, v232, v230, v219, result_type = T{int?}) for v219 is T{Null?}
reaching type to Return:62(v395) for v395 is T{int?}
reaching type to v252 <- phi(v242, v251) alive T{*?} for v242 is T{_Smi}
recomputing type of v350: T{}
  phi 350 input 0: v277 has reaching type T{_Smi}
  phi 350 input 1: v251 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v356: T{*?}
recomputing type of v368: T{*?}
recomputing type of v373: T{*?}
recomputing type of v304: T{}
  phi 304 input 0: v298 has reaching type T{num}
  phi 304 input 1: v429 has reaching type T{int}
  ... new type T{num}
recomputing type of v308: T{_Smi?}
recomputing type of v445: T{int}
  ... new type T{num}
recomputing type of v300: T{}
  phi 300 input 0: v269 has reaching type T{}
  phi 300 input 1: v445 has reaching type T{int}
  ... new type T{int}
recomputing type of v308: T{_Smi?}
recomputing type of v377: T{int?}
recomputing type of v334: T{num}
recomputing type of v360: T{num}
recomputing type of v302: T{}
  phi 302 input 0: v271 has reaching type T{}
  phi 302 input 1: v332 has reaching type T{int}
  ... new type T{int}
recomputing type of v439: T{int}
  ... new type T{int}
recomputing type of v314: T{bool}
recomputing type of v312: T{bool}
recomputing type of v338: T{bool}
recomputing type of v310: T{bool}
recomputing type of v370: T{bool}
recomputing type of v364: T{num}
recomputing type of v358: T{bool}
recomputing type of v328: T{num}
recomputing type of v300: T{int}
  phi 300 input 0: v269 has reaching type T{}
  phi 300 input 1: v445 has reaching type T{int}
recomputing type of v290: T{}
  phi 290 input 0: v379 has reaching type T{int?}
  phi 290 input 1: v403 has reaching type T{int}
  ... new type T{int?}
recomputing type of v441: T{int}
  ... new type T{int}
recomputing type of v338: T{bool}
recomputing type of v310: T{bool}
recomputing type of v271: T{}
  phi 271 input 0: v385 has reaching type T{int}
  phi 271 input 1: v251 has reaching type T{_Smi}
  ... new type T{int}
recomputing type of v302: T{int}
  phi 302 input 0: v271 has reaching type T{int}
  phi 302 input 1: v332 has reaching type T{int}
recomputing type of v269: T{}
  phi 269 input 0: v381 has reaching type T{int}
  phi 269 input 1: v232 has reaching type T{int}
  ... new type T{int}
recomputing type of v298: T{num}
recomputing type of v300: T{int}
  phi 300 input 0: v269 has reaching type T{int}
  phi 300 input 1: v445 has reaching type T{int}
recomputing type of v263: T{}
  phi 263 input 0: v259 has reaching type T{int}
  phi 263 input 1: v389 has reaching type T{num}
  ... new type T{num}
recomputing type of v265: T{bool}
recomputing type of v389: T{num}
recomputing type of v431: T{int}
  ... new type T{num}
recomputing type of v381: T{int}
recomputing type of v267: T{bool}
recomputing type of v252: T{}
  phi 252 input 0: v242 has reaching type T{_Smi}
  phi 252 input 1: v251 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v254: T{num}
reaching type to v224 <- StaticCall:12( get:length<0> v222, recognized_kind = StringBaseLength, result_type = T{_Smi}) T{_Smi} for v222 is T{_StringBase}
reaching type to v227 <- phi(v226, v237) alive T{int?} for v226 is T{_Smi}
reaching type to CheckNull:16(v227, NoSuchMethodError) for v227 is T{int?}
reaching type to v229 <- RelationalOp(<, v239 T{int}, v224) T{bool} for v239 is T{int}
reaching type to v229 <- RelationalOp(<, v239 T{int}, v224) T{bool} for v224 is T{_Smi}
reaching type to AssertBoolean:18(v229) for v229 is T{bool}
reaching type to Branch if StrictCompare:20(===, v229, v231) goto (54, 55) for v229 is T{bool}
reaching type to Branch if StrictCompare:20(===, v229, v231) goto (54, 55) for v231 is T{bool}
reaching type to Return:62(v239 T{int}) for v239 is T{int}
reaching type to v232 <- InstanceCall:30( codeUnitAt<0>, v222, v239 IC[0: ], result_type = T{_Smi} using unchecked entrypoint) for v222 is T{_StringBase}
reaching type to v232 <- InstanceCall:30( codeUnitAt<0>, v222, v239 T{int} IC[0: ], result_type = T{_Smi} using unchecked entrypoint) for v239 is T{int}
reaching type to v234 <- InstanceCall:32( _isWhitespace@0150898<0>, v222, v232 IC[0: ], result_type = T{bool} using unchecked entrypoint) for v222 is T{_StringBase}
reaching type to v234 <- InstanceCall:32( _isWhitespace@0150898<0>, v222, v232 IC[0: ], result_type = T{bool} using unchecked entrypoint) for v232 is T{_Smi}
reaching type to AssertBoolean:34(v234) for v234 is T{bool}
reaching type to Branch if StrictCompare:36(!==, v234, v231) goto (56, 58) for v234 is T{bool}
reaching type to Branch if StrictCompare:36(!==, v234, v231) goto (56, 58) for v231 is T{bool}
reaching type to CheckNull:28(v239 T{int}, NoSuchMethodError) for v239 is T{int}
reaching type to v237 <- BinaryInt64Op(+ [tr], v239 T{int}, v236) T{int} for v239 is T{int}
reaching type to v237 <- BinaryInt64Op(+ [tr], v239 T{int}, v236) T{int} for v236 is T{_Smi}
reaching type to v227 <- phi(v226, v237) alive T{int?} for v237 is T{int}
recomputing type of v227: T{}
  phi 227 input 0: v226 has reaching type T{_Smi}
  phi 227 input 1: v237 has reaching type T{int}
  ... new type T{int}
recomputing type of v239: T{int}
  ... new type T{int}
recomputing type of v237: T{int}
recomputing type of v229: T{bool}
recomputing type of v232: T{_Smi}
reaching type to v224 <- LoadField(v222 . String.length {final}) for v222 is T{_StringBase}
reaching type to Return:10(v224) for v224 is T{_Smi}
reaching type to v231 <- StaticCall:12( get:length<0> v229, recognized_kind = StringBaseLength, result_type = T{_Smi}) T{_Smi} for v229 is T{_StringBase}
reaching type to v234 <- BinaryInt64Op(- [tr], v231, v233) T{int} for v231 is T{_Smi}
reaching type to v234 <- BinaryInt64Op(- [tr], v231, v233) T{int} for v233 is T{_Smi}
reaching type to v236 <- phi(v234, v246) alive T{int?} for v234 is T{int}
reaching type to CheckNull:16(v236, NoSuchMethodError) for v236 is T{int?}
reaching type to v239 <- RelationalOp(>=, v248 T{int}, v238) T{bool} for v248 is T{int}
reaching type to v239 <- RelationalOp(>=, v248 T{int}, v238) T{bool} for v238 is T{_Smi}
reaching type to AssertBoolean:18(v239) for v239 is T{bool}
reaching type to Branch if StrictCompare:20(===, v239, v241) goto (56, 57) for v239 is T{bool}
reaching type to Branch if StrictCompare:20(===, v239, v241) goto (56, 57) for v241 is T{bool}
reaching type to Return:62(v248 T{int}) for v248 is T{int}
reaching type to v242 <- InstanceCall:30( codeUnitAt<0>, v229, v248 IC[0: ], result_type = T{_Smi} using unchecked entrypoint) for v229 is T{_StringBase}
reaching type to v242 <- InstanceCall:30( codeUnitAt<0>, v229, v248 T{int} IC[0: ], result_type = T{_Smi} using unchecked entrypoint) for v248 is T{int}
reaching type to v244 <- InstanceCall:32( _isWhitespace@0150898<0>, v229, v242 IC[0: ], result_type = T{bool} using unchecked entrypoint) for v229 is T{_StringBase}
reaching type to v244 <- InstanceCall:32( _isWhitespace@0150898<0>, v229, v242 IC[0: ], result_type = T{bool} using unchecked entrypoint) for v242 is T{_Smi}
reaching type to AssertBoolean:34(v244) for v244 is T{bool}
reaching type to Branch if StrictCompare:36(!==, v244, v241) goto (58, 60) for v244 is T{bool}
reaching type to Branch if StrictCompare:36(!==, v244, v241) goto (58, 60) for v241 is T{bool}
reaching type to CheckNull:28(v248 T{int}, NoSuchMethodError) for v248 is T{int}
reaching type to v246 <- BinaryInt64Op(- [tr], v248 T{int}, v233) T{int} for v248 is T{int}
reaching type to v246 <- BinaryInt64Op(- [tr], v248 T{int}, v233) T{int} for v233 is T{_Smi}
reaching type to v236 <- phi(v234, v246) alive T{int?} for v246 is T{int}
recomputing type of v236: T{}
  phi 236 input 0: v234 has reaching type T{int}
  phi 236 input 1: v246 has reaching type T{int}
  ... new type T{int}
recomputing type of v248: T{int}
  ... new type T{int}
recomputing type of v246: T{int}
recomputing type of v239: T{bool}
recomputing type of v242: T{_Smi}
reaching type to v5 <- StaticCall:12( _lastNonWhitespace@0150898<0> v2, using unchecked entrypoint, result_type = T{int}) T{int} for v2 is T{_StringBase}
reaching type to v8 <- BinaryInt64Op(+ [tr], v5, v7) T{int} for v5 is T{int}
reaching type to v8 <- BinaryInt64Op(+ [tr], v5, v7) T{int} for v7 is T{_Smi}
reaching type to v11 <- EqualityCompare(v8 == v10) T{bool} for v8 is T{int}
reaching type to v11 <- EqualityCompare(v8 == v10) T{bool} for v10 is T{_Smi}
reaching type to AssertBoolean:18(v11) for v11 is T{bool}
reaching type to Branch if StrictCompare:20(===, v11, v13) goto (3, 4) for v11 is T{bool}
reaching type to Branch if StrictCompare:20(===, v11, v13) goto (3, 4) for v13 is T{bool}
reaching type to v14 <- StaticCall:36( _firstNonWhitespace@0150898<0> v2, using unchecked entrypoint, result_type = T{int}) T{int} for v2 is T{_StringBase}
reaching type to v216 <- LoadClassId(v2) for v2 is T{_StringBase}
reaching type to Branch if StrictCompare:38(===, v216, v128) goto (43, 48) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v128) goto (43, 48) for v128 is T{_Smi}
reaching type to v226 <- Redefinition(v2 ^ T{_OneByteString}) for v2 is T{_StringBase}
reaching type to v176 <- Redefinition(v226) for v226 is T{_OneByteString}
reaching type to v177 <- LoadField(v176 . String.length {final}) for v176 is T{_OneByteString}
reaching type to v179 <- GenericCheckBound:38(v177, v14) for v177 is T{_Smi}
reaching type to v179 <- GenericCheckBound:38(v177, v14) for v14 is T{int}
reaching type to v181 <- LoadIndexed(v176, v179) for v176 is T{_OneByteString}
reaching type to v181 <- LoadIndexed(v176, v179) for v179 is T{int}
reaching type to v183 <- BoxInt64(v181) for v181 is T{_Smi}
reaching type to v217 <- phi(v183, v192, v203, v214) alive T{} for v183 is T{int}
reaching type to Branch if StrictCompare:38(===, v216, v129) goto (44, 49) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v129) goto (44, 49) for v129 is T{_Smi}
reaching type to v228 <- Redefinition(v2 ^ T{_TwoByteString}) for v2 is T{_StringBase}
reaching type to v185 <- Redefinition(v228) for v228 is T{_TwoByteString}
reaching type to v186 <- LoadField(v185 . String.length {final}) for v185 is T{_TwoByteString}
reaching type to v188 <- GenericCheckBound:38(v186, v14) for v186 is T{_Smi}
reaching type to v188 <- GenericCheckBound:38(v186, v14) for v14 is T{int}
reaching type to v190 <- LoadIndexed(v185, v188) for v185 is T{_TwoByteString}
reaching type to v190 <- LoadIndexed(v185, v188) for v188 is T{int}
reaching type to v192 <- BoxInt64(v190) for v190 is T{_Smi}
reaching type to v217 <- phi(v183, v192, v203, v214) alive T{} for v192 is T{int}
reaching type to Branch if StrictCompare:38(===, v216, v130) goto (45, 50) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v130) goto (45, 50) for v130 is T{_Smi}
reaching type to v230 <- Redefinition(v2 ^ T{_ExternalOneByteString}) for v2 is T{_StringBase}
reaching type to v194 <- Redefinition(v230) for v230 is T{_ExternalOneByteString}
reaching type to v195 <- LoadField(v194 . String.length {final}) for v194 is T{_ExternalOneByteString}
reaching type to v197 <- GenericCheckBound:38(v195, v14) for v195 is T{_Smi}
reaching type to v197 <- GenericCheckBound:38(v195, v14) for v14 is T{int}
reaching type to v199 <- LoadUntagged(v194, 16) for v194 is T{_ExternalOneByteString}
reaching type to v201 <- LoadIndexed(v199, v197) for v199 is T{*?}
reaching type to v201 <- LoadIndexed(v199, v197) for v197 is T{int}
reaching type to v203 <- BoxInt64(v201) for v201 is T{_Smi}
reaching type to v217 <- phi(v183, v192, v203, v214) alive T{} for v203 is T{int}
reaching type to v205 <- Redefinition(v2) for v2 is T{_StringBase}
reaching type to v206 <- LoadField(v205 . String.length {final}) for v205 is T{_StringBase}
reaching type to v208 <- GenericCheckBound:38(v206, v14) for v206 is T{_Smi}
reaching type to v208 <- GenericCheckBound:38(v206, v14) for v14 is T{int}
reaching type to v210 <- LoadUntagged(v205, 16) for v205 is T{_StringBase}
reaching type to v212 <- LoadIndexed(v210, v208) for v210 is T{*?}
reaching type to v212 <- LoadIndexed(v210, v208) for v208 is T{int}
reaching type to v214 <- BoxInt64(v212) for v212 is T{_Smi}
reaching type to v217 <- phi(v183, v192, v203, v214) alive T{} for v214 is T{int}
reaching type to v19 <- EqualityCompare(v217 T{_Smi} == v18) T{bool} for v217 is T{_Smi}
reaching type to v19 <- EqualityCompare(v217 T{_Smi} == v18) T{bool} for v18 is T{_Smi}
reaching type to AssertBoolean:44(v19) for v19 is T{bool}
reaching type to Branch if StrictCompare:46(===, v19, v13) goto (7, 5) for v19 is T{bool}
reaching type to Branch if StrictCompare:46(===, v19, v13) goto (7, 5) for v13 is T{bool}
reaching type to v22 <- EqualityCompare(v217 T{_Smi} == v21) T{bool} for v217 is T{_Smi}
reaching type to v22 <- EqualityCompare(v217 T{_Smi} == v21) T{bool} for v21 is T{_Smi}
reaching type to AssertBoolean:52(v22) for v22 is T{bool}
reaching type to Branch if StrictCompare:54(===, v22, v13) goto (8, 11) for v22 is T{bool}
reaching type to Branch if StrictCompare:54(===, v22, v13) goto (8, 11) for v13 is T{bool}
reaching type to v24 <- phi(v14, v69) alive T{int} for v14 is T{int}
reaching type to v26 <- phi(v217, v174 T{_Smi}) alive T{_Smi} for v217 is T{}
reaching type to v28 <- phi(v7, v67) alive T{int} for v7 is T{_Smi}
reaching type to Branch if StrictCompare:102(===, v3, v0, with number check) goto (13, 23) for v3 is T{_Smi?}
reaching type to Branch if StrictCompare:102(===, v3, v0, with number check) goto (13, 23) for v0 is T{Null?}
reaching type to v81 <- Redefinition(v3 ^ T{_Smi}) T{_Smi} for v3 is T{_Smi?}
reaching type to v30 <- phi(v42, v81) alive T{_Smi} for v81 is T{_Smi}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v30 is T{_Smi}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v24 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v8 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v28 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v34 is T{bool}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to Return:204(v35) for v35 is T{int?}
reaching type to v38 <- StrictCompare(===, v26, v37) T{bool} for v26 is T{_Smi}
reaching type to v38 <- StrictCompare(===, v26, v37) T{bool} for v37 is T{_Smi}
reaching type to AssertBoolean:112(v38) for v38 is T{bool}
reaching type to Branch if StrictCompare:114(===, v38, v13) goto (14, 21) for v38 is T{bool}
reaching type to Branch if StrictCompare:114(===, v38, v13) goto (14, 21) for v13 is T{bool}
reaching type to v30 <- phi(v42, v81) alive T{_Smi} for v42 is T{_Smi}
reaching type to v83 <- CheckNull:120(v24, NoSuchMethodError) T{int} for v24 is T{int}
reaching type to v43 <- BinaryInt64Op(+ [tr], v83 T{int}, v7) T{int} for v83 is T{int}
reaching type to v43 <- BinaryInt64Op(+ [tr], v83 T{int}, v7) T{int} for v7 is T{_Smi}
reaching type to v45 <- EqualityCompare(v43 == v8) T{bool} for v43 is T{int}
reaching type to v45 <- EqualityCompare(v43 == v8) T{bool} for v8 is T{int}
reaching type to AssertBoolean:124(v45) for v45 is T{bool}
reaching type to Branch if StrictCompare:126(===, v45, v13) goto (15, 16) for v45 is T{bool}
reaching type to Branch if StrictCompare:126(===, v45, v13) goto (15, 16) for v13 is T{bool}
reaching type to v127 <- LoadClassId(v2) for v2 is T{_StringBase}
reaching type to Branch if StrictCompare:138(===, v127, v128) goto (25, 30) for v127 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v127, v128) goto (25, 30) for v128 is T{_Smi}
reaching type to v232 <- Redefinition(v2 ^ T{_OneByteString}) for v2 is T{_StringBase}
reaching type to v87 <- Redefinition(v232) for v232 is T{_OneByteString}
reaching type to v88 <- LoadField(v87 . String.length {final}) for v87 is T{_OneByteString}
reaching type to v90 <- GenericCheckBound:138(v88, v43) for v88 is T{_Smi}
reaching type to v90 <- GenericCheckBound:138(v88, v43) for v43 is T{int}
reaching type to v92 <- LoadIndexed(v87, v90) for v87 is T{_OneByteString}
reaching type to v92 <- LoadIndexed(v87, v90) for v90 is T{int}
reaching type to v94 <- BoxInt64(v92) for v92 is T{_Smi}
reaching type to v131 <- phi(v94, v103, v114, v125) alive T{} for v94 is T{int}
reaching type to Branch if StrictCompare:138(===, v127, v129) goto (26, 31) for v127 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v127, v129) goto (26, 31) for v129 is T{_Smi}
reaching type to v234 <- Redefinition(v2 ^ T{_TwoByteString}) for v2 is T{_StringBase}
reaching type to v96 <- Redefinition(v234) for v234 is T{_TwoByteString}
reaching type to v97 <- LoadField(v96 . String.length {final}) for v96 is T{_TwoByteString}
reaching type to v99 <- GenericCheckBound:138(v97, v43) for v97 is T{_Smi}
reaching type to v99 <- GenericCheckBound:138(v97, v43) for v43 is T{int}
reaching type to v101 <- LoadIndexed(v96, v99) for v96 is T{_TwoByteString}
reaching type to v101 <- LoadIndexed(v96, v99) for v99 is T{int}
reaching type to v103 <- BoxInt64(v101) for v101 is T{_Smi}
reaching type to v131 <- phi(v94, v103, v114, v125) alive T{} for v103 is T{int}
reaching type to Branch if StrictCompare:138(===, v127, v130) goto (27, 32) for v127 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v127, v130) goto (27, 32) for v130 is T{_Smi}
reaching type to v236 <- Redefinition(v2 ^ T{_ExternalOneByteString}) for v2 is T{_StringBase}
reaching type to v105 <- Redefinition(v236) for v236 is T{_ExternalOneByteString}
reaching type to v106 <- LoadField(v105 . String.length {final}) for v105 is T{_ExternalOneByteString}
reaching type to v108 <- GenericCheckBound:138(v106, v43) for v106 is T{_Smi}
reaching type to v108 <- GenericCheckBound:138(v106, v43) for v43 is T{int}
reaching type to v110 <- LoadUntagged(v105, 16) for v105 is T{_ExternalOneByteString}
reaching type to v112 <- LoadIndexed(v110, v108) for v110 is T{*?}
reaching type to v112 <- LoadIndexed(v110, v108) for v108 is T{int}
reaching type to v114 <- BoxInt64(v112) for v112 is T{_Smi}
reaching type to v131 <- phi(v94, v103, v114, v125) alive T{} for v114 is T{int}
reaching type to v116 <- Redefinition(v2) for v2 is T{_StringBase}
reaching type to v117 <- LoadField(v116 . String.length {final}) for v116 is T{_StringBase}
reaching type to v119 <- GenericCheckBound:138(v117, v43) for v117 is T{_Smi}
reaching type to v119 <- GenericCheckBound:138(v117, v43) for v43 is T{int}
reaching type to v121 <- LoadUntagged(v116, 16) for v116 is T{_StringBase}
reaching type to v123 <- LoadIndexed(v121, v119) for v121 is T{*?}
reaching type to v123 <- LoadIndexed(v121, v119) for v119 is T{int}
reaching type to v125 <- BoxInt64(v123) for v123 is T{_Smi}
reaching type to v131 <- phi(v94, v103, v114, v125) alive T{} for v125 is T{int}
reaching type to v50 <- BinaryInt64Op(| [tr], v131 T{_Smi}, v49) T{int} for v131 is T{_Smi}
reaching type to v50 <- BinaryInt64Op(| [tr], v131 T{_Smi}, v49) T{int} for v49 is T{_Smi}
reaching type to v53 <- EqualityCompare(v50 == v52) T{bool} for v50 is T{int}
reaching type to v53 <- EqualityCompare(v50 == v52) T{bool} for v52 is T{_Smi}
reaching type to AssertBoolean:144(v53) for v53 is T{bool}
reaching type to Branch if StrictCompare:146(===, v53, v13) goto (17, 20) for v53 is T{bool}
reaching type to Branch if StrictCompare:146(===, v53, v13) goto (17, 20) for v13 is T{bool}
reaching type to v55 <- BinaryInt64Op(+ [tr], v43, v7) T{int} for v43 is T{int}
reaching type to v55 <- BinaryInt64Op(+ [tr], v43, v7) T{int} for v7 is T{_Smi}
reaching type to v57 <- EqualityCompare(v55 == v8) T{bool} for v55 is T{int}
reaching type to v57 <- EqualityCompare(v55 == v8) T{bool} for v8 is T{int}
reaching type to AssertBoolean:156(v57) for v57 is T{bool}
reaching type to Branch if StrictCompare:158(===, v57, v13) goto (18, 19) for v57 is T{bool}
reaching type to Branch if StrictCompare:158(===, v57, v13) goto (18, 19) for v13 is T{bool}
reaching type to v85 <- CheckNull:172(v28, NoSuchMethodError) T{int} for v28 is T{int}
reaching type to v60 <- RelationalOp(>, v85 T{int}, v10) T{bool} for v85 is T{int}
reaching type to v60 <- RelationalOp(>, v85 T{int}, v10) T{bool} for v10 is T{_Smi}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v59 is T{_Smi}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v55 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v8 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v85 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v60 is T{bool}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to Return:178(v62) for v62 is T{int?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) T{int?} for v55 is T{int}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:168(v64) for v64 is T{int?}
reaching type to Return:134(v10) for v10 is T{_Smi}
reaching type to v67 <- BinaryInt64Op(- [tr], v66, v217 T{_Smi}) T{int} for v66 is T{_Smi}
reaching type to v67 <- BinaryInt64Op(- [tr], v66, v217 T{_Smi}) T{int} for v217 is T{_Smi}
reaching type to v69 <- BinaryInt64Op(+ [tr], v14, v7) T{int} for v14 is T{int}
reaching type to v69 <- BinaryInt64Op(+ [tr], v14, v7) T{int} for v7 is T{_Smi}
reaching type to v71 <- EqualityCompare(v69 == v8) T{bool} for v69 is T{int}
reaching type to v71 <- EqualityCompare(v69 == v8) T{bool} for v8 is T{int}
reaching type to AssertBoolean:76(v71) for v71 is T{bool}
reaching type to Branch if StrictCompare:78(===, v71, v13) goto (9, 10) for v71 is T{bool}
reaching type to Branch if StrictCompare:78(===, v71, v13) goto (9, 10) for v13 is T{bool}
reaching type to v173 <- LoadClassId(v2) for v2 is T{_StringBase}
reaching type to Branch if StrictCompare:92(===, v173, v128) goto (34, 39) for v173 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v173, v128) goto (34, 39) for v128 is T{_Smi}
reaching type to v238 <- Redefinition(v2 ^ T{_OneByteString}) for v2 is T{_StringBase}
reaching type to v133 <- Redefinition(v238) for v238 is T{_OneByteString}
reaching type to v134 <- LoadField(v133 . String.length {final}) for v133 is T{_OneByteString}
reaching type to v136 <- GenericCheckBound:92(v134, v69) for v134 is T{_Smi}
reaching type to v136 <- GenericCheckBound:92(v134, v69) for v69 is T{int}
reaching type to v138 <- LoadIndexed(v133, v136) for v133 is T{_OneByteString}
reaching type to v138 <- LoadIndexed(v133, v136) for v136 is T{int}
reaching type to v140 <- BoxInt64(v138) for v138 is T{_Smi}
reaching type to v174 <- phi(v140, v149, v160, v171) alive T{} for v140 is T{int}
reaching type to Branch if StrictCompare:92(===, v173, v129) goto (35, 40) for v173 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v173, v129) goto (35, 40) for v129 is T{_Smi}
reaching type to v240 <- Redefinition(v2 ^ T{_TwoByteString}) for v2 is T{_StringBase}
reaching type to v142 <- Redefinition(v240) for v240 is T{_TwoByteString}
reaching type to v143 <- LoadField(v142 . String.length {final}) for v142 is T{_TwoByteString}
reaching type to v145 <- GenericCheckBound:92(v143, v69) for v143 is T{_Smi}
reaching type to v145 <- GenericCheckBound:92(v143, v69) for v69 is T{int}
reaching type to v147 <- LoadIndexed(v142, v145) for v142 is T{_TwoByteString}
reaching type to v147 <- LoadIndexed(v142, v145) for v145 is T{int}
reaching type to v149 <- BoxInt64(v147) for v147 is T{_Smi}
reaching type to v174 <- phi(v140, v149, v160, v171) alive T{} for v149 is T{int}
reaching type to Branch if StrictCompare:92(===, v173, v130) goto (36, 41) for v173 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v173, v130) goto (36, 41) for v130 is T{_Smi}
reaching type to v242 <- Redefinition(v2 ^ T{_ExternalOneByteString}) for v2 is T{_StringBase}
reaching type to v151 <- Redefinition(v242) for v242 is T{_ExternalOneByteString}
reaching type to v152 <- LoadField(v151 . String.length {final}) for v151 is T{_ExternalOneByteString}
reaching type to v154 <- GenericCheckBound:92(v152, v69) for v152 is T{_Smi}
reaching type to v154 <- GenericCheckBound:92(v152, v69) for v69 is T{int}
reaching type to v156 <- LoadUntagged(v151, 16) for v151 is T{_ExternalOneByteString}
reaching type to v158 <- LoadIndexed(v156, v154) for v156 is T{*?}
reaching type to v158 <- LoadIndexed(v156, v154) for v154 is T{int}
reaching type to v160 <- BoxInt64(v158) for v158 is T{_Smi}
reaching type to v174 <- phi(v140, v149, v160, v171) alive T{} for v160 is T{int}
reaching type to v162 <- Redefinition(v2) for v2 is T{_StringBase}
reaching type to v163 <- LoadField(v162 . String.length {final}) for v162 is T{_StringBase}
reaching type to v165 <- GenericCheckBound:92(v163, v69) for v163 is T{_Smi}
reaching type to v165 <- GenericCheckBound:92(v163, v69) for v69 is T{int}
reaching type to v167 <- LoadUntagged(v162, 16) for v162 is T{_StringBase}
reaching type to v169 <- LoadIndexed(v167, v165) for v167 is T{*?}
reaching type to v169 <- LoadIndexed(v167, v165) for v165 is T{int}
reaching type to v171 <- BoxInt64(v169) for v169 is T{_Smi}
reaching type to v174 <- phi(v140, v149, v160, v171) alive T{} for v171 is T{int}
reaching type to v24 <- phi(v14, v69) alive T{int} for v69 is T{int}
reaching type to v26 <- phi(v217, v174) alive T{_Smi} for v174 is T{}
reaching type to v28 <- phi(v7, v67) alive T{int} for v67 is T{int}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) T{int?} for v8 is T{int}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) T{int?} for v3 is T{_Smi?}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:88(v75) for v75 is T{int?}
reaching type to v224 <- LoadField(v2 T{_StringBase} . String.length {final}) T{_Smi} for v2 is T{_StringBase}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v224 is T{_Smi}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v3 is T{_Smi?}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:32(v79) for v79 is T{int?}
recomputing type of v174: T{}
  phi 174 input 0: v140 has reaching type T{int}
  phi 174 input 1: v149 has reaching type T{int}
  phi 174 input 2: v160 has reaching type T{int}
  phi 174 input 3: v171 has reaching type T{int}
  ... new type T{int}
recomputing type of v26: T{}
  phi 26 input 0: v217 has reaching type T{}
  phi 26 input 1: v174 has reaching type T{int}
  ... new type T{int}
recomputing type of v38: T{bool}
recomputing type of v131: T{}
  phi 131 input 0: v94 has reaching type T{int}
  phi 131 input 1: v103 has reaching type T{int}
  phi 131 input 2: v114 has reaching type T{int}
  phi 131 input 3: v125 has reaching type T{int}
  ... new type T{int}
recomputing type of v50: T{int}
recomputing type of v30: T{}
  phi 30 input 0: v42 has reaching type T{_Smi}
  phi 30 input 1: v81 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v35: T{int?}
recomputing type of v28: T{}
  phi 28 input 0: v7 has reaching type T{_Smi}
  phi 28 input 1: v67 has reaching type T{int}
  ... new type T{int}
recomputing type of v35: T{int?}
recomputing type of v85: T{int}
recomputing type of v26: T{int}
  phi 26 input 0: v217 has reaching type T{}
  phi 26 input 1: v174 has reaching type T{int}
recomputing type of v24: T{}
  phi 24 input 0: v14 has reaching type T{int}
  phi 24 input 1: v69 has reaching type T{int}
  ... new type T{int}
recomputing type of v35: T{int?}
recomputing type of v83: T{int}
  ... new type T{int}
recomputing type of v43: T{int}
recomputing type of v217: T{}
  phi 217 input 0: v183 has reaching type T{int}
  phi 217 input 1: v192 has reaching type T{int}
  phi 217 input 2: v203 has reaching type T{int}
  phi 217 input 3: v214 has reaching type T{int}
  ... new type T{int}
recomputing type of v26: T{int}
  phi 26 input 0: v217 has reaching type T{int}
  phi 26 input 1: v174 has reaching type T{int}
recomputing type of v19: T{bool}
recomputing type of v22: T{bool}
recomputing type of v67: T{int}
reaching type to v5 <- StaticCall:12( _lastNonWhitespace@0150898<0> v2, using unchecked entrypoint, result_type = T{int}) T{int} for v2 is T{_StringBase}
reaching type to v8 <- BinaryInt64Op(+ [tr], v5, v7) T{int} for v5 is T{int}
reaching type to v8 <- BinaryInt64Op(+ [tr], v5, v7) T{int} for v7 is T{_Smi}
reaching type to v11 <- EqualityCompare(v8 == v10) T{bool} for v8 is T{int}
reaching type to v11 <- EqualityCompare(v8 == v10) T{bool} for v10 is T{_Smi}
reaching type to AssertBoolean:18(v11) for v11 is T{bool}
reaching type to Branch if StrictCompare:20(===, v11, v13) goto (3, 4) for v11 is T{bool}
reaching type to Branch if StrictCompare:20(===, v11, v13) goto (3, 4) for v13 is T{bool}
reaching type to v14 <- StaticCall:36( _firstNonWhitespace@0150898<0> v2, using unchecked entrypoint, result_type = T{int}) T{int} for v2 is T{_StringBase}
reaching type to v216 <- LoadClassId(v2) T{_Smi} for v2 is T{_StringBase}
reaching type to Branch if StrictCompare:38(===, v216, v128) goto (43, 48) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v128) goto (43, 48) for v128 is T{_Smi}
reaching type to v226 <- Redefinition(v2 ^ T{_OneByteString}) T{_OneByteString} for v2 is T{_StringBase}
reaching type to v176 <- Redefinition(v226) T{_OneByteString} for v226 is T{_OneByteString}
reaching type to v177 <- LoadField(v176 . String.length {final}) T{_Smi} for v176 is T{_OneByteString}
reaching type to v179 <- GenericCheckBound:38(v177, v14) T{int} for v177 is T{_Smi}
reaching type to v179 <- GenericCheckBound:38(v177, v14) T{int} for v14 is T{int}
reaching type to v181 <- LoadIndexed(v176, v179) T{_Smi} for v176 is T{_OneByteString}
reaching type to v181 <- LoadIndexed(v176, v179) T{_Smi} for v179 is T{int}
reaching type to v183 <- BoxInt64(v181) T{int} for v181 is T{_Smi}
reaching type to v217 <- phi(v183, v192, v203, v214) alive T{int} for v183 is T{int}
reaching type to Branch if StrictCompare:38(===, v216, v129) goto (44, 49) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v129) goto (44, 49) for v129 is T{_Smi}
reaching type to v228 <- Redefinition(v2 ^ T{_TwoByteString}) T{_TwoByteString} for v2 is T{_StringBase}
reaching type to v185 <- Redefinition(v228) T{_TwoByteString} for v228 is T{_TwoByteString}
reaching type to v186 <- LoadField(v185 . String.length {final}) T{_Smi} for v185 is T{_TwoByteString}
reaching type to v188 <- GenericCheckBound:38(v186, v14) T{int} for v186 is T{_Smi}
reaching type to v188 <- GenericCheckBound:38(v186, v14) T{int} for v14 is T{int}
reaching type to v190 <- LoadIndexed(v185, v188) T{_Smi} for v185 is T{_TwoByteString}
reaching type to v190 <- LoadIndexed(v185, v188) T{_Smi} for v188 is T{int}
reaching type to v192 <- BoxInt64(v190) T{int} for v190 is T{_Smi}
reaching type to v217 <- phi(v183, v192, v203, v214) alive T{int} for v192 is T{int}
reaching type to Branch if StrictCompare:38(===, v216, v130) goto (45, 50) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v130) goto (45, 50) for v130 is T{_Smi}
reaching type to v230 <- Redefinition(v2 ^ T{_ExternalOneByteString}) T{_ExternalOneByteString} for v2 is T{_StringBase}
reaching type to v194 <- Redefinition(v230) T{_ExternalOneByteString} for v230 is T{_ExternalOneByteString}
reaching type to v195 <- LoadField(v194 . String.length {final}) T{_Smi} for v194 is T{_ExternalOneByteString}
reaching type to v197 <- GenericCheckBound:38(v195, v14) T{int} for v195 is T{_Smi}
reaching type to v197 <- GenericCheckBound:38(v195, v14) T{int} for v14 is T{int}
reaching type to v199 <- LoadUntagged(v194, 16) T{*?} for v194 is T{_ExternalOneByteString}
reaching type to v201 <- LoadIndexed(v199, v197) T{_Smi} for v199 is T{*?}
reaching type to v201 <- LoadIndexed(v199, v197) T{_Smi} for v197 is T{int}
reaching type to v203 <- BoxInt64(v201) T{int} for v201 is T{_Smi}
reaching type to v217 <- phi(v183, v192, v203, v214) alive T{int} for v203 is T{int}
reaching type to v205 <- Redefinition(v2) T{_StringBase} for v2 is T{_StringBase}
reaching type to v206 <- LoadField(v205 . String.length {final}) T{_Smi} for v205 is T{_StringBase}
reaching type to v208 <- GenericCheckBound:38(v206, v14) T{int} for v206 is T{_Smi}
reaching type to v208 <- GenericCheckBound:38(v206, v14) T{int} for v14 is T{int}
reaching type to v210 <- LoadUntagged(v205, 16) T{*?} for v205 is T{_StringBase}
reaching type to v212 <- LoadIndexed(v210, v208) T{_Smi} for v210 is T{*?}
reaching type to v212 <- LoadIndexed(v210, v208) T{_Smi} for v208 is T{int}
reaching type to v214 <- BoxInt64(v212) T{int} for v212 is T{_Smi}
reaching type to v217 <- phi(v183, v192, v203, v214) alive T{int} for v214 is T{int}
reaching type to v19 <- EqualityCompare(v217 T{_Smi} == v18) T{bool} for v217 is T{_Smi}
reaching type to v19 <- EqualityCompare(v217 T{_Smi} == v18) T{bool} for v18 is T{_Smi}
reaching type to AssertBoolean:44(v19) for v19 is T{bool}
reaching type to Branch if StrictCompare:46(===, v19, v13) goto (7, 5) for v19 is T{bool}
reaching type to Branch if StrictCompare:46(===, v19, v13) goto (7, 5) for v13 is T{bool}
reaching type to v22 <- EqualityCompare(v217 T{_Smi} == v21) T{bool} for v217 is T{_Smi}
reaching type to v22 <- EqualityCompare(v217 T{_Smi} == v21) T{bool} for v21 is T{_Smi}
reaching type to AssertBoolean:52(v22) for v22 is T{bool}
reaching type to Branch if StrictCompare:54(===, v22, v13) goto (8, 11) for v22 is T{bool}
reaching type to Branch if StrictCompare:54(===, v22, v13) goto (8, 11) for v13 is T{bool}
reaching type to v24 <- phi(v14, v69) alive T{int} for v14 is T{int}
reaching type to v26 <- phi(v217, v174) alive T{int} for v217 is T{int}
reaching type to v28 <- phi(v7, v67) alive T{int} for v7 is T{_Smi}
reaching type to Branch if StrictCompare:102(===, v3, v0, with number check) goto (13, 23) for v3 is T{_Smi?}
reaching type to Branch if StrictCompare:102(===, v3, v0, with number check) goto (13, 23) for v0 is T{Null?}
reaching type to v81 <- Redefinition(v3 ^ T{_Smi}) T{_Smi} for v3 is T{_Smi?}
reaching type to v30 <- phi(v42, v81) alive T{_Smi} for v81 is T{_Smi}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v30 is T{_Smi}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v24 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v8 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v28 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v34 is T{bool}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to Return:204(v35) for v35 is T{int?}
reaching type to v38 <- StrictCompare(===, v26, v37) T{bool} for v26 is T{int}
reaching type to v38 <- StrictCompare(===, v26, v37) T{bool} for v37 is T{_Smi}
reaching type to AssertBoolean:112(v38) for v38 is T{bool}
reaching type to Branch if StrictCompare:114(===, v38, v13) goto (14, 21) for v38 is T{bool}
reaching type to Branch if StrictCompare:114(===, v38, v13) goto (14, 21) for v13 is T{bool}
reaching type to v30 <- phi(v42, v81) alive T{_Smi} for v42 is T{_Smi}
reaching type to v83 <- CheckNull:120(v24, NoSuchMethodError) T{int} for v24 is T{int}
reaching type to v43 <- BinaryInt64Op(+ [tr], v83 T{int}, v7) T{int} for v83 is T{int}
reaching type to v43 <- BinaryInt64Op(+ [tr], v83 T{int}, v7) T{int} for v7 is T{_Smi}
reaching type to v45 <- EqualityCompare(v43 == v8) T{bool} for v43 is T{int}
reaching type to v45 <- EqualityCompare(v43 == v8) T{bool} for v8 is T{int}
reaching type to AssertBoolean:124(v45) for v45 is T{bool}
reaching type to Branch if StrictCompare:126(===, v45, v13) goto (15, 16) for v45 is T{bool}
reaching type to Branch if StrictCompare:126(===, v45, v13) goto (15, 16) for v13 is T{bool}
reaching type to v127 <- LoadClassId(v2) T{_Smi} for v2 is T{_StringBase}
reaching type to Branch if StrictCompare:138(===, v127, v128) goto (25, 30) for v127 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v127, v128) goto (25, 30) for v128 is T{_Smi}
reaching type to v232 <- Redefinition(v2 ^ T{_OneByteString}) T{_OneByteString} for v2 is T{_StringBase}
reaching type to v87 <- Redefinition(v232) T{_OneByteString} for v232 is T{_OneByteString}
reaching type to v88 <- LoadField(v87 . String.length {final}) T{_Smi} for v87 is T{_OneByteString}
reaching type to v90 <- GenericCheckBound:138(v88, v43) T{int} for v88 is T{_Smi}
reaching type to v90 <- GenericCheckBound:138(v88, v43) T{int} for v43 is T{int}
reaching type to v92 <- LoadIndexed(v87, v90) T{_Smi} for v87 is T{_OneByteString}
reaching type to v92 <- LoadIndexed(v87, v90) T{_Smi} for v90 is T{int}
reaching type to v94 <- BoxInt64(v92) T{int} for v92 is T{_Smi}
reaching type to v131 <- phi(v94, v103, v114, v125) alive T{int} for v94 is T{int}
reaching type to Branch if StrictCompare:138(===, v127, v129) goto (26, 31) for v127 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v127, v129) goto (26, 31) for v129 is T{_Smi}
reaching type to v234 <- Redefinition(v2 ^ T{_TwoByteString}) T{_TwoByteString} for v2 is T{_StringBase}
reaching type to v96 <- Redefinition(v234) T{_TwoByteString} for v234 is T{_TwoByteString}
reaching type to v97 <- LoadField(v96 . String.length {final}) T{_Smi} for v96 is T{_TwoByteString}
reaching type to v99 <- GenericCheckBound:138(v97, v43) T{int} for v97 is T{_Smi}
reaching type to v99 <- GenericCheckBound:138(v97, v43) T{int} for v43 is T{int}
reaching type to v101 <- LoadIndexed(v96, v99) T{_Smi} for v96 is T{_TwoByteString}
reaching type to v101 <- LoadIndexed(v96, v99) T{_Smi} for v99 is T{int}
reaching type to v103 <- BoxInt64(v101) T{int} for v101 is T{_Smi}
reaching type to v131 <- phi(v94, v103, v114, v125) alive T{int} for v103 is T{int}
reaching type to Branch if StrictCompare:138(===, v127, v130) goto (27, 32) for v127 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v127, v130) goto (27, 32) for v130 is T{_Smi}
reaching type to v236 <- Redefinition(v2 ^ T{_ExternalOneByteString}) T{_ExternalOneByteString} for v2 is T{_StringBase}
reaching type to v105 <- Redefinition(v236) T{_ExternalOneByteString} for v236 is T{_ExternalOneByteString}
reaching type to v106 <- LoadField(v105 . String.length {final}) T{_Smi} for v105 is T{_ExternalOneByteString}
reaching type to v108 <- GenericCheckBound:138(v106, v43) T{int} for v106 is T{_Smi}
reaching type to v108 <- GenericCheckBound:138(v106, v43) T{int} for v43 is T{int}
reaching type to v110 <- LoadUntagged(v105, 16) T{*?} for v105 is T{_ExternalOneByteString}
reaching type to v112 <- LoadIndexed(v110, v108) T{_Smi} for v110 is T{*?}
reaching type to v112 <- LoadIndexed(v110, v108) T{_Smi} for v108 is T{int}
reaching type to v114 <- BoxInt64(v112) T{int} for v112 is T{_Smi}
reaching type to v131 <- phi(v94, v103, v114, v125) alive T{int} for v114 is T{int}
reaching type to v116 <- Redefinition(v2) T{_StringBase} for v2 is T{_StringBase}
reaching type to v117 <- LoadField(v116 . String.length {final}) T{_Smi} for v116 is T{_StringBase}
reaching type to v119 <- GenericCheckBound:138(v117, v43) T{int} for v117 is T{_Smi}
reaching type to v119 <- GenericCheckBound:138(v117, v43) T{int} for v43 is T{int}
reaching type to v121 <- LoadUntagged(v116, 16) T{*?} for v116 is T{_StringBase}
reaching type to v123 <- LoadIndexed(v121, v119) T{_Smi} for v121 is T{*?}
reaching type to v123 <- LoadIndexed(v121, v119) T{_Smi} for v119 is T{int}
reaching type to v125 <- BoxInt64(v123) T{int} for v123 is T{_Smi}
reaching type to v131 <- phi(v94, v103, v114, v125) alive T{int} for v125 is T{int}
reaching type to v50 <- BinaryInt64Op(| [tr], v131 T{_Smi}, v49) T{int} for v131 is T{_Smi}
reaching type to v50 <- BinaryInt64Op(| [tr], v131 T{_Smi}, v49) T{int} for v49 is T{_Smi}
reaching type to v53 <- EqualityCompare(v50 == v52) T{bool} for v50 is T{int}
reaching type to v53 <- EqualityCompare(v50 == v52) T{bool} for v52 is T{_Smi}
reaching type to AssertBoolean:144(v53) for v53 is T{bool}
reaching type to Branch if StrictCompare:146(===, v53, v13) goto (17, 20) for v53 is T{bool}
reaching type to Branch if StrictCompare:146(===, v53, v13) goto (17, 20) for v13 is T{bool}
reaching type to v55 <- BinaryInt64Op(+ [tr], v43, v7) T{int} for v43 is T{int}
reaching type to v55 <- BinaryInt64Op(+ [tr], v43, v7) T{int} for v7 is T{_Smi}
reaching type to v57 <- EqualityCompare(v55 == v8) T{bool} for v55 is T{int}
reaching type to v57 <- EqualityCompare(v55 == v8) T{bool} for v8 is T{int}
reaching type to AssertBoolean:156(v57) for v57 is T{bool}
reaching type to Branch if StrictCompare:158(===, v57, v13) goto (18, 19) for v57 is T{bool}
reaching type to Branch if StrictCompare:158(===, v57, v13) goto (18, 19) for v13 is T{bool}
reaching type to v85 <- CheckNull:172(v28, NoSuchMethodError) T{int} for v28 is T{int}
reaching type to v60 <- RelationalOp(>, v85 T{int}, v10) T{bool} for v85 is T{int}
reaching type to v60 <- RelationalOp(>, v85 T{int}, v10) T{bool} for v10 is T{_Smi}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v59 is T{_Smi}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v55 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v8 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v85 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v60 is T{bool}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to Return:178(v62) for v62 is T{int?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) T{int?} for v55 is T{int}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:168(v64) for v64 is T{int?}
reaching type to Return:134(v10) for v10 is T{_Smi}
reaching type to v67 <- BinaryInt64Op(- [tr], v66, v217 T{_Smi}) T{int} for v66 is T{_Smi}
reaching type to v67 <- BinaryInt64Op(- [tr], v66, v217 T{_Smi}) T{int} for v217 is T{_Smi}
reaching type to v69 <- BinaryInt64Op(+ [tr], v14, v7) T{int} for v14 is T{int}
reaching type to v69 <- BinaryInt64Op(+ [tr], v14, v7) T{int} for v7 is T{_Smi}
reaching type to v71 <- EqualityCompare(v69 == v8) T{bool} for v69 is T{int}
reaching type to v71 <- EqualityCompare(v69 == v8) T{bool} for v8 is T{int}
reaching type to AssertBoolean:76(v71) for v71 is T{bool}
reaching type to Branch if StrictCompare:78(===, v71, v13) goto (9, 10) for v71 is T{bool}
reaching type to Branch if StrictCompare:78(===, v71, v13) goto (9, 10) for v13 is T{bool}
reaching type to v173 <- LoadClassId(v2) T{_Smi} for v2 is T{_StringBase}
reaching type to Branch if StrictCompare:92(===, v173, v128) goto (34, 39) for v173 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v173, v128) goto (34, 39) for v128 is T{_Smi}
reaching type to v238 <- Redefinition(v2 ^ T{_OneByteString}) T{_OneByteString} for v2 is T{_StringBase}
reaching type to v133 <- Redefinition(v238) T{_OneByteString} for v238 is T{_OneByteString}
reaching type to v134 <- LoadField(v133 . String.length {final}) T{_Smi} for v133 is T{_OneByteString}
reaching type to v136 <- GenericCheckBound:92(v134, v69) T{int} for v134 is T{_Smi}
reaching type to v136 <- GenericCheckBound:92(v134, v69) T{int} for v69 is T{int}
reaching type to v138 <- LoadIndexed(v133, v136) T{_Smi} for v133 is T{_OneByteString}
reaching type to v138 <- LoadIndexed(v133, v136) T{_Smi} for v136 is T{int}
reaching type to v140 <- BoxInt64(v138) T{int} for v138 is T{_Smi}
reaching type to v174 <- phi(v140, v149, v160, v171) alive T{int} for v140 is T{int}
reaching type to Branch if StrictCompare:92(===, v173, v129) goto (35, 40) for v173 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v173, v129) goto (35, 40) for v129 is T{_Smi}
reaching type to v240 <- Redefinition(v2 ^ T{_TwoByteString}) T{_TwoByteString} for v2 is T{_StringBase}
reaching type to v142 <- Redefinition(v240) T{_TwoByteString} for v240 is T{_TwoByteString}
reaching type to v143 <- LoadField(v142 . String.length {final}) T{_Smi} for v142 is T{_TwoByteString}
reaching type to v145 <- GenericCheckBound:92(v143, v69) T{int} for v143 is T{_Smi}
reaching type to v145 <- GenericCheckBound:92(v143, v69) T{int} for v69 is T{int}
reaching type to v147 <- LoadIndexed(v142, v145) T{_Smi} for v142 is T{_TwoByteString}
reaching type to v147 <- LoadIndexed(v142, v145) T{_Smi} for v145 is T{int}
reaching type to v149 <- BoxInt64(v147) T{int} for v147 is T{_Smi}
reaching type to v174 <- phi(v140, v149, v160, v171) alive T{int} for v149 is T{int}
reaching type to Branch if StrictCompare:92(===, v173, v130) goto (36, 41) for v173 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v173, v130) goto (36, 41) for v130 is T{_Smi}
reaching type to v242 <- Redefinition(v2 ^ T{_ExternalOneByteString}) T{_ExternalOneByteString} for v2 is T{_StringBase}
reaching type to v151 <- Redefinition(v242) T{_ExternalOneByteString} for v242 is T{_ExternalOneByteString}
reaching type to v152 <- LoadField(v151 . String.length {final}) T{_Smi} for v151 is T{_ExternalOneByteString}
reaching type to v154 <- GenericCheckBound:92(v152, v69) T{int} for v152 is T{_Smi}
reaching type to v154 <- GenericCheckBound:92(v152, v69) T{int} for v69 is T{int}
reaching type to v156 <- LoadUntagged(v151, 16) T{*?} for v151 is T{_ExternalOneByteString}
reaching type to v158 <- LoadIndexed(v156, v154) T{_Smi} for v156 is T{*?}
reaching type to v158 <- LoadIndexed(v156, v154) T{_Smi} for v154 is T{int}
reaching type to v160 <- BoxInt64(v158) T{int} for v158 is T{_Smi}
reaching type to v174 <- phi(v140, v149, v160, v171) alive T{int} for v160 is T{int}
reaching type to v162 <- Redefinition(v2) T{_StringBase} for v2 is T{_StringBase}
reaching type to v163 <- LoadField(v162 . String.length {final}) T{_Smi} for v162 is T{_StringBase}
reaching type to v165 <- GenericCheckBound:92(v163, v69) T{int} for v163 is T{_Smi}
reaching type to v165 <- GenericCheckBound:92(v163, v69) T{int} for v69 is T{int}
reaching type to v167 <- LoadUntagged(v162, 16) T{*?} for v162 is T{_StringBase}
reaching type to v169 <- LoadIndexed(v167, v165) T{_Smi} for v167 is T{*?}
reaching type to v169 <- LoadIndexed(v167, v165) T{_Smi} for v165 is T{int}
reaching type to v171 <- BoxInt64(v169) T{int} for v169 is T{_Smi}
reaching type to v174 <- phi(v140, v149, v160, v171) alive T{int} for v171 is T{int}
reaching type to v24 <- phi(v14, v69) alive T{int} for v69 is T{int}
reaching type to v26 <- phi(v217, v174) alive T{int} for v174 is T{int}
reaching type to v28 <- phi(v7, v67) alive T{int} for v67 is T{int}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) T{int?} for v8 is T{int}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) T{int?} for v3 is T{_Smi?}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:88(v75) for v75 is T{int?}
reaching type to v224 <- LoadField(v2 T{_StringBase} . String.length {final}) T{_Smi} for v2 is T{_StringBase}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v224 is T{_Smi}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v3 is T{_Smi?}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:32(v79) for v79 is T{int?}
recomputing type of v174: T{}
  phi 174 input 0: v140 has reaching type T{int}
  phi 174 input 1: v149 has reaching type T{int}
  phi 174 input 2: v160 has reaching type T{int}
  phi 174 input 3: v171 has reaching type T{int}
  ... new type T{int}
recomputing type of v26: T{}
  phi 26 input 0: v217 has reaching type T{}
  phi 26 input 1: v174 has reaching type T{int}
  ... new type T{int}
recomputing type of v38: T{bool}
recomputing type of v131: T{}
  phi 131 input 0: v94 has reaching type T{int}
  phi 131 input 1: v103 has reaching type T{int}
  phi 131 input 2: v114 has reaching type T{int}
  phi 131 input 3: v125 has reaching type T{int}
  ... new type T{int}
recomputing type of v50: T{int}
recomputing type of v30: T{}
  phi 30 input 0: v42 has reaching type T{_Smi}
  phi 30 input 1: v81 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v35: T{int?}
recomputing type of v28: T{}
  phi 28 input 0: v7 has reaching type T{_Smi}
  phi 28 input 1: v67 has reaching type T{int}
  ... new type T{int}
recomputing type of v35: T{int?}
recomputing type of v85: T{int}
recomputing type of v26: T{int}
  phi 26 input 0: v217 has reaching type T{}
  phi 26 input 1: v174 has reaching type T{int}
recomputing type of v24: T{}
  phi 24 input 0: v14 has reaching type T{int}
  phi 24 input 1: v69 has reaching type T{int}
  ... new type T{int}
recomputing type of v35: T{int?}
recomputing type of v83: T{int}
recomputing type of v217: T{}
  phi 217 input 0: v183 has reaching type T{int}
  phi 217 input 1: v192 has reaching type T{int}
  phi 217 input 2: v203 has reaching type T{int}
  phi 217 input 3: v214 has reaching type T{int}
  ... new type T{int}
recomputing type of v26: T{int}
  phi 26 input 0: v217 has reaching type T{int}
  phi 26 input 1: v174 has reaching type T{int}
recomputing type of v19: T{bool}
recomputing type of v22: T{bool}
recomputing type of v67: T{int}
reaching type to v5 <- StaticCall:12( _lastNonWhitespace@0150898<0> v2, using unchecked entrypoint, result_type = T{int}) T{int} for v2 is T{_StringBase}
reaching type to v8 <- BinaryInt64Op(+ [tr], v5, v7) T{int} for v5 is T{int}
reaching type to v8 <- BinaryInt64Op(+ [tr], v5, v7) T{int} for v7 is T{_Smi}
reaching type to v11 <- EqualityCompare(v8 == v10) T{bool} for v8 is T{int}
reaching type to v11 <- EqualityCompare(v8 == v10) T{bool} for v10 is T{_Smi}
reaching type to Branch if StrictCompare:20(===, v11, v13) goto (3, 4) for v11 is T{bool}
reaching type to Branch if StrictCompare:20(===, v11, v13) goto (3, 4) for v13 is T{bool}
reaching type to v14 <- StaticCall:36( _firstNonWhitespace@0150898<0> v2, using unchecked entrypoint, result_type = T{int}) T{int} for v2 is T{_StringBase}
reaching type to v216 <- LoadClassId(v2) T{_Smi} for v2 is T{_StringBase}
reaching type to Branch if StrictCompare:38(===, v216, v128) goto (43, 48) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v128) goto (43, 48) for v128 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v129) goto (44, 49) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v129) goto (44, 49) for v129 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v130) goto (45, 50) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v130) goto (45, 50) for v130 is T{_Smi}
reaching type to v205 <- Redefinition(v2) T{_StringBase} for v2 is T{_StringBase}
reaching type to v206 <- LoadField(v205 . String.length {final}) T{_Smi} for v205 is T{_StringBase}
reaching type to v208 <- GenericCheckBound:38(v206, v14) T{int} for v206 is T{_Smi}
reaching type to v208 <- GenericCheckBound:38(v206, v14) T{int} for v14 is T{int}
reaching type to v210 <- LoadUntagged(v205, 16) T{*?} for v205 is T{_StringBase}
reaching type to v212 <- LoadIndexed(v210, v208) T{_Smi} for v210 is T{*?}
reaching type to v212 <- LoadIndexed(v210, v208) T{_Smi} for v208 is T{int}
reaching type to v214 <- BoxInt64(v212) T{int} for v212 is T{_Smi}
reaching type to v217 <- phi(v183, v192, v203, v214) alive T{int} for v214 is T{int}
reaching type to v230 <- Redefinition(v2 ^ T{_ExternalOneByteString}) T{_ExternalOneByteString} for v2 is T{_StringBase}
reaching type to v194 <- Redefinition(v230) T{_ExternalOneByteString} for v230 is T{_ExternalOneByteString}
reaching type to v195 <- LoadField(v194 . String.length {final}) T{_Smi} for v194 is T{_ExternalOneByteString}
reaching type to v197 <- GenericCheckBound:38(v195, v14) T{int} for v195 is T{_Smi}
reaching type to v197 <- GenericCheckBound:38(v195, v14) T{int} for v14 is T{int}
reaching type to v199 <- LoadUntagged(v194, 16) T{*?} for v194 is T{_ExternalOneByteString}
reaching type to v201 <- LoadIndexed(v199, v197) T{_Smi} for v199 is T{*?}
reaching type to v201 <- LoadIndexed(v199, v197) T{_Smi} for v197 is T{int}
reaching type to v203 <- BoxInt64(v201) T{int} for v201 is T{_Smi}
reaching type to v217 <- phi(v183, v192, v203, v214) alive T{int} for v203 is T{int}
reaching type to v228 <- Redefinition(v2 ^ T{_TwoByteString}) T{_TwoByteString} for v2 is T{_StringBase}
reaching type to v185 <- Redefinition(v228) T{_TwoByteString} for v228 is T{_TwoByteString}
reaching type to v186 <- LoadField(v185 . String.length {final}) T{_Smi} for v185 is T{_TwoByteString}
reaching type to v188 <- GenericCheckBound:38(v186, v14) T{int} for v186 is T{_Smi}
reaching type to v188 <- GenericCheckBound:38(v186, v14) T{int} for v14 is T{int}
reaching type to v190 <- LoadIndexed(v185, v188) T{_Smi} for v185 is T{_TwoByteString}
reaching type to v190 <- LoadIndexed(v185, v188) T{_Smi} for v188 is T{int}
reaching type to v192 <- BoxInt64(v190) T{int} for v190 is T{_Smi}
reaching type to v217 <- phi(v183, v192, v203, v214) alive T{int} for v192 is T{int}
reaching type to v19 <- EqualityCompare(v217 T{_Smi} == v18) T{bool} for v217 is T{_Smi}
reaching type to v19 <- EqualityCompare(v217 T{_Smi} == v18) T{bool} for v18 is T{_Smi}
reaching type to Branch if StrictCompare:46(===, v19, v13) goto (7, 5) for v19 is T{bool}
reaching type to Branch if StrictCompare:46(===, v19, v13) goto (7, 5) for v13 is T{bool}
reaching type to v22 <- EqualityCompare(v217 T{_Smi} == v21) T{bool} for v217 is T{_Smi}
reaching type to v22 <- EqualityCompare(v217 T{_Smi} == v21) T{bool} for v21 is T{_Smi}
reaching type to Branch if StrictCompare:54(===, v22, v13) goto (8, 11) for v22 is T{bool}
reaching type to Branch if StrictCompare:54(===, v22, v13) goto (8, 11) for v13 is T{bool}
reaching type to v24 <- phi(v14, v69) alive T{int} for v14 is T{int}
reaching type to v26 <- phi(v217, v174) alive T{int} for v217 is T{int}
reaching type to v28 <- phi(v7, v67) alive T{int} for v7 is T{_Smi}
reaching type to Branch if StrictCompare:102(===, v3, v0) goto (13, 23) for v3 is T{_Smi?}
reaching type to Branch if StrictCompare:102(===, v3, v0) goto (13, 23) for v0 is T{Null?}
reaching type to v81 <- Redefinition(v3 ^ T{_Smi}) T{_Smi} for v3 is T{_Smi?}
reaching type to v30 <- phi(v42, v81) alive T{_Smi} for v81 is T{_Smi}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v30 is T{_Smi}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v24 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v8 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v28 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v34 is T{bool}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to Return:204(v35) for v35 is T{int?}
reaching type to Branch if StrictCompare(===, v26, v37) T{bool} goto (14, 21) for v26 is T{int}
reaching type to Branch if StrictCompare(===, v26, v37) T{bool} goto (14, 21) for v37 is T{_Smi}
reaching type to v30 <- phi(v42, v81) alive T{_Smi} for v42 is T{_Smi}
reaching type to v43 <- BinaryInt64Op(+ [tr], v24 T{int}, v7) T{int} for v24 is T{int}
reaching type to v43 <- BinaryInt64Op(+ [tr], v24 T{int}, v7) T{int} for v7 is T{_Smi}
reaching type to Branch if EqualityCompare(v43 == v8) T{bool} goto (15, 16) for v43 is T{int}
reaching type to Branch if EqualityCompare(v43 == v8) T{bool} goto (15, 16) for v8 is T{int}
reaching type to v127 <- LoadClassId(v2) T{_Smi} for v2 is T{_StringBase}
reaching type to Branch if StrictCompare:138(===, v127, v128) goto (25, 30) for v127 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v127, v128) goto (25, 30) for v128 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v127, v129) goto (26, 31) for v127 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v127, v129) goto (26, 31) for v129 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v127, v130) goto (27, 32) for v127 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v127, v130) goto (27, 32) for v130 is T{_Smi}
reaching type to v116 <- Redefinition(v2) T{_StringBase} for v2 is T{_StringBase}
reaching type to v117 <- LoadField(v116 . String.length {final}) T{_Smi} for v116 is T{_StringBase}
reaching type to v119 <- GenericCheckBound:138(v117, v43) T{int} for v117 is T{_Smi}
reaching type to v119 <- GenericCheckBound:138(v117, v43) T{int} for v43 is T{int}
reaching type to v121 <- LoadUntagged(v116, 16) T{*?} for v116 is T{_StringBase}
reaching type to v123 <- LoadIndexed(v121, v119) T{_Smi} for v121 is T{*?}
reaching type to v123 <- LoadIndexed(v121, v119) T{_Smi} for v119 is T{int}
reaching type to v125 <- BoxInt64(v123) T{int} for v123 is T{_Smi}
reaching type to v131 <- phi(v94, v103, v114, v125) alive T{int} for v125 is T{int}
reaching type to v236 <- Redefinition(v2 ^ T{_ExternalOneByteString}) T{_ExternalOneByteString} for v2 is T{_StringBase}
reaching type to v105 <- Redefinition(v236) T{_ExternalOneByteString} for v236 is T{_ExternalOneByteString}
reaching type to v106 <- LoadField(v105 . String.length {final}) T{_Smi} for v105 is T{_ExternalOneByteString}
reaching type to v108 <- GenericCheckBound:138(v106, v43) T{int} for v106 is T{_Smi}
reaching type to v108 <- GenericCheckBound:138(v106, v43) T{int} for v43 is T{int}
reaching type to v110 <- LoadUntagged(v105, 16) T{*?} for v105 is T{_ExternalOneByteString}
reaching type to v112 <- LoadIndexed(v110, v108) T{_Smi} for v110 is T{*?}
reaching type to v112 <- LoadIndexed(v110, v108) T{_Smi} for v108 is T{int}
reaching type to v114 <- BoxInt64(v112) T{int} for v112 is T{_Smi}
reaching type to v131 <- phi(v94, v103, v114, v125) alive T{int} for v114 is T{int}
reaching type to v234 <- Redefinition(v2 ^ T{_TwoByteString}) T{_TwoByteString} for v2 is T{_StringBase}
reaching type to v96 <- Redefinition(v234) T{_TwoByteString} for v234 is T{_TwoByteString}
reaching type to v97 <- LoadField(v96 . String.length {final}) T{_Smi} for v96 is T{_TwoByteString}
reaching type to v99 <- GenericCheckBound:138(v97, v43) T{int} for v97 is T{_Smi}
reaching type to v99 <- GenericCheckBound:138(v97, v43) T{int} for v43 is T{int}
reaching type to v101 <- LoadIndexed(v96, v99) T{_Smi} for v96 is T{_TwoByteString}
reaching type to v101 <- LoadIndexed(v96, v99) T{_Smi} for v99 is T{int}
reaching type to v103 <- BoxInt64(v101) T{int} for v101 is T{_Smi}
reaching type to v131 <- phi(v94, v103, v114, v125) alive T{int} for v103 is T{int}
reaching type to v50 <- BinaryInt64Op(| [tr], v131 T{_Smi}, v49) T{int} for v131 is T{_Smi}
reaching type to v50 <- BinaryInt64Op(| [tr], v131 T{_Smi}, v49) T{int} for v49 is T{_Smi}
reaching type to v53 <- EqualityCompare(v50 == v52) T{bool} for v50 is T{int}
reaching type to v53 <- EqualityCompare(v50 == v52) T{bool} for v52 is T{_Smi}
reaching type to Branch if StrictCompare:146(===, v53, v13) goto (17, 20) for v53 is T{bool}
reaching type to Branch if StrictCompare:146(===, v53, v13) goto (17, 20) for v13 is T{bool}
reaching type to v55 <- BinaryInt64Op(+ [tr], v43, v7) T{int} for v43 is T{int}
reaching type to v55 <- BinaryInt64Op(+ [tr], v43, v7) T{int} for v7 is T{_Smi}
reaching type to Branch if EqualityCompare(v55 == v8) T{bool} goto (18, 19) for v55 is T{int}
reaching type to Branch if EqualityCompare(v55 == v8) T{bool} goto (18, 19) for v8 is T{int}
reaching type to v60 <- RelationalOp(>, v28 T{int}, v10) T{bool} for v28 is T{int}
reaching type to v60 <- RelationalOp(>, v28 T{int}, v10) T{bool} for v10 is T{_Smi}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v59 is T{_Smi}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v55 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v8 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v28 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v60 is T{bool}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to Return:178(v62) for v62 is T{int?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) T{int?} for v55 is T{int}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:168(v64) for v64 is T{int?}
reaching type to v232 <- Redefinition(v2 ^ T{_OneByteString}) T{_OneByteString} for v2 is T{_StringBase}
reaching type to v87 <- Redefinition(v232) T{_OneByteString} for v232 is T{_OneByteString}
reaching type to v88 <- LoadField(v87 . String.length {final}) T{_Smi} for v87 is T{_OneByteString}
reaching type to v90 <- GenericCheckBound:138(v88, v43) T{int} for v88 is T{_Smi}
reaching type to v90 <- GenericCheckBound:138(v88, v43) T{int} for v43 is T{int}
reaching type to v92 <- LoadIndexed(v87, v90) T{_Smi} for v87 is T{_OneByteString}
reaching type to v92 <- LoadIndexed(v87, v90) T{_Smi} for v90 is T{int}
reaching type to v94 <- BoxInt64(v92) T{int} for v92 is T{_Smi}
reaching type to v131 <- phi(v94, v103, v114, v125) alive T{int} for v94 is T{int}
reaching type to Return:134(v10) for v10 is T{_Smi}
reaching type to v67 <- BinaryInt64Op(- [tr], v66, v217 T{_Smi}) T{int} for v66 is T{_Smi}
reaching type to v67 <- BinaryInt64Op(- [tr], v66, v217 T{_Smi}) T{int} for v217 is T{_Smi}
reaching type to v69 <- BinaryInt64Op(+ [tr], v14, v7) T{int} for v14 is T{int}
reaching type to v69 <- BinaryInt64Op(+ [tr], v14, v7) T{int} for v7 is T{_Smi}
reaching type to Branch if EqualityCompare(v69 == v8) T{bool} goto (9, 10) for v69 is T{int}
reaching type to Branch if EqualityCompare(v69 == v8) T{bool} goto (9, 10) for v8 is T{int}
reaching type to v173 <- LoadClassId(v2) T{_Smi} for v2 is T{_StringBase}
reaching type to Branch if StrictCompare:92(===, v173, v128) goto (34, 39) for v173 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v173, v128) goto (34, 39) for v128 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v173, v129) goto (35, 40) for v173 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v173, v129) goto (35, 40) for v129 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v173, v130) goto (36, 41) for v173 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v173, v130) goto (36, 41) for v130 is T{_Smi}
reaching type to v162 <- Redefinition(v2) T{_StringBase} for v2 is T{_StringBase}
reaching type to v163 <- LoadField(v162 . String.length {final}) T{_Smi} for v162 is T{_StringBase}
reaching type to v165 <- GenericCheckBound:92(v163, v69) T{int} for v163 is T{_Smi}
reaching type to v165 <- GenericCheckBound:92(v163, v69) T{int} for v69 is T{int}
reaching type to v167 <- LoadUntagged(v162, 16) T{*?} for v162 is T{_StringBase}
reaching type to v169 <- LoadIndexed(v167, v165) T{_Smi} for v167 is T{*?}
reaching type to v169 <- LoadIndexed(v167, v165) T{_Smi} for v165 is T{int}
reaching type to v171 <- BoxInt64(v169) T{int} for v169 is T{_Smi}
reaching type to v174 <- phi(v140, v149, v160, v171) alive T{int} for v171 is T{int}
reaching type to v242 <- Redefinition(v2 ^ T{_ExternalOneByteString}) T{_ExternalOneByteString} for v2 is T{_StringBase}
reaching type to v151 <- Redefinition(v242) T{_ExternalOneByteString} for v242 is T{_ExternalOneByteString}
reaching type to v152 <- LoadField(v151 . String.length {final}) T{_Smi} for v151 is T{_ExternalOneByteString}
reaching type to v154 <- GenericCheckBound:92(v152, v69) T{int} for v152 is T{_Smi}
reaching type to v154 <- GenericCheckBound:92(v152, v69) T{int} for v69 is T{int}
reaching type to v156 <- LoadUntagged(v151, 16) T{*?} for v151 is T{_ExternalOneByteString}
reaching type to v158 <- LoadIndexed(v156, v154) T{_Smi} for v156 is T{*?}
reaching type to v158 <- LoadIndexed(v156, v154) T{_Smi} for v154 is T{int}
reaching type to v160 <- BoxInt64(v158) T{int} for v158 is T{_Smi}
reaching type to v174 <- phi(v140, v149, v160, v171) alive T{int} for v160 is T{int}
reaching type to v240 <- Redefinition(v2 ^ T{_TwoByteString}) T{_TwoByteString} for v2 is T{_StringBase}
reaching type to v142 <- Redefinition(v240) T{_TwoByteString} for v240 is T{_TwoByteString}
reaching type to v143 <- LoadField(v142 . String.length {final}) T{_Smi} for v142 is T{_TwoByteString}
reaching type to v145 <- GenericCheckBound:92(v143, v69) T{int} for v143 is T{_Smi}
reaching type to v145 <- GenericCheckBound:92(v143, v69) T{int} for v69 is T{int}
reaching type to v147 <- LoadIndexed(v142, v145) T{_Smi} for v142 is T{_TwoByteString}
reaching type to v147 <- LoadIndexed(v142, v145) T{_Smi} for v145 is T{int}
reaching type to v149 <- BoxInt64(v147) T{int} for v147 is T{_Smi}
reaching type to v174 <- phi(v140, v149, v160, v171) alive T{int} for v149 is T{int}
reaching type to v24 <- phi(v14, v69) alive T{int} for v69 is T{int}
reaching type to v26 <- phi(v217, v174) alive T{int} for v174 is T{int}
reaching type to v28 <- phi(v7, v67) alive T{int} for v67 is T{int}
reaching type to v238 <- Redefinition(v2 ^ T{_OneByteString}) T{_OneByteString} for v2 is T{_StringBase}
reaching type to v133 <- Redefinition(v238) T{_OneByteString} for v238 is T{_OneByteString}
reaching type to v134 <- LoadField(v133 . String.length {final}) T{_Smi} for v133 is T{_OneByteString}
reaching type to v136 <- GenericCheckBound:92(v134, v69) T{int} for v134 is T{_Smi}
reaching type to v136 <- GenericCheckBound:92(v134, v69) T{int} for v69 is T{int}
reaching type to v138 <- LoadIndexed(v133, v136) T{_Smi} for v133 is T{_OneByteString}
reaching type to v138 <- LoadIndexed(v133, v136) T{_Smi} for v136 is T{int}
reaching type to v140 <- BoxInt64(v138) T{int} for v138 is T{_Smi}
reaching type to v174 <- phi(v140, v149, v160, v171) alive T{int} for v140 is T{int}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) T{int?} for v8 is T{int}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) T{int?} for v3 is T{_Smi?}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:88(v75) for v75 is T{int?}
reaching type to v226 <- Redefinition(v2 ^ T{_OneByteString}) T{_OneByteString} for v2 is T{_StringBase}
reaching type to v176 <- Redefinition(v226) T{_OneByteString} for v226 is T{_OneByteString}
reaching type to v177 <- LoadField(v176 . String.length {final}) T{_Smi} for v176 is T{_OneByteString}
reaching type to v179 <- GenericCheckBound:38(v177, v14) T{int} for v177 is T{_Smi}
reaching type to v179 <- GenericCheckBound:38(v177, v14) T{int} for v14 is T{int}
reaching type to v181 <- LoadIndexed(v176, v179) T{_Smi} for v176 is T{_OneByteString}
reaching type to v181 <- LoadIndexed(v176, v179) T{_Smi} for v179 is T{int}
reaching type to v183 <- BoxInt64(v181) T{int} for v181 is T{_Smi}
reaching type to v217 <- phi(v183, v192, v203, v214) alive T{int} for v183 is T{int}
reaching type to v224 <- LoadField(v2 T{_StringBase} . String.length {final}) T{_Smi} for v2 is T{_StringBase}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v224 is T{_Smi}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v3 is T{_Smi?}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:32(v79) for v79 is T{int?}
recomputing type of v174: T{}
  phi 174 input 0: v140 has reaching type T{int}
  phi 174 input 1: v149 has reaching type T{int}
  phi 174 input 2: v160 has reaching type T{int}
  phi 174 input 3: v171 has reaching type T{int}
  ... new type T{int}
recomputing type of v26: T{}
  phi 26 input 0: v217 has reaching type T{}
  phi 26 input 1: v174 has reaching type T{int}
  ... new type T{int}
recomputing type of v131: T{}
  phi 131 input 0: v94 has reaching type T{int}
  phi 131 input 1: v103 has reaching type T{int}
  phi 131 input 2: v114 has reaching type T{int}
  phi 131 input 3: v125 has reaching type T{int}
  ... new type T{int}
recomputing type of v50: T{int}
recomputing type of v30: T{}
  phi 30 input 0: v42 has reaching type T{_Smi}
  phi 30 input 1: v81 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v35: T{int?}
recomputing type of v28: T{}
  phi 28 input 0: v7 has reaching type T{_Smi}
  phi 28 input 1: v67 has reaching type T{int}
  ... new type T{int}
recomputing type of v35: T{int?}
recomputing type of v60: T{bool}
recomputing type of v62: T{int?}
recomputing type of v26: T{int}
  phi 26 input 0: v217 has reaching type T{}
  phi 26 input 1: v174 has reaching type T{int}
recomputing type of v24: T{}
  phi 24 input 0: v14 has reaching type T{int}
  phi 24 input 1: v69 has reaching type T{int}
  ... new type T{int}
recomputing type of v35: T{int?}
recomputing type of v43: T{int}
recomputing type of v217: T{}
  phi 217 input 0: v183 has reaching type T{int}
  phi 217 input 1: v192 has reaching type T{int}
  phi 217 input 2: v203 has reaching type T{int}
  phi 217 input 3: v214 has reaching type T{int}
  ... new type T{int}
recomputing type of v26: T{int}
  phi 26 input 0: v217 has reaching type T{int}
  phi 26 input 1: v174 has reaching type T{int}
recomputing type of v19: T{bool}
recomputing type of v22: T{bool}
recomputing type of v67: T{int}
reaching type to v5 <- StaticCall:12( _lastNonWhitespace@0150898<0> v2, using unchecked entrypoint, result_type = T{int}) T{int} for v2 is T{_StringBase}
reaching type to v266 <- UnboxInt64(v5) for v5 is T{int}
reaching type to v8 <- BinaryInt64Op(+ [tr], v266 T{int}, v334) T{int} for v266 is T{int}
reaching type to v8 <- BinaryInt64Op(+ [tr], v266 T{int}, v334) T{int} for v334 is T{_Smi}
reaching type to Branch if EqualityCompare(v8 == v336) T{bool} goto (3, 4) for v8 is T{int}
reaching type to Branch if EqualityCompare(v8 == v336) T{bool} goto (3, 4) for v336 is T{_Smi}
reaching type to v14 <- StaticCall:36( _firstNonWhitespace@0150898<0> v2, using unchecked entrypoint, result_type = T{int}) T{int} for v2 is T{_StringBase}
reaching type to v216 <- LoadClassId(v2) T{_Smi} for v2 is T{_StringBase}
reaching type to Branch if StrictCompare:38(===, v216, v128) goto (43, 48) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v128) goto (43, 48) for v128 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v129) goto (44, 49) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v129) goto (44, 49) for v129 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v130) goto (45, 50) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v130) goto (45, 50) for v130 is T{_Smi}
reaching type to v206 <- LoadField(v2 T{_StringBase} . String.length {final}) T{_Smi} for v2 is T{_StringBase}
reaching type to v208 <- GenericCheckBound:38(v206, v14) T{int} for v206 is T{_Smi}
reaching type to v208 <- GenericCheckBound:38(v206, v14) T{int} for v14 is T{int}
reaching type to v210 <- LoadUntagged(v2 T{_StringBase}, 16) T{*?} for v2 is T{_StringBase}
reaching type to v212 <- LoadIndexed(v210, v208) T{_Smi} for v210 is T{*?}
reaching type to v212 <- LoadIndexed(v210, v208) T{_Smi} for v208 is T{int}
reaching type to v217 <- phi(v181, v190, v201, v212) alive int64 T{int} for v212 is T{_Smi}
reaching type to v322 <- phi(v177, v186, v195, v206) alive T{} for v206 is T{_Smi}
reaching type to v354 <- Redefinition(v2 ^ T{_ExternalOneByteString}) for v2 is T{_StringBase}
reaching type to v195 <- LoadField(v354 . String.length {final}) T{_Smi} for v354 is T{_ExternalOneByteString}
reaching type to v197 <- GenericCheckBound:38(v195, v14) T{int} for v195 is T{_Smi}
reaching type to v197 <- GenericCheckBound:38(v195, v14) T{int} for v14 is T{int}
reaching type to v199 <- LoadUntagged(v354, 16) T{*?} for v354 is T{_ExternalOneByteString}
reaching type to v201 <- LoadIndexed(v199, v197) T{_Smi} for v199 is T{*?}
reaching type to v201 <- LoadIndexed(v199, v197) T{_Smi} for v197 is T{int}
reaching type to v217 <- phi(v181, v190, v201, v212) alive int64 T{int} for v201 is T{_Smi}
reaching type to v322 <- phi(v177, v186, v195, v206) alive T{} for v195 is T{_Smi}
reaching type to v352 <- Redefinition(v2 ^ T{_TwoByteString}) for v2 is T{_StringBase}
reaching type to v186 <- LoadField(v352 . String.length {final}) T{_Smi} for v352 is T{_TwoByteString}
reaching type to v188 <- GenericCheckBound:38(v186, v14) T{int} for v186 is T{_Smi}
reaching type to v188 <- GenericCheckBound:38(v186, v14) T{int} for v14 is T{int}
reaching type to v190 <- LoadIndexed(v352, v188) T{_Smi} for v352 is T{_TwoByteString}
reaching type to v190 <- LoadIndexed(v352, v188) T{_Smi} for v188 is T{int}
reaching type to v217 <- phi(v181, v190, v201, v212) alive int64 T{int} for v190 is T{_Smi}
reaching type to v322 <- phi(v177, v186, v195, v206) alive T{} for v186 is T{_Smi}
reaching type to Branch if EqualityCompare(v217 T{_Smi} == v338) T{bool} goto (7, 5) for v217 is T{_Smi}
reaching type to Branch if EqualityCompare(v217 T{_Smi} == v338) T{bool} goto (7, 5) for v338 is T{_Smi}
reaching type to Branch if EqualityCompare(v217 T{_Smi} == v340) T{bool} goto (8, 11) for v217 is T{_Smi}
reaching type to Branch if EqualityCompare(v217 T{_Smi} == v340) T{bool} goto (8, 11) for v340 is T{_Smi}
reaching type to v284 <- BoxInt64(v217) for v217 is T{int}
reaching type to v24 <- phi(v14, v296 T{int}) alive T{int} for v14 is T{int}
reaching type to v26 <- phi(v284 T{int}, v174) alive T{int} for v284 is T{int}
reaching type to v28 <- phi(v7, v286 T{int}) alive T{int} for v7 is T{_Smi}
reaching type to v326 <- phi(v322, v324) alive T{} for v322 is T{}
reaching type to Branch if StrictCompare:102(===, v3, v0) goto (13, 23) for v3 is T{_Smi?}
reaching type to Branch if StrictCompare:102(===, v3, v0) goto (13, 23) for v0 is T{Null?}
reaching type to v356 <- Redefinition(v3 ^ T{_Smi}) for v3 is T{_Smi?}
reaching type to v30 <- phi(v42, v356) alive T{_Smi} for v356 is T{_Smi}
reaching type to v272 <- BoxInt64(v8) for v8 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v30 is T{_Smi}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v24 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v272 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v28 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v34 is T{bool}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to Return:204(v35) for v35 is T{int?}
reaching type to Branch if StrictCompare(===, v26, v37) T{bool} goto (14, 21) for v26 is T{int}
reaching type to Branch if StrictCompare(===, v26, v37) T{bool} goto (14, 21) for v37 is T{_Smi}
reaching type to v30 <- phi(v42, v356) alive T{_Smi} for v42 is T{_Smi}
reaching type to v298 <- UnboxInt64(v24 T{int}) for v24 is T{int}
reaching type to v43 <- BinaryInt64Op(+ [tr], v298 T{int}, v334) T{int} for v298 is T{int}
reaching type to v43 <- BinaryInt64Op(+ [tr], v298 T{int}, v334) T{int} for v334 is T{_Smi}
reaching type to Branch if EqualityCompare(v43 == v8) T{bool} goto (15, 16) for v43 is T{int}
reaching type to Branch if EqualityCompare(v43 == v8) T{bool} goto (15, 16) for v8 is T{int}
reaching type to Branch if StrictCompare:138(===, v216, v128) goto (25, 30) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v216, v128) goto (25, 30) for v128 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v216, v129) goto (26, 31) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v216, v129) goto (26, 31) for v129 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v216, v130) goto (27, 32) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v216, v130) goto (27, 32) for v130 is T{_Smi}
reaching type to v302 <- BoxInt64(v43) for v43 is T{int}
reaching type to v119 <- GenericCheckBound:138(v326 T{_Smi}, v302 T{int}) T{int} for v326 is T{_Smi}
reaching type to v119 <- GenericCheckBound:138(v326 T{_Smi}, v302 T{int}) T{int} for v302 is T{int}
reaching type to v121 <- LoadUntagged(v2 T{_StringBase}, 16) T{*?} for v2 is T{_StringBase}
reaching type to v123 <- LoadIndexed(v121, v119) T{_Smi} for v121 is T{*?}
reaching type to v123 <- LoadIndexed(v121, v119) T{_Smi} for v119 is T{int}
reaching type to v131 <- phi(v92, v101, v112, v123) alive int64 T{int} for v123 is T{_Smi}
reaching type to v328 <- phi(v326, v326, v326, v326) alive for v326 is T{}
reaching type to v362 <- Redefinition(v2 ^ T{_ExternalOneByteString}) for v2 is T{_StringBase}
reaching type to v304 <- BoxInt64(v43) for v43 is T{int}
reaching type to v108 <- GenericCheckBound:138(v326 T{_Smi}, v304 T{int}) T{int} for v326 is T{_Smi}
reaching type to v108 <- GenericCheckBound:138(v326 T{_Smi}, v304 T{int}) T{int} for v304 is T{int}
reaching type to v110 <- LoadUntagged(v362, 16) T{*?} for v362 is T{_ExternalOneByteString}
reaching type to v112 <- LoadIndexed(v110, v108) T{_Smi} for v110 is T{*?}
reaching type to v112 <- LoadIndexed(v110, v108) T{_Smi} for v108 is T{int}
reaching type to v131 <- phi(v92, v101, v112, v123) alive int64 T{int} for v112 is T{_Smi}
reaching type to v328 <- phi(v326, v326, v326, v326) alive for v326 is T{}
reaching type to v360 <- Redefinition(v2 ^ T{_TwoByteString}) for v2 is T{_StringBase}
reaching type to v306 <- BoxInt64(v43) for v43 is T{int}
reaching type to v99 <- GenericCheckBound:138(v326 T{_Smi}, v306 T{int}) T{int} for v326 is T{_Smi}
reaching type to v99 <- GenericCheckBound:138(v326 T{_Smi}, v306 T{int}) T{int} for v306 is T{int}
reaching type to v101 <- LoadIndexed(v360, v99) T{_Smi} for v360 is T{_TwoByteString}
reaching type to v101 <- LoadIndexed(v360, v99) T{_Smi} for v99 is T{int}
reaching type to v131 <- phi(v92, v101, v112, v123) alive int64 T{int} for v101 is T{_Smi}
reaching type to v328 <- phi(v326, v326, v326, v326) alive for v326 is T{}
reaching type to v50 <- BinaryInt64Op(| [tr], v131 T{_Smi}, v344) T{int} for v131 is T{_Smi}
reaching type to v50 <- BinaryInt64Op(| [tr], v131 T{_Smi}, v344) T{int} for v344 is T{_Smi}
reaching type to Branch if EqualityCompare(v50 == v346) T{bool} goto (17, 20) for v50 is T{int}
reaching type to Branch if EqualityCompare(v50 == v346) T{bool} goto (17, 20) for v346 is T{_Smi}
reaching type to v55 <- BinaryInt64Op(+ [tr], v43, v334) T{int} for v43 is T{int}
reaching type to v55 <- BinaryInt64Op(+ [tr], v43, v334) T{int} for v334 is T{_Smi}
reaching type to Branch if EqualityCompare(v55 == v8) T{bool} goto (18, 19) for v55 is T{int}
reaching type to Branch if EqualityCompare(v55 == v8) T{bool} goto (18, 19) for v8 is T{int}
reaching type to v300 <- UnboxInt64(v28 T{int}) for v28 is T{int}
reaching type to v60 <- RelationalOp(>, v300 T{int}, v336) T{bool} for v300 is T{int}
reaching type to v60 <- RelationalOp(>, v300 T{int}, v336) T{bool} for v336 is T{_Smi}
reaching type to v270 <- BoxInt64(v8) for v8 is T{int}
reaching type to v320 <- BoxInt64(v55) for v55 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v59 is T{_Smi}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v320 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v270 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v28 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v60 is T{bool}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to Return:178(v62) for v62 is T{int?}
reaching type to v318 <- BoxInt64(v55) for v55 is T{int}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v318 T{int}, v0, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v318 T{int}, v0, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v318 T{int}, v0, v0, result_type = T{int?}) T{int?} for v318 is T{int}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v318 T{int}, v0, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v318 T{int}, v0, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:168(v64) for v64 is T{int?}
reaching type to v358 <- Redefinition(v2 ^ T{_OneByteString}) for v2 is T{_StringBase}
reaching type to v308 <- BoxInt64(v43) for v43 is T{int}
reaching type to v90 <- GenericCheckBound:138(v326 T{_Smi}, v308 T{int}) T{int} for v326 is T{_Smi}
reaching type to v90 <- GenericCheckBound:138(v326 T{_Smi}, v308 T{int}) T{int} for v308 is T{int}
reaching type to v92 <- LoadIndexed(v358, v90) T{_Smi} for v358 is T{_OneByteString}
reaching type to v92 <- LoadIndexed(v358, v90) T{_Smi} for v90 is T{int}
reaching type to v131 <- phi(v92, v101, v112, v123) alive int64 T{int} for v92 is T{_Smi}
reaching type to v328 <- phi(v326, v326, v326, v326) alive for v326 is T{}
reaching type to Return:134(v10) for v10 is T{_Smi}
reaching type to v67 <- BinaryInt64Op(- [tr], v342, v217 T{_Smi}) T{int} for v342 is T{_Smi}
reaching type to v67 <- BinaryInt64Op(- [tr], v342, v217 T{_Smi}) T{int} for v217 is T{_Smi}
reaching type to v274 <- UnboxInt64(v14) for v14 is T{int}
reaching type to v69 <- BinaryInt64Op(+ [tr], v274 T{int}, v334) T{int} for v274 is T{int}
reaching type to v69 <- BinaryInt64Op(+ [tr], v274 T{int}, v334) T{int} for v334 is T{_Smi}
reaching type to Branch if EqualityCompare(v69 == v8) T{bool} goto (9, 10) for v69 is T{int}
reaching type to Branch if EqualityCompare(v69 == v8) T{bool} goto (9, 10) for v8 is T{int}
reaching type to Branch if StrictCompare:92(===, v216, v128) goto (34, 39) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v216, v128) goto (34, 39) for v128 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v216, v129) goto (35, 40) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v216, v129) goto (35, 40) for v129 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v216, v130) goto (36, 41) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v216, v130) goto (36, 41) for v130 is T{_Smi}
reaching type to v288 <- BoxInt64(v69) for v69 is T{int}
reaching type to v165 <- GenericCheckBound:92(v322 T{_Smi}, v288 T{int}) T{int} for v322 is T{_Smi}
reaching type to v165 <- GenericCheckBound:92(v322 T{_Smi}, v288 T{int}) T{int} for v288 is T{int}
reaching type to v167 <- LoadUntagged(v2 T{_StringBase}, 16) T{*?} for v2 is T{_StringBase}
reaching type to v169 <- LoadIndexed(v167, v165) T{_Smi} for v167 is T{*?}
reaching type to v169 <- LoadIndexed(v167, v165) T{_Smi} for v165 is T{int}
reaching type to v171 <- BoxInt64(v169) T{int} for v169 is T{_Smi}
reaching type to v174 <- phi(v140, v149, v160, v171) alive T{int} for v171 is T{int}
reaching type to v324 <- phi(v322, v322, v322, v322) alive for v322 is T{}
reaching type to v368 <- Redefinition(v2 ^ T{_ExternalOneByteString}) for v2 is T{_StringBase}
reaching type to v290 <- BoxInt64(v69) for v69 is T{int}
reaching type to v154 <- GenericCheckBound:92(v322 T{_Smi}, v290 T{int}) T{int} for v322 is T{_Smi}
reaching type to v154 <- GenericCheckBound:92(v322 T{_Smi}, v290 T{int}) T{int} for v290 is T{int}
reaching type to v156 <- LoadUntagged(v368, 16) T{*?} for v368 is T{_ExternalOneByteString}
reaching type to v158 <- LoadIndexed(v156, v154) T{_Smi} for v156 is T{*?}
reaching type to v158 <- LoadIndexed(v156, v154) T{_Smi} for v154 is T{int}
reaching type to v160 <- BoxInt64(v158) T{int} for v158 is T{_Smi}
reaching type to v174 <- phi(v140, v149, v160, v171) alive T{int} for v160 is T{int}
reaching type to v324 <- phi(v322, v322, v322, v322) alive for v322 is T{}
reaching type to v366 <- Redefinition(v2 ^ T{_TwoByteString}) for v2 is T{_StringBase}
reaching type to v292 <- BoxInt64(v69) for v69 is T{int}
reaching type to v145 <- GenericCheckBound:92(v322 T{_Smi}, v292 T{int}) T{int} for v322 is T{_Smi}
reaching type to v145 <- GenericCheckBound:92(v322 T{_Smi}, v292 T{int}) T{int} for v292 is T{int}
reaching type to v147 <- LoadIndexed(v366, v145) T{_Smi} for v366 is T{_TwoByteString}
reaching type to v147 <- LoadIndexed(v366, v145) T{_Smi} for v145 is T{int}
reaching type to v149 <- BoxInt64(v147) T{int} for v147 is T{_Smi}
reaching type to v174 <- phi(v140, v149, v160, v171) alive T{int} for v149 is T{int}
reaching type to v324 <- phi(v322, v322, v322, v322) alive for v322 is T{}
reaching type to v286 <- BoxInt64(v67) for v67 is T{int}
reaching type to v296 <- BoxInt64(v69) for v69 is T{int}
reaching type to v24 <- phi(v14, v296 T{int}) alive T{int} for v296 is T{int}
reaching type to v26 <- phi(v284 T{int}, v174) alive T{int} for v174 is T{int}
reaching type to v28 <- phi(v7, v286 T{int}) alive T{int} for v286 is T{int}
reaching type to v326 <- phi(v322, v324) alive T{} for v324 is T{}
reaching type to v364 <- Redefinition(v2 ^ T{_OneByteString}) for v2 is T{_StringBase}
reaching type to v294 <- BoxInt64(v69) for v69 is T{int}
reaching type to v136 <- GenericCheckBound:92(v322 T{_Smi}, v294 T{int}) T{int} for v322 is T{_Smi}
reaching type to v136 <- GenericCheckBound:92(v322 T{_Smi}, v294 T{int}) T{int} for v294 is T{int}
reaching type to v138 <- LoadIndexed(v364, v136) T{_Smi} for v364 is T{_OneByteString}
reaching type to v138 <- LoadIndexed(v364, v136) T{_Smi} for v136 is T{int}
reaching type to v140 <- BoxInt64(v138) T{int} for v138 is T{_Smi}
reaching type to v174 <- phi(v140, v149, v160, v171) alive T{int} for v140 is T{int}
reaching type to v324 <- phi(v322, v322, v322, v322) alive T{} for v322 is T{}
reaching type to v268 <- BoxInt64(v8) for v8 is T{int}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v268 T{int}, v3, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v268 T{int}, v3, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v268 T{int}, v3, v0, result_type = T{int?}) T{int?} for v268 is T{int}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v268 T{int}, v3, v0, result_type = T{int?}) T{int?} for v3 is T{_Smi?}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v268 T{int}, v3, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:88(v75) for v75 is T{int?}
reaching type to v350 <- Redefinition(v2 ^ T{_OneByteString}) for v2 is T{_StringBase}
reaching type to v177 <- LoadField(v350 . String.length {final}) T{_Smi} for v350 is T{_OneByteString}
reaching type to v179 <- GenericCheckBound:38(v177, v14) T{int} for v177 is T{_Smi}
reaching type to v179 <- GenericCheckBound:38(v177, v14) T{int} for v14 is T{int}
reaching type to v181 <- LoadIndexed(v350, v179) T{_Smi} for v350 is T{_OneByteString}
reaching type to v181 <- LoadIndexed(v350, v179) T{_Smi} for v179 is T{int}
reaching type to v217 <- phi(v181, v190, v201, v212) alive int64 T{int} for v181 is T{_Smi}
reaching type to v322 <- phi(v177, v186, v195, v206) alive T{} for v177 is T{_Smi}
reaching type to v224 <- LoadField(v2 T{_StringBase} . String.length {final}) T{_Smi} for v2 is T{_StringBase}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v224 is T{_Smi}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v3 is T{_Smi?}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:32(v79) for v79 is T{int?}
recomputing type of v324: T{}
  phi 324 input 0: v322 has reaching type T{}
  phi 324 input 1: v322 has reaching type T{}
  phi 324 input 2: v322 has reaching type T{}
  phi 324 input 3: v322 has reaching type T{}
recomputing type of v174: T{}
  phi 174 input 0: v140 has reaching type T{int}
  phi 174 input 1: v149 has reaching type T{int}
  phi 174 input 2: v160 has reaching type T{int}
  phi 174 input 3: v171 has reaching type T{int}
  ... new type T{int}
recomputing type of v26: T{}
  phi 26 input 0: v284 has reaching type T{int}
  phi 26 input 1: v174 has reaching type T{int}
  ... new type T{int}
recomputing type of v328: T{}
  phi 328 input 0: v326 has reaching type T{}
  phi 328 input 1: v326 has reaching type T{}
  phi 328 input 2: v326 has reaching type T{}
  phi 328 input 3: v326 has reaching type T{}
recomputing type of v131: T{}
  phi 131 input 0: v92 has reaching type T{_Smi}
  phi 131 input 1: v101 has reaching type T{_Smi}
  phi 131 input 2: v112 has reaching type T{_Smi}
  phi 131 input 3: v123 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v50: T{int}
recomputing type of v30: T{}
  phi 30 input 0: v42 has reaching type T{_Smi}
  phi 30 input 1: v356 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v35: T{int?}
recomputing type of v326: T{}
  phi 326 input 0: v322 has reaching type T{}
  phi 326 input 1: v324 has reaching type T{}
recomputing type of v28: T{}
  phi 28 input 0: v7 has reaching type T{_Smi}
  phi 28 input 1: v286 has reaching type T{int}
  ... new type T{int}
recomputing type of v35: T{int?}
recomputing type of v62: T{int?}
recomputing type of v300: T{int}
recomputing type of v26: T{int}
  phi 26 input 0: v284 has reaching type T{int}
  phi 26 input 1: v174 has reaching type T{int}
recomputing type of v24: T{}
  phi 24 input 0: v14 has reaching type T{int}
  phi 24 input 1: v296 has reaching type T{int}
  ... new type T{int}
recomputing type of v35: T{int?}
recomputing type of v298: T{int}
recomputing type of v322: T{}
  phi 322 input 0: v177 has reaching type T{_Smi}
  phi 322 input 1: v186 has reaching type T{_Smi}
  phi 322 input 2: v195 has reaching type T{_Smi}
  phi 322 input 3: v206 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v326: T{}
  phi 326 input 0: v322 has reaching type T{_Smi}
  phi 326 input 1: v324 has reaching type T{}
  ... new type T{_Smi}
recomputing type of v90: T{int}
recomputing type of v99: T{int}
recomputing type of v108: T{int}
recomputing type of v119: T{int}
recomputing type of v328: T{}
  phi 328 input 0: v326 has reaching type T{_Smi}
  phi 328 input 1: v326 has reaching type T{_Smi}
  phi 328 input 2: v326 has reaching type T{_Smi}
  phi 328 input 3: v326 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v136: T{int}
recomputing type of v145: T{int}
recomputing type of v154: T{int}
recomputing type of v165: T{int}
recomputing type of v324: T{}
  phi 324 input 0: v322 has reaching type T{_Smi}
  phi 324 input 1: v322 has reaching type T{_Smi}
  phi 324 input 2: v322 has reaching type T{_Smi}
  phi 324 input 3: v322 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v326: T{_Smi}
  phi 326 input 0: v322 has reaching type T{_Smi}
  phi 326 input 1: v324 has reaching type T{_Smi}
recomputing type of v217: T{}
  phi 217 input 0: v181 has reaching type T{_Smi}
  phi 217 input 1: v190 has reaching type T{_Smi}
  phi 217 input 2: v201 has reaching type T{_Smi}
  phi 217 input 3: v212 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v67: T{int}
recomputing type of v284: T{int}
reaching type to v5 <- StaticCall:12( _lastNonWhitespace@0150898<0> v2, using unchecked entrypoint, result_type = T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v2 is T{_StringBase}
reaching type to v266 <- UnboxInt64(v5) [-9223372036854775808, 9223372036854775807] T{int} for v5 is T{int}
reaching type to v8 <- BinaryInt64Op(+ [tr], v266 T{int}, v334) [-9223372036854775808, 9223372036854775807] T{int} for v266 is T{int}
reaching type to v8 <- BinaryInt64Op(+ [tr], v266 T{int}, v334) [-9223372036854775808, 9223372036854775807] T{int} for v334 is T{_Smi}
reaching type to Branch if EqualityCompare(v8 == v336) T{bool} goto (3, 4) for v8 is T{int}
reaching type to Branch if EqualityCompare(v8 == v336) T{bool} goto (3, 4) for v336 is T{_Smi}
reaching type to v14 <- StaticCall:36( _firstNonWhitespace@0150898<0> v2, using unchecked entrypoint, result_type = T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v2 is T{_StringBase}
reaching type to v216 <- LoadClassId(v2) [-4611686018427387904, 4611686018427387903] T{_Smi} for v2 is T{_StringBase}
reaching type to Branch if StrictCompare:38(===, v216, v128) goto (43, 48) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v128) goto (43, 48) for v128 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v129) goto (44, 49) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v129) goto (44, 49) for v129 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v130) goto (45, 50) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v130) goto (45, 50) for v130 is T{_Smi}
reaching type to v206 <- LoadField(v2 T{_StringBase} . String.length {final}) [0, 2305843009213693951] T{_Smi} for v2 is T{_StringBase}
reaching type to v208 <- GenericCheckBound:38(v206, v14) [-9223372036854775808, 9223372036854775807] T{int} for v206 is T{_Smi}
reaching type to v208 <- GenericCheckBound:38(v206, v14) [-9223372036854775808, 9223372036854775807] T{int} for v14 is T{int}
reaching type to v210 <- LoadUntagged(v2 T{_StringBase}, 16) T{*?} for v2 is T{_StringBase}
reaching type to v212 <- LoadIndexed(v210, v208) [-4611686018427387904, 4611686018427387903] T{_Smi} for v210 is T{*?}
reaching type to v212 <- LoadIndexed(v210, v208) [-4611686018427387904, 4611686018427387903] T{_Smi} for v208 is T{int}
reaching type to v217 <- phi(v181, v190, v201, v212) alive [-4611686018427387904, 4611686018427387903] int64 T{_Smi} for v212 is T{_Smi}
reaching type to v322 <- phi(v177, v186, v195, v206) alive [0, 2305843009213693951] T{_Smi} for v206 is T{_Smi}
reaching type to v354 <- Redefinition(v2 ^ T{_ExternalOneByteString}) T{_ExternalOneByteString} for v2 is T{_StringBase}
reaching type to v195 <- LoadField(v354 . String.length {final}) [0, 2305843009213693951] T{_Smi} for v354 is T{_ExternalOneByteString}
reaching type to v197 <- GenericCheckBound:38(v195, v14) [-9223372036854775808, 9223372036854775807] T{int} for v195 is T{_Smi}
reaching type to v197 <- GenericCheckBound:38(v195, v14) [-9223372036854775808, 9223372036854775807] T{int} for v14 is T{int}
reaching type to v199 <- LoadUntagged(v354, 16) T{*?} for v354 is T{_ExternalOneByteString}
reaching type to v201 <- LoadIndexed(v199, v197) [-4611686018427387904, 4611686018427387903] T{_Smi} for v199 is T{*?}
reaching type to v201 <- LoadIndexed(v199, v197) [-4611686018427387904, 4611686018427387903] T{_Smi} for v197 is T{int}
reaching type to v217 <- phi(v181, v190, v201, v212) alive [-4611686018427387904, 4611686018427387903] int64 T{_Smi} for v201 is T{_Smi}
reaching type to v322 <- phi(v177, v186, v195, v206) alive [0, 2305843009213693951] T{_Smi} for v195 is T{_Smi}
reaching type to v352 <- Redefinition(v2 ^ T{_TwoByteString}) T{_TwoByteString} for v2 is T{_StringBase}
reaching type to v186 <- LoadField(v352 . String.length {final}) [0, 2305843009213693951] T{_Smi} for v352 is T{_TwoByteString}
reaching type to v188 <- GenericCheckBound:38(v186, v14) [-9223372036854775808, 9223372036854775807] T{int} for v186 is T{_Smi}
reaching type to v188 <- GenericCheckBound:38(v186, v14) [-9223372036854775808, 9223372036854775807] T{int} for v14 is T{int}
reaching type to v190 <- LoadIndexed(v352, v188) [0, 65535] T{_Smi} for v352 is T{_TwoByteString}
reaching type to v190 <- LoadIndexed(v352, v188) [0, 65535] T{_Smi} for v188 is T{int}
reaching type to v217 <- phi(v181, v190, v201, v212) alive [-4611686018427387904, 4611686018427387903] int64 T{_Smi} for v190 is T{_Smi}
reaching type to v322 <- phi(v177, v186, v195, v206) alive [0, 2305843009213693951] T{_Smi} for v186 is T{_Smi}
reaching type to Branch if EqualityCompare(v217 == v338) T{bool} goto (7, 5) for v217 is T{_Smi}
reaching type to Branch if EqualityCompare(v217 == v338) T{bool} goto (7, 5) for v338 is T{_Smi}
reaching type to Branch if EqualityCompare(v217 == v340) T{bool} goto (8, 11) for v217 is T{_Smi}
reaching type to Branch if EqualityCompare(v217 == v340) T{bool} goto (8, 11) for v340 is T{_Smi}
reaching type to v284 <- BoxInt64(v217) [-4611686018427387904, 4611686018427387903] T{int} for v217 is T{_Smi}
reaching type to v24 <- phi(v14, v296 T{int}) alive [-9223372036854775808, 9223372036854775807] T{int} for v14 is T{int}
reaching type to v26 <- phi(v284, v174) alive [-4611686018427387904, 4611686018427387903] T{int} for v284 is T{_Smi}
reaching type to v28 <- phi(v7, v286 T{int}) alive [-4611686018427387859, 4611686018427387948] T{int} for v7 is T{_Smi}
reaching type to v326 <- phi(v322, v324) alive [0, 2305843009213693951] T{_Smi} for v322 is T{_Smi}
reaching type to Branch if StrictCompare:102(===, v3, v0) goto (13, 23) for v3 is T{_Smi?}
reaching type to Branch if StrictCompare:102(===, v3, v0) goto (13, 23) for v0 is T{Null?}
reaching type to v356 <- Redefinition(v3 ^ T{_Smi}) [-4611686018427387904, 4611686018427387903] T{_Smi} for v3 is T{_Smi?}
reaching type to v30 <- phi(v42, v356) alive [-4611686018427387904, 4611686018427387903] T{_Smi} for v356 is T{_Smi}
reaching type to v272 <- BoxInt64(v8) [-9223372036854775808, 9223372036854775807] T{int} for v8 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v30 is T{_Smi}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v24 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v272 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v28 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v34 is T{bool}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to Return:204(v35) for v35 is T{int?}
reaching type to Branch if StrictCompare(===, v26, v37) T{bool} goto (14, 21) for v26 is T{int}
reaching type to Branch if StrictCompare(===, v26, v37) T{bool} goto (14, 21) for v37 is T{_Smi}
reaching type to v30 <- phi(v42, v356) alive [-4611686018427387904, 4611686018427387903] T{_Smi} for v42 is T{_Smi}
reaching type to v298 <- UnboxInt64(v24 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v24 is T{int}
reaching type to v43 <- BinaryInt64Op(+ [tr], v298 T{int}, v334) [-9223372036854775808, 9223372036854775807] T{int} for v298 is T{int}
reaching type to v43 <- BinaryInt64Op(+ [tr], v298 T{int}, v334) [-9223372036854775808, 9223372036854775807] T{int} for v334 is T{_Smi}
reaching type to Branch if EqualityCompare(v43 == v8) T{bool} goto (15, 16) for v43 is T{int}
reaching type to Branch if EqualityCompare(v43 == v8) T{bool} goto (15, 16) for v8 is T{int}
reaching type to Branch if StrictCompare:138(===, v216, v128) goto (25, 30) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v216, v128) goto (25, 30) for v128 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v216, v129) goto (26, 31) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v216, v129) goto (26, 31) for v129 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v216, v130) goto (27, 32) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v216, v130) goto (27, 32) for v130 is T{_Smi}
reaching type to v302 <- BoxInt64(v43) [-9223372036854775808, 9223372036854775807] T{int} for v43 is T{int}
reaching type to v119 <- GenericCheckBound:138(v326, v302 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v326 is T{_Smi}
reaching type to v119 <- GenericCheckBound:138(v326, v302 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v302 is T{int}
reaching type to v121 <- LoadUntagged(v2 T{_StringBase}, 16) T{*?} for v2 is T{_StringBase}
reaching type to v123 <- LoadIndexed(v121, v119) [-4611686018427387904, 4611686018427387903] T{_Smi} for v121 is T{*?}
reaching type to v123 <- LoadIndexed(v121, v119) [-4611686018427387904, 4611686018427387903] T{_Smi} for v119 is T{int}
reaching type to v131 <- phi(v92, v101, v112, v123) alive [-4611686018427387904, 4611686018427387903] int64 T{_Smi} for v123 is T{_Smi}
reaching type to v328 <- phi(v326, v326, v326, v326) alive [0, 2305843009213693951] T{_Smi} for v326 is T{_Smi}
reaching type to v362 <- Redefinition(v2 ^ T{_ExternalOneByteString}) T{_ExternalOneByteString} for v2 is T{_StringBase}
reaching type to v304 <- BoxInt64(v43) [-9223372036854775808, 9223372036854775807] T{int} for v43 is T{int}
reaching type to v108 <- GenericCheckBound:138(v326, v304 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v326 is T{_Smi}
reaching type to v108 <- GenericCheckBound:138(v326, v304 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v304 is T{int}
reaching type to v110 <- LoadUntagged(v362, 16) T{*?} for v362 is T{_ExternalOneByteString}
reaching type to v112 <- LoadIndexed(v110, v108) [-4611686018427387904, 4611686018427387903] T{_Smi} for v110 is T{*?}
reaching type to v112 <- LoadIndexed(v110, v108) [-4611686018427387904, 4611686018427387903] T{_Smi} for v108 is T{int}
reaching type to v131 <- phi(v92, v101, v112, v123) alive [-4611686018427387904, 4611686018427387903] int64 T{_Smi} for v112 is T{_Smi}
reaching type to v328 <- phi(v326, v326, v326, v326) alive [0, 2305843009213693951] T{_Smi} for v326 is T{_Smi}
reaching type to v360 <- Redefinition(v2 ^ T{_TwoByteString}) T{_TwoByteString} for v2 is T{_StringBase}
reaching type to v306 <- BoxInt64(v43) [-9223372036854775808, 9223372036854775807] T{int} for v43 is T{int}
reaching type to v99 <- GenericCheckBound:138(v326, v306 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v326 is T{_Smi}
reaching type to v99 <- GenericCheckBound:138(v326, v306 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v306 is T{int}
reaching type to v101 <- LoadIndexed(v360, v99) [0, 65535] T{_Smi} for v360 is T{_TwoByteString}
reaching type to v101 <- LoadIndexed(v360, v99) [0, 65535] T{_Smi} for v99 is T{int}
reaching type to v131 <- phi(v92, v101, v112, v123) alive [-4611686018427387904, 4611686018427387903] int64 T{_Smi} for v101 is T{_Smi}
reaching type to v328 <- phi(v326, v326, v326, v326) alive [0, 2305843009213693951] T{_Smi} for v326 is T{_Smi}
reaching type to v50 <- BinaryInt64Op(| [tr], v131, v344) [-4611686018427387904, 4611686018427387903] T{int} for v131 is T{_Smi}
reaching type to v50 <- BinaryInt64Op(| [tr], v131, v344) [-4611686018427387904, 4611686018427387903] T{int} for v344 is T{_Smi}
reaching type to Branch if EqualityCompare(v50 == v346) T{bool} goto (17, 20) for v50 is T{int}
reaching type to Branch if EqualityCompare(v50 == v346) T{bool} goto (17, 20) for v346 is T{_Smi}
reaching type to v55 <- BinaryInt64Op(+ [tr], v43, v334) [-9223372036854775808, 9223372036854775807] T{int} for v43 is T{int}
reaching type to v55 <- BinaryInt64Op(+ [tr], v43, v334) [-9223372036854775808, 9223372036854775807] T{int} for v334 is T{_Smi}
reaching type to Branch if EqualityCompare(v55 == v8) T{bool} goto (18, 19) for v55 is T{int}
reaching type to Branch if EqualityCompare(v55 == v8) T{bool} goto (18, 19) for v8 is T{int}
reaching type to v300 <- UnboxInt64(v28 T{int}) [-4611686018427387859, 4611686018427387948] T{int} for v28 is T{int}
reaching type to v60 <- RelationalOp(>, v300 T{int}, v336) T{bool} for v300 is T{int}
reaching type to v60 <- RelationalOp(>, v300 T{int}, v336) T{bool} for v336 is T{_Smi}
reaching type to v270 <- BoxInt64(v8) [-9223372036854775808, 9223372036854775807] T{int} for v8 is T{int}
reaching type to v320 <- BoxInt64(v55) [-9223372036854775808, 9223372036854775807] T{int} for v55 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v59 is T{_Smi}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v320 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v270 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v28 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v60 is T{bool}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to Return:178(v62) for v62 is T{int?}
reaching type to v318 <- BoxInt64(v55) [-9223372036854775808, 9223372036854775807] T{int} for v55 is T{int}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v318 T{int}, v0, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v318 T{int}, v0, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v318 T{int}, v0, v0, result_type = T{int?}) T{int?} for v318 is T{int}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v318 T{int}, v0, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v318 T{int}, v0, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:168(v64) for v64 is T{int?}
reaching type to v358 <- Redefinition(v2 ^ T{_OneByteString}) T{_OneByteString} for v2 is T{_StringBase}
reaching type to v308 <- BoxInt64(v43) [-9223372036854775808, 9223372036854775807] T{int} for v43 is T{int}
reaching type to v90 <- GenericCheckBound:138(v326, v308 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v326 is T{_Smi}
reaching type to v90 <- GenericCheckBound:138(v326, v308 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v308 is T{int}
reaching type to v92 <- LoadIndexed(v358, v90) [0, 255] T{_Smi} for v358 is T{_OneByteString}
reaching type to v92 <- LoadIndexed(v358, v90) [0, 255] T{_Smi} for v90 is T{int}
reaching type to v131 <- phi(v92, v101, v112, v123) alive [-4611686018427387904, 4611686018427387903] int64 T{_Smi} for v92 is T{_Smi}
reaching type to v328 <- phi(v326, v326, v326, v326) alive [0, 2305843009213693951] T{_Smi} for v326 is T{_Smi}
reaching type to Return:134(v10) for v10 is T{_Smi}
reaching type to v67 <- BinaryInt64Op(- [tr], v342, v217 T{_Smi}) [-4611686018427387859, 4611686018427387948] T{int} for v342 is T{_Smi}
reaching type to v67 <- BinaryInt64Op(- [tr], v342, v217) [-4611686018427387859, 4611686018427387948] T{int} for v217 is T{_Smi}
reaching type to v274 <- UnboxInt64(v14) [-9223372036854775808, 9223372036854775807] T{int} for v14 is T{int}
reaching type to v69 <- BinaryInt64Op(+ [tr], v274 T{int}, v334) [-9223372036854775808, 9223372036854775807] T{int} for v274 is T{int}
reaching type to v69 <- BinaryInt64Op(+ [tr], v274 T{int}, v334) [-9223372036854775808, 9223372036854775807] T{int} for v334 is T{_Smi}
reaching type to Branch if EqualityCompare(v69 == v8) T{bool} goto (9, 10) for v69 is T{int}
reaching type to Branch if EqualityCompare(v69 == v8) T{bool} goto (9, 10) for v8 is T{int}
reaching type to Branch if StrictCompare:92(===, v216, v128) goto (34, 39) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v216, v128) goto (34, 39) for v128 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v216, v129) goto (35, 40) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v216, v129) goto (35, 40) for v129 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v216, v130) goto (36, 41) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v216, v130) goto (36, 41) for v130 is T{_Smi}
reaching type to v288 <- BoxInt64(v69) [-9223372036854775808, 9223372036854775807] T{int} for v69 is T{int}
reaching type to v165 <- GenericCheckBound:92(v322, v288 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v322 is T{_Smi}
reaching type to v165 <- GenericCheckBound:92(v322, v288 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v288 is T{int}
reaching type to v167 <- LoadUntagged(v2 T{_StringBase}, 16) T{*?} for v2 is T{_StringBase}
reaching type to v169 <- LoadIndexed(v167, v165) [-4611686018427387904, 4611686018427387903] T{_Smi} for v167 is T{*?}
reaching type to v169 <- LoadIndexed(v167, v165) [-4611686018427387904, 4611686018427387903] T{_Smi} for v165 is T{int}
reaching type to v171 <- BoxInt64(v169) [-4611686018427387904, 4611686018427387903] T{int} for v169 is T{_Smi}
reaching type to v174 <- phi(v140, v149, v160, v171) alive [-4611686018427387904, 4611686018427387903] T{int} for v171 is T{_Smi}
reaching type to v324 <- phi(v322, v322, v322, v322) alive [0, 2305843009213693951] T{_Smi} for v322 is T{_Smi}
reaching type to v368 <- Redefinition(v2 ^ T{_ExternalOneByteString}) T{_ExternalOneByteString} for v2 is T{_StringBase}
reaching type to v290 <- BoxInt64(v69) [-9223372036854775808, 9223372036854775807] T{int} for v69 is T{int}
reaching type to v154 <- GenericCheckBound:92(v322, v290 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v322 is T{_Smi}
reaching type to v154 <- GenericCheckBound:92(v322, v290 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v290 is T{int}
reaching type to v156 <- LoadUntagged(v368, 16) T{*?} for v368 is T{_ExternalOneByteString}
reaching type to v158 <- LoadIndexed(v156, v154) [-4611686018427387904, 4611686018427387903] T{_Smi} for v156 is T{*?}
reaching type to v158 <- LoadIndexed(v156, v154) [-4611686018427387904, 4611686018427387903] T{_Smi} for v154 is T{int}
reaching type to v160 <- BoxInt64(v158) [-4611686018427387904, 4611686018427387903] T{int} for v158 is T{_Smi}
reaching type to v174 <- phi(v140, v149, v160, v171) alive [-4611686018427387904, 4611686018427387903] T{int} for v160 is T{_Smi}
reaching type to v324 <- phi(v322, v322, v322, v322) alive [0, 2305843009213693951] T{_Smi} for v322 is T{_Smi}
reaching type to v366 <- Redefinition(v2 ^ T{_TwoByteString}) T{_TwoByteString} for v2 is T{_StringBase}
reaching type to v292 <- BoxInt64(v69) [-9223372036854775808, 9223372036854775807] T{int} for v69 is T{int}
reaching type to v145 <- GenericCheckBound:92(v322, v292 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v322 is T{_Smi}
reaching type to v145 <- GenericCheckBound:92(v322, v292 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v292 is T{int}
reaching type to v147 <- LoadIndexed(v366, v145) [0, 65535] T{_Smi} for v366 is T{_TwoByteString}
reaching type to v147 <- LoadIndexed(v366, v145) [0, 65535] T{_Smi} for v145 is T{int}
reaching type to v149 <- BoxInt64(v147) [0, 65535] T{int} for v147 is T{_Smi}
reaching type to v174 <- phi(v140, v149, v160, v171) alive [-4611686018427387904, 4611686018427387903] T{int} for v149 is T{_Smi}
reaching type to v324 <- phi(v322, v322, v322, v322) alive [0, 2305843009213693951] T{_Smi} for v322 is T{_Smi}
reaching type to v286 <- BoxInt64(v67) [-4611686018427387859, 4611686018427387948] T{int} for v67 is T{int}
reaching type to v296 <- BoxInt64(v69) [-9223372036854775808, 9223372036854775807] T{int} for v69 is T{int}
reaching type to v24 <- phi(v14, v296 T{int}) alive [-9223372036854775808, 9223372036854775807] T{int} for v296 is T{int}
reaching type to v26 <- phi(v284, v174) alive [-4611686018427387904, 4611686018427387903] T{int} for v174 is T{int}
reaching type to v28 <- phi(v7, v286 T{int}) alive [-4611686018427387859, 4611686018427387948] T{int} for v286 is T{int}
reaching type to v326 <- phi(v322, v324) alive [0, 2305843009213693951] T{_Smi} for v324 is T{_Smi}
reaching type to v364 <- Redefinition(v2 ^ T{_OneByteString}) T{_OneByteString} for v2 is T{_StringBase}
reaching type to v294 <- BoxInt64(v69) [-9223372036854775808, 9223372036854775807] T{int} for v69 is T{int}
reaching type to v136 <- GenericCheckBound:92(v322, v294 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v322 is T{_Smi}
reaching type to v136 <- GenericCheckBound:92(v322, v294 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v294 is T{int}
reaching type to v138 <- LoadIndexed(v364, v136) [0, 255] T{_Smi} for v364 is T{_OneByteString}
reaching type to v138 <- LoadIndexed(v364, v136) [0, 255] T{_Smi} for v136 is T{int}
reaching type to v140 <- BoxInt64(v138) [0, 255] T{int} for v138 is T{_Smi}
reaching type to v174 <- phi(v140, v149, v160, v171) alive [-4611686018427387904, 4611686018427387903] T{int} for v140 is T{_Smi}
reaching type to v324 <- phi(v322, v322, v322, v322) alive [0, 2305843009213693951] T{_Smi} for v322 is T{_Smi}
reaching type to v268 <- BoxInt64(v8) [-9223372036854775808, 9223372036854775807] T{int} for v8 is T{int}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v268 T{int}, v3, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v268 T{int}, v3, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v268 T{int}, v3, v0, result_type = T{int?}) T{int?} for v268 is T{int}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v268 T{int}, v3, v0, result_type = T{int?}) T{int?} for v3 is T{_Smi?}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v268 T{int}, v3, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:88(v75) for v75 is T{int?}
reaching type to v350 <- Redefinition(v2 ^ T{_OneByteString}) T{_OneByteString} for v2 is T{_StringBase}
reaching type to v177 <- LoadField(v350 . String.length {final}) [0, 2305843009213693951] T{_Smi} for v350 is T{_OneByteString}
reaching type to v179 <- GenericCheckBound:38(v177, v14) [-9223372036854775808, 9223372036854775807] T{int} for v177 is T{_Smi}
reaching type to v179 <- GenericCheckBound:38(v177, v14) [-9223372036854775808, 9223372036854775807] T{int} for v14 is T{int}
reaching type to v181 <- LoadIndexed(v350, v179) [0, 255] T{_Smi} for v350 is T{_OneByteString}
reaching type to v181 <- LoadIndexed(v350, v179) [0, 255] T{_Smi} for v179 is T{int}
reaching type to v217 <- phi(v181, v190, v201, v212) alive [-4611686018427387904, 4611686018427387903] int64 T{_Smi} for v181 is T{_Smi}
reaching type to v322 <- phi(v177, v186, v195, v206) alive [0, 2305843009213693951] T{_Smi} for v177 is T{_Smi}
reaching type to v224 <- LoadField(v2 T{_StringBase} . String.length {final}) [0, 2305843009213693951] T{_Smi} for v2 is T{_StringBase}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v224 is T{_Smi}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v3 is T{_Smi?}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:32(v79) for v79 is T{int?}
recomputing type of v324: T{}
  phi 324 input 0: v322 has reaching type T{}
  phi 324 input 1: v322 has reaching type T{}
  phi 324 input 2: v322 has reaching type T{}
  phi 324 input 3: v322 has reaching type T{}
recomputing type of v174: T{}
  phi 174 input 0: v140 has reaching type T{_Smi}
  phi 174 input 1: v149 has reaching type T{_Smi}
  phi 174 input 2: v160 has reaching type T{_Smi}
  phi 174 input 3: v171 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v26: T{}
  phi 26 input 0: v284 has reaching type T{_Smi}
  phi 26 input 1: v174 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v328: T{}
  phi 328 input 0: v326 has reaching type T{}
  phi 328 input 1: v326 has reaching type T{}
  phi 328 input 2: v326 has reaching type T{}
  phi 328 input 3: v326 has reaching type T{}
recomputing type of v131: T{}
  phi 131 input 0: v92 has reaching type T{_Smi}
  phi 131 input 1: v101 has reaching type T{_Smi}
  phi 131 input 2: v112 has reaching type T{_Smi}
  phi 131 input 3: v123 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v50: T{int}
recomputing type of v30: T{}
  phi 30 input 0: v42 has reaching type T{_Smi}
  phi 30 input 1: v356 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v35: T{int?}
recomputing type of v326: T{}
  phi 326 input 0: v322 has reaching type T{}
  phi 326 input 1: v324 has reaching type T{}
recomputing type of v28: T{}
  phi 28 input 0: v7 has reaching type T{_Smi}
  phi 28 input 1: v286 has reaching type T{int}
  ... new type T{int}
recomputing type of v35: T{int?}
recomputing type of v62: T{int?}
recomputing type of v300: T{int}
recomputing type of v26: T{_Smi}
  phi 26 input 0: v284 has reaching type T{_Smi}
  phi 26 input 1: v174 has reaching type T{_Smi}
recomputing type of v24: T{}
  phi 24 input 0: v14 has reaching type T{int}
  phi 24 input 1: v296 has reaching type T{int}
  ... new type T{int}
recomputing type of v35: T{int?}
recomputing type of v298: T{int}
recomputing type of v322: T{}
  phi 322 input 0: v177 has reaching type T{_Smi}
  phi 322 input 1: v186 has reaching type T{_Smi}
  phi 322 input 2: v195 has reaching type T{_Smi}
  phi 322 input 3: v206 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v326: T{}
  phi 326 input 0: v322 has reaching type T{_Smi}
  phi 326 input 1: v324 has reaching type T{}
  ... new type T{_Smi}
recomputing type of v90: T{int}
recomputing type of v99: T{int}
recomputing type of v108: T{int}
recomputing type of v119: T{int}
recomputing type of v328: T{}
  phi 328 input 0: v326 has reaching type T{_Smi}
  phi 328 input 1: v326 has reaching type T{_Smi}
  phi 328 input 2: v326 has reaching type T{_Smi}
  phi 328 input 3: v326 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v136: T{int}
recomputing type of v145: T{int}
recomputing type of v154: T{int}
recomputing type of v165: T{int}
recomputing type of v324: T{}
  phi 324 input 0: v322 has reaching type T{_Smi}
  phi 324 input 1: v322 has reaching type T{_Smi}
  phi 324 input 2: v322 has reaching type T{_Smi}
  phi 324 input 3: v322 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v326: T{_Smi}
  phi 326 input 0: v322 has reaching type T{_Smi}
  phi 326 input 1: v324 has reaching type T{_Smi}
recomputing type of v217: T{}
  phi 217 input 0: v181 has reaching type T{_Smi}
  phi 217 input 1: v190 has reaching type T{_Smi}
  phi 217 input 2: v201 has reaching type T{_Smi}
  phi 217 input 3: v212 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v67: T{int}
recomputing type of v284: T{_Smi}
reaching type to v5 <- StaticCall:12( _lastNonWhitespace@0150898<0> v2, using unchecked entrypoint, result_type = T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v2 is T{_StringBase}
reaching type to v266 <- UnboxInt64(v5) [-9223372036854775808, 9223372036854775807] T{int} for v5 is T{int}
reaching type to v8 <- BinaryInt64Op(+ [tr], v266 T{int}, v334) [-9223372036854775808, 9223372036854775807] T{int} for v266 is T{int}
reaching type to v8 <- BinaryInt64Op(+ [tr], v266 T{int}, v334) [-9223372036854775808, 9223372036854775807] T{int} for v334 is T{_Smi}
reaching type to Branch if EqualityCompare(v8 == v336) T{bool} goto (3, 4) for v8 is T{int}
reaching type to Branch if EqualityCompare(v8 == v336) T{bool} goto (3, 4) for v336 is T{_Smi}
reaching type to v14 <- StaticCall:36( _firstNonWhitespace@0150898<0> v2, using unchecked entrypoint, result_type = T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v2 is T{_StringBase}
reaching type to v216 <- LoadClassId(v2) [-4611686018427387904, 4611686018427387903] T{_Smi} for v2 is T{_StringBase}
reaching type to Branch if StrictCompare:38(===, v216, v128) goto (43, 48) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v128) goto (43, 48) for v128 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v129) goto (44, 49) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v129) goto (44, 49) for v129 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v130) goto (45, 50) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v130) goto (45, 50) for v130 is T{_Smi}
reaching type to v206 <- LoadField(v2 T{_StringBase} . String.length {final}) [0, 2305843009213693951] T{_Smi} for v2 is T{_StringBase}
reaching type to v208 <- GenericCheckBound:38(v206, v14) [-9223372036854775808, 9223372036854775807] T{int} for v206 is T{_Smi}
reaching type to v208 <- GenericCheckBound:38(v206, v14) [-9223372036854775808, 9223372036854775807] T{int} for v14 is T{int}
reaching type to v210 <- LoadUntagged(v2 T{_StringBase}, 16) T{*?} for v2 is T{_StringBase}
reaching type to v212 <- LoadIndexed(v210, v208) [-4611686018427387904, 4611686018427387903] T{_Smi} for v210 is T{*?}
reaching type to v212 <- LoadIndexed(v210, v208) [-4611686018427387904, 4611686018427387903] T{_Smi} for v208 is T{int}
reaching type to v217 <- phi(v181, v190, v201, v212) alive [-4611686018427387904, 4611686018427387903] int64 T{_Smi} for v212 is T{_Smi}
reaching type to v322 <- phi(v177, v186, v195, v206) alive [0, 2305843009213693951] T{_Smi} for v206 is T{_Smi}
reaching type to v354 <- Redefinition(v2 ^ T{_ExternalOneByteString}) T{_ExternalOneByteString} for v2 is T{_StringBase}
reaching type to v195 <- LoadField(v354 . String.length {final}) [0, 2305843009213693951] T{_Smi} for v354 is T{_ExternalOneByteString}
reaching type to v197 <- GenericCheckBound:38(v195, v14) [-9223372036854775808, 9223372036854775807] T{int} for v195 is T{_Smi}
reaching type to v197 <- GenericCheckBound:38(v195, v14) [-9223372036854775808, 9223372036854775807] T{int} for v14 is T{int}
reaching type to v199 <- LoadUntagged(v354, 16) T{*?} for v354 is T{_ExternalOneByteString}
reaching type to v201 <- LoadIndexed(v199, v197) [-4611686018427387904, 4611686018427387903] T{_Smi} for v199 is T{*?}
reaching type to v201 <- LoadIndexed(v199, v197) [-4611686018427387904, 4611686018427387903] T{_Smi} for v197 is T{int}
reaching type to v217 <- phi(v181, v190, v201, v212) alive [-4611686018427387904, 4611686018427387903] int64 T{_Smi} for v201 is T{_Smi}
reaching type to v322 <- phi(v177, v186, v195, v206) alive [0, 2305843009213693951] T{_Smi} for v195 is T{_Smi}
reaching type to v352 <- Redefinition(v2 ^ T{_TwoByteString}) T{_TwoByteString} for v2 is T{_StringBase}
reaching type to v186 <- LoadField(v352 . String.length {final}) [0, 2305843009213693951] T{_Smi} for v352 is T{_TwoByteString}
reaching type to v188 <- GenericCheckBound:38(v186, v14) [-9223372036854775808, 9223372036854775807] T{int} for v186 is T{_Smi}
reaching type to v188 <- GenericCheckBound:38(v186, v14) [-9223372036854775808, 9223372036854775807] T{int} for v14 is T{int}
reaching type to v190 <- LoadIndexed(v352, v188) [0, 65535] T{_Smi} for v352 is T{_TwoByteString}
reaching type to v190 <- LoadIndexed(v352, v188) [0, 65535] T{_Smi} for v188 is T{int}
reaching type to v217 <- phi(v181, v190, v201, v212) alive [-4611686018427387904, 4611686018427387903] int64 T{_Smi} for v190 is T{_Smi}
reaching type to v322 <- phi(v177, v186, v195, v206) alive [0, 2305843009213693951] T{_Smi} for v186 is T{_Smi}
reaching type to Branch if EqualityCompare(v217 == v338) T{bool} goto (7, 5) for v217 is T{_Smi}
reaching type to Branch if EqualityCompare(v217 == v338) T{bool} goto (7, 5) for v338 is T{_Smi}
reaching type to Branch if EqualityCompare(v217 == v340) T{bool} goto (8, 11) for v217 is T{_Smi}
reaching type to Branch if EqualityCompare(v217 == v340) T{bool} goto (8, 11) for v340 is T{_Smi}
reaching type to v284 <- BoxInt64(v217) [-4611686018427387904, 4611686018427387903] T{_Smi} for v217 is T{_Smi}
reaching type to v24 <- phi(v14, v296 T{int}) alive [-9223372036854775808, 9223372036854775807] T{int} for v14 is T{int}
reaching type to v26 <- phi(v284, v174) alive [-4611686018427387904, 4611686018427387903] T{_Smi} for v284 is T{_Smi}
reaching type to v28 <- phi(v7, v286 T{int}) alive [-4611686018427387859, 4611686018427387948] T{int} for v7 is T{_Smi}
reaching type to Branch if StrictCompare:102(===, v3, v0) goto (13, 23) for v3 is T{_Smi?}
reaching type to Branch if StrictCompare:102(===, v3, v0) goto (13, 23) for v0 is T{Null?}
reaching type to v356 <- Redefinition(v3 ^ T{_Smi}) [-4611686018427387904, 4611686018427387903] T{_Smi} for v3 is T{_Smi?}
reaching type to v30 <- phi(v42, v356) alive [-4611686018427387904, 4611686018427387903] T{_Smi} for v356 is T{_Smi}
reaching type to v272 <- BoxInt64(v8) [-9223372036854775808, 9223372036854775807] T{int} for v8 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v30 is T{_Smi}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v24 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v272 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v28 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v34 is T{bool}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to Return:204(v35) for v35 is T{int?}
reaching type to Branch if StrictCompare(===, v26, v37) T{bool} goto (14, 21) for v26 is T{_Smi}
reaching type to Branch if StrictCompare(===, v26, v37) T{bool} goto (14, 21) for v37 is T{_Smi}
reaching type to v30 <- phi(v42, v356) alive [-4611686018427387904, 4611686018427387903] T{_Smi} for v42 is T{_Smi}
reaching type to v298 <- UnboxInt64(v24 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v24 is T{int}
reaching type to v43 <- BinaryInt64Op(+ [tr], v298 T{int}, v334) [-9223372036854775808, 9223372036854775807] T{int} for v298 is T{int}
reaching type to v43 <- BinaryInt64Op(+ [tr], v298 T{int}, v334) [-9223372036854775808, 9223372036854775807] T{int} for v334 is T{_Smi}
reaching type to Branch if EqualityCompare(v43 == v8) T{bool} goto (15, 16) for v43 is T{int}
reaching type to Branch if EqualityCompare(v43 == v8) T{bool} goto (15, 16) for v8 is T{int}
reaching type to Branch if StrictCompare:138(===, v216, v128) goto (25, 30) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v216, v128) goto (25, 30) for v128 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v216, v129) goto (26, 31) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v216, v129) goto (26, 31) for v129 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v216, v130) goto (27, 32) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v216, v130) goto (27, 32) for v130 is T{_Smi}
reaching type to v302 <- BoxInt64(v43) [-9223372036854775808, 9223372036854775807] T{int} for v43 is T{int}
reaching type to v119 <- GenericCheckBound:138(v322, v302 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v322 is T{_Smi}
reaching type to v119 <- GenericCheckBound:138(v322, v302 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v302 is T{int}
reaching type to v121 <- LoadUntagged(v2 T{_StringBase}, 16) T{*?} for v2 is T{_StringBase}
reaching type to v123 <- LoadIndexed(v121, v119) [-4611686018427387904, 4611686018427387903] T{_Smi} for v121 is T{*?}
reaching type to v123 <- LoadIndexed(v121, v119) [-4611686018427387904, 4611686018427387903] T{_Smi} for v119 is T{int}
reaching type to v131 <- phi(v92, v101, v112, v123) alive [-4611686018427387904, 4611686018427387903] int64 T{_Smi} for v123 is T{_Smi}
reaching type to v362 <- Redefinition(v2 ^ T{_ExternalOneByteString}) T{_ExternalOneByteString} for v2 is T{_StringBase}
reaching type to v304 <- BoxInt64(v43) [-9223372036854775808, 9223372036854775807] T{int} for v43 is T{int}
reaching type to v108 <- GenericCheckBound:138(v322, v304 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v322 is T{_Smi}
reaching type to v108 <- GenericCheckBound:138(v322, v304 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v304 is T{int}
reaching type to v110 <- LoadUntagged(v362, 16) T{*?} for v362 is T{_ExternalOneByteString}
reaching type to v112 <- LoadIndexed(v110, v108) [-4611686018427387904, 4611686018427387903] T{_Smi} for v110 is T{*?}
reaching type to v112 <- LoadIndexed(v110, v108) [-4611686018427387904, 4611686018427387903] T{_Smi} for v108 is T{int}
reaching type to v131 <- phi(v92, v101, v112, v123) alive [-4611686018427387904, 4611686018427387903] int64 T{_Smi} for v112 is T{_Smi}
reaching type to v360 <- Redefinition(v2 ^ T{_TwoByteString}) T{_TwoByteString} for v2 is T{_StringBase}
reaching type to v306 <- BoxInt64(v43) [-9223372036854775808, 9223372036854775807] T{int} for v43 is T{int}
reaching type to v99 <- GenericCheckBound:138(v322, v306 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v322 is T{_Smi}
reaching type to v99 <- GenericCheckBound:138(v322, v306 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v306 is T{int}
reaching type to v101 <- LoadIndexed(v360, v99) [0, 65535] T{_Smi} for v360 is T{_TwoByteString}
reaching type to v101 <- LoadIndexed(v360, v99) [0, 65535] T{_Smi} for v99 is T{int}
reaching type to v131 <- phi(v92, v101, v112, v123) alive [-4611686018427387904, 4611686018427387903] int64 T{_Smi} for v101 is T{_Smi}
reaching type to v50 <- BinaryInt64Op(| [tr], v131, v344) [-4611686018427387904, 4611686018427387903] T{int} for v131 is T{_Smi}
reaching type to v50 <- BinaryInt64Op(| [tr], v131, v344) [-4611686018427387904, 4611686018427387903] T{int} for v344 is T{_Smi}
reaching type to Branch if EqualityCompare(v50 == v346) T{bool} goto (17, 20) for v50 is T{int}
reaching type to Branch if EqualityCompare(v50 == v346) T{bool} goto (17, 20) for v346 is T{_Smi}
reaching type to v55 <- BinaryInt64Op(+ [tr], v43, v334) [-9223372036854775808, 9223372036854775807] T{int} for v43 is T{int}
reaching type to v55 <- BinaryInt64Op(+ [tr], v43, v334) [-9223372036854775808, 9223372036854775807] T{int} for v334 is T{_Smi}
reaching type to Branch if EqualityCompare(v55 == v8) T{bool} goto (18, 19) for v55 is T{int}
reaching type to Branch if EqualityCompare(v55 == v8) T{bool} goto (18, 19) for v8 is T{int}
reaching type to v300 <- UnboxInt64(v28 T{int}) [-4611686018427387859, 4611686018427387948] T{int} for v28 is T{int}
reaching type to v60 <- RelationalOp(>, v300 T{int}, v336) T{bool} for v300 is T{int}
reaching type to v60 <- RelationalOp(>, v300 T{int}, v336) T{bool} for v336 is T{_Smi}
reaching type to v270 <- BoxInt64(v8) [-9223372036854775808, 9223372036854775807] T{int} for v8 is T{int}
reaching type to v320 <- BoxInt64(v55) [-9223372036854775808, 9223372036854775807] T{int} for v55 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v59 is T{_Smi}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v320 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v270 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v28 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v60 is T{bool}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to Return:178(v62) for v62 is T{int?}
reaching type to v318 <- BoxInt64(v55) [-9223372036854775808, 9223372036854775807] T{int} for v55 is T{int}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v318 T{int}, v0, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v318 T{int}, v0, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v318 T{int}, v0, v0, result_type = T{int?}) T{int?} for v318 is T{int}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v318 T{int}, v0, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v318 T{int}, v0, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:168(v64) for v64 is T{int?}
reaching type to v358 <- Redefinition(v2 ^ T{_OneByteString}) T{_OneByteString} for v2 is T{_StringBase}
reaching type to v308 <- BoxInt64(v43) [-9223372036854775808, 9223372036854775807] T{int} for v43 is T{int}
reaching type to v90 <- GenericCheckBound:138(v322, v308 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v322 is T{_Smi}
reaching type to v90 <- GenericCheckBound:138(v322, v308 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v308 is T{int}
reaching type to v92 <- LoadIndexed(v358, v90) [0, 255] T{_Smi} for v358 is T{_OneByteString}
reaching type to v92 <- LoadIndexed(v358, v90) [0, 255] T{_Smi} for v90 is T{int}
reaching type to v131 <- phi(v92, v101, v112, v123) alive [-4611686018427387904, 4611686018427387903] int64 T{_Smi} for v92 is T{_Smi}
reaching type to Return:134(v10) for v10 is T{_Smi}
reaching type to v67 <- BinaryInt64Op(- [tr], v342, v217) [-4611686018427387859, 4611686018427387948] T{int} for v342 is T{_Smi}
reaching type to v67 <- BinaryInt64Op(- [tr], v342, v217) [-4611686018427387859, 4611686018427387948] T{int} for v217 is T{_Smi}
reaching type to v274 <- UnboxInt64(v14) [-9223372036854775808, 9223372036854775807] T{int} for v14 is T{int}
reaching type to v69 <- BinaryInt64Op(+ [tr], v274 T{int}, v334) [-9223372036854775808, 9223372036854775807] T{int} for v274 is T{int}
reaching type to v69 <- BinaryInt64Op(+ [tr], v274 T{int}, v334) [-9223372036854775808, 9223372036854775807] T{int} for v334 is T{_Smi}
reaching type to Branch if EqualityCompare(v69 == v8) T{bool} goto (9, 10) for v69 is T{int}
reaching type to Branch if EqualityCompare(v69 == v8) T{bool} goto (9, 10) for v8 is T{int}
reaching type to Branch if StrictCompare:92(===, v216, v128) goto (34, 39) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v216, v128) goto (34, 39) for v128 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v216, v129) goto (35, 40) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v216, v129) goto (35, 40) for v129 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v216, v130) goto (36, 41) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v216, v130) goto (36, 41) for v130 is T{_Smi}
reaching type to v288 <- BoxInt64(v69) [-9223372036854775808, 9223372036854775807] T{int} for v69 is T{int}
reaching type to v165 <- GenericCheckBound:92(v322, v288 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v322 is T{_Smi}
reaching type to v165 <- GenericCheckBound:92(v322, v288 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v288 is T{int}
reaching type to v167 <- LoadUntagged(v2 T{_StringBase}, 16) T{*?} for v2 is T{_StringBase}
reaching type to v169 <- LoadIndexed(v167, v165) [-4611686018427387904, 4611686018427387903] T{_Smi} for v167 is T{*?}
reaching type to v169 <- LoadIndexed(v167, v165) [-4611686018427387904, 4611686018427387903] T{_Smi} for v165 is T{int}
reaching type to v171 <- BoxInt64(v169) [-4611686018427387904, 4611686018427387903] T{_Smi} for v169 is T{_Smi}
reaching type to v174 <- phi(v140, v149, v160, v171) alive [-4611686018427387904, 4611686018427387903] T{_Smi} for v171 is T{_Smi}
reaching type to v368 <- Redefinition(v2 ^ T{_ExternalOneByteString}) T{_ExternalOneByteString} for v2 is T{_StringBase}
reaching type to v290 <- BoxInt64(v69) [-9223372036854775808, 9223372036854775807] T{int} for v69 is T{int}
reaching type to v154 <- GenericCheckBound:92(v322, v290 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v322 is T{_Smi}
reaching type to v154 <- GenericCheckBound:92(v322, v290 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v290 is T{int}
reaching type to v156 <- LoadUntagged(v368, 16) T{*?} for v368 is T{_ExternalOneByteString}
reaching type to v158 <- LoadIndexed(v156, v154) [-4611686018427387904, 4611686018427387903] T{_Smi} for v156 is T{*?}
reaching type to v158 <- LoadIndexed(v156, v154) [-4611686018427387904, 4611686018427387903] T{_Smi} for v154 is T{int}
reaching type to v160 <- BoxInt64(v158) [-4611686018427387904, 4611686018427387903] T{_Smi} for v158 is T{_Smi}
reaching type to v174 <- phi(v140, v149, v160, v171) alive [-4611686018427387904, 4611686018427387903] T{_Smi} for v160 is T{_Smi}
reaching type to v366 <- Redefinition(v2 ^ T{_TwoByteString}) T{_TwoByteString} for v2 is T{_StringBase}
reaching type to v292 <- BoxInt64(v69) [-9223372036854775808, 9223372036854775807] T{int} for v69 is T{int}
reaching type to v145 <- GenericCheckBound:92(v322, v292 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v322 is T{_Smi}
reaching type to v145 <- GenericCheckBound:92(v322, v292 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v292 is T{int}
reaching type to v147 <- LoadIndexed(v366, v145) [0, 65535] T{_Smi} for v366 is T{_TwoByteString}
reaching type to v147 <- LoadIndexed(v366, v145) [0, 65535] T{_Smi} for v145 is T{int}
reaching type to v149 <- BoxInt64(v147) [0, 65535] T{_Smi} for v147 is T{_Smi}
reaching type to v174 <- phi(v140, v149, v160, v171) alive [-4611686018427387904, 4611686018427387903] T{_Smi} for v149 is T{_Smi}
reaching type to v286 <- BoxInt64(v67) [-4611686018427387859, 4611686018427387948] T{int} for v67 is T{int}
reaching type to v296 <- BoxInt64(v69) [-9223372036854775808, 9223372036854775807] T{int} for v69 is T{int}
reaching type to v24 <- phi(v14, v296 T{int}) alive [-9223372036854775808, 9223372036854775807] T{int} for v296 is T{int}
reaching type to v26 <- phi(v284, v174) alive [-4611686018427387904, 4611686018427387903] T{_Smi} for v174 is T{_Smi}
reaching type to v28 <- phi(v7, v286 T{int}) alive [-4611686018427387859, 4611686018427387948] T{int} for v286 is T{int}
reaching type to v364 <- Redefinition(v2 ^ T{_OneByteString}) T{_OneByteString} for v2 is T{_StringBase}
reaching type to v294 <- BoxInt64(v69) [-9223372036854775808, 9223372036854775807] T{int} for v69 is T{int}
reaching type to v136 <- GenericCheckBound:92(v322, v294 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v322 is T{_Smi}
reaching type to v136 <- GenericCheckBound:92(v322, v294 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v294 is T{int}
reaching type to v138 <- LoadIndexed(v364, v136) [0, 255] T{_Smi} for v364 is T{_OneByteString}
reaching type to v138 <- LoadIndexed(v364, v136) [0, 255] T{_Smi} for v136 is T{int}
reaching type to v140 <- BoxInt64(v138) [0, 255] T{_Smi} for v138 is T{_Smi}
reaching type to v174 <- phi(v140, v149, v160, v171) alive [-4611686018427387904, 4611686018427387903] T{_Smi} for v140 is T{_Smi}
reaching type to v268 <- BoxInt64(v8) [-9223372036854775808, 9223372036854775807] T{int} for v8 is T{int}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v268 T{int}, v3, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v268 T{int}, v3, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v268 T{int}, v3, v0, result_type = T{int?}) T{int?} for v268 is T{int}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v268 T{int}, v3, v0, result_type = T{int?}) T{int?} for v3 is T{_Smi?}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v268 T{int}, v3, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:88(v75) for v75 is T{int?}
reaching type to v350 <- Redefinition(v2 ^ T{_OneByteString}) T{_OneByteString} for v2 is T{_StringBase}
reaching type to v177 <- LoadField(v350 . String.length {final}) [0, 2305843009213693951] T{_Smi} for v350 is T{_OneByteString}
reaching type to v179 <- GenericCheckBound:38(v177, v14) [-9223372036854775808, 9223372036854775807] T{int} for v177 is T{_Smi}
reaching type to v179 <- GenericCheckBound:38(v177, v14) [-9223372036854775808, 9223372036854775807] T{int} for v14 is T{int}
reaching type to v181 <- LoadIndexed(v350, v179) [0, 255] T{_Smi} for v350 is T{_OneByteString}
reaching type to v181 <- LoadIndexed(v350, v179) [0, 255] T{_Smi} for v179 is T{int}
reaching type to v217 <- phi(v181, v190, v201, v212) alive [-4611686018427387904, 4611686018427387903] int64 T{_Smi} for v181 is T{_Smi}
reaching type to v322 <- phi(v177, v186, v195, v206) alive [0, 2305843009213693951] T{_Smi} for v177 is T{_Smi}
reaching type to v224 <- LoadField(v2 T{_StringBase} . String.length {final}) [0, 2305843009213693951] T{_Smi} for v2 is T{_StringBase}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v224 is T{_Smi}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v3 is T{_Smi?}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:32(v79) for v79 is T{int?}
recomputing type of v174: T{}
  phi 174 input 0: v140 has reaching type T{_Smi}
  phi 174 input 1: v149 has reaching type T{_Smi}
  phi 174 input 2: v160 has reaching type T{_Smi}
  phi 174 input 3: v171 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v26: T{}
  phi 26 input 0: v284 has reaching type T{_Smi}
  phi 26 input 1: v174 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v131: T{}
  phi 131 input 0: v92 has reaching type T{_Smi}
  phi 131 input 1: v101 has reaching type T{_Smi}
  phi 131 input 2: v112 has reaching type T{_Smi}
  phi 131 input 3: v123 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v50: T{int}
recomputing type of v30: T{}
  phi 30 input 0: v42 has reaching type T{_Smi}
  phi 30 input 1: v356 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v35: T{int?}
recomputing type of v28: T{}
  phi 28 input 0: v7 has reaching type T{_Smi}
  phi 28 input 1: v286 has reaching type T{int}
  ... new type T{int}
recomputing type of v35: T{int?}
recomputing type of v62: T{int?}
recomputing type of v300: T{int}
recomputing type of v26: T{_Smi}
  phi 26 input 0: v284 has reaching type T{_Smi}
  phi 26 input 1: v174 has reaching type T{_Smi}
recomputing type of v24: T{}
  phi 24 input 0: v14 has reaching type T{int}
  phi 24 input 1: v296 has reaching type T{int}
  ... new type T{int}
recomputing type of v35: T{int?}
recomputing type of v298: T{int}
recomputing type of v322: T{}
  phi 322 input 0: v177 has reaching type T{_Smi}
  phi 322 input 1: v186 has reaching type T{_Smi}
  phi 322 input 2: v195 has reaching type T{_Smi}
  phi 322 input 3: v206 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v136: T{int}
recomputing type of v145: T{int}
recomputing type of v154: T{int}
recomputing type of v165: T{int}
recomputing type of v90: T{int}
recomputing type of v99: T{int}
recomputing type of v108: T{int}
recomputing type of v119: T{int}
recomputing type of v217: T{}
  phi 217 input 0: v181 has reaching type T{_Smi}
  phi 217 input 1: v190 has reaching type T{_Smi}
  phi 217 input 2: v201 has reaching type T{_Smi}
  phi 217 input 3: v212 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v67: T{int}
recomputing type of v284: T{_Smi}

windows-type-computation.txt

reaching type to v5 <- StaticCall:12( _lastNonWhitespace@0150898<0> v2, using unchecked entrypoint, result_type = T{int}) T{int} for v2 is T{_StringBase}
reaching type to v8 <- BinaryInt64Op(+ [tr], v5, v7) T{int} for v5 is T{int}
reaching type to v8 <- BinaryInt64Op(+ [tr], v5, v7) T{int} for v7 is T{_Smi}
reaching type to v11 <- EqualityCompare(v8 == v10) T{bool} for v8 is T{int}
reaching type to v11 <- EqualityCompare(v8 == v10) T{bool} for v10 is T{_Smi}
reaching type to AssertBoolean:18(v11) for v11 is T{bool}
reaching type to Branch if StrictCompare:20(===, v11, v13) goto (3, 4) for v11 is T{bool}
reaching type to Branch if StrictCompare:20(===, v11, v13) goto (3, 4) for v13 is T{bool}
reaching type to v14 <- StaticCall:36( _firstNonWhitespace@0150898<0> v2, using unchecked entrypoint, result_type = T{int}) T{int} for v2 is T{_StringBase}
reaching type to v16 <- InstanceCall:38( codeUnitAt<0>, v2, v14 IC[0: ], result_type = T{_Smi}) T{_Smi} for v2 is T{_StringBase}
reaching type to v16 <- InstanceCall:38( codeUnitAt<0>, v2, v14 IC[0: ], result_type = T{_Smi}) T{_Smi} for v14 is T{int}
reaching type to v19 <- EqualityCompare(v16 == v18) T{bool} for v16 is T{_Smi}
reaching type to v19 <- EqualityCompare(v16 == v18) T{bool} for v18 is T{_Smi}
reaching type to AssertBoolean:44(v19) for v19 is T{bool}
reaching type to Branch if StrictCompare:46(===, v19, v13) goto (7, 5) for v19 is T{bool}
reaching type to Branch if StrictCompare:46(===, v19, v13) goto (7, 5) for v13 is T{bool}
reaching type to v22 <- EqualityCompare(v16 == v21) T{bool} for v16 is T{_Smi}
reaching type to v22 <- EqualityCompare(v16 == v21) T{bool} for v21 is T{_Smi}
reaching type to AssertBoolean:52(v22) for v22 is T{bool}
reaching type to Branch if StrictCompare:54(===, v22, v13) goto (8, 11) for v22 is T{bool}
reaching type to Branch if StrictCompare:54(===, v22, v13) goto (8, 11) for v13 is T{bool}
reaching type to v24 <- phi(v69, v14) alive T{int?} for v14 is T{int}
reaching type to v26 <- phi(v73, v16) alive T{int?} for v16 is T{_Smi}
reaching type to v28 <- phi(v67, v7) alive T{int?} for v7 is T{_Smi}
reaching type to Branch if StrictCompare:102(===, v3, v0, with number check) goto (13, 23) for v3 is T{_Smi?}
reaching type to Branch if StrictCompare:102(===, v3, v0, with number check) goto (13, 23) for v0 is T{Null?}
reaching type to v81 <- Redefinition(v3 ^ T{_Smi}) for v3 is T{_Smi?}
reaching type to v30 <- phi(v42, v81) alive T{int?} for v81 is T{_Smi}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) for v2 is T{_StringBase}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) for v30 is T{int?}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) for v24 is T{int?}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) for v8 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) for v28 is T{int?}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) for v34 is T{bool}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) for v4 is T{*?}
reaching type to Return:204(v35) for v35 is T{int?}
reaching type to v38 <- StrictCompare(===, v26, v37) T{bool} for v26 is T{int?}
reaching type to v38 <- StrictCompare(===, v26, v37) T{bool} for v37 is T{_Smi}
reaching type to AssertBoolean:112(v38) for v38 is T{bool}
reaching type to Branch if StrictCompare:114(===, v38, v13) goto (14, 21) for v38 is T{bool}
reaching type to Branch if StrictCompare:114(===, v38, v13) goto (14, 21) for v13 is T{bool}
reaching type to v30 <- phi(v42, v81) alive T{int?} for v42 is T{_Smi}
reaching type to CheckNull:120(v24, NoSuchMethodError) for v24 is T{int?}
reaching type to v43 <- BinaryInt64Op(+ [tr], v83 T{int}, v7) T{int} for v83 is T{int}
reaching type to v43 <- BinaryInt64Op(+ [tr], v83 T{int}, v7) T{int} for v7 is T{_Smi}
reaching type to v45 <- EqualityCompare(v43 == v8) T{bool} for v43 is T{int}
reaching type to v45 <- EqualityCompare(v43 == v8) T{bool} for v8 is T{int}
reaching type to AssertBoolean:124(v45) for v45 is T{bool}
reaching type to Branch if StrictCompare:126(===, v45, v13) goto (15, 16) for v45 is T{bool}
reaching type to Branch if StrictCompare:126(===, v45, v13) goto (15, 16) for v13 is T{bool}
reaching type to v47 <- InstanceCall:138( codeUnitAt<0>, v2, v43 IC[0: ], result_type = T{_Smi}) T{_Smi} for v2 is T{_StringBase}
reaching type to v47 <- InstanceCall:138( codeUnitAt<0>, v2, v43 IC[0: ], result_type = T{_Smi}) T{_Smi} for v43 is T{int}
reaching type to v50 <- BinaryInt64Op(| [tr], v47, v49) T{int} for v47 is T{_Smi}
reaching type to v50 <- BinaryInt64Op(| [tr], v47, v49) T{int} for v49 is T{_Smi}
reaching type to v53 <- EqualityCompare(v50 == v52) T{bool} for v50 is T{int}
reaching type to v53 <- EqualityCompare(v50 == v52) T{bool} for v52 is T{_Smi}
reaching type to AssertBoolean:144(v53) for v53 is T{bool}
reaching type to Branch if StrictCompare:146(===, v53, v13) goto (17, 20) for v53 is T{bool}
reaching type to Branch if StrictCompare:146(===, v53, v13) goto (17, 20) for v13 is T{bool}
reaching type to v55 <- BinaryInt64Op(+ [tr], v43, v7) T{int} for v43 is T{int}
reaching type to v55 <- BinaryInt64Op(+ [tr], v43, v7) T{int} for v7 is T{_Smi}
reaching type to v57 <- EqualityCompare(v55 == v8) T{bool} for v55 is T{int}
reaching type to v57 <- EqualityCompare(v55 == v8) T{bool} for v8 is T{int}
reaching type to AssertBoolean:156(v57) for v57 is T{bool}
reaching type to Branch if StrictCompare:158(===, v57, v13) goto (18, 19) for v57 is T{bool}
reaching type to Branch if StrictCompare:158(===, v57, v13) goto (18, 19) for v13 is T{bool}
reaching type to CheckNull:172(v28, NoSuchMethodError) for v28 is T{int?}
reaching type to v60 <- RelationalOp(>, v85 T{int}, v10) T{bool} for v85 is T{int}
reaching type to v60 <- RelationalOp(>, v85 T{int}, v10) T{bool} for v10 is T{_Smi}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85, v60, v4, result_type = T{int?}) for v2 is T{_StringBase}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85, v60, v4, result_type = T{int?}) for v59 is T{_Smi}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85, v60, v4, result_type = T{int?}) for v55 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85, v60, v4, result_type = T{int?}) for v8 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) for v85 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) for v60 is T{bool}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) for v4 is T{*?}
reaching type to Return:178(v62) for v62 is T{int?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) for v4 is T{*?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) for v2 is T{_StringBase}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) for v55 is T{int}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) for v0 is T{Null?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) for v0 is T{Null?}
reaching type to Return:168(v64) for v64 is T{int?}
reaching type to Return:134(v10) for v10 is T{_Smi}
reaching type to v67 <- BinaryInt64Op(- [tr], v66, v16) T{int} for v66 is T{_Smi}
reaching type to v67 <- BinaryInt64Op(- [tr], v66, v16) T{int} for v16 is T{_Smi}
reaching type to v69 <- BinaryInt64Op(+ [tr], v14, v7) T{int} for v14 is T{int}
reaching type to v69 <- BinaryInt64Op(+ [tr], v14, v7) T{int} for v7 is T{_Smi}
reaching type to v71 <- EqualityCompare(v69 == v8) T{bool} for v69 is T{int}
reaching type to v71 <- EqualityCompare(v69 == v8) T{bool} for v8 is T{int}
reaching type to AssertBoolean:76(v71) for v71 is T{bool}
reaching type to Branch if StrictCompare:78(===, v71, v13) goto (9, 10) for v71 is T{bool}
reaching type to Branch if StrictCompare:78(===, v71, v13) goto (9, 10) for v13 is T{bool}
reaching type to v73 <- InstanceCall:92( codeUnitAt<0>, v2, v69 IC[0: ], result_type = T{_Smi}) for v2 is T{_StringBase}
reaching type to v73 <- InstanceCall:92( codeUnitAt<0>, v2, v69 IC[0: ], result_type = T{_Smi}) for v69 is T{int}
reaching type to v24 <- phi(v69, v14) alive T{int?} for v69 is T{int}
reaching type to v26 <- phi(v73, v16) alive T{int?} for v73 is T{_Smi}
reaching type to v28 <- phi(v67, v7) alive T{int?} for v67 is T{int}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) for v4 is T{*?}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) for v2 is T{_StringBase}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) for v8 is T{int}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) for v3 is T{_Smi?}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) for v0 is T{Null?}
reaching type to Return:88(v75) for v75 is T{int?}
reaching type to v77 <- StaticCall:26( get:length<0> v2, recognized_kind = StringBaseLength, result_type = T{_Smi}) for v2 is T{_StringBase}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v77, v3, v0, result_type = T{int?}) for v4 is T{*?}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v77, v3, v0, result_type = T{int?}) for v2 is T{_StringBase}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v77, v3, v0, result_type = T{int?}) for v77 is T{_Smi}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v77, v3, v0, result_type = T{int?}) for v3 is T{_Smi?}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v77, v3, v0, result_type = T{int?}) for v0 is T{Null?}
reaching type to Return:32(v79) for v79 is T{int?}
recomputing type of v30: T{}
  phi 30 input 0: v42 has reaching type T{_Smi}
  phi 30 input 1: v81 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v35: T{int?}
recomputing type of v28: T{}
  phi 28 input 0: v67 has reaching type T{int}
  phi 28 input 1: v7 has reaching type T{_Smi}
  ... new type T{int}
recomputing type of v35: T{int?}
recomputing type of v85: T{int}
  ... new type T{int}
recomputing type of v60: T{bool}
recomputing type of v62: T{int?}
recomputing type of v26: T{}
  phi 26 input 0: v73 has reaching type T{_Smi}
  phi 26 input 1: v16 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v38: T{bool}
recomputing type of v24: T{}
  phi 24 input 0: v69 has reaching type T{int}
  phi 24 input 1: v14 has reaching type T{int}
  ... new type T{int}
recomputing type of v35: T{int?}
recomputing type of v83: T{int}
reaching type to v5 <- StaticCall:12( _lastNonWhitespace@0150898<0> v2, using unchecked entrypoint, result_type = T{int}) T{int} for v2 is T{_StringBase}
reaching type to v8 <- BinaryInt64Op(+ [tr], v5, v7) T{int} for v5 is T{int}
reaching type to v8 <- BinaryInt64Op(+ [tr], v5, v7) T{int} for v7 is T{_Smi}
reaching type to v11 <- EqualityCompare(v8 == v10) T{bool} for v8 is T{int}
reaching type to v11 <- EqualityCompare(v8 == v10) T{bool} for v10 is T{_Smi}
reaching type to AssertBoolean:18(v11) for v11 is T{bool}
reaching type to Branch if StrictCompare:20(===, v11, v13) goto (3, 4) for v11 is T{bool}
reaching type to Branch if StrictCompare:20(===, v11, v13) goto (3, 4) for v13 is T{bool}
reaching type to v14 <- StaticCall:36( _firstNonWhitespace@0150898<0> v2, using unchecked entrypoint, result_type = T{int}) T{int} for v2 is T{_StringBase}
reaching type to v16 <- PolymorphicInstanceCall:38( codeUnitAt<0>, v2, v14 Targets[4: _TwoByteString@0150898 cid 80 cnt:1 trgt:'_TwoByteString@0150898.codeUnitAt' | _ExternalOneByteString@0150898 cid 81 cnt:1 trgt:'_ExternalOneByteString@0150898.codeUnitAt' | _ExternalTwoByteString@0150898 cid 82 cnt:1 trgt:'_ExternalTwoByteString@0150898.codeUnitAt' | _OneByteString@0150898 cid 79 cnt:1 trgt:'_OneByteString@0150898.codeUnitAt'] COMPLETE) T{_Smi} for v2 is T{_StringBase}
reaching type to v16 <- PolymorphicInstanceCall:38( codeUnitAt<0>, v2, v14 Targets[4: _TwoByteString@0150898 cid 80 cnt:1 trgt:'_TwoByteString@0150898.codeUnitAt' | _ExternalOneByteString@0150898 cid 81 cnt:1 trgt:'_ExternalOneByteString@0150898.codeUnitAt' | _ExternalTwoByteString@0150898 cid 82 cnt:1 trgt:'_ExternalTwoByteString@0150898.codeUnitAt' | _OneByteString@0150898 cid 79 cnt:1 trgt:'_OneByteString@0150898.codeUnitAt'] COMPLETE) T{_Smi} for v14 is T{int}
reaching type to v19 <- EqualityCompare(v16 == v18) T{bool} for v16 is T{_Smi}
reaching type to v19 <- EqualityCompare(v16 == v18) T{bool} for v18 is T{_Smi}
reaching type to AssertBoolean:44(v19) for v19 is T{bool}
reaching type to Branch if StrictCompare:46(===, v19, v13) goto (7, 5) for v19 is T{bool}
reaching type to Branch if StrictCompare:46(===, v19, v13) goto (7, 5) for v13 is T{bool}
reaching type to v22 <- EqualityCompare(v16 == v21) T{bool} for v16 is T{_Smi}
reaching type to v22 <- EqualityCompare(v16 == v21) T{bool} for v21 is T{_Smi}
reaching type to AssertBoolean:52(v22) for v22 is T{bool}
reaching type to Branch if StrictCompare:54(===, v22, v13) goto (8, 11) for v22 is T{bool}
reaching type to Branch if StrictCompare:54(===, v22, v13) goto (8, 11) for v13 is T{bool}
reaching type to v24 <- phi(v69, v14) alive T{int} for v14 is T{int}
reaching type to v26 <- phi(v73, v16) alive T{_Smi} for v16 is T{_Smi}
reaching type to v28 <- phi(v67, v7) alive T{int} for v7 is T{_Smi}
reaching type to Branch if StrictCompare:102(===, v3, v0, with number check) goto (13, 23) for v3 is T{_Smi?}
reaching type to Branch if StrictCompare:102(===, v3, v0, with number check) goto (13, 23) for v0 is T{Null?}
reaching type to v81 <- Redefinition(v3 ^ T{_Smi}) T{_Smi} for v3 is T{_Smi?}
reaching type to v30 <- phi(v42, v81) alive T{_Smi} for v81 is T{_Smi}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v30 is T{_Smi}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v24 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v8 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v28 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v34 is T{bool}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to Return:204(v35) for v35 is T{int?}
reaching type to v38 <- StrictCompare(===, v26, v37) T{bool} for v26 is T{_Smi}
reaching type to v38 <- StrictCompare(===, v26, v37) T{bool} for v37 is T{_Smi}
reaching type to AssertBoolean:112(v38) for v38 is T{bool}
reaching type to Branch if StrictCompare:114(===, v38, v13) goto (14, 21) for v38 is T{bool}
reaching type to Branch if StrictCompare:114(===, v38, v13) goto (14, 21) for v13 is T{bool}
reaching type to v30 <- phi(v42, v81) alive T{_Smi} for v42 is T{_Smi}
reaching type to v83 <- CheckNull:120(v24, NoSuchMethodError) T{int} for v24 is T{int}
reaching type to v43 <- BinaryInt64Op(+ [tr], v83 T{int}, v7) T{int} for v83 is T{int}
reaching type to v43 <- BinaryInt64Op(+ [tr], v83 T{int}, v7) T{int} for v7 is T{_Smi}
reaching type to v45 <- EqualityCompare(v43 == v8) T{bool} for v43 is T{int}
reaching type to v45 <- EqualityCompare(v43 == v8) T{bool} for v8 is T{int}
reaching type to AssertBoolean:124(v45) for v45 is T{bool}
reaching type to Branch if StrictCompare:126(===, v45, v13) goto (15, 16) for v45 is T{bool}
reaching type to Branch if StrictCompare:126(===, v45, v13) goto (15, 16) for v13 is T{bool}
reaching type to v47 <- PolymorphicInstanceCall:138( codeUnitAt<0>, v2, v43 Targets[4: _TwoByteString@0150898 cid 80 cnt:1 trgt:'_TwoByteString@0150898.codeUnitAt' | _ExternalOneByteString@0150898 cid 81 cnt:1 trgt:'_ExternalOneByteString@0150898.codeUnitAt' | _ExternalTwoByteString@0150898 cid 82 cnt:1 trgt:'_ExternalTwoByteString@0150898.codeUnitAt' | _OneByteString@0150898 cid 79 cnt:1 trgt:'_OneByteString@0150898.codeUnitAt'] COMPLETE) T{_Smi} for v2 is T{_StringBase}
reaching type to v47 <- PolymorphicInstanceCall:138( codeUnitAt<0>, v2, v43 Targets[4: _TwoByteString@0150898 cid 80 cnt:1 trgt:'_TwoByteString@0150898.codeUnitAt' | _ExternalOneByteString@0150898 cid 81 cnt:1 trgt:'_ExternalOneByteString@0150898.codeUnitAt' | _ExternalTwoByteString@0150898 cid 82 cnt:1 trgt:'_ExternalTwoByteString@0150898.codeUnitAt' | _OneByteString@0150898 cid 79 cnt:1 trgt:'_OneByteString@0150898.codeUnitAt'] COMPLETE) T{_Smi} for v43 is T{int}
reaching type to v50 <- BinaryInt64Op(| [tr], v47, v49) T{int} for v47 is T{_Smi}
reaching type to v50 <- BinaryInt64Op(| [tr], v47, v49) T{int} for v49 is T{_Smi}
reaching type to v53 <- EqualityCompare(v50 == v52) T{bool} for v50 is T{int}
reaching type to v53 <- EqualityCompare(v50 == v52) T{bool} for v52 is T{_Smi}
reaching type to AssertBoolean:144(v53) for v53 is T{bool}
reaching type to Branch if StrictCompare:146(===, v53, v13) goto (17, 20) for v53 is T{bool}
reaching type to Branch if StrictCompare:146(===, v53, v13) goto (17, 20) for v13 is T{bool}
reaching type to v55 <- BinaryInt64Op(+ [tr], v43, v7) T{int} for v43 is T{int}
reaching type to v55 <- BinaryInt64Op(+ [tr], v43, v7) T{int} for v7 is T{_Smi}
reaching type to v57 <- EqualityCompare(v55 == v8) T{bool} for v55 is T{int}
reaching type to v57 <- EqualityCompare(v55 == v8) T{bool} for v8 is T{int}
reaching type to AssertBoolean:156(v57) for v57 is T{bool}
reaching type to Branch if StrictCompare:158(===, v57, v13) goto (18, 19) for v57 is T{bool}
reaching type to Branch if StrictCompare:158(===, v57, v13) goto (18, 19) for v13 is T{bool}
reaching type to v85 <- CheckNull:172(v28, NoSuchMethodError) T{int} for v28 is T{int}
reaching type to v60 <- RelationalOp(>, v85 T{int}, v10) T{bool} for v85 is T{int}
reaching type to v60 <- RelationalOp(>, v85 T{int}, v10) T{bool} for v10 is T{_Smi}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v59 is T{_Smi}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v55 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v8 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v85 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v60 is T{bool}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to Return:178(v62) for v62 is T{int?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) T{int?} for v55 is T{int}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:168(v64) for v64 is T{int?}
reaching type to Return:134(v10) for v10 is T{_Smi}
reaching type to v67 <- BinaryInt64Op(- [tr], v66, v16) T{int} for v66 is T{_Smi}
reaching type to v67 <- BinaryInt64Op(- [tr], v66, v16) T{int} for v16 is T{_Smi}
reaching type to v69 <- BinaryInt64Op(+ [tr], v14, v7) T{int} for v14 is T{int}
reaching type to v69 <- BinaryInt64Op(+ [tr], v14, v7) T{int} for v7 is T{_Smi}
reaching type to v71 <- EqualityCompare(v69 == v8) T{bool} for v69 is T{int}
reaching type to v71 <- EqualityCompare(v69 == v8) T{bool} for v8 is T{int}
reaching type to AssertBoolean:76(v71) for v71 is T{bool}
reaching type to Branch if StrictCompare:78(===, v71, v13) goto (9, 10) for v71 is T{bool}
reaching type to Branch if StrictCompare:78(===, v71, v13) goto (9, 10) for v13 is T{bool}
reaching type to v73 <- PolymorphicInstanceCall:92( codeUnitAt<0>, v2, v69 Targets[4: _TwoByteString@0150898 cid 80 cnt:1 trgt:'_TwoByteString@0150898.codeUnitAt' | _ExternalOneByteString@0150898 cid 81 cnt:1 trgt:'_ExternalOneByteString@0150898.codeUnitAt' | _ExternalTwoByteString@0150898 cid 82 cnt:1 trgt:'_ExternalTwoByteString@0150898.codeUnitAt' | _OneByteString@0150898 cid 79 cnt:1 trgt:'_OneByteString@0150898.codeUnitAt'] COMPLETE) T{_Smi} for v2 is T{_StringBase}
reaching type to v73 <- PolymorphicInstanceCall:92( codeUnitAt<0>, v2, v69 Targets[4: _TwoByteString@0150898 cid 80 cnt:1 trgt:'_TwoByteString@0150898.codeUnitAt' | _ExternalOneByteString@0150898 cid 81 cnt:1 trgt:'_ExternalOneByteString@0150898.codeUnitAt' | _ExternalTwoByteString@0150898 cid 82 cnt:1 trgt:'_ExternalTwoByteString@0150898.codeUnitAt' | _OneByteString@0150898 cid 79 cnt:1 trgt:'_OneByteString@0150898.codeUnitAt'] COMPLETE) T{_Smi} for v69 is T{int}
reaching type to v24 <- phi(v69, v14) alive T{int} for v69 is T{int}
reaching type to v26 <- phi(v73, v16) alive T{_Smi} for v73 is T{_Smi}
reaching type to v28 <- phi(v67, v7) alive T{int} for v67 is T{int}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) T{int?} for v8 is T{int}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) T{int?} for v3 is T{_Smi?}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:88(v75) for v75 is T{int?}
reaching type to v77 <- StaticCall:26( get:length<0> v2, recognized_kind = StringBaseLength, result_type = T{_Smi}) T{_Smi} for v2 is T{_StringBase}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v77, v3, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v77, v3, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v77, v3, v0, result_type = T{int?}) T{int?} for v77 is T{_Smi}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v77, v3, v0, result_type = T{int?}) T{int?} for v3 is T{_Smi?}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v77, v3, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:32(v79) for v79 is T{int?}
recomputing type of v30: T{}
  phi 30 input 0: v42 has reaching type T{_Smi}
  phi 30 input 1: v81 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v35: T{int?}
recomputing type of v28: T{}
  phi 28 input 0: v67 has reaching type T{int}
  phi 28 input 1: v7 has reaching type T{_Smi}
  ... new type T{int}
recomputing type of v35: T{int?}
recomputing type of v85: T{int}
recomputing type of v26: T{}
  phi 26 input 0: v73 has reaching type T{_Smi}
  phi 26 input 1: v16 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v38: T{bool}
recomputing type of v24: T{}
  phi 24 input 0: v69 has reaching type T{int}
  phi 24 input 1: v14 has reaching type T{int}
  ... new type T{int}
recomputing type of v35: T{int?}
recomputing type of v83: T{int}
reaching type to v243 <- BinaryInt64Op(- [tr], v230, v242) T{int} for v230 is T{_Smi}
reaching type to v243 <- BinaryInt64Op(- [tr], v230, v242) T{int} for v242 is T{_Smi}
reaching type to v246 <- BinaryInt64Op(* [tr], v243, v245) T{int} for v243 is T{int}
reaching type to v246 <- BinaryInt64Op(* [tr], v243, v245) T{int} for v245 is T{_Smi}
reaching type to AssertBoolean:18(v248) for v248 is T{bool?}
reaching type to Branch if StrictCompare:20(===, v248, v250) goto (54, 55) for v248 is T{bool?}
reaching type to Branch if StrictCompare:20(===, v248, v250) goto (54, 55) for v250 is T{bool}
reaching type to v252 <- phi(v242, v251) alive T{*?} for v251 is T{_Smi}
reaching type to v254 <- StaticCall:34( +<0> v246, v252, using unchecked entrypoint, recognized_kind = Integer_add, result_type = T{int}) T{num} for v246 is T{int}
reaching type to v254 <- StaticCall:34( +<0> v246, v252, using unchecked entrypoint, recognized_kind = Integer_add, result_type = T{int}) T{num} for v252 is T{*?}
reaching type to v257 <- StaticCall:36( []<0> v256, v254, recognized_kind = ImmutableArrayGetIndexed) T{*?} for v256 is T{_ImmutableList}
reaching type to v257 <- StaticCall:36( []<0> v256, v254, recognized_kind = ImmutableArrayGetIndexed) T{*?} for v254 is T{num}
reaching type to v259 <- BinaryInt64Op(- [tr], v234, v232) T{int} for v234 is T{int}
reaching type to v259 <- BinaryInt64Op(- [tr], v234, v232) T{int} for v232 is T{int}
reaching type to v261 <- StaticCall:40( <=<0> v259, v257, using unchecked entrypoint, recognized_kind = Integer_lessEqualThan, result_type = T{bool}) for v259 is T{int}
reaching type to v261 <- StaticCall:40( <=<0> v259, v257, using unchecked entrypoint, recognized_kind = Integer_lessEqualThan, result_type = T{bool}) for v257 is T{*?}
reaching type to AssertBoolean:42(v261) for v261 is T{bool}
reaching type to Branch if StrictCompare:44(===, v261, v250) goto (57, 60) for v261 is T{bool}
reaching type to Branch if StrictCompare:44(===, v261, v250) goto (57, 60) for v250 is T{bool}
reaching type to v263 <- phi(v259, v389) alive T{int?} for v259 is T{int}
reaching type to v265 <- StaticCall:76( >=<0> v263, v257, using unchecked entrypoint, recognized_kind = Integer_greaterEqualThan, result_type = T{bool}) for v263 is T{int?}
reaching type to v265 <- StaticCall:76( >=<0> v263, v257, using unchecked entrypoint, recognized_kind = Integer_greaterEqualThan, result_type = T{bool}) for v257 is T{*?}
reaching type to AssertBoolean:78(v265) for v265 is T{bool}
reaching type to Branch if StrictCompare:80(===, v265, v250) goto (61, 63) for v265 is T{bool}
reaching type to Branch if StrictCompare:80(===, v265, v250) goto (61, 63) for v250 is T{bool}
reaching type to CheckNull:100(v263, NoSuchMethodError) for v263 is T{int?}
reaching type to v267 <- RelationalOp(>, v431 T{int}, v251) T{bool} for v431 is T{int}
reaching type to v267 <- RelationalOp(>, v431 T{int}, v251) T{bool} for v251 is T{_Smi}
reaching type to AssertBoolean:102(v267) for v267 is T{bool}
reaching type to Branch if StrictCompare:104(===, v267, v250) goto (64, 67) for v267 is T{bool}
reaching type to Branch if StrictCompare:104(===, v267, v250) goto (64, 67) for v250 is T{bool}
reaching type to v269 <- phi(v381, v232) alive T{int?} for v232 is T{int}
reaching type to v271 <- phi(v385, v251) alive for v251 is T{_Smi}
reaching type to v397 <- Redefinition(v254 ^ T{int}) T{int} for v254 is T{num}
reaching type to v278 <- BinaryInt64Op(+ [tr], v397, v277) T{int} for v397 is T{int}
reaching type to v278 <- BinaryInt64Op(+ [tr], v397, v277) T{int} for v277 is T{_Smi}
reaching type to v280 <- StaticCall:142( []<0> v256, v278, recognized_kind = ImmutableArrayGetIndexed) T{*?} for v256 is T{_ImmutableList}
reaching type to v280 <- StaticCall:142( []<0> v256, v278, recognized_kind = ImmutableArrayGetIndexed) T{*?} for v278 is T{int}
reaching type to v282 <- ShiftInt64Op(<< [tr], v397, v277) T{int} for v397 is T{int}
reaching type to v282 <- ShiftInt64Op(<< [tr], v397, v277) T{int} for v277 is T{_Smi}
reaching type to CheckNull:152(v284, NoSuchMethodError) for v284 is T{_Int64List?}
reaching type to v399 <- LoadField(v433 T{_Int64List} . TypedDataBase.length {final}) for v433 is T{_Int64List}
reaching type to v401 <- GenericCheckBound:154(v399, v282) for v399 is T{_Smi}
reaching type to v401 <- GenericCheckBound:154(v399, v282) for v282 is T{int}
reaching type to v403 <- LoadIndexed(v433 T{_Int64List}, v401) T{int} for v433 is T{_Int64List}
reaching type to v403 <- LoadIndexed(v433 T{_Int64List}, v401) T{int} for v401 is T{int}
reaching type to v288 <- EqualityCompare(v403 == v251) T{bool} for v403 is T{int}
reaching type to v288 <- EqualityCompare(v403 == v251) T{bool} for v251 is T{_Smi}
reaching type to AssertBoolean:158(v288) for v288 is T{bool}
reaching type to Branch if StrictCompare:160(===, v288, v250) goto (69, 70) for v288 is T{bool}
reaching type to Branch if StrictCompare:160(===, v288, v250) goto (69, 70) for v250 is T{bool}
reaching type to v290 <- phi(v379, v403) alive T{int?} for v403 is T{int}
reaching type to v294 <- BinaryInt64Op(+ [tr], v282, v277) T{int} for v282 is T{int}
reaching type to v294 <- BinaryInt64Op(+ [tr], v282, v277) T{int} for v277 is T{_Smi}
reaching type to CheckNull:180(v292, NoSuchMethodError) for v292 is T{_Int64List?}
reaching type to v405 <- LoadField(v435 T{_Int64List} . TypedDataBase.length {final}) for v435 is T{_Int64List}
reaching type to v407 <- GenericCheckBound:182(v405, v294) for v405 is T{_Smi}
reaching type to v407 <- GenericCheckBound:182(v405, v294) for v294 is T{int}
reaching type to v409 <- LoadIndexed(v435 T{_Int64List}, v407) T{int} for v435 is T{_Int64List}
reaching type to v409 <- LoadIndexed(v435 T{_Int64List}, v407) T{int} for v407 is T{int}
reaching type to v298 <- StaticCall:184( +<0> v269, v257, using unchecked entrypoint, recognized_kind = Integer_add, result_type = T{int}) for v269 is T{int?}
reaching type to v298 <- StaticCall:184( +<0> v269, v257, using unchecked entrypoint, recognized_kind = Integer_add, result_type = T{int}) for v257 is T{*?}
reaching type to v300 <- phi(v269, v304) alive T{int?} for v269 is T{int?}
reaching type to v302 <- phi(v271, v332) alive T{int?} for v271 is T{}
reaching type to v304 <- phi(v298, v429) alive T{int?} for v298 is T{num}
reaching type to v308 <- StaticCall:186( _parseBlock@0150898<0> v228, v230, v300, v304, result_type = T{_Smi?}) T{_Smi?} for v228 is T{_StringBase}
reaching type to v308 <- StaticCall:186( _parseBlock@0150898<0> v228, v230, v300, v304, result_type = T{_Smi?}) T{_Smi?} for v230 is T{_Smi}
reaching type to v308 <- StaticCall:186( _parseBlock@0150898<0> v228, v230, v300, v304, result_type = T{_Smi?}) T{_Smi?} for v300 is T{int?}
reaching type to v308 <- StaticCall:186( _parseBlock@0150898<0> v228, v230, v300, v304, result_type = T{_Smi?}) T{_Smi?} for v304 is T{int?}
reaching type to Branch if StrictCompare:188(===, v308, v219, with number check) goto (72, 73) for v308 is T{_Smi?}
reaching type to Branch if StrictCompare:188(===, v308, v219, with number check) goto (72, 73) for v219 is T{Null?}
reaching type to v437 <- Redefinition(v308 ^ T{_Smi}) for v308 is T{_Smi?}
reaching type to CheckNull:202(v302, NoSuchMethodError) for v302 is T{int?}
reaching type to CheckNull:202(v290, NoSuchMethodError) for v290 is T{int?}
reaching type to v310 <- RelationalOp(>=, v439 T{int}, v441 T{int?}) T{bool} for v439 is T{int}
reaching type to v310 <- RelationalOp(>=, v439 T{int}, v441 T{int}) T{bool} for v441 is T{int}
reaching type to AssertBoolean:204(v310) for v310 is T{bool}
reaching type to Branch if StrictCompare:206(===, v310, v250) goto (74, 95) for v310 is T{bool}
reaching type to Branch if StrictCompare:206(===, v310, v250) goto (74, 95) for v250 is T{bool}
reaching type to CheckNull:368(v439 T{int}, NoSuchMethodError) for v439 is T{int}
reaching type to v312 <- RelationalOp(<=, v439 T{int}, v409) T{bool} for v439 is T{int}
reaching type to v312 <- RelationalOp(<=, v439 T{int}, v409) T{bool} for v409 is T{int}
reaching type to AssertBoolean:370(v312) for v312 is T{bool}
reaching type to Branch if StrictCompare:372(===, v312, v250) goto (96, 102) for v312 is T{bool}
reaching type to Branch if StrictCompare:372(===, v312, v250) goto (96, 102) for v250 is T{bool}
reaching type to CheckNull:378(v439 T{int}, NoSuchMethodError) for v439 is T{int}
reaching type to v314 <- RelationalOp(<, v439 T{int}, v409) T{bool} for v439 is T{int}
reaching type to v314 <- RelationalOp(<, v439 T{int}, v409) T{bool} for v409 is T{int}
reaching type to AssertBoolean:380(v314) for v314 is T{bool}
reaching type to Branch if StrictCompare:382(===, v314, v250) goto (99, 97) for v314 is T{bool}
reaching type to Branch if StrictCompare:382(===, v314, v250) goto (99, 97) for v250 is T{bool}
reaching type to v319 <- BinaryInt64Op(+ [tr], v282, v318) T{int} for v282 is T{int}
reaching type to v319 <- BinaryInt64Op(+ [tr], v282, v318) T{int} for v318 is T{_Smi}
reaching type to CheckNull:390(v316, NoSuchMethodError) for v316 is T{_Int64List?}
reaching type to v421 <- LoadField(v443 T{_Int64List} . TypedDataBase.length {final}) for v443 is T{_Int64List}
reaching type to v423 <- GenericCheckBound:392(v421, v319) for v421 is T{_Smi}
reaching type to v423 <- GenericCheckBound:392(v421, v319) for v319 is T{int}
reaching type to v425 <- LoadIndexed(v443 T{_Int64List}, v423) T{int} for v443 is T{_Int64List}
reaching type to v425 <- LoadIndexed(v443 T{_Int64List}, v423) T{int} for v423 is T{int}
reaching type to CheckNull:394(v437, NoSuchMethodError) for v437 is T{_Smi}
reaching type to v323 <- RelationalOp(>, v437, v425) T{bool} for v437 is T{_Smi}
reaching type to v323 <- RelationalOp(>, v437, v425) T{bool} for v425 is T{int}
reaching type to AssertBoolean:396(v323) for v323 is T{bool}
reaching type to Branch if StrictCompare:398(===, v323, v250) goto (100, 101) for v323 is T{bool}
reaching type to Branch if StrictCompare:398(===, v323, v250) goto (100, 101) for v250 is T{bool}
reaching type to v326 <- StaticCall:414( _throwFormatException@0150898<0> v240, v228, v219, v230, v325, result_type = T{int?}) for v240 is T{*?}
reaching type to v326 <- StaticCall:414( _throwFormatException@0150898<0> v240, v228, v219, v230, v325, result_type = T{int?}) for v228 is T{_StringBase}
reaching type to v326 <- StaticCall:414( _throwFormatException@0150898<0> v240, v228, v219, v230, v325, result_type = T{int?}) for v219 is T{Null?}
reaching type to v326 <- StaticCall:414( _throwFormatException@0150898<0> v240, v228, v219, v230, v325, result_type = T{int?}) for v230 is T{_Smi}
reaching type to v326 <- StaticCall:414( _throwFormatException@0150898<0> v240, v228, v219, v230, v325, result_type = T{int?}) for v325 is T{_OneByteString}
reaching type to Return:418(v326) for v326 is T{int?}
reaching type to v328 <- StaticCall:436( *<0> v439 T{int}, v280, using unchecked entrypoint, recognized_kind = Integer_mul, result_type = T{int}) T{num} for v439 is T{int}
reaching type to v328 <- StaticCall:436( *<0> v439 T{int}, v280, using unchecked entrypoint, recognized_kind = Integer_mul, result_type = T{int}) T{num} for v280 is T{*?}
reaching type to CheckNull:438(v437, NoSuchMethodError) for v437 is T{_Smi}
reaching type to v330 <- BinaryInt64Op(* [tr], v236, v437 T{_Smi?}) T{int} for v236 is T{int}
reaching type to v330 <- BinaryInt64Op(* [tr], v236, v437) T{int} for v437 is T{_Smi}
reaching type to v427 <- Redefinition(v328 ^ T{int}) T{int} for v328 is T{num}
reaching type to v332 <- BinaryInt64Op(+ [tr], v427, v330) T{int} for v427 is T{int}
reaching type to v332 <- BinaryInt64Op(+ [tr], v427, v330) T{int} for v330 is T{int}
reaching type to CheckNull:444(v304, NoSuchMethodError) for v304 is T{int?}
reaching type to v334 <- StaticCall:446( +<0> v445 T{int}, v257, using unchecked entrypoint, recognized_kind = Integer_add, result_type = T{int}) T{num} for v445 is T{int}
reaching type to v334 <- StaticCall:446( +<0> v445 T{int}, v257, using unchecked entrypoint, recognized_kind = Integer_add, result_type = T{int}) T{num} for v257 is T{*?}
reaching type to v429 <- Redefinition(v334 ^ T{int}) T{int} for v334 is T{num}
reaching type to v336 <- RelationalOp(<=, v429, v234) T{bool} for v429 is T{int}
reaching type to v336 <- RelationalOp(<=, v429, v234) T{bool} for v234 is T{int}
reaching type to AssertBoolean:450(v336) for v336 is T{bool}
reaching type to Branch if StrictCompare:452(===, v336, v250) goto (106, 107) for v336 is T{bool}
reaching type to Branch if StrictCompare:452(===, v336, v250) goto (106, 107) for v250 is T{bool}
reaching type to Return:470(v332) for v332 is T{int}
reaching type to v300 <- phi(v269, v445 T{int}) alive T{int?} for v445 is T{int}
reaching type to v302 <- phi(v271, v332) alive T{int?} for v332 is T{int}
reaching type to v304 <- phi(v298, v429) alive T{int?} for v429 is T{int}
reaching type to CheckNull:212(v439 T{int}, NoSuchMethodError) for v439 is T{int}
reaching type to CheckNull:212(v441 T{int}, NoSuchMethodError) for v441 is T{int}
reaching type to v338 <- RelationalOp(>, v439 T{int}, v441 T{int?}) T{bool} for v439 is T{int}
reaching type to v338 <- RelationalOp(>, v439 T{int}, v441 T{int}) T{bool} for v441 is T{int}
reaching type to AssertBoolean:214(v338) for v338 is T{bool}
reaching type to Branch if StrictCompare:216(===, v338, v250) goto (77, 75) for v338 is T{bool}
reaching type to Branch if StrictCompare:216(===, v338, v250) goto (77, 75) for v250 is T{bool}
reaching type to v342 <- BinaryInt64Op(+ [tr], v282, v242) T{int} for v282 is T{int}
reaching type to v342 <- BinaryInt64Op(+ [tr], v282, v242) T{int} for v242 is T{_Smi}
reaching type to CheckNull:224(v340, NoSuchMethodError) for v340 is T{_Int64List?}
reaching type to v411 <- LoadField(v447 T{_Int64List} . TypedDataBase.length {final}) for v447 is T{_Int64List}
reaching type to v413 <- GenericCheckBound:226(v411, v342) for v411 is T{_Smi}
reaching type to v413 <- GenericCheckBound:226(v411, v342) for v342 is T{int}
reaching type to v415 <- LoadIndexed(v447 T{_Int64List}, v413) T{int} for v447 is T{_Int64List}
reaching type to v415 <- LoadIndexed(v447 T{_Int64List}, v413) T{int} for v413 is T{int}
reaching type to CheckNull:228(v437, NoSuchMethodError) for v437 is T{_Smi}
reaching type to v346 <- RelationalOp(>, v437, v415) T{bool} for v437 is T{_Smi}
reaching type to v346 <- RelationalOp(>, v437, v415) T{bool} for v415 is T{int}
reaching type to AssertBoolean:230(v346) for v346 is T{bool}
reaching type to Branch if StrictCompare:232(===, v346, v250) goto (78, 94) for v346 is T{bool}
reaching type to Branch if StrictCompare:232(===, v346, v250) goto (78, 94) for v250 is T{bool}
reaching type to AssertBoolean:250(v348) for v348 is T{bool?}
reaching type to Branch if StrictCompare:252(===, v348, v250) goto (79, 80) for v348 is T{bool?}
reaching type to Branch if StrictCompare:252(===, v348, v250) goto (79, 80) for v250 is T{bool}
reaching type to v350 <- phi(v277, v251) alive T{*?} for v251 is T{_Smi}
reaching type to AssertBoolean:268(v238) for v238 is T{bool}
reaching type to Branch if StrictCompare:270(===, v238, v250) goto (84, 90) for v238 is T{bool}
reaching type to Branch if StrictCompare:270(===, v238, v250) goto (84, 90) for v250 is T{bool}
reaching type to v353 <- StaticCall:358( _throwFormatException@0150898<0> v240, v228, v219, v230, v352, result_type = T{int?}) for v240 is T{*?}
reaching type to v353 <- StaticCall:358( _throwFormatException@0150898<0> v240, v228, v219, v230, v352, result_type = T{int?}) for v228 is T{_StringBase}
reaching type to v353 <- StaticCall:358( _throwFormatException@0150898<0> v240, v228, v219, v230, v352, result_type = T{int?}) for v219 is T{Null?}
reaching type to v353 <- StaticCall:358( _throwFormatException@0150898<0> v240, v228, v219, v230, v352, result_type = T{int?}) for v230 is T{_Smi}
reaching type to v353 <- StaticCall:358( _throwFormatException@0150898<0> v240, v228, v219, v230, v352, result_type = T{int?}) for v352 is T{_OneByteString}
reaching type to Return:362(v353) for v353 is T{int?}
reaching type to v356 <- StaticCall:274( []<0> v355, v350, recognized_kind = ImmutableArrayGetIndexed) T{*?} for v355 is T{_ImmutableList}
reaching type to v356 <- StaticCall:274( []<0> v355, v350, recognized_kind = ImmutableArrayGetIndexed) T{*?} for v350 is T{*?}
reaching type to v358 <- StaticCall:276( >=<0> v439 T{int}, v356, using unchecked entrypoint, recognized_kind = Integer_greaterEqualThan, result_type = T{bool}) for v439 is T{int}
reaching type to v358 <- StaticCall:276( >=<0> v439 T{int}, v356, using unchecked entrypoint, recognized_kind = Integer_greaterEqualThan, result_type = T{bool}) for v356 is T{*?}
reaching type to AssertBoolean:278(v358) for v358 is T{bool}
reaching type to Branch if StrictCompare:280(===, v358, v250) goto (83, 86) for v358 is T{bool}
reaching type to Branch if StrictCompare:280(===, v358, v250) goto (83, 86) for v250 is T{bool}
reaching type to v360 <- StaticCall:310( +<0> v304, v257, using unchecked entrypoint, recognized_kind = Integer_add, result_type = T{int}) T{num} for v304 is T{int?}
reaching type to v360 <- StaticCall:310( +<0> v304, v257, using unchecked entrypoint, recognized_kind = Integer_add, result_type = T{int}) T{num} for v257 is T{*?}
reaching type to v417 <- Redefinition(v360 ^ T{int}) T{int} for v360 is T{num}
reaching type to v362 <- RelationalOp(>, v417, v234) T{bool} for v417 is T{int}
reaching type to v362 <- RelationalOp(>, v417, v234) T{bool} for v234 is T{int}
reaching type to AssertBoolean:314(v362) for v362 is T{bool}
reaching type to Branch if StrictCompare:316(===, v362, v250) goto (88, 93) for v362 is T{bool}
reaching type to Branch if StrictCompare:316(===, v362, v250) goto (88, 93) for v250 is T{bool}
reaching type to v364 <- StaticCall:332( *<0> v439 T{int}, v280, using unchecked entrypoint, recognized_kind = Integer_mul, result_type = T{int}) T{num} for v439 is T{int}
reaching type to v364 <- StaticCall:332( *<0> v439 T{int}, v280, using unchecked entrypoint, recognized_kind = Integer_mul, result_type = T{int}) T{num} for v280 is T{*?}
reaching type to v419 <- Redefinition(v364 ^ T{int}) T{int} for v364 is T{num}
reaching type to CheckNull:334(v437, NoSuchMethodError) for v437 is T{_Smi}
reaching type to v366 <- BinaryInt64Op(+ [tr], v419, v437 T{_Smi?}) T{int} for v419 is T{int}
reaching type to v366 <- BinaryInt64Op(+ [tr], v419, v437) T{int} for v437 is T{_Smi}
reaching type to Return:338(v366) for v366 is T{int}
reaching type to v368 <- StaticCall:284( []<0> v355, v350, recognized_kind = ImmutableArrayGetIndexed) T{*?} for v355 is T{_ImmutableList}
reaching type to v368 <- StaticCall:284( []<0> v355, v350, recognized_kind = ImmutableArrayGetIndexed) T{*?} for v350 is T{*?}
reaching type to v370 <- StaticCall:286( ><0> v439 T{int}, v368, using unchecked entrypoint, recognized_kind = Integer_greaterThan, result_type = T{bool}) for v439 is T{int}
reaching type to v370 <- StaticCall:286( ><0> v439 T{int}, v368, using unchecked entrypoint, recognized_kind = Integer_greaterThan, result_type = T{bool}) for v368 is T{*?}
reaching type to AssertBoolean:288(v370) for v370 is T{bool}
reaching type to Branch if StrictCompare:290(===, v370, v250) goto (91, 82) for v370 is T{bool}
reaching type to Branch if StrictCompare:290(===, v370, v250) goto (91, 82) for v250 is T{bool}
reaching type to v373 <- StaticCall:294( []<0> v372, v350, recognized_kind = ImmutableArrayGetIndexed) T{*?} for v372 is T{_ImmutableList}
reaching type to v373 <- StaticCall:294( []<0> v372, v350, recognized_kind = ImmutableArrayGetIndexed) T{*?} for v350 is T{*?}
reaching type to v375 <- StaticCall:296( ><0> v437, v373, using unchecked entrypoint, recognized_kind = Integer_greaterThan, result_type = T{bool}) for v437 is T{_Smi}
reaching type to v375 <- StaticCall:296( ><0> v437, v373, using unchecked entrypoint, recognized_kind = Integer_greaterThan, result_type = T{bool}) for v373 is T{*?}
reaching type to AssertBoolean:298(v375) for v375 is T{bool}
reaching type to Branch if StrictCompare:300(===, v375, v250) goto (92, 87) for v375 is T{bool}
reaching type to Branch if StrictCompare:300(===, v375, v250) goto (92, 87) for v250 is T{bool}
reaching type to v350 <- phi(v277, v251) alive T{*?} for v277 is T{_Smi}
reaching type to v377 <- StaticCall:194( _throwFormatException@0150898<0> v240, v228, v300, v230, v219, result_type = T{int?}) for v240 is T{*?}
reaching type to v377 <- StaticCall:194( _throwFormatException@0150898<0> v240, v228, v300, v230, v219, result_type = T{int?}) for v228 is T{_StringBase}
reaching type to v377 <- StaticCall:194( _throwFormatException@0150898<0> v240, v228, v300, v230, v219, result_type = T{int?}) for v300 is T{int?}
reaching type to v377 <- StaticCall:194( _throwFormatException@0150898<0> v240, v228, v300, v230, v219, result_type = T{int?}) for v230 is T{_Smi}
reaching type to v377 <- StaticCall:194( _throwFormatException@0150898<0> v240, v228, v300, v230, v219, result_type = T{int?}) for v219 is T{Null?}
reaching type to Return:198(v377) for v377 is T{int?}
reaching type to v379 <- StaticCall:166( _initInt64OverflowLimits@0150898<0> v282, v280, result_type = T{int?}) for v282 is T{int}
reaching type to v379 <- StaticCall:166( _initInt64OverflowLimits@0150898<0> v282, v280, result_type = T{int?}) for v280 is T{*?}
reaching type to v290 <- phi(v379, v403) alive T{int?} for v379 is T{int?}
reaching type to CheckNull:110(v431 T{int}, NoSuchMethodError) for v431 is T{int}
reaching type to v381 <- BinaryInt64Op(+ [tr], v232, v431 T{int?}) T{int} for v232 is T{int}
reaching type to v381 <- BinaryInt64Op(+ [tr], v232, v431 T{int}) T{int} for v431 is T{int}
reaching type to v383 <- StaticCall:112( _parseBlock@0150898<0> v228, v230, v232, v381, result_type = T{_Smi?}) T{_Smi?} for v228 is T{_StringBase}
reaching type to v383 <- StaticCall:112( _parseBlock@0150898<0> v228, v230, v232, v381, result_type = T{_Smi?}) T{_Smi?} for v230 is T{_Smi}
reaching type to v383 <- StaticCall:112( _parseBlock@0150898<0> v228, v230, v232, v381, result_type = T{_Smi?}) T{_Smi?} for v232 is T{int}
reaching type to v383 <- StaticCall:112( _parseBlock@0150898<0> v228, v230, v232, v381, result_type = T{_Smi?}) T{_Smi?} for v381 is T{int}
reaching type to Branch if StrictCompare:114(===, v383, v219, with number check) goto (65, 66) for v383 is T{_Smi?}
reaching type to Branch if StrictCompare:114(===, v383, v219, with number check) goto (65, 66) for v219 is T{Null?}
reaching type to v449 <- Redefinition(v383 ^ T{_Smi}) for v383 is T{_Smi?}
reaching type to CheckNull:128(v449, NoSuchMethodError) for v449 is T{_Smi}
reaching type to v385 <- BinaryInt64Op(* [tr], v236, v449 T{_Smi?}) T{int} for v236 is T{int}
reaching type to v385 <- BinaryInt64Op(* [tr], v236, v449) T{int} for v449 is T{_Smi}
reaching type to v269 <- phi(v381, v232) alive T{int?} for v381 is T{int}
reaching type to v271 <- phi(v385, v251) alive T{} for v385 is T{int}
reaching type to v387 <- StaticCall:120( _throwFormatException@0150898<0> v240, v228, v232, v230, v219, result_type = T{int?}) for v240 is T{*?}
reaching type to v387 <- StaticCall:120( _throwFormatException@0150898<0> v240, v228, v232, v230, v219, result_type = T{int?}) for v228 is T{_StringBase}
reaching type to v387 <- StaticCall:120( _throwFormatException@0150898<0> v240, v228, v232, v230, v219, result_type = T{int?}) for v232 is T{int}
reaching type to v387 <- StaticCall:120( _throwFormatException@0150898<0> v240, v228, v232, v230, v219, result_type = T{int?}) for v230 is T{_Smi}
reaching type to v387 <- StaticCall:120( _throwFormatException@0150898<0> v240, v228, v232, v230, v219, result_type = T{int?}) for v219 is T{Null?}
reaching type to Return:124(v387) for v387 is T{int?}
reaching type to v389 <- StaticCall:84( -<0> v263, v257, using unchecked entrypoint, recognized_kind = Integer_sub, result_type = T{int}) for v263 is T{int?}
reaching type to v389 <- StaticCall:84( -<0> v263, v257, using unchecked entrypoint, recognized_kind = Integer_sub, result_type = T{int}) for v257 is T{*?}
reaching type to v263 <- phi(v259, v389) alive T{int?} for v389 is T{num}
reaching type to v391 <- StaticCall:50( _parseBlock@0150898<0> v228, v230, v232, v234, result_type = T{_Smi?}) T{_Smi?} for v228 is T{_StringBase}
reaching type to v391 <- StaticCall:50( _parseBlock@0150898<0> v228, v230, v232, v234, result_type = T{_Smi?}) T{_Smi?} for v230 is T{_Smi}
reaching type to v391 <- StaticCall:50( _parseBlock@0150898<0> v228, v230, v232, v234, result_type = T{_Smi?}) T{_Smi?} for v232 is T{int}
reaching type to v391 <- StaticCall:50( _parseBlock@0150898<0> v228, v230, v232, v234, result_type = T{_Smi?}) T{_Smi?} for v234 is T{int}
reaching type to Branch if StrictCompare:52(===, v391, v219, with number check) goto (58, 59) for v391 is T{_Smi?}
reaching type to Branch if StrictCompare:52(===, v391, v219, with number check) goto (58, 59) for v219 is T{Null?}
reaching type to v451 <- Redefinition(v391 ^ T{_Smi}) for v391 is T{_Smi?}
reaching type to CheckNull:66(v451, NoSuchMethodError) for v451 is T{_Smi}
reaching type to v393 <- BinaryInt64Op(* [tr], v236, v451 T{_Smi?}) T{int} for v236 is T{int}
reaching type to v393 <- BinaryInt64Op(* [tr], v236, v451) T{int} for v451 is T{_Smi}
reaching type to Return:70(v393) for v393 is T{int}
reaching type to v395 <- StaticCall:58( _throwFormatException@0150898<0> v240, v228, v232, v230, v219, result_type = T{int?}) for v240 is T{*?}
reaching type to v395 <- StaticCall:58( _throwFormatException@0150898<0> v240, v228, v232, v230, v219, result_type = T{int?}) for v228 is T{_StringBase}
reaching type to v395 <- StaticCall:58( _throwFormatException@0150898<0> v240, v228, v232, v230, v219, result_type = T{int?}) for v232 is T{int}
reaching type to v395 <- StaticCall:58( _throwFormatException@0150898<0> v240, v228, v232, v230, v219, result_type = T{int?}) for v230 is T{_Smi}
reaching type to v395 <- StaticCall:58( _throwFormatException@0150898<0> v240, v228, v232, v230, v219, result_type = T{int?}) for v219 is T{Null?}
reaching type to Return:62(v395) for v395 is T{int?}
reaching type to v252 <- phi(v242, v251) alive T{*?} for v242 is T{_Smi}
recomputing type of v350: T{}
  phi 350 input 0: v277 has reaching type T{_Smi}
  phi 350 input 1: v251 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v356: T{*?}
recomputing type of v368: T{*?}
recomputing type of v373: T{*?}
recomputing type of v304: T{}
  phi 304 input 0: v298 has reaching type T{num}
  phi 304 input 1: v429 has reaching type T{int}
  ... new type T{num}
recomputing type of v308: T{_Smi?}
recomputing type of v445: T{int}
  ... new type T{num}
recomputing type of v300: T{}
  phi 300 input 0: v269 has reaching type T{}
  phi 300 input 1: v445 has reaching type T{int}
  ... new type T{int}
recomputing type of v308: T{_Smi?}
recomputing type of v377: T{int?}
recomputing type of v334: T{num}
recomputing type of v360: T{num}
recomputing type of v302: T{}
  phi 302 input 0: v271 has reaching type T{}
  phi 302 input 1: v332 has reaching type T{int}
  ... new type T{int}
recomputing type of v439: T{int}
  ... new type T{int}
recomputing type of v314: T{bool}
recomputing type of v312: T{bool}
recomputing type of v338: T{bool}
recomputing type of v310: T{bool}
recomputing type of v370: T{bool}
recomputing type of v364: T{num}
recomputing type of v358: T{bool}
recomputing type of v328: T{num}
recomputing type of v300: T{int}
  phi 300 input 0: v269 has reaching type T{}
  phi 300 input 1: v445 has reaching type T{int}
recomputing type of v290: T{}
  phi 290 input 0: v379 has reaching type T{int?}
  phi 290 input 1: v403 has reaching type T{int}
  ... new type T{int?}
recomputing type of v441: T{int}
  ... new type T{int}
recomputing type of v338: T{bool}
recomputing type of v310: T{bool}
recomputing type of v271: T{}
  phi 271 input 0: v385 has reaching type T{int}
  phi 271 input 1: v251 has reaching type T{_Smi}
  ... new type T{int}
recomputing type of v302: T{int}
  phi 302 input 0: v271 has reaching type T{int}
  phi 302 input 1: v332 has reaching type T{int}
recomputing type of v269: T{}
  phi 269 input 0: v381 has reaching type T{int}
  phi 269 input 1: v232 has reaching type T{int}
  ... new type T{int}
recomputing type of v298: T{num}
recomputing type of v300: T{int}
  phi 300 input 0: v269 has reaching type T{int}
  phi 300 input 1: v445 has reaching type T{int}
recomputing type of v263: T{}
  phi 263 input 0: v259 has reaching type T{int}
  phi 263 input 1: v389 has reaching type T{num}
  ... new type T{num}
recomputing type of v265: T{bool}
recomputing type of v389: T{num}
recomputing type of v431: T{int}
  ... new type T{num}
recomputing type of v381: T{int}
recomputing type of v267: T{bool}
recomputing type of v252: T{}
  phi 252 input 0: v242 has reaching type T{_Smi}
  phi 252 input 1: v251 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v254: T{num}
reaching type to v224 <- StaticCall:12( get:length<0> v222, recognized_kind = StringBaseLength, result_type = T{_Smi}) T{_Smi} for v222 is T{_StringBase}
reaching type to v227 <- phi(v226, v237) alive T{int?} for v226 is T{_Smi}
reaching type to CheckNull:16(v227, NoSuchMethodError) for v227 is T{int?}
reaching type to v229 <- RelationalOp(<, v239 T{int}, v224) T{bool} for v239 is T{int}
reaching type to v229 <- RelationalOp(<, v239 T{int}, v224) T{bool} for v224 is T{_Smi}
reaching type to AssertBoolean:18(v229) for v229 is T{bool}
reaching type to Branch if StrictCompare:20(===, v229, v231) goto (54, 55) for v229 is T{bool}
reaching type to Branch if StrictCompare:20(===, v229, v231) goto (54, 55) for v231 is T{bool}
reaching type to Return:62(v239 T{int}) for v239 is T{int}
reaching type to v232 <- InstanceCall:30( codeUnitAt<0>, v222, v239 IC[0: ], result_type = T{_Smi} using unchecked entrypoint) for v222 is T{_StringBase}
reaching type to v232 <- InstanceCall:30( codeUnitAt<0>, v222, v239 T{int} IC[0: ], result_type = T{_Smi} using unchecked entrypoint) for v239 is T{int}
reaching type to v234 <- InstanceCall:32( _isWhitespace@0150898<0>, v222, v232 IC[0: ], result_type = T{bool} using unchecked entrypoint) for v222 is T{_StringBase}
reaching type to v234 <- InstanceCall:32( _isWhitespace@0150898<0>, v222, v232 IC[0: ], result_type = T{bool} using unchecked entrypoint) for v232 is T{_Smi}
reaching type to AssertBoolean:34(v234) for v234 is T{bool}
reaching type to Branch if StrictCompare:36(!==, v234, v231) goto (56, 58) for v234 is T{bool}
reaching type to Branch if StrictCompare:36(!==, v234, v231) goto (56, 58) for v231 is T{bool}
reaching type to CheckNull:28(v239 T{int}, NoSuchMethodError) for v239 is T{int}
reaching type to v237 <- BinaryInt64Op(+ [tr], v239 T{int}, v236) T{int} for v239 is T{int}
reaching type to v237 <- BinaryInt64Op(+ [tr], v239 T{int}, v236) T{int} for v236 is T{_Smi}
reaching type to v227 <- phi(v226, v237) alive T{int?} for v237 is T{int}
recomputing type of v227: T{}
  phi 227 input 0: v226 has reaching type T{_Smi}
  phi 227 input 1: v237 has reaching type T{int}
  ... new type T{int}
recomputing type of v239: T{int}
  ... new type T{int}
recomputing type of v237: T{int}
recomputing type of v229: T{bool}
recomputing type of v232: T{_Smi}
reaching type to v224 <- LoadField(v222 . String.length {final}) for v222 is T{_StringBase}
reaching type to Return:10(v224) for v224 is T{_Smi}
reaching type to v231 <- StaticCall:12( get:length<0> v229, recognized_kind = StringBaseLength, result_type = T{_Smi}) T{_Smi} for v229 is T{_StringBase}
reaching type to v234 <- BinaryInt64Op(- [tr], v231, v233) T{int} for v231 is T{_Smi}
reaching type to v234 <- BinaryInt64Op(- [tr], v231, v233) T{int} for v233 is T{_Smi}
reaching type to v236 <- phi(v234, v246) alive T{int?} for v234 is T{int}
reaching type to CheckNull:16(v236, NoSuchMethodError) for v236 is T{int?}
reaching type to v239 <- RelationalOp(>=, v248 T{int}, v238) T{bool} for v248 is T{int}
reaching type to v239 <- RelationalOp(>=, v248 T{int}, v238) T{bool} for v238 is T{_Smi}
reaching type to AssertBoolean:18(v239) for v239 is T{bool}
reaching type to Branch if StrictCompare:20(===, v239, v241) goto (56, 57) for v239 is T{bool}
reaching type to Branch if StrictCompare:20(===, v239, v241) goto (56, 57) for v241 is T{bool}
reaching type to Return:62(v248 T{int}) for v248 is T{int}
reaching type to v242 <- InstanceCall:30( codeUnitAt<0>, v229, v248 IC[0: ], result_type = T{_Smi} using unchecked entrypoint) for v229 is T{_StringBase}
reaching type to v242 <- InstanceCall:30( codeUnitAt<0>, v229, v248 T{int} IC[0: ], result_type = T{_Smi} using unchecked entrypoint) for v248 is T{int}
reaching type to v244 <- InstanceCall:32( _isWhitespace@0150898<0>, v229, v242 IC[0: ], result_type = T{bool} using unchecked entrypoint) for v229 is T{_StringBase}
reaching type to v244 <- InstanceCall:32( _isWhitespace@0150898<0>, v229, v242 IC[0: ], result_type = T{bool} using unchecked entrypoint) for v242 is T{_Smi}
reaching type to AssertBoolean:34(v244) for v244 is T{bool}
reaching type to Branch if StrictCompare:36(!==, v244, v241) goto (58, 60) for v244 is T{bool}
reaching type to Branch if StrictCompare:36(!==, v244, v241) goto (58, 60) for v241 is T{bool}
reaching type to CheckNull:28(v248 T{int}, NoSuchMethodError) for v248 is T{int}
reaching type to v246 <- BinaryInt64Op(- [tr], v248 T{int}, v233) T{int} for v248 is T{int}
reaching type to v246 <- BinaryInt64Op(- [tr], v248 T{int}, v233) T{int} for v233 is T{_Smi}
reaching type to v236 <- phi(v234, v246) alive T{int?} for v246 is T{int}
recomputing type of v236: T{}
  phi 236 input 0: v234 has reaching type T{int}
  phi 236 input 1: v246 has reaching type T{int}
  ... new type T{int}
recomputing type of v248: T{int}
  ... new type T{int}
recomputing type of v246: T{int}
recomputing type of v239: T{bool}
recomputing type of v242: T{_Smi}
reaching type to v5 <- StaticCall:12( _lastNonWhitespace@0150898<0> v2, using unchecked entrypoint, result_type = T{int}) T{int} for v2 is T{_StringBase}
reaching type to v8 <- BinaryInt64Op(+ [tr], v5, v7) T{int} for v5 is T{int}
reaching type to v8 <- BinaryInt64Op(+ [tr], v5, v7) T{int} for v7 is T{_Smi}
reaching type to v11 <- EqualityCompare(v8 == v10) T{bool} for v8 is T{int}
reaching type to v11 <- EqualityCompare(v8 == v10) T{bool} for v10 is T{_Smi}
reaching type to AssertBoolean:18(v11) for v11 is T{bool}
reaching type to Branch if StrictCompare:20(===, v11, v13) goto (3, 4) for v11 is T{bool}
reaching type to Branch if StrictCompare:20(===, v11, v13) goto (3, 4) for v13 is T{bool}
reaching type to v14 <- StaticCall:36( _firstNonWhitespace@0150898<0> v2, using unchecked entrypoint, result_type = T{int}) T{int} for v2 is T{_StringBase}
reaching type to v216 <- LoadClassId(v2) for v2 is T{_StringBase}
reaching type to Branch if StrictCompare:38(===, v216, v128) goto (43, 48) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v128) goto (43, 48) for v128 is T{_Smi}
reaching type to v226 <- Redefinition(v2 ^ T{_TwoByteString}) for v2 is T{_StringBase}
reaching type to v176 <- Redefinition(v226) for v226 is T{_TwoByteString}
reaching type to v177 <- LoadField(v176 . String.length {final}) for v176 is T{_TwoByteString}
reaching type to v179 <- GenericCheckBound:38(v177, v14) for v177 is T{_Smi}
reaching type to v179 <- GenericCheckBound:38(v177, v14) for v14 is T{int}
reaching type to v181 <- LoadIndexed(v176, v179) for v176 is T{_TwoByteString}
reaching type to v181 <- LoadIndexed(v176, v179) for v179 is T{int}
reaching type to v183 <- BoxInt64(v181) for v181 is T{_Smi}
reaching type to v217 <- phi(v183, v194, v205, v214) alive T{} for v183 is T{int}
reaching type to Branch if StrictCompare:38(===, v216, v129) goto (44, 49) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v129) goto (44, 49) for v129 is T{_Smi}
reaching type to v228 <- Redefinition(v2 ^ T{_ExternalOneByteString}) for v2 is T{_StringBase}
reaching type to v185 <- Redefinition(v228) for v228 is T{_ExternalOneByteString}
reaching type to v186 <- LoadField(v185 . String.length {final}) for v185 is T{_ExternalOneByteString}
reaching type to v188 <- GenericCheckBound:38(v186, v14) for v186 is T{_Smi}
reaching type to v188 <- GenericCheckBound:38(v186, v14) for v14 is T{int}
reaching type to v190 <- LoadUntagged(v185, 16) for v185 is T{_ExternalOneByteString}
reaching type to v192 <- LoadIndexed(v190, v188) for v190 is T{*?}
reaching type to v192 <- LoadIndexed(v190, v188) for v188 is T{int}
reaching type to v194 <- BoxInt64(v192) for v192 is T{_Smi}
reaching type to v217 <- phi(v183, v194, v205, v214) alive T{} for v194 is T{int}
reaching type to Branch if StrictCompare:38(===, v216, v130) goto (45, 50) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v130) goto (45, 50) for v130 is T{_Smi}
reaching type to v230 <- Redefinition(v2 ^ T{_ExternalTwoByteString}) for v2 is T{_StringBase}
reaching type to v196 <- Redefinition(v230) for v230 is T{_ExternalTwoByteString}
reaching type to v197 <- LoadField(v196 . String.length {final}) for v196 is T{_ExternalTwoByteString}
reaching type to v199 <- GenericCheckBound:38(v197, v14) for v197 is T{_Smi}
reaching type to v199 <- GenericCheckBound:38(v197, v14) for v14 is T{int}
reaching type to v201 <- LoadUntagged(v196, 16) for v196 is T{_ExternalTwoByteString}
reaching type to v203 <- LoadIndexed(v201, v199) for v201 is T{*?}
reaching type to v203 <- LoadIndexed(v201, v199) for v199 is T{int}
reaching type to v205 <- BoxInt64(v203) for v203 is T{_Smi}
reaching type to v217 <- phi(v183, v194, v205, v214) alive T{} for v205 is T{int}
reaching type to v207 <- Redefinition(v2) for v2 is T{_StringBase}
reaching type to v208 <- LoadField(v207 . String.length {final}) for v207 is T{_StringBase}
reaching type to v210 <- GenericCheckBound:38(v208, v14) for v208 is T{_Smi}
reaching type to v210 <- GenericCheckBound:38(v208, v14) for v14 is T{int}
reaching type to v212 <- LoadIndexed(v207, v210) for v207 is T{_StringBase}
reaching type to v212 <- LoadIndexed(v207, v210) for v210 is T{int}
reaching type to v214 <- BoxInt64(v212) for v212 is T{_Smi}
reaching type to v217 <- phi(v183, v194, v205, v214) alive T{} for v214 is T{int}
reaching type to v19 <- EqualityCompare(v217 T{_Smi} == v18) T{bool} for v217 is T{_Smi}
reaching type to v19 <- EqualityCompare(v217 T{_Smi} == v18) T{bool} for v18 is T{_Smi}
reaching type to AssertBoolean:44(v19) for v19 is T{bool}
reaching type to Branch if StrictCompare:46(===, v19, v13) goto (7, 5) for v19 is T{bool}
reaching type to Branch if StrictCompare:46(===, v19, v13) goto (7, 5) for v13 is T{bool}
reaching type to v22 <- EqualityCompare(v217 T{_Smi} == v21) T{bool} for v217 is T{_Smi}
reaching type to v22 <- EqualityCompare(v217 T{_Smi} == v21) T{bool} for v21 is T{_Smi}
reaching type to AssertBoolean:52(v22) for v22 is T{bool}
reaching type to Branch if StrictCompare:54(===, v22, v13) goto (8, 11) for v22 is T{bool}
reaching type to Branch if StrictCompare:54(===, v22, v13) goto (8, 11) for v13 is T{bool}
reaching type to v24 <- phi(v14, v69) alive T{int} for v14 is T{int}
reaching type to v26 <- phi(v217, v174 T{_Smi}) alive T{_Smi} for v217 is T{}
reaching type to v28 <- phi(v7, v67) alive T{int} for v7 is T{_Smi}
reaching type to Branch if StrictCompare:102(===, v3, v0, with number check) goto (13, 23) for v3 is T{_Smi?}
reaching type to Branch if StrictCompare:102(===, v3, v0, with number check) goto (13, 23) for v0 is T{Null?}
reaching type to v81 <- Redefinition(v3 ^ T{_Smi}) T{_Smi} for v3 is T{_Smi?}
reaching type to v30 <- phi(v42, v81) alive T{_Smi} for v81 is T{_Smi}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v30 is T{_Smi}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v24 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v8 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v28 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v34 is T{bool}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to Return:204(v35) for v35 is T{int?}
reaching type to v38 <- StrictCompare(===, v26, v37) T{bool} for v26 is T{_Smi}
reaching type to v38 <- StrictCompare(===, v26, v37) T{bool} for v37 is T{_Smi}
reaching type to AssertBoolean:112(v38) for v38 is T{bool}
reaching type to Branch if StrictCompare:114(===, v38, v13) goto (14, 21) for v38 is T{bool}
reaching type to Branch if StrictCompare:114(===, v38, v13) goto (14, 21) for v13 is T{bool}
reaching type to v30 <- phi(v42, v81) alive T{_Smi} for v42 is T{_Smi}
reaching type to v83 <- CheckNull:120(v24, NoSuchMethodError) T{int} for v24 is T{int}
reaching type to v43 <- BinaryInt64Op(+ [tr], v83 T{int}, v7) T{int} for v83 is T{int}
reaching type to v43 <- BinaryInt64Op(+ [tr], v83 T{int}, v7) T{int} for v7 is T{_Smi}
reaching type to v45 <- EqualityCompare(v43 == v8) T{bool} for v43 is T{int}
reaching type to v45 <- EqualityCompare(v43 == v8) T{bool} for v8 is T{int}
reaching type to AssertBoolean:124(v45) for v45 is T{bool}
reaching type to Branch if StrictCompare:126(===, v45, v13) goto (15, 16) for v45 is T{bool}
reaching type to Branch if StrictCompare:126(===, v45, v13) goto (15, 16) for v13 is T{bool}
reaching type to v127 <- LoadClassId(v2) for v2 is T{_StringBase}
reaching type to Branch if StrictCompare:138(===, v127, v128) goto (25, 30) for v127 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v127, v128) goto (25, 30) for v128 is T{_Smi}
reaching type to v232 <- Redefinition(v2 ^ T{_TwoByteString}) for v2 is T{_StringBase}
reaching type to v87 <- Redefinition(v232) for v232 is T{_TwoByteString}
reaching type to v88 <- LoadField(v87 . String.length {final}) for v87 is T{_TwoByteString}
reaching type to v90 <- GenericCheckBound:138(v88, v43) for v88 is T{_Smi}
reaching type to v90 <- GenericCheckBound:138(v88, v43) for v43 is T{int}
reaching type to v92 <- LoadIndexed(v87, v90) for v87 is T{_TwoByteString}
reaching type to v92 <- LoadIndexed(v87, v90) for v90 is T{int}
reaching type to v94 <- BoxInt64(v92) for v92 is T{_Smi}
reaching type to v131 <- phi(v94, v105, v116, v125) alive T{} for v94 is T{int}
reaching type to Branch if StrictCompare:138(===, v127, v129) goto (26, 31) for v127 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v127, v129) goto (26, 31) for v129 is T{_Smi}
reaching type to v234 <- Redefinition(v2 ^ T{_ExternalOneByteString}) for v2 is T{_StringBase}
reaching type to v96 <- Redefinition(v234) for v234 is T{_ExternalOneByteString}
reaching type to v97 <- LoadField(v96 . String.length {final}) for v96 is T{_ExternalOneByteString}
reaching type to v99 <- GenericCheckBound:138(v97, v43) for v97 is T{_Smi}
reaching type to v99 <- GenericCheckBound:138(v97, v43) for v43 is T{int}
reaching type to v101 <- LoadUntagged(v96, 16) for v96 is T{_ExternalOneByteString}
reaching type to v103 <- LoadIndexed(v101, v99) for v101 is T{*?}
reaching type to v103 <- LoadIndexed(v101, v99) for v99 is T{int}
reaching type to v105 <- BoxInt64(v103) for v103 is T{_Smi}
reaching type to v131 <- phi(v94, v105, v116, v125) alive T{} for v105 is T{int}
reaching type to Branch if StrictCompare:138(===, v127, v130) goto (27, 32) for v127 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v127, v130) goto (27, 32) for v130 is T{_Smi}
reaching type to v236 <- Redefinition(v2 ^ T{_ExternalTwoByteString}) for v2 is T{_StringBase}
reaching type to v107 <- Redefinition(v236) for v236 is T{_ExternalTwoByteString}
reaching type to v108 <- LoadField(v107 . String.length {final}) for v107 is T{_ExternalTwoByteString}
reaching type to v110 <- GenericCheckBound:138(v108, v43) for v108 is T{_Smi}
reaching type to v110 <- GenericCheckBound:138(v108, v43) for v43 is T{int}
reaching type to v112 <- LoadUntagged(v107, 16) for v107 is T{_ExternalTwoByteString}
reaching type to v114 <- LoadIndexed(v112, v110) for v112 is T{*?}
reaching type to v114 <- LoadIndexed(v112, v110) for v110 is T{int}
reaching type to v116 <- BoxInt64(v114) for v114 is T{_Smi}
reaching type to v131 <- phi(v94, v105, v116, v125) alive T{} for v116 is T{int}
reaching type to v118 <- Redefinition(v2) for v2 is T{_StringBase}
reaching type to v119 <- LoadField(v118 . String.length {final}) for v118 is T{_StringBase}
reaching type to v121 <- GenericCheckBound:138(v119, v43) for v119 is T{_Smi}
reaching type to v121 <- GenericCheckBound:138(v119, v43) for v43 is T{int}
reaching type to v123 <- LoadIndexed(v118, v121) for v118 is T{_StringBase}
reaching type to v123 <- LoadIndexed(v118, v121) for v121 is T{int}
reaching type to v125 <- BoxInt64(v123) for v123 is T{_Smi}
reaching type to v131 <- phi(v94, v105, v116, v125) alive T{} for v125 is T{int}
reaching type to v50 <- BinaryInt64Op(| [tr], v131 T{_Smi}, v49) T{int} for v131 is T{_Smi}
reaching type to v50 <- BinaryInt64Op(| [tr], v131 T{_Smi}, v49) T{int} for v49 is T{_Smi}
reaching type to v53 <- EqualityCompare(v50 == v52) T{bool} for v50 is T{int}
reaching type to v53 <- EqualityCompare(v50 == v52) T{bool} for v52 is T{_Smi}
reaching type to AssertBoolean:144(v53) for v53 is T{bool}
reaching type to Branch if StrictCompare:146(===, v53, v13) goto (17, 20) for v53 is T{bool}
reaching type to Branch if StrictCompare:146(===, v53, v13) goto (17, 20) for v13 is T{bool}
reaching type to v55 <- BinaryInt64Op(+ [tr], v43, v7) T{int} for v43 is T{int}
reaching type to v55 <- BinaryInt64Op(+ [tr], v43, v7) T{int} for v7 is T{_Smi}
reaching type to v57 <- EqualityCompare(v55 == v8) T{bool} for v55 is T{int}
reaching type to v57 <- EqualityCompare(v55 == v8) T{bool} for v8 is T{int}
reaching type to AssertBoolean:156(v57) for v57 is T{bool}
reaching type to Branch if StrictCompare:158(===, v57, v13) goto (18, 19) for v57 is T{bool}
reaching type to Branch if StrictCompare:158(===, v57, v13) goto (18, 19) for v13 is T{bool}
reaching type to v85 <- CheckNull:172(v28, NoSuchMethodError) T{int} for v28 is T{int}
reaching type to v60 <- RelationalOp(>, v85 T{int}, v10) T{bool} for v85 is T{int}
reaching type to v60 <- RelationalOp(>, v85 T{int}, v10) T{bool} for v10 is T{_Smi}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v59 is T{_Smi}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v55 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v8 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v85 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v60 is T{bool}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to Return:178(v62) for v62 is T{int?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) T{int?} for v55 is T{int}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:168(v64) for v64 is T{int?}
reaching type to Return:134(v10) for v10 is T{_Smi}
reaching type to v67 <- BinaryInt64Op(- [tr], v66, v217 T{_Smi}) T{int} for v66 is T{_Smi}
reaching type to v67 <- BinaryInt64Op(- [tr], v66, v217 T{_Smi}) T{int} for v217 is T{_Smi}
reaching type to v69 <- BinaryInt64Op(+ [tr], v14, v7) T{int} for v14 is T{int}
reaching type to v69 <- BinaryInt64Op(+ [tr], v14, v7) T{int} for v7 is T{_Smi}
reaching type to v71 <- EqualityCompare(v69 == v8) T{bool} for v69 is T{int}
reaching type to v71 <- EqualityCompare(v69 == v8) T{bool} for v8 is T{int}
reaching type to AssertBoolean:76(v71) for v71 is T{bool}
reaching type to Branch if StrictCompare:78(===, v71, v13) goto (9, 10) for v71 is T{bool}
reaching type to Branch if StrictCompare:78(===, v71, v13) goto (9, 10) for v13 is T{bool}
reaching type to v173 <- LoadClassId(v2) for v2 is T{_StringBase}
reaching type to Branch if StrictCompare:92(===, v173, v128) goto (34, 39) for v173 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v173, v128) goto (34, 39) for v128 is T{_Smi}
reaching type to v238 <- Redefinition(v2 ^ T{_TwoByteString}) for v2 is T{_StringBase}
reaching type to v133 <- Redefinition(v238) for v238 is T{_TwoByteString}
reaching type to v134 <- LoadField(v133 . String.length {final}) for v133 is T{_TwoByteString}
reaching type to v136 <- GenericCheckBound:92(v134, v69) for v134 is T{_Smi}
reaching type to v136 <- GenericCheckBound:92(v134, v69) for v69 is T{int}
reaching type to v138 <- LoadIndexed(v133, v136) for v133 is T{_TwoByteString}
reaching type to v138 <- LoadIndexed(v133, v136) for v136 is T{int}
reaching type to v140 <- BoxInt64(v138) for v138 is T{_Smi}
reaching type to v174 <- phi(v140, v151, v162, v171) alive T{} for v140 is T{int}
reaching type to Branch if StrictCompare:92(===, v173, v129) goto (35, 40) for v173 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v173, v129) goto (35, 40) for v129 is T{_Smi}
reaching type to v240 <- Redefinition(v2 ^ T{_ExternalOneByteString}) for v2 is T{_StringBase}
reaching type to v142 <- Redefinition(v240) for v240 is T{_ExternalOneByteString}
reaching type to v143 <- LoadField(v142 . String.length {final}) for v142 is T{_ExternalOneByteString}
reaching type to v145 <- GenericCheckBound:92(v143, v69) for v143 is T{_Smi}
reaching type to v145 <- GenericCheckBound:92(v143, v69) for v69 is T{int}
reaching type to v147 <- LoadUntagged(v142, 16) for v142 is T{_ExternalOneByteString}
reaching type to v149 <- LoadIndexed(v147, v145) for v147 is T{*?}
reaching type to v149 <- LoadIndexed(v147, v145) for v145 is T{int}
reaching type to v151 <- BoxInt64(v149) for v149 is T{_Smi}
reaching type to v174 <- phi(v140, v151, v162, v171) alive T{} for v151 is T{int}
reaching type to Branch if StrictCompare:92(===, v173, v130) goto (36, 41) for v173 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v173, v130) goto (36, 41) for v130 is T{_Smi}
reaching type to v242 <- Redefinition(v2 ^ T{_ExternalTwoByteString}) for v2 is T{_StringBase}
reaching type to v153 <- Redefinition(v242) for v242 is T{_ExternalTwoByteString}
reaching type to v154 <- LoadField(v153 . String.length {final}) for v153 is T{_ExternalTwoByteString}
reaching type to v156 <- GenericCheckBound:92(v154, v69) for v154 is T{_Smi}
reaching type to v156 <- GenericCheckBound:92(v154, v69) for v69 is T{int}
reaching type to v158 <- LoadUntagged(v153, 16) for v153 is T{_ExternalTwoByteString}
reaching type to v160 <- LoadIndexed(v158, v156) for v158 is T{*?}
reaching type to v160 <- LoadIndexed(v158, v156) for v156 is T{int}
reaching type to v162 <- BoxInt64(v160) for v160 is T{_Smi}
reaching type to v174 <- phi(v140, v151, v162, v171) alive T{} for v162 is T{int}
reaching type to v164 <- Redefinition(v2) for v2 is T{_StringBase}
reaching type to v165 <- LoadField(v164 . String.length {final}) for v164 is T{_StringBase}
reaching type to v167 <- GenericCheckBound:92(v165, v69) for v165 is T{_Smi}
reaching type to v167 <- GenericCheckBound:92(v165, v69) for v69 is T{int}
reaching type to v169 <- LoadIndexed(v164, v167) for v164 is T{_StringBase}
reaching type to v169 <- LoadIndexed(v164, v167) for v167 is T{int}
reaching type to v171 <- BoxInt64(v169) for v169 is T{_Smi}
reaching type to v174 <- phi(v140, v151, v162, v171) alive T{} for v171 is T{int}
reaching type to v24 <- phi(v14, v69) alive T{int} for v69 is T{int}
reaching type to v26 <- phi(v217, v174) alive T{_Smi} for v174 is T{}
reaching type to v28 <- phi(v7, v67) alive T{int} for v67 is T{int}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) T{int?} for v8 is T{int}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) T{int?} for v3 is T{_Smi?}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:88(v75) for v75 is T{int?}
reaching type to v224 <- LoadField(v2 T{_StringBase} . String.length {final}) T{_Smi} for v2 is T{_StringBase}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v224 is T{_Smi}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v3 is T{_Smi?}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:32(v79) for v79 is T{int?}
recomputing type of v174: T{}
  phi 174 input 0: v140 has reaching type T{int}
  phi 174 input 1: v151 has reaching type T{int}
  phi 174 input 2: v162 has reaching type T{int}
  phi 174 input 3: v171 has reaching type T{int}
  ... new type T{int}
recomputing type of v26: T{}
  phi 26 input 0: v217 has reaching type T{}
  phi 26 input 1: v174 has reaching type T{int}
  ... new type T{int}
recomputing type of v38: T{bool}
recomputing type of v131: T{}
  phi 131 input 0: v94 has reaching type T{int}
  phi 131 input 1: v105 has reaching type T{int}
  phi 131 input 2: v116 has reaching type T{int}
  phi 131 input 3: v125 has reaching type T{int}
  ... new type T{int}
recomputing type of v50: T{int}
recomputing type of v30: T{}
  phi 30 input 0: v42 has reaching type T{_Smi}
  phi 30 input 1: v81 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v35: T{int?}
recomputing type of v28: T{}
  phi 28 input 0: v7 has reaching type T{_Smi}
  phi 28 input 1: v67 has reaching type T{int}
  ... new type T{int}
recomputing type of v35: T{int?}
recomputing type of v85: T{int}
recomputing type of v26: T{int}
  phi 26 input 0: v217 has reaching type T{}
  phi 26 input 1: v174 has reaching type T{int}
recomputing type of v24: T{}
  phi 24 input 0: v14 has reaching type T{int}
  phi 24 input 1: v69 has reaching type T{int}
  ... new type T{int}
recomputing type of v35: T{int?}
recomputing type of v83: T{int}
  ... new type T{int}
recomputing type of v43: T{int}
recomputing type of v217: T{}
  phi 217 input 0: v183 has reaching type T{int}
  phi 217 input 1: v194 has reaching type T{int}
  phi 217 input 2: v205 has reaching type T{int}
  phi 217 input 3: v214 has reaching type T{int}
  ... new type T{int}
recomputing type of v26: T{int}
  phi 26 input 0: v217 has reaching type T{int}
  phi 26 input 1: v174 has reaching type T{int}
recomputing type of v19: T{bool}
recomputing type of v22: T{bool}
recomputing type of v67: T{int}
reaching type to v5 <- StaticCall:12( _lastNonWhitespace@0150898<0> v2, using unchecked entrypoint, result_type = T{int}) T{int} for v2 is T{_StringBase}
reaching type to v8 <- BinaryInt64Op(+ [tr], v5, v7) T{int} for v5 is T{int}
reaching type to v8 <- BinaryInt64Op(+ [tr], v5, v7) T{int} for v7 is T{_Smi}
reaching type to v11 <- EqualityCompare(v8 == v10) T{bool} for v8 is T{int}
reaching type to v11 <- EqualityCompare(v8 == v10) T{bool} for v10 is T{_Smi}
reaching type to AssertBoolean:18(v11) for v11 is T{bool}
reaching type to Branch if StrictCompare:20(===, v11, v13) goto (3, 4) for v11 is T{bool}
reaching type to Branch if StrictCompare:20(===, v11, v13) goto (3, 4) for v13 is T{bool}
reaching type to v14 <- StaticCall:36( _firstNonWhitespace@0150898<0> v2, using unchecked entrypoint, result_type = T{int}) T{int} for v2 is T{_StringBase}
reaching type to v216 <- LoadClassId(v2) T{_Smi} for v2 is T{_StringBase}
reaching type to Branch if StrictCompare:38(===, v216, v128) goto (43, 48) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v128) goto (43, 48) for v128 is T{_Smi}
reaching type to v226 <- Redefinition(v2 ^ T{_TwoByteString}) T{_TwoByteString} for v2 is T{_StringBase}
reaching type to v176 <- Redefinition(v226) T{_TwoByteString} for v226 is T{_TwoByteString}
reaching type to v177 <- LoadField(v176 . String.length {final}) T{_Smi} for v176 is T{_TwoByteString}
reaching type to v179 <- GenericCheckBound:38(v177, v14) T{int} for v177 is T{_Smi}
reaching type to v179 <- GenericCheckBound:38(v177, v14) T{int} for v14 is T{int}
reaching type to v181 <- LoadIndexed(v176, v179) T{_Smi} for v176 is T{_TwoByteString}
reaching type to v181 <- LoadIndexed(v176, v179) T{_Smi} for v179 is T{int}
reaching type to v183 <- BoxInt64(v181) T{int} for v181 is T{_Smi}
reaching type to v217 <- phi(v183, v194, v205, v214) alive T{int} for v183 is T{int}
reaching type to Branch if StrictCompare:38(===, v216, v129) goto (44, 49) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v129) goto (44, 49) for v129 is T{_Smi}
reaching type to v228 <- Redefinition(v2 ^ T{_ExternalOneByteString}) T{_ExternalOneByteString} for v2 is T{_StringBase}
reaching type to v185 <- Redefinition(v228) T{_ExternalOneByteString} for v228 is T{_ExternalOneByteString}
reaching type to v186 <- LoadField(v185 . String.length {final}) T{_Smi} for v185 is T{_ExternalOneByteString}
reaching type to v188 <- GenericCheckBound:38(v186, v14) T{int} for v186 is T{_Smi}
reaching type to v188 <- GenericCheckBound:38(v186, v14) T{int} for v14 is T{int}
reaching type to v190 <- LoadUntagged(v185, 16) T{*?} for v185 is T{_ExternalOneByteString}
reaching type to v192 <- LoadIndexed(v190, v188) T{_Smi} for v190 is T{*?}
reaching type to v192 <- LoadIndexed(v190, v188) T{_Smi} for v188 is T{int}
reaching type to v194 <- BoxInt64(v192) T{int} for v192 is T{_Smi}
reaching type to v217 <- phi(v183, v194, v205, v214) alive T{int} for v194 is T{int}
reaching type to Branch if StrictCompare:38(===, v216, v130) goto (45, 50) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v130) goto (45, 50) for v130 is T{_Smi}
reaching type to v230 <- Redefinition(v2 ^ T{_ExternalTwoByteString}) T{_ExternalTwoByteString} for v2 is T{_StringBase}
reaching type to v196 <- Redefinition(v230) T{_ExternalTwoByteString} for v230 is T{_ExternalTwoByteString}
reaching type to v197 <- LoadField(v196 . String.length {final}) T{_Smi} for v196 is T{_ExternalTwoByteString}
reaching type to v199 <- GenericCheckBound:38(v197, v14) T{int} for v197 is T{_Smi}
reaching type to v199 <- GenericCheckBound:38(v197, v14) T{int} for v14 is T{int}
reaching type to v201 <- LoadUntagged(v196, 16) T{*?} for v196 is T{_ExternalTwoByteString}
reaching type to v203 <- LoadIndexed(v201, v199) T{_Smi} for v201 is T{*?}
reaching type to v203 <- LoadIndexed(v201, v199) T{_Smi} for v199 is T{int}
reaching type to v205 <- BoxInt64(v203) T{int} for v203 is T{_Smi}
reaching type to v217 <- phi(v183, v194, v205, v214) alive T{int} for v205 is T{int}
reaching type to v207 <- Redefinition(v2) T{_StringBase} for v2 is T{_StringBase}
reaching type to v208 <- LoadField(v207 . String.length {final}) T{_Smi} for v207 is T{_StringBase}
reaching type to v210 <- GenericCheckBound:38(v208, v14) T{int} for v208 is T{_Smi}
reaching type to v210 <- GenericCheckBound:38(v208, v14) T{int} for v14 is T{int}
reaching type to v212 <- LoadIndexed(v207, v210) T{_Smi} for v207 is T{_StringBase}
reaching type to v212 <- LoadIndexed(v207, v210) T{_Smi} for v210 is T{int}
reaching type to v214 <- BoxInt64(v212) T{int} for v212 is T{_Smi}
reaching type to v217 <- phi(v183, v194, v205, v214) alive T{int} for v214 is T{int}
reaching type to v19 <- EqualityCompare(v217 T{_Smi} == v18) T{bool} for v217 is T{_Smi}
reaching type to v19 <- EqualityCompare(v217 T{_Smi} == v18) T{bool} for v18 is T{_Smi}
reaching type to AssertBoolean:44(v19) for v19 is T{bool}
reaching type to Branch if StrictCompare:46(===, v19, v13) goto (7, 5) for v19 is T{bool}
reaching type to Branch if StrictCompare:46(===, v19, v13) goto (7, 5) for v13 is T{bool}
reaching type to v22 <- EqualityCompare(v217 T{_Smi} == v21) T{bool} for v217 is T{_Smi}
reaching type to v22 <- EqualityCompare(v217 T{_Smi} == v21) T{bool} for v21 is T{_Smi}
reaching type to AssertBoolean:52(v22) for v22 is T{bool}
reaching type to Branch if StrictCompare:54(===, v22, v13) goto (8, 11) for v22 is T{bool}
reaching type to Branch if StrictCompare:54(===, v22, v13) goto (8, 11) for v13 is T{bool}
reaching type to v24 <- phi(v14, v69) alive T{int} for v14 is T{int}
reaching type to v26 <- phi(v217, v174) alive T{int} for v217 is T{int}
reaching type to v28 <- phi(v7, v67) alive T{int} for v7 is T{_Smi}
reaching type to Branch if StrictCompare:102(===, v3, v0, with number check) goto (13, 23) for v3 is T{_Smi?}
reaching type to Branch if StrictCompare:102(===, v3, v0, with number check) goto (13, 23) for v0 is T{Null?}
reaching type to v81 <- Redefinition(v3 ^ T{_Smi}) T{_Smi} for v3 is T{_Smi?}
reaching type to v30 <- phi(v42, v81) alive T{_Smi} for v81 is T{_Smi}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v30 is T{_Smi}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v24 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v8 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v28 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v34 is T{bool}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to Return:204(v35) for v35 is T{int?}
reaching type to v38 <- StrictCompare(===, v26, v37) T{bool} for v26 is T{int}
reaching type to v38 <- StrictCompare(===, v26, v37) T{bool} for v37 is T{_Smi}
reaching type to AssertBoolean:112(v38) for v38 is T{bool}
reaching type to Branch if StrictCompare:114(===, v38, v13) goto (14, 21) for v38 is T{bool}
reaching type to Branch if StrictCompare:114(===, v38, v13) goto (14, 21) for v13 is T{bool}
reaching type to v30 <- phi(v42, v81) alive T{_Smi} for v42 is T{_Smi}
reaching type to v83 <- CheckNull:120(v24, NoSuchMethodError) T{int} for v24 is T{int}
reaching type to v43 <- BinaryInt64Op(+ [tr], v83 T{int}, v7) T{int} for v83 is T{int}
reaching type to v43 <- BinaryInt64Op(+ [tr], v83 T{int}, v7) T{int} for v7 is T{_Smi}
reaching type to v45 <- EqualityCompare(v43 == v8) T{bool} for v43 is T{int}
reaching type to v45 <- EqualityCompare(v43 == v8) T{bool} for v8 is T{int}
reaching type to AssertBoolean:124(v45) for v45 is T{bool}
reaching type to Branch if StrictCompare:126(===, v45, v13) goto (15, 16) for v45 is T{bool}
reaching type to Branch if StrictCompare:126(===, v45, v13) goto (15, 16) for v13 is T{bool}
reaching type to v127 <- LoadClassId(v2) T{_Smi} for v2 is T{_StringBase}
reaching type to Branch if StrictCompare:138(===, v127, v128) goto (25, 30) for v127 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v127, v128) goto (25, 30) for v128 is T{_Smi}
reaching type to v232 <- Redefinition(v2 ^ T{_TwoByteString}) T{_TwoByteString} for v2 is T{_StringBase}
reaching type to v87 <- Redefinition(v232) T{_TwoByteString} for v232 is T{_TwoByteString}
reaching type to v88 <- LoadField(v87 . String.length {final}) T{_Smi} for v87 is T{_TwoByteString}
reaching type to v90 <- GenericCheckBound:138(v88, v43) T{int} for v88 is T{_Smi}
reaching type to v90 <- GenericCheckBound:138(v88, v43) T{int} for v43 is T{int}
reaching type to v92 <- LoadIndexed(v87, v90) T{_Smi} for v87 is T{_TwoByteString}
reaching type to v92 <- LoadIndexed(v87, v90) T{_Smi} for v90 is T{int}
reaching type to v94 <- BoxInt64(v92) T{int} for v92 is T{_Smi}
reaching type to v131 <- phi(v94, v105, v116, v125) alive T{int} for v94 is T{int}
reaching type to Branch if StrictCompare:138(===, v127, v129) goto (26, 31) for v127 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v127, v129) goto (26, 31) for v129 is T{_Smi}
reaching type to v234 <- Redefinition(v2 ^ T{_ExternalOneByteString}) T{_ExternalOneByteString} for v2 is T{_StringBase}
reaching type to v96 <- Redefinition(v234) T{_ExternalOneByteString} for v234 is T{_ExternalOneByteString}
reaching type to v97 <- LoadField(v96 . String.length {final}) T{_Smi} for v96 is T{_ExternalOneByteString}
reaching type to v99 <- GenericCheckBound:138(v97, v43) T{int} for v97 is T{_Smi}
reaching type to v99 <- GenericCheckBound:138(v97, v43) T{int} for v43 is T{int}
reaching type to v101 <- LoadUntagged(v96, 16) T{*?} for v96 is T{_ExternalOneByteString}
reaching type to v103 <- LoadIndexed(v101, v99) T{_Smi} for v101 is T{*?}
reaching type to v103 <- LoadIndexed(v101, v99) T{_Smi} for v99 is T{int}
reaching type to v105 <- BoxInt64(v103) T{int} for v103 is T{_Smi}
reaching type to v131 <- phi(v94, v105, v116, v125) alive T{int} for v105 is T{int}
reaching type to Branch if StrictCompare:138(===, v127, v130) goto (27, 32) for v127 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v127, v130) goto (27, 32) for v130 is T{_Smi}
reaching type to v236 <- Redefinition(v2 ^ T{_ExternalTwoByteString}) T{_ExternalTwoByteString} for v2 is T{_StringBase}
reaching type to v107 <- Redefinition(v236) T{_ExternalTwoByteString} for v236 is T{_ExternalTwoByteString}
reaching type to v108 <- LoadField(v107 . String.length {final}) T{_Smi} for v107 is T{_ExternalTwoByteString}
reaching type to v110 <- GenericCheckBound:138(v108, v43) T{int} for v108 is T{_Smi}
reaching type to v110 <- GenericCheckBound:138(v108, v43) T{int} for v43 is T{int}
reaching type to v112 <- LoadUntagged(v107, 16) T{*?} for v107 is T{_ExternalTwoByteString}
reaching type to v114 <- LoadIndexed(v112, v110) T{_Smi} for v112 is T{*?}
reaching type to v114 <- LoadIndexed(v112, v110) T{_Smi} for v110 is T{int}
reaching type to v116 <- BoxInt64(v114) T{int} for v114 is T{_Smi}
reaching type to v131 <- phi(v94, v105, v116, v125) alive T{int} for v116 is T{int}
reaching type to v118 <- Redefinition(v2) T{_StringBase} for v2 is T{_StringBase}
reaching type to v119 <- LoadField(v118 . String.length {final}) T{_Smi} for v118 is T{_StringBase}
reaching type to v121 <- GenericCheckBound:138(v119, v43) T{int} for v119 is T{_Smi}
reaching type to v121 <- GenericCheckBound:138(v119, v43) T{int} for v43 is T{int}
reaching type to v123 <- LoadIndexed(v118, v121) T{_Smi} for v118 is T{_StringBase}
reaching type to v123 <- LoadIndexed(v118, v121) T{_Smi} for v121 is T{int}
reaching type to v125 <- BoxInt64(v123) T{int} for v123 is T{_Smi}
reaching type to v131 <- phi(v94, v105, v116, v125) alive T{int} for v125 is T{int}
reaching type to v50 <- BinaryInt64Op(| [tr], v131 T{_Smi}, v49) T{int} for v131 is T{_Smi}
reaching type to v50 <- BinaryInt64Op(| [tr], v131 T{_Smi}, v49) T{int} for v49 is T{_Smi}
reaching type to v53 <- EqualityCompare(v50 == v52) T{bool} for v50 is T{int}
reaching type to v53 <- EqualityCompare(v50 == v52) T{bool} for v52 is T{_Smi}
reaching type to AssertBoolean:144(v53) for v53 is T{bool}
reaching type to Branch if StrictCompare:146(===, v53, v13) goto (17, 20) for v53 is T{bool}
reaching type to Branch if StrictCompare:146(===, v53, v13) goto (17, 20) for v13 is T{bool}
reaching type to v55 <- BinaryInt64Op(+ [tr], v43, v7) T{int} for v43 is T{int}
reaching type to v55 <- BinaryInt64Op(+ [tr], v43, v7) T{int} for v7 is T{_Smi}
reaching type to v57 <- EqualityCompare(v55 == v8) T{bool} for v55 is T{int}
reaching type to v57 <- EqualityCompare(v55 == v8) T{bool} for v8 is T{int}
reaching type to AssertBoolean:156(v57) for v57 is T{bool}
reaching type to Branch if StrictCompare:158(===, v57, v13) goto (18, 19) for v57 is T{bool}
reaching type to Branch if StrictCompare:158(===, v57, v13) goto (18, 19) for v13 is T{bool}
reaching type to v85 <- CheckNull:172(v28, NoSuchMethodError) T{int} for v28 is T{int}
reaching type to v60 <- RelationalOp(>, v85 T{int}, v10) T{bool} for v85 is T{int}
reaching type to v60 <- RelationalOp(>, v85 T{int}, v10) T{bool} for v10 is T{_Smi}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v59 is T{_Smi}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v55 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v8 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v85 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v60 is T{bool}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v85 T{int}, v60, v4, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to Return:178(v62) for v62 is T{int?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) T{int?} for v55 is T{int}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:168(v64) for v64 is T{int?}
reaching type to Return:134(v10) for v10 is T{_Smi}
reaching type to v67 <- BinaryInt64Op(- [tr], v66, v217 T{_Smi}) T{int} for v66 is T{_Smi}
reaching type to v67 <- BinaryInt64Op(- [tr], v66, v217 T{_Smi}) T{int} for v217 is T{_Smi}
reaching type to v69 <- BinaryInt64Op(+ [tr], v14, v7) T{int} for v14 is T{int}
reaching type to v69 <- BinaryInt64Op(+ [tr], v14, v7) T{int} for v7 is T{_Smi}
reaching type to v71 <- EqualityCompare(v69 == v8) T{bool} for v69 is T{int}
reaching type to v71 <- EqualityCompare(v69 == v8) T{bool} for v8 is T{int}
reaching type to AssertBoolean:76(v71) for v71 is T{bool}
reaching type to Branch if StrictCompare:78(===, v71, v13) goto (9, 10) for v71 is T{bool}
reaching type to Branch if StrictCompare:78(===, v71, v13) goto (9, 10) for v13 is T{bool}
reaching type to v173 <- LoadClassId(v2) T{_Smi} for v2 is T{_StringBase}
reaching type to Branch if StrictCompare:92(===, v173, v128) goto (34, 39) for v173 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v173, v128) goto (34, 39) for v128 is T{_Smi}
reaching type to v238 <- Redefinition(v2 ^ T{_TwoByteString}) T{_TwoByteString} for v2 is T{_StringBase}
reaching type to v133 <- Redefinition(v238) T{_TwoByteString} for v238 is T{_TwoByteString}
reaching type to v134 <- LoadField(v133 . String.length {final}) T{_Smi} for v133 is T{_TwoByteString}
reaching type to v136 <- GenericCheckBound:92(v134, v69) T{int} for v134 is T{_Smi}
reaching type to v136 <- GenericCheckBound:92(v134, v69) T{int} for v69 is T{int}
reaching type to v138 <- LoadIndexed(v133, v136) T{_Smi} for v133 is T{_TwoByteString}
reaching type to v138 <- LoadIndexed(v133, v136) T{_Smi} for v136 is T{int}
reaching type to v140 <- BoxInt64(v138) T{int} for v138 is T{_Smi}
reaching type to v174 <- phi(v140, v151, v162, v171) alive T{int} for v140 is T{int}
reaching type to Branch if StrictCompare:92(===, v173, v129) goto (35, 40) for v173 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v173, v129) goto (35, 40) for v129 is T{_Smi}
reaching type to v240 <- Redefinition(v2 ^ T{_ExternalOneByteString}) T{_ExternalOneByteString} for v2 is T{_StringBase}
reaching type to v142 <- Redefinition(v240) T{_ExternalOneByteString} for v240 is T{_ExternalOneByteString}
reaching type to v143 <- LoadField(v142 . String.length {final}) T{_Smi} for v142 is T{_ExternalOneByteString}
reaching type to v145 <- GenericCheckBound:92(v143, v69) T{int} for v143 is T{_Smi}
reaching type to v145 <- GenericCheckBound:92(v143, v69) T{int} for v69 is T{int}
reaching type to v147 <- LoadUntagged(v142, 16) T{*?} for v142 is T{_ExternalOneByteString}
reaching type to v149 <- LoadIndexed(v147, v145) T{_Smi} for v147 is T{*?}
reaching type to v149 <- LoadIndexed(v147, v145) T{_Smi} for v145 is T{int}
reaching type to v151 <- BoxInt64(v149) T{int} for v149 is T{_Smi}
reaching type to v174 <- phi(v140, v151, v162, v171) alive T{int} for v151 is T{int}
reaching type to Branch if StrictCompare:92(===, v173, v130) goto (36, 41) for v173 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v173, v130) goto (36, 41) for v130 is T{_Smi}
reaching type to v242 <- Redefinition(v2 ^ T{_ExternalTwoByteString}) T{_ExternalTwoByteString} for v2 is T{_StringBase}
reaching type to v153 <- Redefinition(v242) T{_ExternalTwoByteString} for v242 is T{_ExternalTwoByteString}
reaching type to v154 <- LoadField(v153 . String.length {final}) T{_Smi} for v153 is T{_ExternalTwoByteString}
reaching type to v156 <- GenericCheckBound:92(v154, v69) T{int} for v154 is T{_Smi}
reaching type to v156 <- GenericCheckBound:92(v154, v69) T{int} for v69 is T{int}
reaching type to v158 <- LoadUntagged(v153, 16) T{*?} for v153 is T{_ExternalTwoByteString}
reaching type to v160 <- LoadIndexed(v158, v156) T{_Smi} for v158 is T{*?}
reaching type to v160 <- LoadIndexed(v158, v156) T{_Smi} for v156 is T{int}
reaching type to v162 <- BoxInt64(v160) T{int} for v160 is T{_Smi}
reaching type to v174 <- phi(v140, v151, v162, v171) alive T{int} for v162 is T{int}
reaching type to v164 <- Redefinition(v2) T{_StringBase} for v2 is T{_StringBase}
reaching type to v165 <- LoadField(v164 . String.length {final}) T{_Smi} for v164 is T{_StringBase}
reaching type to v167 <- GenericCheckBound:92(v165, v69) T{int} for v165 is T{_Smi}
reaching type to v167 <- GenericCheckBound:92(v165, v69) T{int} for v69 is T{int}
reaching type to v169 <- LoadIndexed(v164, v167) T{_Smi} for v164 is T{_StringBase}
reaching type to v169 <- LoadIndexed(v164, v167) T{_Smi} for v167 is T{int}
reaching type to v171 <- BoxInt64(v169) T{int} for v169 is T{_Smi}
reaching type to v174 <- phi(v140, v151, v162, v171) alive T{int} for v171 is T{int}
reaching type to v24 <- phi(v14, v69) alive T{int} for v69 is T{int}
reaching type to v26 <- phi(v217, v174) alive T{int} for v174 is T{int}
reaching type to v28 <- phi(v7, v67) alive T{int} for v67 is T{int}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) T{int?} for v8 is T{int}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) T{int?} for v3 is T{_Smi?}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:88(v75) for v75 is T{int?}
reaching type to v224 <- LoadField(v2 T{_StringBase} . String.length {final}) T{_Smi} for v2 is T{_StringBase}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v224 is T{_Smi}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v3 is T{_Smi?}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:32(v79) for v79 is T{int?}
recomputing type of v174: T{}
  phi 174 input 0: v140 has reaching type T{int}
  phi 174 input 1: v151 has reaching type T{int}
  phi 174 input 2: v162 has reaching type T{int}
  phi 174 input 3: v171 has reaching type T{int}
  ... new type T{int}
recomputing type of v26: T{}
  phi 26 input 0: v217 has reaching type T{}
  phi 26 input 1: v174 has reaching type T{int}
  ... new type T{int}
recomputing type of v38: T{bool}
recomputing type of v131: T{}
  phi 131 input 0: v94 has reaching type T{int}
  phi 131 input 1: v105 has reaching type T{int}
  phi 131 input 2: v116 has reaching type T{int}
  phi 131 input 3: v125 has reaching type T{int}
  ... new type T{int}
recomputing type of v50: T{int}
recomputing type of v30: T{}
  phi 30 input 0: v42 has reaching type T{_Smi}
  phi 30 input 1: v81 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v35: T{int?}
recomputing type of v28: T{}
  phi 28 input 0: v7 has reaching type T{_Smi}
  phi 28 input 1: v67 has reaching type T{int}
  ... new type T{int}
recomputing type of v35: T{int?}
recomputing type of v85: T{int}
recomputing type of v26: T{int}
  phi 26 input 0: v217 has reaching type T{}
  phi 26 input 1: v174 has reaching type T{int}
recomputing type of v24: T{}
  phi 24 input 0: v14 has reaching type T{int}
  phi 24 input 1: v69 has reaching type T{int}
  ... new type T{int}
recomputing type of v35: T{int?}
recomputing type of v83: T{int}
recomputing type of v217: T{}
  phi 217 input 0: v183 has reaching type T{int}
  phi 217 input 1: v194 has reaching type T{int}
  phi 217 input 2: v205 has reaching type T{int}
  phi 217 input 3: v214 has reaching type T{int}
  ... new type T{int}
recomputing type of v26: T{int}
  phi 26 input 0: v217 has reaching type T{int}
  phi 26 input 1: v174 has reaching type T{int}
recomputing type of v19: T{bool}
recomputing type of v22: T{bool}
recomputing type of v67: T{int}
reaching type to v5 <- StaticCall:12( _lastNonWhitespace@0150898<0> v2, using unchecked entrypoint, result_type = T{int}) T{int} for v2 is T{_StringBase}
reaching type to v8 <- BinaryInt64Op(+ [tr], v5, v7) T{int} for v5 is T{int}
reaching type to v8 <- BinaryInt64Op(+ [tr], v5, v7) T{int} for v7 is T{_Smi}
reaching type to v11 <- EqualityCompare(v8 == v10) T{bool} for v8 is T{int}
reaching type to v11 <- EqualityCompare(v8 == v10) T{bool} for v10 is T{_Smi}
reaching type to Branch if StrictCompare:20(===, v11, v13) goto (3, 4) for v11 is T{bool}
reaching type to Branch if StrictCompare:20(===, v11, v13) goto (3, 4) for v13 is T{bool}
reaching type to v14 <- StaticCall:36( _firstNonWhitespace@0150898<0> v2, using unchecked entrypoint, result_type = T{int}) T{int} for v2 is T{_StringBase}
reaching type to v216 <- LoadClassId(v2) T{_Smi} for v2 is T{_StringBase}
reaching type to Branch if StrictCompare:38(===, v216, v128) goto (43, 48) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v128) goto (43, 48) for v128 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v129) goto (44, 49) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v129) goto (44, 49) for v129 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v130) goto (45, 50) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v130) goto (45, 50) for v130 is T{_Smi}
reaching type to v207 <- Redefinition(v2) T{_StringBase} for v2 is T{_StringBase}
reaching type to v208 <- LoadField(v207 . String.length {final}) T{_Smi} for v207 is T{_StringBase}
reaching type to v210 <- GenericCheckBound:38(v208, v14) T{int} for v208 is T{_Smi}
reaching type to v210 <- GenericCheckBound:38(v208, v14) T{int} for v14 is T{int}
reaching type to v212 <- LoadIndexed(v207, v210) T{_Smi} for v207 is T{_StringBase}
reaching type to v212 <- LoadIndexed(v207, v210) T{_Smi} for v210 is T{int}
reaching type to v214 <- BoxInt64(v212) T{int} for v212 is T{_Smi}
reaching type to v217 <- phi(v183, v194, v205, v214) alive T{int} for v214 is T{int}
reaching type to v230 <- Redefinition(v2 ^ T{_ExternalTwoByteString}) T{_ExternalTwoByteString} for v2 is T{_StringBase}
reaching type to v196 <- Redefinition(v230) T{_ExternalTwoByteString} for v230 is T{_ExternalTwoByteString}
reaching type to v197 <- LoadField(v196 . String.length {final}) T{_Smi} for v196 is T{_ExternalTwoByteString}
reaching type to v199 <- GenericCheckBound:38(v197, v14) T{int} for v197 is T{_Smi}
reaching type to v199 <- GenericCheckBound:38(v197, v14) T{int} for v14 is T{int}
reaching type to v201 <- LoadUntagged(v196, 16) T{*?} for v196 is T{_ExternalTwoByteString}
reaching type to v203 <- LoadIndexed(v201, v199) T{_Smi} for v201 is T{*?}
reaching type to v203 <- LoadIndexed(v201, v199) T{_Smi} for v199 is T{int}
reaching type to v205 <- BoxInt64(v203) T{int} for v203 is T{_Smi}
reaching type to v217 <- phi(v183, v194, v205, v214) alive T{int} for v205 is T{int}
reaching type to v228 <- Redefinition(v2 ^ T{_ExternalOneByteString}) T{_ExternalOneByteString} for v2 is T{_StringBase}
reaching type to v185 <- Redefinition(v228) T{_ExternalOneByteString} for v228 is T{_ExternalOneByteString}
reaching type to v186 <- LoadField(v185 . String.length {final}) T{_Smi} for v185 is T{_ExternalOneByteString}
reaching type to v188 <- GenericCheckBound:38(v186, v14) T{int} for v186 is T{_Smi}
reaching type to v188 <- GenericCheckBound:38(v186, v14) T{int} for v14 is T{int}
reaching type to v190 <- LoadUntagged(v185, 16) T{*?} for v185 is T{_ExternalOneByteString}
reaching type to v192 <- LoadIndexed(v190, v188) T{_Smi} for v190 is T{*?}
reaching type to v192 <- LoadIndexed(v190, v188) T{_Smi} for v188 is T{int}
reaching type to v194 <- BoxInt64(v192) T{int} for v192 is T{_Smi}
reaching type to v217 <- phi(v183, v194, v205, v214) alive T{int} for v194 is T{int}
reaching type to v19 <- EqualityCompare(v217 T{_Smi} == v18) T{bool} for v217 is T{_Smi}
reaching type to v19 <- EqualityCompare(v217 T{_Smi} == v18) T{bool} for v18 is T{_Smi}
reaching type to Branch if StrictCompare:46(===, v19, v13) goto (7, 5) for v19 is T{bool}
reaching type to Branch if StrictCompare:46(===, v19, v13) goto (7, 5) for v13 is T{bool}
reaching type to v22 <- EqualityCompare(v217 T{_Smi} == v21) T{bool} for v217 is T{_Smi}
reaching type to v22 <- EqualityCompare(v217 T{_Smi} == v21) T{bool} for v21 is T{_Smi}
reaching type to Branch if StrictCompare:54(===, v22, v13) goto (8, 11) for v22 is T{bool}
reaching type to Branch if StrictCompare:54(===, v22, v13) goto (8, 11) for v13 is T{bool}
reaching type to v24 <- phi(v14, v69) alive T{int} for v14 is T{int}
reaching type to v26 <- phi(v217, v174) alive T{int} for v217 is T{int}
reaching type to v28 <- phi(v7, v67) alive T{int} for v7 is T{_Smi}
reaching type to Branch if StrictCompare:102(===, v3, v0) goto (13, 23) for v3 is T{_Smi?}
reaching type to Branch if StrictCompare:102(===, v3, v0) goto (13, 23) for v0 is T{Null?}
reaching type to v81 <- Redefinition(v3 ^ T{_Smi}) T{_Smi} for v3 is T{_Smi?}
reaching type to v30 <- phi(v42, v81) alive T{_Smi} for v81 is T{_Smi}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v30 is T{_Smi}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v24 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v8 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v28 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v34 is T{bool}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v8, v28, v34, v4, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to Return:204(v35) for v35 is T{int?}
reaching type to Branch if StrictCompare(===, v26, v37) T{bool} goto (14, 21) for v26 is T{int}
reaching type to Branch if StrictCompare(===, v26, v37) T{bool} goto (14, 21) for v37 is T{_Smi}
reaching type to v30 <- phi(v42, v81) alive T{_Smi} for v42 is T{_Smi}
reaching type to v43 <- BinaryInt64Op(+ [tr], v24 T{int}, v7) T{int} for v24 is T{int}
reaching type to v43 <- BinaryInt64Op(+ [tr], v24 T{int}, v7) T{int} for v7 is T{_Smi}
reaching type to Branch if EqualityCompare(v43 == v8) T{bool} goto (15, 16) for v43 is T{int}
reaching type to Branch if EqualityCompare(v43 == v8) T{bool} goto (15, 16) for v8 is T{int}
reaching type to v127 <- LoadClassId(v2) T{_Smi} for v2 is T{_StringBase}
reaching type to Branch if StrictCompare:138(===, v127, v128) goto (25, 30) for v127 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v127, v128) goto (25, 30) for v128 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v127, v129) goto (26, 31) for v127 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v127, v129) goto (26, 31) for v129 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v127, v130) goto (27, 32) for v127 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v127, v130) goto (27, 32) for v130 is T{_Smi}
reaching type to v118 <- Redefinition(v2) T{_StringBase} for v2 is T{_StringBase}
reaching type to v119 <- LoadField(v118 . String.length {final}) T{_Smi} for v118 is T{_StringBase}
reaching type to v121 <- GenericCheckBound:138(v119, v43) T{int} for v119 is T{_Smi}
reaching type to v121 <- GenericCheckBound:138(v119, v43) T{int} for v43 is T{int}
reaching type to v123 <- LoadIndexed(v118, v121) T{_Smi} for v118 is T{_StringBase}
reaching type to v123 <- LoadIndexed(v118, v121) T{_Smi} for v121 is T{int}
reaching type to v125 <- BoxInt64(v123) T{int} for v123 is T{_Smi}
reaching type to v131 <- phi(v94, v105, v116, v125) alive T{int} for v125 is T{int}
reaching type to v236 <- Redefinition(v2 ^ T{_ExternalTwoByteString}) T{_ExternalTwoByteString} for v2 is T{_StringBase}
reaching type to v107 <- Redefinition(v236) T{_ExternalTwoByteString} for v236 is T{_ExternalTwoByteString}
reaching type to v108 <- LoadField(v107 . String.length {final}) T{_Smi} for v107 is T{_ExternalTwoByteString}
reaching type to v110 <- GenericCheckBound:138(v108, v43) T{int} for v108 is T{_Smi}
reaching type to v110 <- GenericCheckBound:138(v108, v43) T{int} for v43 is T{int}
reaching type to v112 <- LoadUntagged(v107, 16) T{*?} for v107 is T{_ExternalTwoByteString}
reaching type to v114 <- LoadIndexed(v112, v110) T{_Smi} for v112 is T{*?}
reaching type to v114 <- LoadIndexed(v112, v110) T{_Smi} for v110 is T{int}
reaching type to v116 <- BoxInt64(v114) T{int} for v114 is T{_Smi}
reaching type to v131 <- phi(v94, v105, v116, v125) alive T{int} for v116 is T{int}
reaching type to v234 <- Redefinition(v2 ^ T{_ExternalOneByteString}) T{_ExternalOneByteString} for v2 is T{_StringBase}
reaching type to v96 <- Redefinition(v234) T{_ExternalOneByteString} for v234 is T{_ExternalOneByteString}
reaching type to v97 <- LoadField(v96 . String.length {final}) T{_Smi} for v96 is T{_ExternalOneByteString}
reaching type to v99 <- GenericCheckBound:138(v97, v43) T{int} for v97 is T{_Smi}
reaching type to v99 <- GenericCheckBound:138(v97, v43) T{int} for v43 is T{int}
reaching type to v101 <- LoadUntagged(v96, 16) T{*?} for v96 is T{_ExternalOneByteString}
reaching type to v103 <- LoadIndexed(v101, v99) T{_Smi} for v101 is T{*?}
reaching type to v103 <- LoadIndexed(v101, v99) T{_Smi} for v99 is T{int}
reaching type to v105 <- BoxInt64(v103) T{int} for v103 is T{_Smi}
reaching type to v131 <- phi(v94, v105, v116, v125) alive T{int} for v105 is T{int}
reaching type to v50 <- BinaryInt64Op(| [tr], v131 T{_Smi}, v49) T{int} for v131 is T{_Smi}
reaching type to v50 <- BinaryInt64Op(| [tr], v131 T{_Smi}, v49) T{int} for v49 is T{_Smi}
reaching type to v53 <- EqualityCompare(v50 == v52) T{bool} for v50 is T{int}
reaching type to v53 <- EqualityCompare(v50 == v52) T{bool} for v52 is T{_Smi}
reaching type to Branch if StrictCompare:146(===, v53, v13) goto (17, 20) for v53 is T{bool}
reaching type to Branch if StrictCompare:146(===, v53, v13) goto (17, 20) for v13 is T{bool}
reaching type to v55 <- BinaryInt64Op(+ [tr], v43, v7) T{int} for v43 is T{int}
reaching type to v55 <- BinaryInt64Op(+ [tr], v43, v7) T{int} for v7 is T{_Smi}
reaching type to Branch if EqualityCompare(v55 == v8) T{bool} goto (18, 19) for v55 is T{int}
reaching type to Branch if EqualityCompare(v55 == v8) T{bool} goto (18, 19) for v8 is T{int}
reaching type to v60 <- RelationalOp(>, v28 T{int}, v10) T{bool} for v28 is T{int}
reaching type to v60 <- RelationalOp(>, v28 T{int}, v10) T{bool} for v10 is T{_Smi}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v59 is T{_Smi}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v55 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v8 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v28 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v60 is T{bool}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v55, v8, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to Return:178(v62) for v62 is T{int?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) T{int?} for v55 is T{int}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v55, v0, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:168(v64) for v64 is T{int?}
reaching type to v232 <- Redefinition(v2 ^ T{_TwoByteString}) T{_TwoByteString} for v2 is T{_StringBase}
reaching type to v87 <- Redefinition(v232) T{_TwoByteString} for v232 is T{_TwoByteString}
reaching type to v88 <- LoadField(v87 . String.length {final}) T{_Smi} for v87 is T{_TwoByteString}
reaching type to v90 <- GenericCheckBound:138(v88, v43) T{int} for v88 is T{_Smi}
reaching type to v90 <- GenericCheckBound:138(v88, v43) T{int} for v43 is T{int}
reaching type to v92 <- LoadIndexed(v87, v90) T{_Smi} for v87 is T{_TwoByteString}
reaching type to v92 <- LoadIndexed(v87, v90) T{_Smi} for v90 is T{int}
reaching type to v94 <- BoxInt64(v92) T{int} for v92 is T{_Smi}
reaching type to v131 <- phi(v94, v105, v116, v125) alive T{int} for v94 is T{int}
reaching type to Return:134(v10) for v10 is T{_Smi}
reaching type to v67 <- BinaryInt64Op(- [tr], v66, v217 T{_Smi}) T{int} for v66 is T{_Smi}
reaching type to v67 <- BinaryInt64Op(- [tr], v66, v217 T{_Smi}) T{int} for v217 is T{_Smi}
reaching type to v69 <- BinaryInt64Op(+ [tr], v14, v7) T{int} for v14 is T{int}
reaching type to v69 <- BinaryInt64Op(+ [tr], v14, v7) T{int} for v7 is T{_Smi}
reaching type to Branch if EqualityCompare(v69 == v8) T{bool} goto (9, 10) for v69 is T{int}
reaching type to Branch if EqualityCompare(v69 == v8) T{bool} goto (9, 10) for v8 is T{int}
reaching type to v173 <- LoadClassId(v2) T{_Smi} for v2 is T{_StringBase}
reaching type to Branch if StrictCompare:92(===, v173, v128) goto (34, 39) for v173 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v173, v128) goto (34, 39) for v128 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v173, v129) goto (35, 40) for v173 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v173, v129) goto (35, 40) for v129 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v173, v130) goto (36, 41) for v173 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v173, v130) goto (36, 41) for v130 is T{_Smi}
reaching type to v164 <- Redefinition(v2) T{_StringBase} for v2 is T{_StringBase}
reaching type to v165 <- LoadField(v164 . String.length {final}) T{_Smi} for v164 is T{_StringBase}
reaching type to v167 <- GenericCheckBound:92(v165, v69) T{int} for v165 is T{_Smi}
reaching type to v167 <- GenericCheckBound:92(v165, v69) T{int} for v69 is T{int}
reaching type to v169 <- LoadIndexed(v164, v167) T{_Smi} for v164 is T{_StringBase}
reaching type to v169 <- LoadIndexed(v164, v167) T{_Smi} for v167 is T{int}
reaching type to v171 <- BoxInt64(v169) T{int} for v169 is T{_Smi}
reaching type to v174 <- phi(v140, v151, v162, v171) alive T{int} for v171 is T{int}
reaching type to v242 <- Redefinition(v2 ^ T{_ExternalTwoByteString}) T{_ExternalTwoByteString} for v2 is T{_StringBase}
reaching type to v153 <- Redefinition(v242) T{_ExternalTwoByteString} for v242 is T{_ExternalTwoByteString}
reaching type to v154 <- LoadField(v153 . String.length {final}) T{_Smi} for v153 is T{_ExternalTwoByteString}
reaching type to v156 <- GenericCheckBound:92(v154, v69) T{int} for v154 is T{_Smi}
reaching type to v156 <- GenericCheckBound:92(v154, v69) T{int} for v69 is T{int}
reaching type to v158 <- LoadUntagged(v153, 16) T{*?} for v153 is T{_ExternalTwoByteString}
reaching type to v160 <- LoadIndexed(v158, v156) T{_Smi} for v158 is T{*?}
reaching type to v160 <- LoadIndexed(v158, v156) T{_Smi} for v156 is T{int}
reaching type to v162 <- BoxInt64(v160) T{int} for v160 is T{_Smi}
reaching type to v174 <- phi(v140, v151, v162, v171) alive T{int} for v162 is T{int}
reaching type to v240 <- Redefinition(v2 ^ T{_ExternalOneByteString}) T{_ExternalOneByteString} for v2 is T{_StringBase}
reaching type to v142 <- Redefinition(v240) T{_ExternalOneByteString} for v240 is T{_ExternalOneByteString}
reaching type to v143 <- LoadField(v142 . String.length {final}) T{_Smi} for v142 is T{_ExternalOneByteString}
reaching type to v145 <- GenericCheckBound:92(v143, v69) T{int} for v143 is T{_Smi}
reaching type to v145 <- GenericCheckBound:92(v143, v69) T{int} for v69 is T{int}
reaching type to v147 <- LoadUntagged(v142, 16) T{*?} for v142 is T{_ExternalOneByteString}
reaching type to v149 <- LoadIndexed(v147, v145) T{_Smi} for v147 is T{*?}
reaching type to v149 <- LoadIndexed(v147, v145) T{_Smi} for v145 is T{int}
reaching type to v151 <- BoxInt64(v149) T{int} for v149 is T{_Smi}
reaching type to v174 <- phi(v140, v151, v162, v171) alive T{int} for v151 is T{int}
reaching type to v24 <- phi(v14, v69) alive T{int} for v69 is T{int}
reaching type to v26 <- phi(v217, v174) alive T{int} for v174 is T{int}
reaching type to v28 <- phi(v7, v67) alive T{int} for v67 is T{int}
reaching type to v238 <- Redefinition(v2 ^ T{_TwoByteString}) T{_TwoByteString} for v2 is T{_StringBase}
reaching type to v133 <- Redefinition(v238) T{_TwoByteString} for v238 is T{_TwoByteString}
reaching type to v134 <- LoadField(v133 . String.length {final}) T{_Smi} for v133 is T{_TwoByteString}
reaching type to v136 <- GenericCheckBound:92(v134, v69) T{int} for v134 is T{_Smi}
reaching type to v136 <- GenericCheckBound:92(v134, v69) T{int} for v69 is T{int}
reaching type to v138 <- LoadIndexed(v133, v136) T{_Smi} for v133 is T{_TwoByteString}
reaching type to v138 <- LoadIndexed(v133, v136) T{_Smi} for v136 is T{int}
reaching type to v140 <- BoxInt64(v138) T{int} for v138 is T{_Smi}
reaching type to v174 <- phi(v140, v151, v162, v171) alive T{int} for v140 is T{int}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) T{int?} for v8 is T{int}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) T{int?} for v3 is T{_Smi?}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v8, v3, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:88(v75) for v75 is T{int?}
reaching type to v226 <- Redefinition(v2 ^ T{_TwoByteString}) T{_TwoByteString} for v2 is T{_StringBase}
reaching type to v176 <- Redefinition(v226) T{_TwoByteString} for v226 is T{_TwoByteString}
reaching type to v177 <- LoadField(v176 . String.length {final}) T{_Smi} for v176 is T{_TwoByteString}
reaching type to v179 <- GenericCheckBound:38(v177, v14) T{int} for v177 is T{_Smi}
reaching type to v179 <- GenericCheckBound:38(v177, v14) T{int} for v14 is T{int}
reaching type to v181 <- LoadIndexed(v176, v179) T{_Smi} for v176 is T{_TwoByteString}
reaching type to v181 <- LoadIndexed(v176, v179) T{_Smi} for v179 is T{int}
reaching type to v183 <- BoxInt64(v181) T{int} for v181 is T{_Smi}
reaching type to v217 <- phi(v183, v194, v205, v214) alive T{int} for v183 is T{int}
reaching type to v224 <- LoadField(v2 T{_StringBase} . String.length {final}) T{_Smi} for v2 is T{_StringBase}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v224 is T{_Smi}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v3 is T{_Smi?}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:32(v79) for v79 is T{int?}
recomputing type of v174: T{}
  phi 174 input 0: v140 has reaching type T{int}
  phi 174 input 1: v151 has reaching type T{int}
  phi 174 input 2: v162 has reaching type T{int}
  phi 174 input 3: v171 has reaching type T{int}
  ... new type T{int}
recomputing type of v26: T{}
  phi 26 input 0: v217 has reaching type T{}
  phi 26 input 1: v174 has reaching type T{int}
  ... new type T{int}
recomputing type of v131: T{}
  phi 131 input 0: v94 has reaching type T{int}
  phi 131 input 1: v105 has reaching type T{int}
  phi 131 input 2: v116 has reaching type T{int}
  phi 131 input 3: v125 has reaching type T{int}
  ... new type T{int}
recomputing type of v50: T{int}
recomputing type of v30: T{}
  phi 30 input 0: v42 has reaching type T{_Smi}
  phi 30 input 1: v81 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v35: T{int?}
recomputing type of v28: T{}
  phi 28 input 0: v7 has reaching type T{_Smi}
  phi 28 input 1: v67 has reaching type T{int}
  ... new type T{int}
recomputing type of v35: T{int?}
recomputing type of v60: T{bool}
recomputing type of v62: T{int?}
recomputing type of v26: T{int}
  phi 26 input 0: v217 has reaching type T{}
  phi 26 input 1: v174 has reaching type T{int}
recomputing type of v24: T{}
  phi 24 input 0: v14 has reaching type T{int}
  phi 24 input 1: v69 has reaching type T{int}
  ... new type T{int}
recomputing type of v35: T{int?}
recomputing type of v43: T{int}
recomputing type of v217: T{}
  phi 217 input 0: v183 has reaching type T{int}
  phi 217 input 1: v194 has reaching type T{int}
  phi 217 input 2: v205 has reaching type T{int}
  phi 217 input 3: v214 has reaching type T{int}
  ... new type T{int}
recomputing type of v26: T{int}
  phi 26 input 0: v217 has reaching type T{int}
  phi 26 input 1: v174 has reaching type T{int}
recomputing type of v19: T{bool}
recomputing type of v22: T{bool}
recomputing type of v67: T{int}
reaching type to v5 <- StaticCall:12( _lastNonWhitespace@0150898<0> v2, using unchecked entrypoint, result_type = T{int}) T{int} for v2 is T{_StringBase}
reaching type to v266 <- UnboxInt64(v5) for v5 is T{int}
reaching type to v8 <- BinaryInt64Op(+ [tr], v266 T{int}, v334) T{int} for v266 is T{int}
reaching type to v8 <- BinaryInt64Op(+ [tr], v266 T{int}, v334) T{int} for v334 is T{_Smi}
reaching type to Branch if EqualityCompare(v8 == v336) T{bool} goto (3, 4) for v8 is T{int}
reaching type to Branch if EqualityCompare(v8 == v336) T{bool} goto (3, 4) for v336 is T{_Smi}
reaching type to v14 <- StaticCall:36( _firstNonWhitespace@0150898<0> v2, using unchecked entrypoint, result_type = T{int}) T{int} for v2 is T{_StringBase}
reaching type to v216 <- LoadClassId(v2) T{_Smi} for v2 is T{_StringBase}
reaching type to Branch if StrictCompare:38(===, v216, v128) goto (43, 48) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v128) goto (43, 48) for v128 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v129) goto (44, 49) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v129) goto (44, 49) for v129 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v130) goto (45, 50) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v130) goto (45, 50) for v130 is T{_Smi}
reaching type to v208 <- LoadField(v2 T{_StringBase} . String.length {final}) T{_Smi} for v2 is T{_StringBase}
reaching type to v210 <- GenericCheckBound:38(v208, v14) T{int} for v208 is T{_Smi}
reaching type to v210 <- GenericCheckBound:38(v208, v14) T{int} for v14 is T{int}
reaching type to v212 <- LoadIndexed(v2 T{_StringBase}, v210) T{_Smi} for v2 is T{_StringBase}
reaching type to v212 <- LoadIndexed(v2 T{_StringBase}, v210) T{_Smi} for v210 is T{int}
reaching type to v217 <- phi(v181, v192, v203, v212) alive int64 T{int} for v212 is T{_Smi}
reaching type to v322 <- phi(v177, v186, v197, v208) alive T{} for v208 is T{_Smi}
reaching type to v354 <- Redefinition(v2 ^ T{_ExternalTwoByteString}) for v2 is T{_StringBase}
reaching type to v197 <- LoadField(v354 . String.length {final}) T{_Smi} for v354 is T{_ExternalTwoByteString}
reaching type to v199 <- GenericCheckBound:38(v197, v14) T{int} for v197 is T{_Smi}
reaching type to v199 <- GenericCheckBound:38(v197, v14) T{int} for v14 is T{int}
reaching type to v201 <- LoadUntagged(v354, 16) T{*?} for v354 is T{_ExternalTwoByteString}
reaching type to v203 <- LoadIndexed(v201, v199) T{_Smi} for v201 is T{*?}
reaching type to v203 <- LoadIndexed(v201, v199) T{_Smi} for v199 is T{int}
reaching type to v217 <- phi(v181, v192, v203, v212) alive int64 T{int} for v203 is T{_Smi}
reaching type to v322 <- phi(v177, v186, v197, v208) alive T{} for v197 is T{_Smi}
reaching type to v352 <- Redefinition(v2 ^ T{_ExternalOneByteString}) for v2 is T{_StringBase}
reaching type to v186 <- LoadField(v352 . String.length {final}) T{_Smi} for v352 is T{_ExternalOneByteString}
reaching type to v188 <- GenericCheckBound:38(v186, v14) T{int} for v186 is T{_Smi}
reaching type to v188 <- GenericCheckBound:38(v186, v14) T{int} for v14 is T{int}
reaching type to v190 <- LoadUntagged(v352, 16) T{*?} for v352 is T{_ExternalOneByteString}
reaching type to v192 <- LoadIndexed(v190, v188) T{_Smi} for v190 is T{*?}
reaching type to v192 <- LoadIndexed(v190, v188) T{_Smi} for v188 is T{int}
reaching type to v217 <- phi(v181, v192, v203, v212) alive int64 T{int} for v192 is T{_Smi}
reaching type to v322 <- phi(v177, v186, v197, v208) alive T{} for v186 is T{_Smi}
reaching type to Branch if EqualityCompare(v217 T{_Smi} == v338) T{bool} goto (7, 5) for v217 is T{_Smi}
reaching type to Branch if EqualityCompare(v217 T{_Smi} == v338) T{bool} goto (7, 5) for v338 is T{_Smi}
reaching type to Branch if EqualityCompare(v217 T{_Smi} == v340) T{bool} goto (8, 11) for v217 is T{_Smi}
reaching type to Branch if EqualityCompare(v217 T{_Smi} == v340) T{bool} goto (8, 11) for v340 is T{_Smi}
reaching type to v284 <- BoxInt64(v217) for v217 is T{int}
reaching type to v24 <- phi(v14, v296 T{int}) alive T{int} for v14 is T{int}
reaching type to v26 <- phi(v284 T{int}, v174) alive T{int} for v284 is T{int}
reaching type to v28 <- phi(v7, v286 T{int}) alive T{int} for v7 is T{_Smi}
reaching type to v326 <- phi(v322, v324) alive T{} for v322 is T{}
reaching type to Branch if StrictCompare:102(===, v3, v0) goto (13, 23) for v3 is T{_Smi?}
reaching type to Branch if StrictCompare:102(===, v3, v0) goto (13, 23) for v0 is T{Null?}
reaching type to v356 <- Redefinition(v3 ^ T{_Smi}) for v3 is T{_Smi?}
reaching type to v30 <- phi(v42, v356) alive T{_Smi} for v356 is T{_Smi}
reaching type to v272 <- BoxInt64(v8) for v8 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v30 is T{_Smi}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v24 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v272 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v28 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v34 is T{bool}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to Return:204(v35) for v35 is T{int?}
reaching type to Branch if StrictCompare(===, v26, v37) T{bool} goto (14, 21) for v26 is T{int}
reaching type to Branch if StrictCompare(===, v26, v37) T{bool} goto (14, 21) for v37 is T{_Smi}
reaching type to v30 <- phi(v42, v356) alive T{_Smi} for v42 is T{_Smi}
reaching type to v298 <- UnboxInt64(v24 T{int}) for v24 is T{int}
reaching type to v43 <- BinaryInt64Op(+ [tr], v298 T{int}, v334) T{int} for v298 is T{int}
reaching type to v43 <- BinaryInt64Op(+ [tr], v298 T{int}, v334) T{int} for v334 is T{_Smi}
reaching type to Branch if EqualityCompare(v43 == v8) T{bool} goto (15, 16) for v43 is T{int}
reaching type to Branch if EqualityCompare(v43 == v8) T{bool} goto (15, 16) for v8 is T{int}
reaching type to Branch if StrictCompare:138(===, v216, v128) goto (25, 30) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v216, v128) goto (25, 30) for v128 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v216, v129) goto (26, 31) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v216, v129) goto (26, 31) for v129 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v216, v130) goto (27, 32) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v216, v130) goto (27, 32) for v130 is T{_Smi}
reaching type to v302 <- BoxInt64(v43) for v43 is T{int}
reaching type to v121 <- GenericCheckBound:138(v326 T{_Smi}, v302 T{int}) T{int} for v326 is T{_Smi}
reaching type to v121 <- GenericCheckBound:138(v326 T{_Smi}, v302 T{int}) T{int} for v302 is T{int}
reaching type to v123 <- LoadIndexed(v2 T{_StringBase}, v121) T{_Smi} for v2 is T{_StringBase}
reaching type to v123 <- LoadIndexed(v2 T{_StringBase}, v121) T{_Smi} for v121 is T{int}
reaching type to v131 <- phi(v92, v103, v114, v123) alive int64 T{int} for v123 is T{_Smi}
reaching type to v328 <- phi(v326, v326, v326, v326) alive for v326 is T{}
reaching type to v362 <- Redefinition(v2 ^ T{_ExternalTwoByteString}) for v2 is T{_StringBase}
reaching type to v304 <- BoxInt64(v43) for v43 is T{int}
reaching type to v110 <- GenericCheckBound:138(v326 T{_Smi}, v304 T{int}) T{int} for v326 is T{_Smi}
reaching type to v110 <- GenericCheckBound:138(v326 T{_Smi}, v304 T{int}) T{int} for v304 is T{int}
reaching type to v112 <- LoadUntagged(v362, 16) T{*?} for v362 is T{_ExternalTwoByteString}
reaching type to v114 <- LoadIndexed(v112, v110) T{_Smi} for v112 is T{*?}
reaching type to v114 <- LoadIndexed(v112, v110) T{_Smi} for v110 is T{int}
reaching type to v131 <- phi(v92, v103, v114, v123) alive int64 T{int} for v114 is T{_Smi}
reaching type to v328 <- phi(v326, v326, v326, v326) alive for v326 is T{}
reaching type to v360 <- Redefinition(v2 ^ T{_ExternalOneByteString}) for v2 is T{_StringBase}
reaching type to v306 <- BoxInt64(v43) for v43 is T{int}
reaching type to v99 <- GenericCheckBound:138(v326 T{_Smi}, v306 T{int}) T{int} for v326 is T{_Smi}
reaching type to v99 <- GenericCheckBound:138(v326 T{_Smi}, v306 T{int}) T{int} for v306 is T{int}
reaching type to v101 <- LoadUntagged(v360, 16) T{*?} for v360 is T{_ExternalOneByteString}
reaching type to v103 <- LoadIndexed(v101, v99) T{_Smi} for v101 is T{*?}
reaching type to v103 <- LoadIndexed(v101, v99) T{_Smi} for v99 is T{int}
reaching type to v131 <- phi(v92, v103, v114, v123) alive int64 T{int} for v103 is T{_Smi}
reaching type to v328 <- phi(v326, v326, v326, v326) alive for v326 is T{}
reaching type to v50 <- BinaryInt64Op(| [tr], v131 T{_Smi}, v344) T{int} for v131 is T{_Smi}
reaching type to v50 <- BinaryInt64Op(| [tr], v131 T{_Smi}, v344) T{int} for v344 is T{_Smi}
reaching type to Branch if EqualityCompare(v50 == v346) T{bool} goto (17, 20) for v50 is T{int}
reaching type to Branch if EqualityCompare(v50 == v346) T{bool} goto (17, 20) for v346 is T{_Smi}
reaching type to v55 <- BinaryInt64Op(+ [tr], v43, v334) T{int} for v43 is T{int}
reaching type to v55 <- BinaryInt64Op(+ [tr], v43, v334) T{int} for v334 is T{_Smi}
reaching type to Branch if EqualityCompare(v55 == v8) T{bool} goto (18, 19) for v55 is T{int}
reaching type to Branch if EqualityCompare(v55 == v8) T{bool} goto (18, 19) for v8 is T{int}
reaching type to v300 <- UnboxInt64(v28 T{int}) for v28 is T{int}
reaching type to v60 <- RelationalOp(>, v300 T{int}, v336) T{bool} for v300 is T{int}
reaching type to v60 <- RelationalOp(>, v300 T{int}, v336) T{bool} for v336 is T{_Smi}
reaching type to v270 <- BoxInt64(v8) for v8 is T{int}
reaching type to v320 <- BoxInt64(v55) for v55 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v59 is T{_Smi}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v320 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v270 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v28 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v60 is T{bool}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to Return:178(v62) for v62 is T{int?}
reaching type to v318 <- BoxInt64(v55) for v55 is T{int}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v318 T{int}, v0, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v318 T{int}, v0, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v318 T{int}, v0, v0, result_type = T{int?}) T{int?} for v318 is T{int}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v318 T{int}, v0, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v318 T{int}, v0, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:168(v64) for v64 is T{int?}
reaching type to v358 <- Redefinition(v2 ^ T{_TwoByteString}) for v2 is T{_StringBase}
reaching type to v308 <- BoxInt64(v43) for v43 is T{int}
reaching type to v90 <- GenericCheckBound:138(v326 T{_Smi}, v308 T{int}) T{int} for v326 is T{_Smi}
reaching type to v90 <- GenericCheckBound:138(v326 T{_Smi}, v308 T{int}) T{int} for v308 is T{int}
reaching type to v92 <- LoadIndexed(v358, v90) T{_Smi} for v358 is T{_TwoByteString}
reaching type to v92 <- LoadIndexed(v358, v90) T{_Smi} for v90 is T{int}
reaching type to v131 <- phi(v92, v103, v114, v123) alive int64 T{int} for v92 is T{_Smi}
reaching type to v328 <- phi(v326, v326, v326, v326) alive for v326 is T{}
reaching type to Return:134(v10) for v10 is T{_Smi}
reaching type to v67 <- BinaryInt64Op(- [tr], v342, v217 T{_Smi}) T{int} for v342 is T{_Smi}
reaching type to v67 <- BinaryInt64Op(- [tr], v342, v217 T{_Smi}) T{int} for v217 is T{_Smi}
reaching type to v274 <- UnboxInt64(v14) for v14 is T{int}
reaching type to v69 <- BinaryInt64Op(+ [tr], v274 T{int}, v334) T{int} for v274 is T{int}
reaching type to v69 <- BinaryInt64Op(+ [tr], v274 T{int}, v334) T{int} for v334 is T{_Smi}
reaching type to Branch if EqualityCompare(v69 == v8) T{bool} goto (9, 10) for v69 is T{int}
reaching type to Branch if EqualityCompare(v69 == v8) T{bool} goto (9, 10) for v8 is T{int}
reaching type to Branch if StrictCompare:92(===, v216, v128) goto (34, 39) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v216, v128) goto (34, 39) for v128 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v216, v129) goto (35, 40) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v216, v129) goto (35, 40) for v129 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v216, v130) goto (36, 41) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v216, v130) goto (36, 41) for v130 is T{_Smi}
reaching type to v288 <- BoxInt64(v69) for v69 is T{int}
reaching type to v167 <- GenericCheckBound:92(v322 T{_Smi}, v288 T{int}) T{int} for v322 is T{_Smi}
reaching type to v167 <- GenericCheckBound:92(v322 T{_Smi}, v288 T{int}) T{int} for v288 is T{int}
reaching type to v169 <- LoadIndexed(v2 T{_StringBase}, v167) T{_Smi} for v2 is T{_StringBase}
reaching type to v169 <- LoadIndexed(v2 T{_StringBase}, v167) T{_Smi} for v167 is T{int}
reaching type to v171 <- BoxInt64(v169) T{int} for v169 is T{_Smi}
reaching type to v174 <- phi(v140, v151, v162, v171) alive T{int} for v171 is T{int}
reaching type to v324 <- phi(v322, v322, v322, v322) alive for v322 is T{}
reaching type to v368 <- Redefinition(v2 ^ T{_ExternalTwoByteString}) for v2 is T{_StringBase}
reaching type to v290 <- BoxInt64(v69) for v69 is T{int}
reaching type to v156 <- GenericCheckBound:92(v322 T{_Smi}, v290 T{int}) T{int} for v322 is T{_Smi}
reaching type to v156 <- GenericCheckBound:92(v322 T{_Smi}, v290 T{int}) T{int} for v290 is T{int}
reaching type to v158 <- LoadUntagged(v368, 16) T{*?} for v368 is T{_ExternalTwoByteString}
reaching type to v160 <- LoadIndexed(v158, v156) T{_Smi} for v158 is T{*?}
reaching type to v160 <- LoadIndexed(v158, v156) T{_Smi} for v156 is T{int}
reaching type to v162 <- BoxInt64(v160) T{int} for v160 is T{_Smi}
reaching type to v174 <- phi(v140, v151, v162, v171) alive T{int} for v162 is T{int}
reaching type to v324 <- phi(v322, v322, v322, v322) alive for v322 is T{}
reaching type to v366 <- Redefinition(v2 ^ T{_ExternalOneByteString}) for v2 is T{_StringBase}
reaching type to v292 <- BoxInt64(v69) for v69 is T{int}
reaching type to v145 <- GenericCheckBound:92(v322 T{_Smi}, v292 T{int}) T{int} for v322 is T{_Smi}
reaching type to v145 <- GenericCheckBound:92(v322 T{_Smi}, v292 T{int}) T{int} for v292 is T{int}
reaching type to v147 <- LoadUntagged(v366, 16) T{*?} for v366 is T{_ExternalOneByteString}
reaching type to v149 <- LoadIndexed(v147, v145) T{_Smi} for v147 is T{*?}
reaching type to v149 <- LoadIndexed(v147, v145) T{_Smi} for v145 is T{int}
reaching type to v151 <- BoxInt64(v149) T{int} for v149 is T{_Smi}
reaching type to v174 <- phi(v140, v151, v162, v171) alive T{int} for v151 is T{int}
reaching type to v324 <- phi(v322, v322, v322, v322) alive for v322 is T{}
reaching type to v286 <- BoxInt64(v67) for v67 is T{int}
reaching type to v296 <- BoxInt64(v69) for v69 is T{int}
reaching type to v24 <- phi(v14, v296 T{int}) alive T{int} for v296 is T{int}
reaching type to v26 <- phi(v284 T{int}, v174) alive T{int} for v174 is T{int}
reaching type to v28 <- phi(v7, v286 T{int}) alive T{int} for v286 is T{int}
reaching type to v326 <- phi(v322, v324) alive T{} for v324 is T{}
reaching type to v364 <- Redefinition(v2 ^ T{_TwoByteString}) for v2 is T{_StringBase}
reaching type to v294 <- BoxInt64(v69) for v69 is T{int}
reaching type to v136 <- GenericCheckBound:92(v322 T{_Smi}, v294 T{int}) T{int} for v322 is T{_Smi}
reaching type to v136 <- GenericCheckBound:92(v322 T{_Smi}, v294 T{int}) T{int} for v294 is T{int}
reaching type to v138 <- LoadIndexed(v364, v136) T{_Smi} for v364 is T{_TwoByteString}
reaching type to v138 <- LoadIndexed(v364, v136) T{_Smi} for v136 is T{int}
reaching type to v140 <- BoxInt64(v138) T{int} for v138 is T{_Smi}
reaching type to v174 <- phi(v140, v151, v162, v171) alive T{int} for v140 is T{int}
reaching type to v324 <- phi(v322, v322, v322, v322) alive T{} for v322 is T{}
reaching type to v268 <- BoxInt64(v8) for v8 is T{int}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v268 T{int}, v3, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v268 T{int}, v3, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v268 T{int}, v3, v0, result_type = T{int?}) T{int?} for v268 is T{int}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v268 T{int}, v3, v0, result_type = T{int?}) T{int?} for v3 is T{_Smi?}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v268 T{int}, v3, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:88(v75) for v75 is T{int?}
reaching type to v350 <- Redefinition(v2 ^ T{_TwoByteString}) for v2 is T{_StringBase}
reaching type to v177 <- LoadField(v350 . String.length {final}) T{_Smi} for v350 is T{_TwoByteString}
reaching type to v179 <- GenericCheckBound:38(v177, v14) T{int} for v177 is T{_Smi}
reaching type to v179 <- GenericCheckBound:38(v177, v14) T{int} for v14 is T{int}
reaching type to v181 <- LoadIndexed(v350, v179) T{_Smi} for v350 is T{_TwoByteString}
reaching type to v181 <- LoadIndexed(v350, v179) T{_Smi} for v179 is T{int}
reaching type to v217 <- phi(v181, v192, v203, v212) alive int64 T{int} for v181 is T{_Smi}
reaching type to v322 <- phi(v177, v186, v197, v208) alive T{} for v177 is T{_Smi}
reaching type to v224 <- LoadField(v2 T{_StringBase} . String.length {final}) T{_Smi} for v2 is T{_StringBase}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v224 is T{_Smi}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v3 is T{_Smi?}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:32(v79) for v79 is T{int?}
recomputing type of v324: T{}
  phi 324 input 0: v322 has reaching type T{}
  phi 324 input 1: v322 has reaching type T{}
  phi 324 input 2: v322 has reaching type T{}
  phi 324 input 3: v322 has reaching type T{}
recomputing type of v174: T{}
  phi 174 input 0: v140 has reaching type T{int}
  phi 174 input 1: v151 has reaching type T{int}
  phi 174 input 2: v162 has reaching type T{int}
  phi 174 input 3: v171 has reaching type T{int}
  ... new type T{int}
recomputing type of v26: T{}
  phi 26 input 0: v284 has reaching type T{int}
  phi 26 input 1: v174 has reaching type T{int}
  ... new type T{int}
recomputing type of v328: T{}
  phi 328 input 0: v326 has reaching type T{}
  phi 328 input 1: v326 has reaching type T{}
  phi 328 input 2: v326 has reaching type T{}
  phi 328 input 3: v326 has reaching type T{}
recomputing type of v131: T{}
  phi 131 input 0: v92 has reaching type T{_Smi}
  phi 131 input 1: v103 has reaching type T{_Smi}
  phi 131 input 2: v114 has reaching type T{_Smi}
  phi 131 input 3: v123 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v50: T{int}
recomputing type of v30: T{}
  phi 30 input 0: v42 has reaching type T{_Smi}
  phi 30 input 1: v356 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v35: T{int?}
recomputing type of v326: T{}
  phi 326 input 0: v322 has reaching type T{}
  phi 326 input 1: v324 has reaching type T{}
recomputing type of v28: T{}
  phi 28 input 0: v7 has reaching type T{_Smi}
  phi 28 input 1: v286 has reaching type T{int}
  ... new type T{int}
recomputing type of v35: T{int?}
recomputing type of v62: T{int?}
recomputing type of v300: T{int}
recomputing type of v26: T{int}
  phi 26 input 0: v284 has reaching type T{int}
  phi 26 input 1: v174 has reaching type T{int}
recomputing type of v24: T{}
  phi 24 input 0: v14 has reaching type T{int}
  phi 24 input 1: v296 has reaching type T{int}
  ... new type T{int}
recomputing type of v35: T{int?}
recomputing type of v298: T{int}
recomputing type of v322: T{}
  phi 322 input 0: v177 has reaching type T{_Smi}
  phi 322 input 1: v186 has reaching type T{_Smi}
  phi 322 input 2: v197 has reaching type T{_Smi}
  phi 322 input 3: v208 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v326: T{}
  phi 326 input 0: v322 has reaching type T{_Smi}
  phi 326 input 1: v324 has reaching type T{}
  ... new type T{_Smi}
recomputing type of v90: T{int}
recomputing type of v99: T{int}
recomputing type of v110: T{int}
recomputing type of v121: T{int}
recomputing type of v328: T{}
  phi 328 input 0: v326 has reaching type T{_Smi}
  phi 328 input 1: v326 has reaching type T{_Smi}
  phi 328 input 2: v326 has reaching type T{_Smi}
  phi 328 input 3: v326 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v136: T{int}
recomputing type of v145: T{int}
recomputing type of v156: T{int}
recomputing type of v167: T{int}
recomputing type of v324: T{}
  phi 324 input 0: v322 has reaching type T{_Smi}
  phi 324 input 1: v322 has reaching type T{_Smi}
  phi 324 input 2: v322 has reaching type T{_Smi}
  phi 324 input 3: v322 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v326: T{_Smi}
  phi 326 input 0: v322 has reaching type T{_Smi}
  phi 326 input 1: v324 has reaching type T{_Smi}
recomputing type of v217: T{}
  phi 217 input 0: v181 has reaching type T{_Smi}
  phi 217 input 1: v192 has reaching type T{_Smi}
  phi 217 input 2: v203 has reaching type T{_Smi}
  phi 217 input 3: v212 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v67: T{int}
recomputing type of v284: T{int}
reaching type to v5 <- StaticCall:12( _lastNonWhitespace@0150898<0> v2, using unchecked entrypoint, result_type = T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v2 is T{_StringBase}
reaching type to v266 <- UnboxInt64(v5) [-9223372036854775808, 9223372036854775807] T{int} for v5 is T{int}
reaching type to v8 <- BinaryInt64Op(+ [tr], v266 T{int}, v334) [-9223372036854775808, 9223372036854775807] T{int} for v266 is T{int}
reaching type to v8 <- BinaryInt64Op(+ [tr], v266 T{int}, v334) [-9223372036854775808, 9223372036854775807] T{int} for v334 is T{_Smi}
reaching type to Branch if EqualityCompare(v8 == v336) T{bool} goto (3, 4) for v8 is T{int}
reaching type to Branch if EqualityCompare(v8 == v336) T{bool} goto (3, 4) for v336 is T{_Smi}
reaching type to v14 <- StaticCall:36( _firstNonWhitespace@0150898<0> v2, using unchecked entrypoint, result_type = T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v2 is T{_StringBase}
reaching type to v216 <- LoadClassId(v2) [-4611686018427387904, 4611686018427387903] T{_Smi} for v2 is T{_StringBase}
reaching type to Branch if StrictCompare:38(===, v216, v128) goto (43, 48) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v128) goto (43, 48) for v128 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v129) goto (44, 49) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v129) goto (44, 49) for v129 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v130) goto (45, 50) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v130) goto (45, 50) for v130 is T{_Smi}
reaching type to v208 <- LoadField(v2 T{_StringBase} . String.length {final}) [0, 2305843009213693951] T{_Smi} for v2 is T{_StringBase}
reaching type to v210 <- GenericCheckBound:38(v208, v14) [-9223372036854775808, 9223372036854775807] T{int} for v208 is T{_Smi}
reaching type to v210 <- GenericCheckBound:38(v208, v14) [-9223372036854775808, 9223372036854775807] T{int} for v14 is T{int}
reaching type to v212 <- LoadIndexed(v2 T{_StringBase}, v210) [0, 255] T{_Smi} for v2 is T{_StringBase}
reaching type to v212 <- LoadIndexed(v2 T{_StringBase}, v210) [0, 255] T{_Smi} for v210 is T{int}
reaching type to v217 <- phi(v181, v192, v203, v212) alive [-4611686018427387904, 4611686018427387903] int64 T{_Smi} for v212 is T{_Smi}
reaching type to v322 <- phi(v177, v186, v197, v208) alive [0, 2305843009213693951] T{_Smi} for v208 is T{_Smi}
reaching type to v354 <- Redefinition(v2 ^ T{_ExternalTwoByteString}) T{_ExternalTwoByteString} for v2 is T{_StringBase}
reaching type to v197 <- LoadField(v354 . String.length {final}) [0, 2305843009213693951] T{_Smi} for v354 is T{_ExternalTwoByteString}
reaching type to v199 <- GenericCheckBound:38(v197, v14) [-9223372036854775808, 9223372036854775807] T{int} for v197 is T{_Smi}
reaching type to v199 <- GenericCheckBound:38(v197, v14) [-9223372036854775808, 9223372036854775807] T{int} for v14 is T{int}
reaching type to v201 <- LoadUntagged(v354, 16) T{*?} for v354 is T{_ExternalTwoByteString}
reaching type to v203 <- LoadIndexed(v201, v199) [-4611686018427387904, 4611686018427387903] T{_Smi} for v201 is T{*?}
reaching type to v203 <- LoadIndexed(v201, v199) [-4611686018427387904, 4611686018427387903] T{_Smi} for v199 is T{int}
reaching type to v217 <- phi(v181, v192, v203, v212) alive [-4611686018427387904, 4611686018427387903] int64 T{_Smi} for v203 is T{_Smi}
reaching type to v322 <- phi(v177, v186, v197, v208) alive [0, 2305843009213693951] T{_Smi} for v197 is T{_Smi}
reaching type to v352 <- Redefinition(v2 ^ T{_ExternalOneByteString}) T{_ExternalOneByteString} for v2 is T{_StringBase}
reaching type to v186 <- LoadField(v352 . String.length {final}) [0, 2305843009213693951] T{_Smi} for v352 is T{_ExternalOneByteString}
reaching type to v188 <- GenericCheckBound:38(v186, v14) [-9223372036854775808, 9223372036854775807] T{int} for v186 is T{_Smi}
reaching type to v188 <- GenericCheckBound:38(v186, v14) [-9223372036854775808, 9223372036854775807] T{int} for v14 is T{int}
reaching type to v190 <- LoadUntagged(v352, 16) T{*?} for v352 is T{_ExternalOneByteString}
reaching type to v192 <- LoadIndexed(v190, v188) [-4611686018427387904, 4611686018427387903] T{_Smi} for v190 is T{*?}
reaching type to v192 <- LoadIndexed(v190, v188) [-4611686018427387904, 4611686018427387903] T{_Smi} for v188 is T{int}
reaching type to v217 <- phi(v181, v192, v203, v212) alive [-4611686018427387904, 4611686018427387903] int64 T{_Smi} for v192 is T{_Smi}
reaching type to v322 <- phi(v177, v186, v197, v208) alive [0, 2305843009213693951] T{_Smi} for v186 is T{_Smi}
reaching type to Branch if EqualityCompare(v217 == v338) T{bool} goto (7, 5) for v217 is T{_Smi}
reaching type to Branch if EqualityCompare(v217 == v338) T{bool} goto (7, 5) for v338 is T{_Smi}
reaching type to Branch if EqualityCompare(v217 == v340) T{bool} goto (8, 11) for v217 is T{_Smi}
reaching type to Branch if EqualityCompare(v217 == v340) T{bool} goto (8, 11) for v340 is T{_Smi}
reaching type to v284 <- BoxInt64(v217) [-4611686018427387904, 4611686018427387903] T{int} for v217 is T{_Smi}
reaching type to v24 <- phi(v14, v296 T{int}) alive [-9223372036854775808, 9223372036854775807] T{int} for v14 is T{int}
reaching type to v26 <- phi(v284, v174) alive [-4611686018427387904, 4611686018427387903] T{int} for v284 is T{_Smi}
reaching type to v28 <- phi(v7, v286 T{int}) alive [-4611686018427387859, 4611686018427387948] T{int} for v7 is T{_Smi}
reaching type to v326 <- phi(v322, v324) alive [0, 2305843009213693951] T{_Smi} for v322 is T{_Smi}
reaching type to Branch if StrictCompare:102(===, v3, v0) goto (13, 23) for v3 is T{_Smi?}
reaching type to Branch if StrictCompare:102(===, v3, v0) goto (13, 23) for v0 is T{Null?}
reaching type to v356 <- Redefinition(v3 ^ T{_Smi}) [-4611686018427387904, 4611686018427387903] T{_Smi} for v3 is T{_Smi?}
reaching type to v30 <- phi(v42, v356) alive [-4611686018427387904, 4611686018427387903] T{_Smi} for v356 is T{_Smi}
reaching type to v272 <- BoxInt64(v8) [-9223372036854775808, 9223372036854775807] T{int} for v8 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v30 is T{_Smi}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v24 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v272 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v28 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v34 is T{bool}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to Return:204(v35) for v35 is T{int?}
reaching type to Branch if StrictCompare(===, v26, v37) T{bool} goto (14, 21) for v26 is T{int}
reaching type to Branch if StrictCompare(===, v26, v37) T{bool} goto (14, 21) for v37 is T{_Smi}
reaching type to v30 <- phi(v42, v356) alive [-4611686018427387904, 4611686018427387903] T{_Smi} for v42 is T{_Smi}
reaching type to v298 <- UnboxInt64(v24 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v24 is T{int}
reaching type to v43 <- BinaryInt64Op(+ [tr], v298 T{int}, v334) [-9223372036854775808, 9223372036854775807] T{int} for v298 is T{int}
reaching type to v43 <- BinaryInt64Op(+ [tr], v298 T{int}, v334) [-9223372036854775808, 9223372036854775807] T{int} for v334 is T{_Smi}
reaching type to Branch if EqualityCompare(v43 == v8) T{bool} goto (15, 16) for v43 is T{int}
reaching type to Branch if EqualityCompare(v43 == v8) T{bool} goto (15, 16) for v8 is T{int}
reaching type to Branch if StrictCompare:138(===, v216, v128) goto (25, 30) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v216, v128) goto (25, 30) for v128 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v216, v129) goto (26, 31) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v216, v129) goto (26, 31) for v129 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v216, v130) goto (27, 32) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v216, v130) goto (27, 32) for v130 is T{_Smi}
reaching type to v302 <- BoxInt64(v43) [-9223372036854775808, 9223372036854775807] T{int} for v43 is T{int}
reaching type to v121 <- GenericCheckBound:138(v326, v302 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v326 is T{_Smi}
reaching type to v121 <- GenericCheckBound:138(v326, v302 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v302 is T{int}
reaching type to v123 <- LoadIndexed(v2 T{_StringBase}, v121) [0, 255] T{_Smi} for v2 is T{_StringBase}
reaching type to v123 <- LoadIndexed(v2 T{_StringBase}, v121) [0, 255] T{_Smi} for v121 is T{int}
reaching type to v131 <- phi(v92, v103, v114, v123) alive [-4611686018427387904, 4611686018427387903] int64 T{_Smi} for v123 is T{_Smi}
reaching type to v328 <- phi(v326, v326, v326, v326) alive [0, 2305843009213693951] T{_Smi} for v326 is T{_Smi}
reaching type to v362 <- Redefinition(v2 ^ T{_ExternalTwoByteString}) T{_ExternalTwoByteString} for v2 is T{_StringBase}
reaching type to v304 <- BoxInt64(v43) [-9223372036854775808, 9223372036854775807] T{int} for v43 is T{int}
reaching type to v110 <- GenericCheckBound:138(v326, v304 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v326 is T{_Smi}
reaching type to v110 <- GenericCheckBound:138(v326, v304 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v304 is T{int}
reaching type to v112 <- LoadUntagged(v362, 16) T{*?} for v362 is T{_ExternalTwoByteString}
reaching type to v114 <- LoadIndexed(v112, v110) [-4611686018427387904, 4611686018427387903] T{_Smi} for v112 is T{*?}
reaching type to v114 <- LoadIndexed(v112, v110) [-4611686018427387904, 4611686018427387903] T{_Smi} for v110 is T{int}
reaching type to v131 <- phi(v92, v103, v114, v123) alive [-4611686018427387904, 4611686018427387903] int64 T{_Smi} for v114 is T{_Smi}
reaching type to v328 <- phi(v326, v326, v326, v326) alive [0, 2305843009213693951] T{_Smi} for v326 is T{_Smi}
reaching type to v360 <- Redefinition(v2 ^ T{_ExternalOneByteString}) T{_ExternalOneByteString} for v2 is T{_StringBase}
reaching type to v306 <- BoxInt64(v43) [-9223372036854775808, 9223372036854775807] T{int} for v43 is T{int}
reaching type to v99 <- GenericCheckBound:138(v326, v306 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v326 is T{_Smi}
reaching type to v99 <- GenericCheckBound:138(v326, v306 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v306 is T{int}
reaching type to v101 <- LoadUntagged(v360, 16) T{*?} for v360 is T{_ExternalOneByteString}
reaching type to v103 <- LoadIndexed(v101, v99) [-4611686018427387904, 4611686018427387903] T{_Smi} for v101 is T{*?}
reaching type to v103 <- LoadIndexed(v101, v99) [-4611686018427387904, 4611686018427387903] T{_Smi} for v99 is T{int}
reaching type to v131 <- phi(v92, v103, v114, v123) alive [-4611686018427387904, 4611686018427387903] int64 T{_Smi} for v103 is T{_Smi}
reaching type to v328 <- phi(v326, v326, v326, v326) alive [0, 2305843009213693951] T{_Smi} for v326 is T{_Smi}
reaching type to v50 <- BinaryInt64Op(| [tr], v131, v344) [-4611686018427387904, 4611686018427387903] T{int} for v131 is T{_Smi}
reaching type to v50 <- BinaryInt64Op(| [tr], v131, v344) [-4611686018427387904, 4611686018427387903] T{int} for v344 is T{_Smi}
reaching type to Branch if EqualityCompare(v50 == v346) T{bool} goto (17, 20) for v50 is T{int}
reaching type to Branch if EqualityCompare(v50 == v346) T{bool} goto (17, 20) for v346 is T{_Smi}
reaching type to v55 <- BinaryInt64Op(+ [tr], v43, v334) [-9223372036854775808, 9223372036854775807] T{int} for v43 is T{int}
reaching type to v55 <- BinaryInt64Op(+ [tr], v43, v334) [-9223372036854775808, 9223372036854775807] T{int} for v334 is T{_Smi}
reaching type to Branch if EqualityCompare(v55 == v8) T{bool} goto (18, 19) for v55 is T{int}
reaching type to Branch if EqualityCompare(v55 == v8) T{bool} goto (18, 19) for v8 is T{int}
reaching type to v300 <- UnboxInt64(v28 T{int}) [-4611686018427387859, 4611686018427387948] T{int} for v28 is T{int}
reaching type to v60 <- RelationalOp(>, v300 T{int}, v336) T{bool} for v300 is T{int}
reaching type to v60 <- RelationalOp(>, v300 T{int}, v336) T{bool} for v336 is T{_Smi}
reaching type to v270 <- BoxInt64(v8) [-9223372036854775808, 9223372036854775807] T{int} for v8 is T{int}
reaching type to v320 <- BoxInt64(v55) [-9223372036854775808, 9223372036854775807] T{int} for v55 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v59 is T{_Smi}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v320 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v270 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v28 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v60 is T{bool}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to Return:178(v62) for v62 is T{int?}
reaching type to v318 <- BoxInt64(v55) [-9223372036854775808, 9223372036854775807] T{int} for v55 is T{int}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v318 T{int}, v0, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v318 T{int}, v0, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v318 T{int}, v0, v0, result_type = T{int?}) T{int?} for v318 is T{int}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v318 T{int}, v0, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v318 T{int}, v0, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:168(v64) for v64 is T{int?}
reaching type to v358 <- Redefinition(v2 ^ T{_TwoByteString}) T{_TwoByteString} for v2 is T{_StringBase}
reaching type to v308 <- BoxInt64(v43) [-9223372036854775808, 9223372036854775807] T{int} for v43 is T{int}
reaching type to v90 <- GenericCheckBound:138(v326, v308 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v326 is T{_Smi}
reaching type to v90 <- GenericCheckBound:138(v326, v308 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v308 is T{int}
reaching type to v92 <- LoadIndexed(v358, v90) [0, 65535] T{_Smi} for v358 is T{_TwoByteString}
reaching type to v92 <- LoadIndexed(v358, v90) [0, 65535] T{_Smi} for v90 is T{int}
reaching type to v131 <- phi(v92, v103, v114, v123) alive [-4611686018427387904, 4611686018427387903] int64 T{_Smi} for v92 is T{_Smi}
reaching type to v328 <- phi(v326, v326, v326, v326) alive [0, 2305843009213693951] T{_Smi} for v326 is T{_Smi}
reaching type to Return:134(v10) for v10 is T{_Smi}
reaching type to v67 <- BinaryInt64Op(- [tr], v342, v217 T{_Smi}) [-4611686018427387859, 4611686018427387948] T{int} for v342 is T{_Smi}
reaching type to v67 <- BinaryInt64Op(- [tr], v342, v217) [-4611686018427387859, 4611686018427387948] T{int} for v217 is T{_Smi}
reaching type to v274 <- UnboxInt64(v14) [-9223372036854775808, 9223372036854775807] T{int} for v14 is T{int}
reaching type to v69 <- BinaryInt64Op(+ [tr], v274 T{int}, v334) [-9223372036854775808, 9223372036854775807] T{int} for v274 is T{int}
reaching type to v69 <- BinaryInt64Op(+ [tr], v274 T{int}, v334) [-9223372036854775808, 9223372036854775807] T{int} for v334 is T{_Smi}
reaching type to Branch if EqualityCompare(v69 == v8) T{bool} goto (9, 10) for v69 is T{int}
reaching type to Branch if EqualityCompare(v69 == v8) T{bool} goto (9, 10) for v8 is T{int}
reaching type to Branch if StrictCompare:92(===, v216, v128) goto (34, 39) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v216, v128) goto (34, 39) for v128 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v216, v129) goto (35, 40) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v216, v129) goto (35, 40) for v129 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v216, v130) goto (36, 41) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v216, v130) goto (36, 41) for v130 is T{_Smi}
reaching type to v288 <- BoxInt64(v69) [-9223372036854775808, 9223372036854775807] T{int} for v69 is T{int}
reaching type to v167 <- GenericCheckBound:92(v322, v288 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v322 is T{_Smi}
reaching type to v167 <- GenericCheckBound:92(v322, v288 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v288 is T{int}
reaching type to v169 <- LoadIndexed(v2 T{_StringBase}, v167) [0, 255] T{_Smi} for v2 is T{_StringBase}
reaching type to v169 <- LoadIndexed(v2 T{_StringBase}, v167) [0, 255] T{_Smi} for v167 is T{int}
reaching type to v171 <- BoxInt64(v169) [0, 255] T{int} for v169 is T{_Smi}
reaching type to v174 <- phi(v140, v151, v162, v171) alive [-4611686018427387904, 4611686018427387903] T{int} for v171 is T{_Smi}
reaching type to v324 <- phi(v322, v322, v322, v322) alive [0, 2305843009213693951] T{_Smi} for v322 is T{_Smi}
reaching type to v368 <- Redefinition(v2 ^ T{_ExternalTwoByteString}) T{_ExternalTwoByteString} for v2 is T{_StringBase}
reaching type to v290 <- BoxInt64(v69) [-9223372036854775808, 9223372036854775807] T{int} for v69 is T{int}
reaching type to v156 <- GenericCheckBound:92(v322, v290 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v322 is T{_Smi}
reaching type to v156 <- GenericCheckBound:92(v322, v290 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v290 is T{int}
reaching type to v158 <- LoadUntagged(v368, 16) T{*?} for v368 is T{_ExternalTwoByteString}
reaching type to v160 <- LoadIndexed(v158, v156) [-4611686018427387904, 4611686018427387903] T{_Smi} for v158 is T{*?}
reaching type to v160 <- LoadIndexed(v158, v156) [-4611686018427387904, 4611686018427387903] T{_Smi} for v156 is T{int}
reaching type to v162 <- BoxInt64(v160) [-4611686018427387904, 4611686018427387903] T{int} for v160 is T{_Smi}
reaching type to v174 <- phi(v140, v151, v162, v171) alive [-4611686018427387904, 4611686018427387903] T{int} for v162 is T{_Smi}
reaching type to v324 <- phi(v322, v322, v322, v322) alive [0, 2305843009213693951] T{_Smi} for v322 is T{_Smi}
reaching type to v366 <- Redefinition(v2 ^ T{_ExternalOneByteString}) T{_ExternalOneByteString} for v2 is T{_StringBase}
reaching type to v292 <- BoxInt64(v69) [-9223372036854775808, 9223372036854775807] T{int} for v69 is T{int}
reaching type to v145 <- GenericCheckBound:92(v322, v292 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v322 is T{_Smi}
reaching type to v145 <- GenericCheckBound:92(v322, v292 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v292 is T{int}
reaching type to v147 <- LoadUntagged(v366, 16) T{*?} for v366 is T{_ExternalOneByteString}
reaching type to v149 <- LoadIndexed(v147, v145) [-4611686018427387904, 4611686018427387903] T{_Smi} for v147 is T{*?}
reaching type to v149 <- LoadIndexed(v147, v145) [-4611686018427387904, 4611686018427387903] T{_Smi} for v145 is T{int}
reaching type to v151 <- BoxInt64(v149) [-4611686018427387904, 4611686018427387903] T{int} for v149 is T{_Smi}
reaching type to v174 <- phi(v140, v151, v162, v171) alive [-4611686018427387904, 4611686018427387903] T{int} for v151 is T{_Smi}
reaching type to v324 <- phi(v322, v322, v322, v322) alive [0, 2305843009213693951] T{_Smi} for v322 is T{_Smi}
reaching type to v286 <- BoxInt64(v67) [-4611686018427387859, 4611686018427387948] T{int} for v67 is T{int}
reaching type to v296 <- BoxInt64(v69) [-9223372036854775808, 9223372036854775807] T{int} for v69 is T{int}
reaching type to v24 <- phi(v14, v296 T{int}) alive [-9223372036854775808, 9223372036854775807] T{int} for v296 is T{int}
reaching type to v26 <- phi(v284, v174) alive [-4611686018427387904, 4611686018427387903] T{int} for v174 is T{int}
reaching type to v28 <- phi(v7, v286 T{int}) alive [-4611686018427387859, 4611686018427387948] T{int} for v286 is T{int}
reaching type to v326 <- phi(v322, v324) alive [0, 2305843009213693951] T{_Smi} for v324 is T{_Smi}
reaching type to v364 <- Redefinition(v2 ^ T{_TwoByteString}) T{_TwoByteString} for v2 is T{_StringBase}
reaching type to v294 <- BoxInt64(v69) [-9223372036854775808, 9223372036854775807] T{int} for v69 is T{int}
reaching type to v136 <- GenericCheckBound:92(v322, v294 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v322 is T{_Smi}
reaching type to v136 <- GenericCheckBound:92(v322, v294 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v294 is T{int}
reaching type to v138 <- LoadIndexed(v364, v136) [0, 65535] T{_Smi} for v364 is T{_TwoByteString}
reaching type to v138 <- LoadIndexed(v364, v136) [0, 65535] T{_Smi} for v136 is T{int}
reaching type to v140 <- BoxInt64(v138) [0, 65535] T{int} for v138 is T{_Smi}
reaching type to v174 <- phi(v140, v151, v162, v171) alive [-4611686018427387904, 4611686018427387903] T{int} for v140 is T{_Smi}
reaching type to v324 <- phi(v322, v322, v322, v322) alive [0, 2305843009213693951] T{_Smi} for v322 is T{_Smi}
reaching type to v268 <- BoxInt64(v8) [-9223372036854775808, 9223372036854775807] T{int} for v8 is T{int}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v268 T{int}, v3, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v268 T{int}, v3, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v268 T{int}, v3, v0, result_type = T{int?}) T{int?} for v268 is T{int}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v268 T{int}, v3, v0, result_type = T{int?}) T{int?} for v3 is T{_Smi?}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v268 T{int}, v3, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:88(v75) for v75 is T{int?}
reaching type to v350 <- Redefinition(v2 ^ T{_TwoByteString}) T{_TwoByteString} for v2 is T{_StringBase}
reaching type to v177 <- LoadField(v350 . String.length {final}) [0, 2305843009213693951] T{_Smi} for v350 is T{_TwoByteString}
reaching type to v179 <- GenericCheckBound:38(v177, v14) [-9223372036854775808, 9223372036854775807] T{int} for v177 is T{_Smi}
reaching type to v179 <- GenericCheckBound:38(v177, v14) [-9223372036854775808, 9223372036854775807] T{int} for v14 is T{int}
reaching type to v181 <- LoadIndexed(v350, v179) [0, 65535] T{_Smi} for v350 is T{_TwoByteString}
reaching type to v181 <- LoadIndexed(v350, v179) [0, 65535] T{_Smi} for v179 is T{int}
reaching type to v217 <- phi(v181, v192, v203, v212) alive [-4611686018427387904, 4611686018427387903] int64 T{_Smi} for v181 is T{_Smi}
reaching type to v322 <- phi(v177, v186, v197, v208) alive [0, 2305843009213693951] T{_Smi} for v177 is T{_Smi}
reaching type to v224 <- LoadField(v2 T{_StringBase} . String.length {final}) [0, 2305843009213693951] T{_Smi} for v2 is T{_StringBase}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v224 is T{_Smi}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v3 is T{_Smi?}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:32(v79) for v79 is T{int?}
recomputing type of v324: T{}
  phi 324 input 0: v322 has reaching type T{}
  phi 324 input 1: v322 has reaching type T{}
  phi 324 input 2: v322 has reaching type T{}
  phi 324 input 3: v322 has reaching type T{}
recomputing type of v174: T{}
  phi 174 input 0: v140 has reaching type T{_Smi}
  phi 174 input 1: v151 has reaching type T{_Smi}
  phi 174 input 2: v162 has reaching type T{_Smi}
  phi 174 input 3: v171 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v26: T{}
  phi 26 input 0: v284 has reaching type T{_Smi}
  phi 26 input 1: v174 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v328: T{}
  phi 328 input 0: v326 has reaching type T{}
  phi 328 input 1: v326 has reaching type T{}
  phi 328 input 2: v326 has reaching type T{}
  phi 328 input 3: v326 has reaching type T{}
recomputing type of v131: T{}
  phi 131 input 0: v92 has reaching type T{_Smi}
  phi 131 input 1: v103 has reaching type T{_Smi}
  phi 131 input 2: v114 has reaching type T{_Smi}
  phi 131 input 3: v123 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v50: T{int}
recomputing type of v30: T{}
  phi 30 input 0: v42 has reaching type T{_Smi}
  phi 30 input 1: v356 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v35: T{int?}
recomputing type of v326: T{}
  phi 326 input 0: v322 has reaching type T{}
  phi 326 input 1: v324 has reaching type T{}
recomputing type of v28: T{}
  phi 28 input 0: v7 has reaching type T{_Smi}
  phi 28 input 1: v286 has reaching type T{int}
  ... new type T{int}
recomputing type of v35: T{int?}
recomputing type of v62: T{int?}
recomputing type of v300: T{int}
recomputing type of v26: T{_Smi}
  phi 26 input 0: v284 has reaching type T{_Smi}
  phi 26 input 1: v174 has reaching type T{_Smi}
recomputing type of v24: T{}
  phi 24 input 0: v14 has reaching type T{int}
  phi 24 input 1: v296 has reaching type T{int}
  ... new type T{int}
recomputing type of v35: T{int?}
recomputing type of v298: T{int}
recomputing type of v322: T{}
  phi 322 input 0: v177 has reaching type T{_Smi}
  phi 322 input 1: v186 has reaching type T{_Smi}
  phi 322 input 2: v197 has reaching type T{_Smi}
  phi 322 input 3: v208 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v326: T{}
  phi 326 input 0: v322 has reaching type T{_Smi}
  phi 326 input 1: v324 has reaching type T{}
  ... new type T{_Smi}
recomputing type of v90: T{int}
recomputing type of v99: T{int}
recomputing type of v110: T{int}
recomputing type of v121: T{int}
recomputing type of v328: T{}
  phi 328 input 0: v326 has reaching type T{_Smi}
  phi 328 input 1: v326 has reaching type T{_Smi}
  phi 328 input 2: v326 has reaching type T{_Smi}
  phi 328 input 3: v326 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v136: T{int}
recomputing type of v145: T{int}
recomputing type of v156: T{int}
recomputing type of v167: T{int}
recomputing type of v324: T{}
  phi 324 input 0: v322 has reaching type T{_Smi}
  phi 324 input 1: v322 has reaching type T{_Smi}
  phi 324 input 2: v322 has reaching type T{_Smi}
  phi 324 input 3: v322 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v326: T{_Smi}
  phi 326 input 0: v322 has reaching type T{_Smi}
  phi 326 input 1: v324 has reaching type T{_Smi}
recomputing type of v217: T{}
  phi 217 input 0: v181 has reaching type T{_Smi}
  phi 217 input 1: v192 has reaching type T{_Smi}
  phi 217 input 2: v203 has reaching type T{_Smi}
  phi 217 input 3: v212 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v67: T{int}
recomputing type of v284: T{_Smi}
reaching type to v5 <- StaticCall:12( _lastNonWhitespace@0150898<0> v2, using unchecked entrypoint, result_type = T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v2 is T{_StringBase}
reaching type to v266 <- UnboxInt64(v5) [-9223372036854775808, 9223372036854775807] T{int} for v5 is T{int}
reaching type to v8 <- BinaryInt64Op(+ [tr], v266 T{int}, v334) [-9223372036854775808, 9223372036854775807] T{int} for v266 is T{int}
reaching type to v8 <- BinaryInt64Op(+ [tr], v266 T{int}, v334) [-9223372036854775808, 9223372036854775807] T{int} for v334 is T{_Smi}
reaching type to Branch if EqualityCompare(v8 == v336) T{bool} goto (3, 4) for v8 is T{int}
reaching type to Branch if EqualityCompare(v8 == v336) T{bool} goto (3, 4) for v336 is T{_Smi}
reaching type to v14 <- StaticCall:36( _firstNonWhitespace@0150898<0> v2, using unchecked entrypoint, result_type = T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v2 is T{_StringBase}
reaching type to v216 <- LoadClassId(v2) [-4611686018427387904, 4611686018427387903] T{_Smi} for v2 is T{_StringBase}
reaching type to Branch if StrictCompare:38(===, v216, v128) goto (43, 48) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v128) goto (43, 48) for v128 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v129) goto (44, 49) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v129) goto (44, 49) for v129 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v130) goto (45, 50) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:38(===, v216, v130) goto (45, 50) for v130 is T{_Smi}
reaching type to v208 <- LoadField(v2 T{_StringBase} . String.length {final}) [0, 2305843009213693951] T{_Smi} for v2 is T{_StringBase}
reaching type to v210 <- GenericCheckBound:38(v208, v14) [-9223372036854775808, 9223372036854775807] T{int} for v208 is T{_Smi}
reaching type to v210 <- GenericCheckBound:38(v208, v14) [-9223372036854775808, 9223372036854775807] T{int} for v14 is T{int}
reaching type to v212 <- LoadIndexed(v2 T{_StringBase}, v210) [0, 255] T{_Smi} for v2 is T{_StringBase}
reaching type to v212 <- LoadIndexed(v2 T{_StringBase}, v210) [0, 255] T{_Smi} for v210 is T{int}
reaching type to v217 <- phi(v181, v192, v203, v212) alive [-4611686018427387904, 4611686018427387903] int64 T{_Smi} for v212 is T{_Smi}
reaching type to v322 <- phi(v177, v186, v197, v208) alive [0, 2305843009213693951] T{_Smi} for v208 is T{_Smi}
reaching type to v354 <- Redefinition(v2 ^ T{_ExternalTwoByteString}) T{_ExternalTwoByteString} for v2 is T{_StringBase}
reaching type to v197 <- LoadField(v354 . String.length {final}) [0, 2305843009213693951] T{_Smi} for v354 is T{_ExternalTwoByteString}
reaching type to v199 <- GenericCheckBound:38(v197, v14) [-9223372036854775808, 9223372036854775807] T{int} for v197 is T{_Smi}
reaching type to v199 <- GenericCheckBound:38(v197, v14) [-9223372036854775808, 9223372036854775807] T{int} for v14 is T{int}
reaching type to v201 <- LoadUntagged(v354, 16) T{*?} for v354 is T{_ExternalTwoByteString}
reaching type to v203 <- LoadIndexed(v201, v199) [-4611686018427387904, 4611686018427387903] T{_Smi} for v201 is T{*?}
reaching type to v203 <- LoadIndexed(v201, v199) [-4611686018427387904, 4611686018427387903] T{_Smi} for v199 is T{int}
reaching type to v217 <- phi(v181, v192, v203, v212) alive [-4611686018427387904, 4611686018427387903] int64 T{_Smi} for v203 is T{_Smi}
reaching type to v322 <- phi(v177, v186, v197, v208) alive [0, 2305843009213693951] T{_Smi} for v197 is T{_Smi}
reaching type to v352 <- Redefinition(v2 ^ T{_ExternalOneByteString}) T{_ExternalOneByteString} for v2 is T{_StringBase}
reaching type to v186 <- LoadField(v352 . String.length {final}) [0, 2305843009213693951] T{_Smi} for v352 is T{_ExternalOneByteString}
reaching type to v188 <- GenericCheckBound:38(v186, v14) [-9223372036854775808, 9223372036854775807] T{int} for v186 is T{_Smi}
reaching type to v188 <- GenericCheckBound:38(v186, v14) [-9223372036854775808, 9223372036854775807] T{int} for v14 is T{int}
reaching type to v190 <- LoadUntagged(v352, 16) T{*?} for v352 is T{_ExternalOneByteString}
reaching type to v192 <- LoadIndexed(v190, v188) [-4611686018427387904, 4611686018427387903] T{_Smi} for v190 is T{*?}
reaching type to v192 <- LoadIndexed(v190, v188) [-4611686018427387904, 4611686018427387903] T{_Smi} for v188 is T{int}
reaching type to v217 <- phi(v181, v192, v203, v212) alive [-4611686018427387904, 4611686018427387903] int64 T{_Smi} for v192 is T{_Smi}
reaching type to v322 <- phi(v177, v186, v197, v208) alive [0, 2305843009213693951] T{_Smi} for v186 is T{_Smi}
reaching type to Branch if EqualityCompare(v217 == v338) T{bool} goto (7, 5) for v217 is T{_Smi}
reaching type to Branch if EqualityCompare(v217 == v338) T{bool} goto (7, 5) for v338 is T{_Smi}
reaching type to Branch if EqualityCompare(v217 == v340) T{bool} goto (8, 11) for v217 is T{_Smi}
reaching type to Branch if EqualityCompare(v217 == v340) T{bool} goto (8, 11) for v340 is T{_Smi}
reaching type to v284 <- BoxInt64(v217) [-4611686018427387904, 4611686018427387903] T{_Smi} for v217 is T{_Smi}
reaching type to v24 <- phi(v14, v296 T{int}) alive [-9223372036854775808, 9223372036854775807] T{int} for v14 is T{int}
reaching type to v26 <- phi(v284, v174) alive [-4611686018427387904, 4611686018427387903] T{_Smi} for v284 is T{_Smi}
reaching type to v28 <- phi(v7, v286 T{int}) alive [-4611686018427387859, 4611686018427387948] T{int} for v7 is T{_Smi}
reaching type to Branch if StrictCompare:102(===, v3, v0) goto (13, 23) for v3 is T{_Smi?}
reaching type to Branch if StrictCompare:102(===, v3, v0) goto (13, 23) for v0 is T{Null?}
reaching type to v356 <- Redefinition(v3 ^ T{_Smi}) [-4611686018427387904, 4611686018427387903] T{_Smi} for v3 is T{_Smi?}
reaching type to v30 <- phi(v42, v356) alive [-4611686018427387904, 4611686018427387903] T{_Smi} for v356 is T{_Smi}
reaching type to v272 <- BoxInt64(v8) [-9223372036854775808, 9223372036854775807] T{int} for v8 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v30 is T{_Smi}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v24 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v272 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v28 is T{int}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v34 is T{bool}
reaching type to v35 <- StaticCall:200( _parseRadix@0150898<0> v2, v30, v24, v272 T{int}, v28, v34, v4, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to Return:204(v35) for v35 is T{int?}
reaching type to Branch if StrictCompare(===, v26, v37) T{bool} goto (14, 21) for v26 is T{_Smi}
reaching type to Branch if StrictCompare(===, v26, v37) T{bool} goto (14, 21) for v37 is T{_Smi}
reaching type to v30 <- phi(v42, v356) alive [-4611686018427387904, 4611686018427387903] T{_Smi} for v42 is T{_Smi}
reaching type to v298 <- UnboxInt64(v24 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v24 is T{int}
reaching type to v43 <- BinaryInt64Op(+ [tr], v298 T{int}, v334) [-9223372036854775808, 9223372036854775807] T{int} for v298 is T{int}
reaching type to v43 <- BinaryInt64Op(+ [tr], v298 T{int}, v334) [-9223372036854775808, 9223372036854775807] T{int} for v334 is T{_Smi}
reaching type to Branch if EqualityCompare(v43 == v8) T{bool} goto (15, 16) for v43 is T{int}
reaching type to Branch if EqualityCompare(v43 == v8) T{bool} goto (15, 16) for v8 is T{int}
reaching type to Branch if StrictCompare:138(===, v216, v128) goto (25, 30) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v216, v128) goto (25, 30) for v128 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v216, v129) goto (26, 31) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v216, v129) goto (26, 31) for v129 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v216, v130) goto (27, 32) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:138(===, v216, v130) goto (27, 32) for v130 is T{_Smi}
reaching type to v302 <- BoxInt64(v43) [-9223372036854775808, 9223372036854775807] T{int} for v43 is T{int}
reaching type to v121 <- GenericCheckBound:138(v322, v302 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v322 is T{_Smi}
reaching type to v121 <- GenericCheckBound:138(v322, v302 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v302 is T{int}
reaching type to v123 <- LoadIndexed(v2 T{_StringBase}, v121) [0, 255] T{_Smi} for v2 is T{_StringBase}
reaching type to v123 <- LoadIndexed(v2 T{_StringBase}, v121) [0, 255] T{_Smi} for v121 is T{int}
reaching type to v131 <- phi(v92, v103, v114, v123) alive [-4611686018427387904, 4611686018427387903] int64 T{_Smi} for v123 is T{_Smi}
reaching type to v362 <- Redefinition(v2 ^ T{_ExternalTwoByteString}) T{_ExternalTwoByteString} for v2 is T{_StringBase}
reaching type to v304 <- BoxInt64(v43) [-9223372036854775808, 9223372036854775807] T{int} for v43 is T{int}
reaching type to v110 <- GenericCheckBound:138(v322, v304 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v322 is T{_Smi}
reaching type to v110 <- GenericCheckBound:138(v322, v304 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v304 is T{int}
reaching type to v112 <- LoadUntagged(v362, 16) T{*?} for v362 is T{_ExternalTwoByteString}
reaching type to v114 <- LoadIndexed(v112, v110) [-4611686018427387904, 4611686018427387903] T{_Smi} for v112 is T{*?}
reaching type to v114 <- LoadIndexed(v112, v110) [-4611686018427387904, 4611686018427387903] T{_Smi} for v110 is T{int}
reaching type to v131 <- phi(v92, v103, v114, v123) alive [-4611686018427387904, 4611686018427387903] int64 T{_Smi} for v114 is T{_Smi}
reaching type to v360 <- Redefinition(v2 ^ T{_ExternalOneByteString}) T{_ExternalOneByteString} for v2 is T{_StringBase}
reaching type to v306 <- BoxInt64(v43) [-9223372036854775808, 9223372036854775807] T{int} for v43 is T{int}
reaching type to v99 <- GenericCheckBound:138(v322, v306 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v322 is T{_Smi}
reaching type to v99 <- GenericCheckBound:138(v322, v306 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v306 is T{int}
reaching type to v101 <- LoadUntagged(v360, 16) T{*?} for v360 is T{_ExternalOneByteString}
reaching type to v103 <- LoadIndexed(v101, v99) [-4611686018427387904, 4611686018427387903] T{_Smi} for v101 is T{*?}
reaching type to v103 <- LoadIndexed(v101, v99) [-4611686018427387904, 4611686018427387903] T{_Smi} for v99 is T{int}
reaching type to v131 <- phi(v92, v103, v114, v123) alive [-4611686018427387904, 4611686018427387903] int64 T{_Smi} for v103 is T{_Smi}
reaching type to v50 <- BinaryInt64Op(| [tr], v131, v344) [-4611686018427387904, 4611686018427387903] T{int} for v131 is T{_Smi}
reaching type to v50 <- BinaryInt64Op(| [tr], v131, v344) [-4611686018427387904, 4611686018427387903] T{int} for v344 is T{_Smi}
reaching type to Branch if EqualityCompare(v50 == v346) T{bool} goto (17, 20) for v50 is T{int}
reaching type to Branch if EqualityCompare(v50 == v346) T{bool} goto (17, 20) for v346 is T{_Smi}
reaching type to v55 <- BinaryInt64Op(+ [tr], v43, v334) [-9223372036854775808, 9223372036854775807] T{int} for v43 is T{int}
reaching type to v55 <- BinaryInt64Op(+ [tr], v43, v334) [-9223372036854775808, 9223372036854775807] T{int} for v334 is T{_Smi}
reaching type to Branch if EqualityCompare(v55 == v8) T{bool} goto (18, 19) for v55 is T{int}
reaching type to Branch if EqualityCompare(v55 == v8) T{bool} goto (18, 19) for v8 is T{int}
reaching type to v300 <- UnboxInt64(v28 T{int}) [-4611686018427387859, 4611686018427387948] T{int} for v28 is T{int}
reaching type to v60 <- RelationalOp(>, v300 T{int}, v336) T{bool} for v300 is T{int}
reaching type to v60 <- RelationalOp(>, v300 T{int}, v336) T{bool} for v336 is T{_Smi}
reaching type to v270 <- BoxInt64(v8) [-9223372036854775808, 9223372036854775807] T{int} for v8 is T{int}
reaching type to v320 <- BoxInt64(v55) [-9223372036854775808, 9223372036854775807] T{int} for v55 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v59 is T{_Smi}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v320 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v270 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v28 is T{int}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v60 is T{bool}
reaching type to v62 <- StaticCall:174( _parseRadix@0150898<0> v2, v59, v320 T{int}, v270 T{int}, v28 T{int}, v60, v4, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to Return:178(v62) for v62 is T{int?}
reaching type to v318 <- BoxInt64(v55) [-9223372036854775808, 9223372036854775807] T{int} for v55 is T{int}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v318 T{int}, v0, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v318 T{int}, v0, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v318 T{int}, v0, v0, result_type = T{int?}) T{int?} for v318 is T{int}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v318 T{int}, v0, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to v64 <- StaticCall:164( _throwFormatException@0150898<0> v4, v2, v318 T{int}, v0, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:168(v64) for v64 is T{int?}
reaching type to v358 <- Redefinition(v2 ^ T{_TwoByteString}) T{_TwoByteString} for v2 is T{_StringBase}
reaching type to v308 <- BoxInt64(v43) [-9223372036854775808, 9223372036854775807] T{int} for v43 is T{int}
reaching type to v90 <- GenericCheckBound:138(v322, v308 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v322 is T{_Smi}
reaching type to v90 <- GenericCheckBound:138(v322, v308 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v308 is T{int}
reaching type to v92 <- LoadIndexed(v358, v90) [0, 65535] T{_Smi} for v358 is T{_TwoByteString}
reaching type to v92 <- LoadIndexed(v358, v90) [0, 65535] T{_Smi} for v90 is T{int}
reaching type to v131 <- phi(v92, v103, v114, v123) alive [-4611686018427387904, 4611686018427387903] int64 T{_Smi} for v92 is T{_Smi}
reaching type to Return:134(v10) for v10 is T{_Smi}
reaching type to v67 <- BinaryInt64Op(- [tr], v342, v217) [-4611686018427387859, 4611686018427387948] T{int} for v342 is T{_Smi}
reaching type to v67 <- BinaryInt64Op(- [tr], v342, v217) [-4611686018427387859, 4611686018427387948] T{int} for v217 is T{_Smi}
reaching type to v274 <- UnboxInt64(v14) [-9223372036854775808, 9223372036854775807] T{int} for v14 is T{int}
reaching type to v69 <- BinaryInt64Op(+ [tr], v274 T{int}, v334) [-9223372036854775808, 9223372036854775807] T{int} for v274 is T{int}
reaching type to v69 <- BinaryInt64Op(+ [tr], v274 T{int}, v334) [-9223372036854775808, 9223372036854775807] T{int} for v334 is T{_Smi}
reaching type to Branch if EqualityCompare(v69 == v8) T{bool} goto (9, 10) for v69 is T{int}
reaching type to Branch if EqualityCompare(v69 == v8) T{bool} goto (9, 10) for v8 is T{int}
reaching type to Branch if StrictCompare:92(===, v216, v128) goto (34, 39) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v216, v128) goto (34, 39) for v128 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v216, v129) goto (35, 40) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v216, v129) goto (35, 40) for v129 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v216, v130) goto (36, 41) for v216 is T{_Smi}
reaching type to Branch if StrictCompare:92(===, v216, v130) goto (36, 41) for v130 is T{_Smi}
reaching type to v288 <- BoxInt64(v69) [-9223372036854775808, 9223372036854775807] T{int} for v69 is T{int}
reaching type to v167 <- GenericCheckBound:92(v322, v288 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v322 is T{_Smi}
reaching type to v167 <- GenericCheckBound:92(v322, v288 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v288 is T{int}
reaching type to v169 <- LoadIndexed(v2 T{_StringBase}, v167) [0, 255] T{_Smi} for v2 is T{_StringBase}
reaching type to v169 <- LoadIndexed(v2 T{_StringBase}, v167) [0, 255] T{_Smi} for v167 is T{int}
reaching type to v171 <- BoxInt64(v169) [0, 255] T{_Smi} for v169 is T{_Smi}
reaching type to v174 <- phi(v140, v151, v162, v171) alive [-4611686018427387904, 4611686018427387903] T{_Smi} for v171 is T{_Smi}
reaching type to v368 <- Redefinition(v2 ^ T{_ExternalTwoByteString}) T{_ExternalTwoByteString} for v2 is T{_StringBase}
reaching type to v290 <- BoxInt64(v69) [-9223372036854775808, 9223372036854775807] T{int} for v69 is T{int}
reaching type to v156 <- GenericCheckBound:92(v322, v290 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v322 is T{_Smi}
reaching type to v156 <- GenericCheckBound:92(v322, v290 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v290 is T{int}
reaching type to v158 <- LoadUntagged(v368, 16) T{*?} for v368 is T{_ExternalTwoByteString}
reaching type to v160 <- LoadIndexed(v158, v156) [-4611686018427387904, 4611686018427387903] T{_Smi} for v158 is T{*?}
reaching type to v160 <- LoadIndexed(v158, v156) [-4611686018427387904, 4611686018427387903] T{_Smi} for v156 is T{int}
reaching type to v162 <- BoxInt64(v160) [-4611686018427387904, 4611686018427387903] T{_Smi} for v160 is T{_Smi}
reaching type to v174 <- phi(v140, v151, v162, v171) alive [-4611686018427387904, 4611686018427387903] T{_Smi} for v162 is T{_Smi}
reaching type to v366 <- Redefinition(v2 ^ T{_ExternalOneByteString}) T{_ExternalOneByteString} for v2 is T{_StringBase}
reaching type to v292 <- BoxInt64(v69) [-9223372036854775808, 9223372036854775807] T{int} for v69 is T{int}
reaching type to v145 <- GenericCheckBound:92(v322, v292 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v322 is T{_Smi}
reaching type to v145 <- GenericCheckBound:92(v322, v292 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v292 is T{int}
reaching type to v147 <- LoadUntagged(v366, 16) T{*?} for v366 is T{_ExternalOneByteString}
reaching type to v149 <- LoadIndexed(v147, v145) [-4611686018427387904, 4611686018427387903] T{_Smi} for v147 is T{*?}
reaching type to v149 <- LoadIndexed(v147, v145) [-4611686018427387904, 4611686018427387903] T{_Smi} for v145 is T{int}
reaching type to v151 <- BoxInt64(v149) [-4611686018427387904, 4611686018427387903] T{_Smi} for v149 is T{_Smi}
reaching type to v174 <- phi(v140, v151, v162, v171) alive [-4611686018427387904, 4611686018427387903] T{_Smi} for v151 is T{_Smi}
reaching type to v286 <- BoxInt64(v67) [-4611686018427387859, 4611686018427387948] T{int} for v67 is T{int}
reaching type to v296 <- BoxInt64(v69) [-9223372036854775808, 9223372036854775807] T{int} for v69 is T{int}
reaching type to v24 <- phi(v14, v296 T{int}) alive [-9223372036854775808, 9223372036854775807] T{int} for v296 is T{int}
reaching type to v26 <- phi(v284, v174) alive [-4611686018427387904, 4611686018427387903] T{_Smi} for v174 is T{_Smi}
reaching type to v28 <- phi(v7, v286 T{int}) alive [-4611686018427387859, 4611686018427387948] T{int} for v286 is T{int}
reaching type to v364 <- Redefinition(v2 ^ T{_TwoByteString}) T{_TwoByteString} for v2 is T{_StringBase}
reaching type to v294 <- BoxInt64(v69) [-9223372036854775808, 9223372036854775807] T{int} for v69 is T{int}
reaching type to v136 <- GenericCheckBound:92(v322, v294 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v322 is T{_Smi}
reaching type to v136 <- GenericCheckBound:92(v322, v294 T{int}) [-9223372036854775808, 9223372036854775807] T{int} for v294 is T{int}
reaching type to v138 <- LoadIndexed(v364, v136) [0, 65535] T{_Smi} for v364 is T{_TwoByteString}
reaching type to v138 <- LoadIndexed(v364, v136) [0, 65535] T{_Smi} for v136 is T{int}
reaching type to v140 <- BoxInt64(v138) [0, 65535] T{_Smi} for v138 is T{_Smi}
reaching type to v174 <- phi(v140, v151, v162, v171) alive [-4611686018427387904, 4611686018427387903] T{_Smi} for v140 is T{_Smi}
reaching type to v268 <- BoxInt64(v8) [-9223372036854775808, 9223372036854775807] T{int} for v8 is T{int}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v268 T{int}, v3, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v268 T{int}, v3, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v268 T{int}, v3, v0, result_type = T{int?}) T{int?} for v268 is T{int}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v268 T{int}, v3, v0, result_type = T{int?}) T{int?} for v3 is T{_Smi?}
reaching type to v75 <- StaticCall:84( _throwFormatException@0150898<0> v4, v2, v268 T{int}, v3, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:88(v75) for v75 is T{int?}
reaching type to v350 <- Redefinition(v2 ^ T{_TwoByteString}) T{_TwoByteString} for v2 is T{_StringBase}
reaching type to v177 <- LoadField(v350 . String.length {final}) [0, 2305843009213693951] T{_Smi} for v350 is T{_TwoByteString}
reaching type to v179 <- GenericCheckBound:38(v177, v14) [-9223372036854775808, 9223372036854775807] T{int} for v177 is T{_Smi}
reaching type to v179 <- GenericCheckBound:38(v177, v14) [-9223372036854775808, 9223372036854775807] T{int} for v14 is T{int}
reaching type to v181 <- LoadIndexed(v350, v179) [0, 65535] T{_Smi} for v350 is T{_TwoByteString}
reaching type to v181 <- LoadIndexed(v350, v179) [0, 65535] T{_Smi} for v179 is T{int}
reaching type to v217 <- phi(v181, v192, v203, v212) alive [-4611686018427387904, 4611686018427387903] int64 T{_Smi} for v181 is T{_Smi}
reaching type to v322 <- phi(v177, v186, v197, v208) alive [0, 2305843009213693951] T{_Smi} for v177 is T{_Smi}
reaching type to v224 <- LoadField(v2 T{_StringBase} . String.length {final}) [0, 2305843009213693951] T{_Smi} for v2 is T{_StringBase}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v4 is T{*?}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v2 is T{_StringBase}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v224 is T{_Smi}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v3 is T{_Smi?}
reaching type to v79 <- StaticCall:28( _throwFormatException@0150898<0> v4, v2, v224, v3, v0, result_type = T{int?}) T{int?} for v0 is T{Null?}
reaching type to Return:32(v79) for v79 is T{int?}
recomputing type of v174: T{}
  phi 174 input 0: v140 has reaching type T{_Smi}
  phi 174 input 1: v151 has reaching type T{_Smi}
  phi 174 input 2: v162 has reaching type T{_Smi}
  phi 174 input 3: v171 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v26: T{}
  phi 26 input 0: v284 has reaching type T{_Smi}
  phi 26 input 1: v174 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v131: T{}
  phi 131 input 0: v92 has reaching type T{_Smi}
  phi 131 input 1: v103 has reaching type T{_Smi}
  phi 131 input 2: v114 has reaching type T{_Smi}
  phi 131 input 3: v123 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v50: T{int}
recomputing type of v30: T{}
  phi 30 input 0: v42 has reaching type T{_Smi}
  phi 30 input 1: v356 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v35: T{int?}
recomputing type of v28: T{}
  phi 28 input 0: v7 has reaching type T{_Smi}
  phi 28 input 1: v286 has reaching type T{int}
  ... new type T{int}
recomputing type of v35: T{int?}
recomputing type of v62: T{int?}
recomputing type of v300: T{int}
recomputing type of v26: T{_Smi}
  phi 26 input 0: v284 has reaching type T{_Smi}
  phi 26 input 1: v174 has reaching type T{_Smi}
recomputing type of v24: T{}
  phi 24 input 0: v14 has reaching type T{int}
  phi 24 input 1: v296 has reaching type T{int}
  ... new type T{int}
recomputing type of v35: T{int?}
recomputing type of v298: T{int}
recomputing type of v322: T{}
  phi 322 input 0: v177 has reaching type T{_Smi}
  phi 322 input 1: v186 has reaching type T{_Smi}
  phi 322 input 2: v197 has reaching type T{_Smi}
  phi 322 input 3: v208 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v136: T{int}
recomputing type of v145: T{int}
recomputing type of v156: T{int}
recomputing type of v167: T{int}
recomputing type of v90: T{int}
recomputing type of v99: T{int}
recomputing type of v110: T{int}
recomputing type of v121: T{int}
recomputing type of v217: T{}
  phi 217 input 0: v181 has reaching type T{_Smi}
  phi 217 input 1: v192 has reaching type T{_Smi}
  phi 217 input 2: v203 has reaching type T{_Smi}
  phi 217 input 3: v212 has reaching type T{_Smi}
  ... new type T{_Smi}
recomputing type of v67: T{int}
recomputing type of v284: T{_Smi}