roc-lang/roc
1
1
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2024-09-21 15:59:20 +03:00
Code Issues Packages Projects Releases Wiki Activity

mono test output update

Browse Source
This commit is contained in:
Anton-4 2022-04-28 13:03:52 +02:00
parent d8d3d7b30c
commit 2b3eef1cbe
No known key found for this signature in database
GPG Key ID: C954D6E0F9C0ABFD
43 changed files with 564 additions and 586 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
compiler/test_mono/generated/closure_in_list.txt
View File

@ -1,21 +1,21 @@
procedure List.7 (#Attr.2):
let Test.8 : U64 = lowlevel ListLen #Attr.2;
ret Test.8;
procedure List.6 (#Attr.2):
let List.139 : U64 = lowlevel ListLen #Attr.2;
ret List.139;
procedure Test.1 (Test.5):
let Test.2 : I64 = 41i64;
let Test.12 : {I64} = Struct {Test.2};
let Test.11 : List {I64} = Array [Test.12];
ret Test.11;
let Test.11 : {I64} = Struct {Test.2};
let Test.10 : List {I64} = Array [Test.11];
ret Test.10;
procedure Test.3 (Test.10, #Attr.12):
procedure Test.3 (Test.9, #Attr.12):
let Test.2 : I64 = StructAtIndex 0 #Attr.12;
let Test.2 : I64 = 41i64;
ret Test.2;
procedure Test.0 ():
let Test.9 : {} = Struct {};
let Test.7 : List {I64} = CallByName Test.1 Test.9;
let Test.6 : U64 = CallByName List.7 Test.7;
let Test.8 : {} = Struct {};
let Test.7 : List {I64} = CallByName Test.1 Test.8;
let Test.6 : U64 = CallByName List.6 Test.7;
dec Test.7;
ret Test.6;

16
compiler/test_mono/generated/dict.txt
View File

@ -1,13 +1,13 @@
procedure Dict.2 ():
let Test.4 : Dict [] [] = lowlevel DictEmpty ;
ret Test.4;
procedure Dict.1 ():
let Dict.28 : Dict [] [] = lowlevel DictEmpty ;
ret Dict.28;
procedure Dict.8 (#Attr.2):
let Test.3 : U64 = lowlevel DictSize #Attr.2;
procedure Dict.7 (#Attr.2):
let Dict.27 : U64 = lowlevel DictSize #Attr.2;
dec #Attr.2;
ret Test.3;
ret Dict.27;
procedure Test.0 ():
let Test.2 : Dict [] [] = CallByName Dict.2;
let Test.1 : U64 = CallByName Dict.8 Test.2;
let Test.2 : Dict [] [] = CallByName Dict.1;
let Test.1 : U64 = CallByName Dict.7 Test.2;
ret Test.1;

40
compiler/test_mono/generated/empty_list_of_function_type.txt
View File

@ -1,23 +1,23 @@
procedure List.3 (#Attr.2, #Attr.3):
let Test.20 : U64 = lowlevel ListLen #Attr.2;
let Test.17 : Int1 = lowlevel NumLt #Attr.3 Test.20;
if Test.17 then
let Test.19 : {} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
let Test.18 : [C {}, C {}] = Ok Test.19;
ret Test.18;
procedure List.2 (#Attr.2, #Attr.3):
let List.144 : U64 = lowlevel ListLen #Attr.2;
let List.141 : Int1 = lowlevel NumLt #Attr.3 List.144;
if List.141 then
let List.143 : {} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
let List.142 : [C {}, C {}] = Ok List.143;
ret List.142;
else
let Test.16 : {} = Struct {};
let Test.15 : [C {}, C {}] = Err Test.16;
ret Test.15;
let List.140 : {} = Struct {};
let List.139 : [C {}, C {}] = Err List.140;
ret List.139;
procedure Test.2 (Test.6):
let Test.24 : Str = "bar";
ret Test.24;
let Test.18 : Str = "bar";
ret Test.18;
procedure Test.0 ():
joinpoint Test.22 Test.3:
joinpoint Test.16 Test.3:
let Test.14 : U64 = 0i64;
let Test.7 : [C {}, C {}] = CallByName List.3 Test.3 Test.14;
let Test.7 : [C {}, C {}] = CallByName List.2 Test.3 Test.14;
dec Test.3;
let Test.11 : U8 = 1i64;
let Test.12 : U8 = GetTagId Test.7;
@ -32,11 +32,11 @@ procedure Test.0 ():
let Test.10 : Str = "bad!";
ret Test.10;
in
let Test.25 : Int1 = false;
if Test.25 then
let Test.19 : Int1 = false;
if Test.19 then
let Test.1 : List {} = Array [];
jump Test.22 Test.1;
jump Test.16 Test.1;
else
let Test.23 : {} = Struct {};
let Test.21 : List {} = Array [Test.23];
jump Test.22 Test.21;
let Test.17 : {} = Struct {};
let Test.15 : List {} = Array [Test.17];
jump Test.16 Test.15;

28
compiler/test_mono/generated/factorial.txt
View File

@ -1,24 +1,24 @@
procedure Num.23 (#Attr.2, #Attr.3):
let Test.14 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Test.14;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.229 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.229;
procedure Num.24 (#Attr.2, #Attr.3):
let Test.12 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Test.12;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.228 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.228;
procedure Test.1 (Test.17, Test.18):
procedure Test.1 (Test.15, Test.16):
joinpoint Test.7 Test.2 Test.3:
let Test.15 : I64 = 0i64;
let Test.16 : Int1 = lowlevel Eq Test.15 Test.2;
if Test.16 then
let Test.13 : I64 = 0i64;
let Test.14 : Int1 = lowlevel Eq Test.13 Test.2;
if Test.14 then
ret Test.3;
else
let Test.13 : I64 = 1i64;
let Test.10 : I64 = CallByName Num.23 Test.2 Test.13;
let Test.11 : I64 = CallByName Num.24 Test.2 Test.3;
let Test.12 : I64 = 1i64;
let Test.10 : I64 = CallByName Num.20 Test.2 Test.12;
let Test.11 : I64 = CallByName Num.21 Test.2 Test.3;
jump Test.7 Test.10 Test.11;
in
jump Test.7 Test.17 Test.18;
jump Test.7 Test.15 Test.16;
procedure Test.0 ():
let Test.5 : I64 = 10i64;

6
compiler/test_mono/generated/has_none.txt
View File

@ -15,7 +15,7 @@ procedure Test.3 (Test.29):
let Test.15 : Int1 = true;
ret Test.15;
else
let Test.7 : TODO = UnionAtIndex (Id 0) (Index 1) Test.4;
let Test.7 : [<rnu><null>, C [C I64, C ] *self] = UnionAtIndex (Id 0) (Index 1) Test.4;
jump Test.13 Test.7;
in
jump Test.13 Test.29;
@ -23,8 +23,8 @@ procedure Test.3 (Test.29):
procedure Test.0 ():
let Test.28 : I64 = 3i64;
let Test.26 : [C I64, C ] = Just Test.28;
let Test.27 : TODO = Nil ;
let Test.12 : TODO = Cons Test.26 Test.27;
let Test.27 : [<rnu><null>, C [C I64, C ] *self] = Nil ;
let Test.12 : [<rnu><null>, C [C I64, C ] *self] = Cons Test.26 Test.27;
let Test.11 : Int1 = CallByName Test.3 Test.12;
dec Test.12;
ret Test.11;

12
compiler/test_mono/generated/if_guard_bind_variable_false.txt
View File

@ -1,16 +1,16 @@
procedure Bool.7 (#Attr.2, #Attr.3):
let Test.11 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Test.11;
let Bool.14 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.14;
procedure Test.1 (Test.3):
let Test.6 : I64 = 10i64;
joinpoint Test.8 Test.13:
if Test.13 then
joinpoint Test.8 Test.12:
if Test.12 then
let Test.7 : I64 = 0i64;
ret Test.7;
else
let Test.12 : I64 = 42i64;
ret Test.12;
let Test.11 : I64 = 42i64;
ret Test.11;
in
let Test.10 : I64 = 5i64;
let Test.9 : Int1 = CallByName Bool.7 Test.6 Test.10;

30
compiler/test_mono/generated/ir_int_add.txt
View File

@ -1,19 +1,19 @@
procedure List.7 (#Attr.2):
let Test.7 : U64 = lowlevel ListLen #Attr.2;
ret Test.7;
procedure List.6 (#Attr.2):
let List.139 : U64 = lowlevel ListLen #Attr.2;
ret List.139;
procedure Num.22 (#Attr.2, #Attr.3):
let Test.5 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Test.5;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.230 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.230;
procedure Test.0 ():
let Test.10 : U64 = 5i64;
let Test.11 : U64 = 4i64;
let Test.8 : U64 = CallByName Num.22 Test.10 Test.11;
let Test.9 : U64 = 3i64;
let Test.3 : U64 = CallByName Num.22 Test.8 Test.9;
let Test.6 : List I64 = Array [1i64, 2i64];
let Test.4 : U64 = CallByName List.7 Test.6;
dec Test.6;
let Test.2 : U64 = CallByName Num.22 Test.3 Test.4;
let Test.8 : U64 = 5i64;
let Test.9 : U64 = 4i64;
let Test.6 : U64 = CallByName Num.19 Test.8 Test.9;
let Test.7 : U64 = 3i64;
let Test.3 : U64 = CallByName Num.19 Test.6 Test.7;
let Test.5 : List I64 = Array [1i64, 2i64];
let Test.4 : U64 = CallByName List.6 Test.5;
dec Test.5;
let Test.2 : U64 = CallByName Num.19 Test.3 Test.4;
ret Test.2;

8
compiler/test_mono/generated/ir_plus.txt
View File

@ -1,9 +1,9 @@
procedure Num.22 (#Attr.2, #Attr.3):
let Test.4 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Test.4;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.228 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.228;
procedure Test.0 ():
let Test.2 : I64 = 1i64;
let Test.3 : I64 = 2i64;
let Test.1 : I64 = CallByName Num.22 Test.2 Test.3;
let Test.1 : I64 = CallByName Num.19 Test.2 Test.3;
ret Test.1;

4
compiler/test_mono/generated/ir_round.txt
View File

@ -1,6 +1,6 @@
procedure Num.45 (#Attr.2):
let Test.3 : I64 = lowlevel NumRound #Attr.2;
ret Test.3;
let Num.228 : I64 = lowlevel NumRound #Attr.2;
ret Num.228;
procedure Test.0 ():
let Test.2 : Float64 = 3.6f64;

8
compiler/test_mono/generated/ir_two_defs.txt
View File

@ -1,9 +1,9 @@
procedure Num.22 (#Attr.2, #Attr.3):
let Test.6 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Test.6;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.228 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.228;
procedure Test.0 ():
let Test.4 : I64 = 3i64;
let Test.5 : I64 = 4i64;
let Test.3 : I64 = CallByName Num.22 Test.4 Test.5;
let Test.3 : I64 = CallByName Num.19 Test.4 Test.5;
ret Test.3;

18
compiler/test_mono/generated/ir_when_idiv.txt
View File

@ -1,14 +1,14 @@
procedure Num.40 (#Attr.2, #Attr.3):
let Test.15 : I64 = 0i64;
let Test.12 : Int1 = lowlevel NotEq #Attr.3 Test.15;
if Test.12 then
let Test.14 : I64 = lowlevel NumDivUnchecked #Attr.2 #Attr.3;
let Test.13 : [C {}, C I64] = Ok Test.14;
ret Test.13;
let Num.233 : I64 = 0i64;
let Num.230 : Int1 = lowlevel NotEq #Attr.3 Num.233;
if Num.230 then
let Num.232 : I64 = lowlevel NumDivUnchecked #Attr.2 #Attr.3;
let Num.231 : [C {}, C I64] = Ok Num.232;
ret Num.231;
else
let Test.11 : {} = Struct {};
let Test.10 : [C {}, C I64] = Err Test.11;
ret Test.10;
let Num.229 : {} = Struct {};
let Num.228 : [C {}, C I64] = Err Num.229;
ret Num.228;
procedure Test.0 ():
let Test.8 : I64 = 1000i64;

24
compiler/test_mono/generated/ir_when_just.txt
View File

@ -1,18 +1,18 @@
procedure Num.22 (#Attr.2, #Attr.3):
let Test.6 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Test.6;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.228 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.228;
procedure Test.0 ():
let Test.11 : I64 = 41i64;
let Test.1 : [C I64, C ] = Just Test.11;
let Test.8 : U8 = 0i64;
let Test.9 : U8 = GetTagId Test.1;
let Test.10 : Int1 = lowlevel Eq Test.8 Test.9;
if Test.10 then
let Test.10 : I64 = 41i64;
let Test.1 : [C I64, C ] = Just Test.10;
let Test.7 : U8 = 0i64;
let Test.8 : U8 = GetTagId Test.1;
let Test.9 : Int1 = lowlevel Eq Test.7 Test.8;
if Test.9 then
let Test.3 : I64 = UnionAtIndex (Id 0) (Index 0) Test.1;
let Test.5 : I64 = 1i64;
let Test.4 : I64 = CallByName Num.22 Test.3 Test.5;
let Test.4 : I64 = CallByName Num.19 Test.3 Test.5;
ret Test.4;
else
let Test.7 : I64 = 1i64;
ret Test.7;
let Test.6 : I64 = 1i64;
ret Test.6;

4
compiler/test_mono/generated/is_nil.txt
View File

@ -11,8 +11,8 @@ procedure Test.2 (Test.3):
procedure Test.0 ():
let Test.15 : I64 = 2i64;
let Test.16 : TODO = Nil ;
let Test.9 : TODO = Cons Test.15 Test.16;
let Test.16 : [<rnu><null>, C I64 *self] = Nil ;
let Test.9 : [<rnu><null>, C I64 *self] = Cons Test.15 Test.16;
let Test.8 : Int1 = CallByName Test.2 Test.9;
dec Test.9;
ret Test.8;

60
compiler/test_mono/generated/issue_2583_specialize_errors_behind_unified_branches.txt
View File

@ -1,40 +1,40 @@
procedure List.10 (#Attr.2):
let Test.20 : U64 = 0i64;
let Test.21 : U64 = lowlevel ListLen #Attr.2;
let Test.16 : Int1 = lowlevel NotEq Test.20 Test.21;
if Test.16 then
let Test.19 : U64 = 0i64;
let Test.18 : I64 = lowlevel ListGetUnsafe #Attr.2 Test.19;
let Test.17 : [C Int1, C I64] = Ok Test.18;
ret Test.17;
procedure List.9 (#Attr.2):
let List.145 : U64 = 0i64;
let List.146 : U64 = lowlevel ListLen #Attr.2;
let List.141 : Int1 = lowlevel NotEq List.145 List.146;
if List.141 then
let List.144 : U64 = 0i64;
let List.143 : I64 = lowlevel ListGetUnsafe #Attr.2 List.144;
let List.142 : [C Int1, C I64] = Ok List.143;
ret List.142;
else
let Test.15 : Int1 = true;
let Test.14 : [C Int1, C I64] = Err Test.15;
ret Test.14;
let List.140 : Int1 = true;
let List.139 : [C Int1, C I64] = Err List.140;
ret List.139;
procedure Str.28 (#Attr.2):
procedure Str.27 (#Attr.2):
let #Attr.3 : {I64, U8} = lowlevel StrToNum #Attr.2;
let Test.9 : U8 = StructAtIndex 1 #Attr.3;
let Test.10 : U8 = 0i64;
let Test.6 : Int1 = lowlevel NumGt Test.9 Test.10;
if Test.6 then
let Test.8 : Int1 = false;
let Test.7 : [C Int1, C I64] = Err Test.8;
ret Test.7;
let Str.69 : U8 = StructAtIndex 1 #Attr.3;
let Str.70 : U8 = 0i64;
let Str.66 : Int1 = lowlevel NumGt Str.69 Str.70;
if Str.66 then
let Str.68 : Int1 = false;
let Str.67 : [C Int1, C I64] = Err Str.68;
ret Str.67;
else
let Test.5 : I64 = StructAtIndex 0 #Attr.3;
let Test.4 : [C Int1, C I64] = Ok Test.5;
ret Test.4;
let Str.65 : I64 = StructAtIndex 0 #Attr.3;
let Str.64 : [C Int1, C I64] = Ok Str.65;
ret Str.64;
procedure Test.0 ():
let Test.11 : Int1 = true;
if Test.11 then
let Test.13 : List I64 = Array [];
let Test.12 : [C Int1, C I64] = CallByName List.10 Test.13;
dec Test.13;
ret Test.12;
let Test.4 : Int1 = true;
if Test.4 then
let Test.6 : List I64 = Array [];
let Test.5 : [C Int1, C I64] = CallByName List.9 Test.6;
dec Test.6;
ret Test.5;
else
let Test.3 : Str = "";
let Test.2 : [C Int1, C I64] = CallByName Str.28 Test.3;
let Test.2 : [C Int1, C I64] = CallByName Str.27 Test.3;
dec Test.3;
ret Test.2;

8
compiler/test_mono/generated/issue_2810.txt
View File

@ -1,6 +1,6 @@
procedure Test.0 ():
let Test.16 : [C TODO, C ] = SystemTool ;
let Test.14 : TODO = Job Test.16;
let Test.13 : [C TODO, C ] = FromJob Test.14;
let Test.4 : TODO = Job Test.13;
let Test.16 : [C [<rnnu>C [C *self, C ]], C ] = SystemTool ;
let Test.14 : [<rnnu>C [C *self, C ]] = Job Test.16;
let Test.13 : [C [<rnnu>C [C *self, C ]], C ] = FromJob Test.14;
let Test.4 : [<rnnu>C [C *self, C ]] = Job Test.13;
ret Test.4;

32
compiler/test_mono/generated/linked_list_length_twice.txt
View File

@ -1,25 +1,25 @@
procedure Num.22 (#Attr.2, #Attr.3):
let Test.10 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Test.10;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.229 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.229;
procedure Test.3 (Test.5):
let Test.16 : Int1 = 1i64;
let Test.17 : Int1 = GetTagId Test.5;
let Test.18 : Int1 = lowlevel Eq Test.16 Test.17;
if Test.18 then
let Test.12 : I64 = 0i64;
ret Test.12;
let Test.15 : Int1 = 1i64;
let Test.16 : Int1 = GetTagId Test.5;
let Test.17 : Int1 = lowlevel Eq Test.15 Test.16;
if Test.17 then
let Test.11 : I64 = 0i64;
ret Test.11;
else
let Test.6 : TODO = UnionAtIndex (Id 0) (Index 1) Test.5;
let Test.14 : I64 = 1i64;
let Test.15 : I64 = CallByName Test.3 Test.6;
let Test.13 : I64 = CallByName Num.22 Test.14 Test.15;
ret Test.13;
let Test.6 : [<rnu><null>, C I64 *self] = UnionAtIndex (Id 0) (Index 1) Test.5;
let Test.13 : I64 = 1i64;
let Test.14 : I64 = CallByName Test.3 Test.6;
let Test.12 : I64 = CallByName Num.19 Test.13 Test.14;
ret Test.12;
procedure Test.0 ():
let Test.2 : TODO = Nil ;
let Test.2 : [<rnu><null>, C I64 *self] = Nil ;
let Test.8 : I64 = CallByName Test.3 Test.2;
let Test.9 : I64 = CallByName Test.3 Test.2;
dec Test.2;
let Test.7 : I64 = CallByName Num.22 Test.8 Test.9;
let Test.7 : I64 = CallByName Num.19 Test.8 Test.9;
ret Test.7;

8
compiler/test_mono/generated/list_append.txt
View File

@ -1,9 +1,9 @@
procedure List.5 (#Attr.2, #Attr.3):
let Test.4 : List I64 = lowlevel ListAppend #Attr.2 #Attr.3;
ret Test.4;
procedure List.4 (#Attr.2, #Attr.3):
let List.139 : List I64 = lowlevel ListAppend #Attr.2 #Attr.3;
ret List.139;
procedure Test.0 ():
let Test.2 : List I64 = Array [1i64];
let Test.3 : I64 = 2i64;
let Test.1 : List I64 = CallByName List.5 Test.2 Test.3;
let Test.1 : List I64 = CallByName List.4 Test.2 Test.3;
ret Test.1;

8
compiler/test_mono/generated/list_append_closure.txt
View File

@ -1,10 +1,10 @@
procedure List.5 (#Attr.2, #Attr.3):
let Test.7 : List I64 = lowlevel ListAppend #Attr.2 #Attr.3;
ret Test.7;
procedure List.4 (#Attr.2, #Attr.3):
let List.139 : List I64 = lowlevel ListAppend #Attr.2 #Attr.3;
ret List.139;
procedure Test.1 (Test.2):
let Test.6 : I64 = 42i64;
let Test.5 : List I64 = CallByName List.5 Test.2 Test.6;
let Test.5 : List I64 = CallByName List.4 Test.2 Test.6;
ret Test.5;
procedure Test.0 ():

75
compiler/test_mono/generated/list_cannot_update_inplace.txt
View File

@ -1,50 +1,45 @@
procedure List.4 (#Attr.2, #Attr.3, #Attr.4):
let Test.24 : U64 = lowlevel ListLen #Attr.2;
let Test.17 : Int1 = lowlevel NumLt #Attr.3 Test.24;
if Test.17 then
let Test.19 : {List I64, I64} = CallByName List.58 #Attr.2 #Attr.3 #Attr.4;
let Test.18 : List I64 = StructAtIndex 0 Test.19;
inc Test.18;
dec Test.19;
ret Test.18;
procedure List.3 (List.63, List.64, List.65):
let List.142 : {List I64, I64} = CallByName List.57 List.63 List.64 List.65;
let List.141 : List I64 = StructAtIndex 0 List.142;
inc List.141;
dec List.142;
ret List.141;
procedure List.57 (#Attr.2, #Attr.3, #Attr.4):
let List.146 : U64 = lowlevel ListLen #Attr.2;
let List.144 : Int1 = lowlevel NumLt #Attr.3 List.146;
if List.144 then
let List.145 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.145;
else
ret #Attr.2;
let List.143 : {List I64, I64} = Struct {#Attr.2, #Attr.4};
ret List.143;
procedure List.58 (#Attr.2, #Attr.3, #Attr.4):
let Test.23 : U64 = lowlevel ListLen #Attr.2;
let Test.21 : Int1 = lowlevel NumLt #Attr.3 Test.23;
if Test.21 then
let Test.22 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Test.22;
else
let Test.20 : {List I64, I64} = Struct {#Attr.2, #Attr.4};
ret Test.20;
procedure List.6 (#Attr.2):
let List.140 : U64 = lowlevel ListLen #Attr.2;
ret List.140;
procedure List.7 (#Attr.2):
let Test.9 : U64 = lowlevel ListLen #Attr.2;
ret Test.9;
procedure Num.22 (#Attr.2, #Attr.3):
let Test.7 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Test.7;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.228 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.228;
procedure Test.1 ():
let Test.10 : List I64 = Array [1i64, 2i64, 3i64];
ret Test.10;
let Test.8 : List I64 = Array [1i64, 2i64, 3i64];
ret Test.8;
procedure Test.2 (Test.3):
let Test.14 : U64 = 0i64;
let Test.15 : I64 = 0i64;
let Test.13 : List I64 = CallByName List.4 Test.3 Test.14 Test.15;
ret Test.13;
let Test.12 : U64 = 0i64;
let Test.13 : I64 = 0i64;
let Test.11 : List I64 = CallByName List.3 Test.3 Test.12 Test.13;
ret Test.11;
procedure Test.0 ():
let Test.12 : List I64 = CallByName Test.1;
let Test.11 : List I64 = CallByName Test.2 Test.12;
let Test.5 : U64 = CallByName List.7 Test.11;
dec Test.11;
let Test.8 : List I64 = CallByName Test.1;
let Test.6 : U64 = CallByName List.7 Test.8;
dec Test.8;
let Test.4 : U64 = CallByName Num.22 Test.5 Test.6;
let Test.10 : List I64 = CallByName Test.1;
let Test.9 : List I64 = CallByName Test.2 Test.10;
let Test.5 : U64 = CallByName List.6 Test.9;
dec Test.9;
let Test.7 : List I64 = CallByName Test.1;
let Test.6 : U64 = CallByName List.6 Test.7;
dec Test.7;
let Test.4 : U64 = CallByName Num.19 Test.5 Test.6;
ret Test.4;

22
compiler/test_mono/generated/list_get.txt
View File

@ -1,19 +1,19 @@
procedure List.3 (#Attr.2, #Attr.3):
let Test.13 : U64 = lowlevel ListLen #Attr.2;
let Test.10 : Int1 = lowlevel NumLt #Attr.3 Test.13;
if Test.10 then
let Test.12 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
let Test.11 : [C {}, C I64] = Ok Test.12;
ret Test.11;
procedure List.2 (#Attr.2, #Attr.3):
let List.144 : U64 = lowlevel ListLen #Attr.2;
let List.141 : Int1 = lowlevel NumLt #Attr.3 List.144;
if List.141 then
let List.143 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
let List.142 : [C {}, C I64] = Ok List.143;
ret List.142;
else
let Test.9 : {} = Struct {};
let Test.8 : [C {}, C I64] = Err Test.9;
ret Test.8;
let List.140 : {} = Struct {};
let List.139 : [C {}, C I64] = Err List.140;
ret List.139;
procedure Test.1 (Test.2):
let Test.6 : List I64 = Array [1i64, 2i64, 3i64];
let Test.7 : U64 = 0i64;
let Test.5 : [C {}, C I64] = CallByName List.3 Test.6 Test.7;
let Test.5 : [C {}, C I64] = CallByName List.2 Test.6 Test.7;
dec Test.6;
ret Test.5;

30
compiler/test_mono/generated/list_len.txt
View File

@ -1,21 +1,21 @@
procedure List.7 (#Attr.2):
let Test.10 : U64 = lowlevel ListLen #Attr.2;
ret Test.10;
procedure List.6 (#Attr.2):
let List.139 : U64 = lowlevel ListLen #Attr.2;
ret List.139;
procedure List.7 (#Attr.2):
let Test.8 : U64 = lowlevel ListLen #Attr.2;
ret Test.8;
procedure List.6 (#Attr.2):
let List.140 : U64 = lowlevel ListLen #Attr.2;
ret List.140;
procedure Num.22 (#Attr.2, #Attr.3):
let Test.6 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Test.6;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.228 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.228;
procedure Test.0 ():
let Test.9 : List I64 = Array [1i64, 2i64, 3i64];
let Test.4 : U64 = CallByName List.7 Test.9;
dec Test.9;
let Test.7 : List Float64 = Array [1f64];
let Test.5 : U64 = CallByName List.7 Test.7;
let Test.7 : List I64 = Array [1i64, 2i64, 3i64];
let Test.4 : U64 = CallByName List.6 Test.7;
dec Test.7;
let Test.3 : U64 = CallByName Num.22 Test.4 Test.5;
let Test.6 : List Float64 = Array [1f64];
let Test.5 : U64 = CallByName List.6 Test.6;
dec Test.6;
let Test.3 : U64 = CallByName Num.19 Test.4 Test.5;
ret Test.3;

35
compiler/test_mono/generated/list_pass_to_function.txt
View File

@ -1,29 +1,24 @@
procedure List.4 (#Attr.2, #Attr.3, #Attr.4):
let Test.16 : U64 = lowlevel ListLen #Attr.2;
let Test.9 : Int1 = lowlevel NumLt #Attr.3 Test.16;
if Test.9 then
let Test.11 : {List I64, I64} = CallByName List.58 #Attr.2 #Attr.3 #Attr.4;
let Test.10 : List I64 = StructAtIndex 0 Test.11;
inc Test.10;
dec Test.11;
ret Test.10;
else
ret #Attr.2;
procedure List.3 (List.63, List.64, List.65):
let List.140 : {List I64, I64} = CallByName List.57 List.63 List.64 List.65;
let List.139 : List I64 = StructAtIndex 0 List.140;
inc List.139;
dec List.140;
ret List.139;
procedure List.58 (#Attr.2, #Attr.3, #Attr.4):
let Test.15 : U64 = lowlevel ListLen #Attr.2;
let Test.13 : Int1 = lowlevel NumLt #Attr.3 Test.15;
if Test.13 then
let Test.14 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Test.14;
procedure List.57 (#Attr.2, #Attr.3, #Attr.4):
let List.144 : U64 = lowlevel ListLen #Attr.2;
let List.142 : Int1 = lowlevel NumLt #Attr.3 List.144;
if List.142 then
let List.143 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.143;
else
let Test.12 : {List I64, I64} = Struct {#Attr.2, #Attr.4};
ret Test.12;
let List.141 : {List I64, I64} = Struct {#Attr.2, #Attr.4};
ret List.141;
procedure Test.2 (Test.3):
let Test.6 : U64 = 0i64;
let Test.7 : I64 = 0i64;
let Test.5 : List I64 = CallByName List.4 Test.3 Test.6 Test.7;
let Test.5 : List I64 = CallByName List.3 Test.3 Test.6 Test.7;
ret Test.5;
procedure Test.0 ():

28
compiler/test_mono/generated/monomorphized_ints_aliased.txt
View File

@ -1,21 +1,21 @@
procedure Num.22 (#Attr.2, #Attr.3):
let Test.12 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Test.12;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.228 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.228;
procedure Test.5 (Test.7, Test.8):
let Test.18 : U64 = 1i64;
ret Test.18;
let Test.17 : U64 = 1i64;
ret Test.17;
procedure Test.6 (Test.7, Test.8):
let Test.15 : U64 = 1i64;
ret Test.15;
let Test.14 : U64 = 1i64;
ret Test.14;
procedure Test.0 ():
let Test.16 : U8 = 100i64;
let Test.17 : U32 = 100i64;
let Test.10 : U64 = CallByName Test.5 Test.16 Test.17;
let Test.13 : U32 = 100i64;
let Test.14 : U8 = 100i64;
let Test.11 : U64 = CallByName Test.6 Test.13 Test.14;
let Test.9 : U64 = CallByName Num.22 Test.10 Test.11;
let Test.15 : U8 = 100i64;
let Test.16 : U32 = 100i64;
let Test.10 : U64 = CallByName Test.5 Test.15 Test.16;
let Test.12 : U32 = 100i64;
let Test.13 : U8 = 100i64;
let Test.11 : U64 = CallByName Test.6 Test.12 Test.13;
let Test.9 : U64 = CallByName Num.19 Test.10 Test.11;
ret Test.9;

46
compiler/test_mono/generated/nested_pattern_match.txt
View File

@ -1,30 +1,30 @@
procedure Num.22 (#Attr.2, #Attr.3):
let Test.8 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Test.8;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.228 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.228;
procedure Test.0 ():
let Test.20 : I64 = 41i64;
let Test.19 : [C I64, C ] = Just Test.20;
let Test.2 : [C [C I64, C ], C ] = Just Test.19;
joinpoint Test.16:
let Test.9 : I64 = 1i64;
ret Test.9;
let Test.19 : I64 = 41i64;
let Test.18 : [C I64, C ] = Just Test.19;
let Test.2 : [C [C I64, C ], C ] = Just Test.18;
joinpoint Test.15:
let Test.8 : I64 = 1i64;
ret Test.8;
in
let Test.14 : U8 = 0i64;
let Test.15 : U8 = GetTagId Test.2;
let Test.18 : Int1 = lowlevel Eq Test.14 Test.15;
if Test.18 then
let Test.11 : [C I64, C ] = UnionAtIndex (Id 0) (Index 0) Test.2;
let Test.12 : U8 = 0i64;
let Test.13 : U8 = GetTagId Test.11;
let Test.17 : Int1 = lowlevel Eq Test.12 Test.13;
if Test.17 then
let Test.10 : [C I64, C ] = UnionAtIndex (Id 0) (Index 0) Test.2;
let Test.5 : I64 = UnionAtIndex (Id 0) (Index 0) Test.10;
let Test.13 : U8 = 0i64;
let Test.14 : U8 = GetTagId Test.2;
let Test.17 : Int1 = lowlevel Eq Test.13 Test.14;
if Test.17 then
let Test.10 : [C I64, C ] = UnionAtIndex (Id 0) (Index 0) Test.2;
let Test.11 : U8 = 0i64;
let Test.12 : U8 = GetTagId Test.10;
let Test.16 : Int1 = lowlevel Eq Test.11 Test.12;
if Test.16 then
let Test.9 : [C I64, C ] = UnionAtIndex (Id 0) (Index 0) Test.2;
let Test.5 : I64 = UnionAtIndex (Id 0) (Index 0) Test.9;
let Test.7 : I64 = 1i64;
let Test.6 : I64 = CallByName Num.22 Test.5 Test.7;
let Test.6 : I64 = CallByName Num.19 Test.5 Test.7;
ret Test.6;
else
jump Test.16;
jump Test.15;
else
jump Test.16;
jump Test.15;

16
compiler/test_mono/generated/opaque_assign_to_symbol.txt
View File

@ -1,10 +1,8 @@
procedure : `#UserApp.fromUtf8` [C {}, C U8]
procedure = `#UserApp.fromUtf8` (`#UserApp.char`):
let `#UserApp.3` : [C {}, C U8] = Ok `#UserApp.4`;
ret `#UserApp.3`;
procedure Test.3 (Test.4):
let Test.8 : [C {}, C U8] = Ok Test.4;
ret Test.8;
procedure : `#UserApp.out` [C {}, C U8]
procedure = `#UserApp.out` ():
let `#UserApp.2` : U8 = 98i64;
let `#UserApp.1` : [C {}, C U8] = CallByName `#UserApp.fromUtf8` `#UserApp.2`;
ret `#UserApp.1`;
procedure Test.0 ():
let Test.7 : U8 = 98i64;
let Test.6 : [C {}, C U8] = CallByName Test.3 Test.7;
ret Test.6;

50
compiler/test_mono/generated/optional_when.txt
View File

@ -1,11 +1,11 @@
procedure Num.24 (#Attr.2, #Attr.3):
let Test.18 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Test.18;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.230 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.230;
procedure Test.1 (Test.6):
let Test.22 : Int1 = false;
let Test.23 : Int1 = lowlevel Eq Test.22 Test.6;
if Test.23 then
let Test.21 : Int1 = false;
let Test.22 : Int1 = lowlevel Eq Test.21 Test.6;
if Test.22 then
let Test.8 : I64 = 3i64;
ret Test.8;
else
@ -13,10 +13,10 @@ procedure Test.1 (Test.6):
ret Test.10;
procedure Test.1 (Test.6):
let Test.30 : Int1 = StructAtIndex 1 Test.6;
let Test.31 : Int1 = false;
let Test.32 : Int1 = lowlevel Eq Test.31 Test.30;
if Test.32 then
let Test.29 : Int1 = StructAtIndex 1 Test.6;
let Test.30 : Int1 = false;
let Test.31 : Int1 = lowlevel Eq Test.30 Test.29;
if Test.31 then
let Test.8 : I64 = StructAtIndex 0 Test.6;
ret Test.8;
else
@ -24,19 +24,19 @@ procedure Test.1 (Test.6):
ret Test.10;
procedure Test.0 ():
let Test.40 : I64 = 7i64;
let Test.41 : Int1 = false;
let Test.39 : {I64, Int1} = Struct {Test.40, Test.41};
let Test.35 : I64 = CallByName Test.1 Test.39;
let Test.38 : Int1 = false;
let Test.36 : I64 = CallByName Test.1 Test.38;
let Test.25 : I64 = CallByName Num.24 Test.35 Test.36;
let Test.33 : I64 = 11i64;
let Test.34 : Int1 = true;
let Test.27 : {I64, Int1} = Struct {Test.33, Test.34};
let Test.26 : I64 = CallByName Test.1 Test.27;
let Test.16 : I64 = CallByName Num.24 Test.25 Test.26;
let Test.24 : Int1 = true;
let Test.17 : I64 = CallByName Test.1 Test.24;
let Test.15 : I64 = CallByName Num.24 Test.16 Test.17;
let Test.39 : I64 = 7i64;
let Test.40 : Int1 = false;
let Test.38 : {I64, Int1} = Struct {Test.39, Test.40};
let Test.34 : I64 = CallByName Test.1 Test.38;
let Test.37 : Int1 = false;
let Test.35 : I64 = CallByName Test.1 Test.37;
let Test.24 : I64 = CallByName Num.21 Test.34 Test.35;
let Test.32 : I64 = 11i64;
let Test.33 : Int1 = true;
let Test.26 : {I64, Int1} = Struct {Test.32, Test.33};
let Test.25 : I64 = CallByName Test.1 Test.26;
let Test.16 : I64 = CallByName Num.21 Test.24 Test.25;
let Test.23 : Int1 = true;
let Test.17 : I64 = CallByName Test.1 Test.23;
let Test.15 : I64 = CallByName Num.21 Test.16 Test.17;
ret Test.15;

8
compiler/test_mono/generated/peano.txt
View File

@ -1,6 +1,6 @@
procedure Test.0 ():
let Test.10 : TODO = Z ;
let Test.9 : TODO = S Test.10;
let Test.8 : TODO = S Test.9;
let Test.2 : TODO = S Test.8;
let Test.10 : [<rnu><null>, C *self] = Z ;
let Test.9 : [<rnu><null>, C *self] = S Test.10;
let Test.8 : [<rnu><null>, C *self] = S Test.9;
let Test.2 : [<rnu><null>, C *self] = S Test.8;
ret Test.2;

8
compiler/test_mono/generated/peano1.txt
View File

@ -1,8 +1,8 @@
procedure Test.0 ():
let Test.14 : TODO = Z ;
let Test.13 : TODO = S Test.14;
let Test.12 : TODO = S Test.13;
let Test.2 : TODO = S Test.12;
let Test.14 : [<rnu><null>, C *self] = Z ;
let Test.13 : [<rnu><null>, C *self] = S Test.14;
let Test.12 : [<rnu><null>, C *self] = S Test.13;
let Test.2 : [<rnu><null>, C *self] = S Test.12;
let Test.9 : Int1 = 1i64;
let Test.10 : Int1 = GetTagId Test.2;
dec Test.2;

10
compiler/test_mono/generated/peano2.txt
View File

@ -1,13 +1,13 @@
procedure Test.0 ():
let Test.20 : TODO = Z ;
let Test.19 : TODO = S Test.20;
let Test.18 : TODO = S Test.19;
let Test.2 : TODO = S Test.18;
let Test.20 : [<rnu><null>, C *self] = Z ;
let Test.19 : [<rnu><null>, C *self] = S Test.20;
let Test.18 : [<rnu><null>, C *self] = S Test.19;
let Test.2 : [<rnu><null>, C *self] = S Test.18;
let Test.15 : Int1 = 0i64;
let Test.16 : Int1 = GetTagId Test.2;
let Test.17 : Int1 = lowlevel Eq Test.15 Test.16;
if Test.17 then
let Test.11 : TODO = UnionAtIndex (Id 0) (Index 0) Test.2;
let Test.11 : [<rnu><null>, C *self] = UnionAtIndex (Id 0) (Index 0) Test.2;
inc Test.11;
dec Test.2;
let Test.12 : Int1 = 0i64;

46
compiler/test_mono/generated/quicksort_help.txt
View File

@ -1,37 +1,37 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.228 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.228;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.229 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.229;
procedure Num.22 (#Attr.2, #Attr.3):
let Test.19 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Test.19;
let Num.230 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.230;
procedure Num.23 (#Attr.2, #Attr.3):
let Test.22 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Test.22;
procedure Num.25 (#Attr.2, #Attr.3):
let Test.26 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Test.26;
procedure Test.1 (Test.27, Test.28, Test.29):
procedure Test.1 (Test.24, Test.25, Test.26):
joinpoint Test.12 Test.2 Test.3 Test.4:
let Test.14 : Int1 = CallByName Num.25 Test.3 Test.4;
let Test.14 : Int1 = CallByName Num.22 Test.3 Test.4;
if Test.14 then
dec Test.2;
let Test.25 : List [] = Array [];
let Test.24 : I64 = 0i64;
let Test.23 : {I64, List []} = Struct {Test.24, Test.25};
let Test.5 : I64 = StructAtIndex 0 Test.23;
let Test.6 : List [] = StructAtIndex 1 Test.23;
let Test.23 : List [] = Array [];
let Test.22 : I64 = 0i64;
let Test.21 : {I64, List []} = Struct {Test.22, Test.23};
let Test.5 : I64 = StructAtIndex 0 Test.21;
let Test.6 : List [] = StructAtIndex 1 Test.21;
inc Test.6;
dec Test.23;
let Test.21 : I64 = 1i64;
let Test.20 : I64 = CallByName Num.23 Test.5 Test.21;
let Test.16 : List I64 = CallByName Test.1 Test.6 Test.3 Test.20;
dec Test.21;
let Test.20 : I64 = 1i64;
let Test.19 : I64 = CallByName Num.20 Test.5 Test.20;
let Test.16 : List I64 = CallByName Test.1 Test.6 Test.3 Test.19;
let Test.18 : I64 = 1i64;
let Test.17 : I64 = CallByName Num.22 Test.5 Test.18;
let Test.17 : I64 = CallByName Num.19 Test.5 Test.18;
jump Test.12 Test.16 Test.17 Test.4;
else
ret Test.2;
in
jump Test.12 Test.27 Test.28 Test.29;
jump Test.12 Test.24 Test.25 Test.26;
procedure Test.0 ():
let Test.9 : List I64 = Array [];

107
compiler/test_mono/generated/quicksort_swap.txt
View File

@ -1,72 +1,67 @@
procedure List.3 (#Attr.2, #Attr.3):
let Test.42 : U64 = lowlevel ListLen #Attr.2;
let Test.39 : Int1 = lowlevel NumLt #Attr.3 Test.42;
if Test.39 then
let Test.41 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
let Test.40 : [C {}, C I64] = Ok Test.41;
ret Test.40;
procedure List.2 (#Attr.2, #Attr.3):
let List.154 : U64 = lowlevel ListLen #Attr.2;
let List.151 : Int1 = lowlevel NumLt #Attr.3 List.154;
if List.151 then
let List.153 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
let List.152 : [C {}, C I64] = Ok List.153;
ret List.152;
else
let Test.38 : {} = Struct {};
let Test.37 : [C {}, C I64] = Err Test.38;
ret Test.37;
let List.150 : {} = Struct {};
let List.149 : [C {}, C I64] = Err List.150;
ret List.149;
procedure List.4 (#Attr.2, #Attr.3, #Attr.4):
let Test.20 : U64 = lowlevel ListLen #Attr.2;
let Test.13 : Int1 = lowlevel NumLt #Attr.3 Test.20;
if Test.13 then
let Test.15 : {List I64, I64} = CallByName List.58 #Attr.2 #Attr.3 #Attr.4;
let Test.14 : List I64 = StructAtIndex 0 Test.15;
inc Test.14;
dec Test.15;
ret Test.14;
else
ret #Attr.2;
procedure List.3 (List.63, List.64, List.65):
let List.142 : {List I64, I64} = CallByName List.57 List.63 List.64 List.65;
let List.141 : List I64 = StructAtIndex 0 List.142;
inc List.141;
dec List.142;
ret List.141;
procedure List.58 (#Attr.2, #Attr.3, #Attr.4):
let Test.19 : U64 = lowlevel ListLen #Attr.2;
let Test.17 : Int1 = lowlevel NumLt #Attr.3 Test.19;
if Test.17 then
let Test.18 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Test.18;
procedure List.57 (#Attr.2, #Attr.3, #Attr.4):
let List.158 : U64 = lowlevel ListLen #Attr.2;
let List.156 : Int1 = lowlevel NumLt #Attr.3 List.158;
if List.156 then
let List.157 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.157;
else
let Test.16 : {List I64, I64} = Struct {#Attr.2, #Attr.4};
ret Test.16;
let List.155 : {List I64, I64} = Struct {#Attr.2, #Attr.4};
ret List.155;
procedure Test.1 (Test.2):
let Test.43 : U64 = 0i64;
let Test.35 : [C {}, C I64] = CallByName List.3 Test.2 Test.43;
let Test.36 : U64 = 0i64;
let Test.34 : [C {}, C I64] = CallByName List.3 Test.2 Test.36;
let Test.8 : {[C {}, C I64], [C {}, C I64]} = Struct {Test.34, Test.35};
joinpoint Test.31:
let Test.22 : List I64 = Array [];
ret Test.22;
let Test.28 : U64 = 0i64;
let Test.26 : [C {}, C I64] = CallByName List.2 Test.2 Test.28;
let Test.27 : U64 = 0i64;
let Test.25 : [C {}, C I64] = CallByName List.2 Test.2 Test.27;
let Test.8 : {[C {}, C I64], [C {}, C I64]} = Struct {Test.25, Test.26};
joinpoint Test.22:
let Test.13 : List I64 = Array [];
ret Test.13;
in
let Test.28 : [C {}, C I64] = StructAtIndex 1 Test.8;
let Test.29 : U8 = 1i64;
let Test.30 : U8 = GetTagId Test.28;
let Test.33 : Int1 = lowlevel Eq Test.29 Test.30;
if Test.33 then
let Test.25 : [C {}, C I64] = StructAtIndex 0 Test.8;
let Test.26 : U8 = 1i64;
let Test.27 : U8 = GetTagId Test.25;
let Test.32 : Int1 = lowlevel Eq Test.26 Test.27;
if Test.32 then
let Test.24 : [C {}, C I64] = StructAtIndex 0 Test.8;
let Test.4 : I64 = UnionAtIndex (Id 1) (Index 0) Test.24;
let Test.23 : [C {}, C I64] = StructAtIndex 1 Test.8;
let Test.5 : I64 = UnionAtIndex (Id 1) (Index 0) Test.23;
let Test.21 : U64 = 0i64;
let Test.10 : List I64 = CallByName List.4 Test.2 Test.21 Test.5;
let Test.19 : [C {}, C I64] = StructAtIndex 1 Test.8;
let Test.20 : U8 = 1i64;
let Test.21 : U8 = GetTagId Test.19;
let Test.24 : Int1 = lowlevel Eq Test.20 Test.21;
if Test.24 then
let Test.16 : [C {}, C I64] = StructAtIndex 0 Test.8;
let Test.17 : U8 = 1i64;
let Test.18 : U8 = GetTagId Test.16;
let Test.23 : Int1 = lowlevel Eq Test.17 Test.18;
if Test.23 then
let Test.15 : [C {}, C I64] = StructAtIndex 0 Test.8;
let Test.4 : I64 = UnionAtIndex (Id 1) (Index 0) Test.15;
let Test.14 : [C {}, C I64] = StructAtIndex 1 Test.8;
let Test.5 : I64 = UnionAtIndex (Id 1) (Index 0) Test.14;
let Test.12 : U64 = 0i64;
let Test.10 : List I64 = CallByName List.3 Test.2 Test.12 Test.5;
let Test.11 : U64 = 0i64;
let Test.9 : List I64 = CallByName List.4 Test.10 Test.11 Test.4;
let Test.9 : List I64 = CallByName List.3 Test.10 Test.11 Test.4;
ret Test.9;
else
dec Test.2;
jump Test.31;
jump Test.22;
else
dec Test.2;
jump Test.31;
jump Test.22;
procedure Test.0 ():
let Test.7 : List I64 = Array [1i64, 2i64];

14
compiler/test_mono/generated/record_optional_field_function_no_use_default.txt
View File

@ -1,16 +1,16 @@
procedure Num.22 (#Attr.2, #Attr.3):
let Test.8 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Test.8;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.228 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.228;
procedure Test.1 (Test.4):
let Test.2 : I64 = StructAtIndex 0 Test.4;
let Test.3 : I64 = StructAtIndex 1 Test.4;
let Test.7 : I64 = CallByName Num.22 Test.2 Test.3;
let Test.7 : I64 = CallByName Num.19 Test.2 Test.3;
ret Test.7;
procedure Test.0 ():
let Test.9 : I64 = 4i64;
let Test.10 : I64 = 9i64;
let Test.6 : {I64, I64} = Struct {Test.9, Test.10};
let Test.8 : I64 = 4i64;
let Test.9 : I64 = 9i64;
let Test.6 : {I64, I64} = Struct {Test.8, Test.9};
let Test.5 : I64 = CallByName Test.1 Test.6;
ret Test.5;

12
compiler/test_mono/generated/record_optional_field_function_use_default.txt
View File

@ -1,13 +1,13 @@
procedure Num.22 (#Attr.2, #Attr.3):
let Test.9 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Test.9;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.228 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.228;
procedure Test.1 (Test.4):
let Test.8 : I64 = 10i64;
let Test.7 : I64 = CallByName Num.22 Test.8 Test.4;
let Test.7 : I64 = CallByName Num.19 Test.8 Test.4;
ret Test.7;
procedure Test.0 ():
let Test.10 : I64 = 9i64;
let Test.5 : I64 = CallByName Test.1 Test.10;
let Test.9 : I64 = 9i64;
let Test.5 : I64 = CallByName Test.1 Test.9;
ret Test.5;

14
compiler/test_mono/generated/record_optional_field_let_no_use_default.txt
View File

@ -1,16 +1,16 @@
procedure Num.22 (#Attr.2, #Attr.3):
let Test.8 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Test.8;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.228 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.228;
procedure Test.1 (Test.2):
let Test.3 : I64 = StructAtIndex 0 Test.2;
let Test.4 : I64 = StructAtIndex 1 Test.2;
let Test.7 : I64 = CallByName Num.22 Test.3 Test.4;
let Test.7 : I64 = CallByName Num.19 Test.3 Test.4;
ret Test.7;
procedure Test.0 ():
let Test.9 : I64 = 4i64;
let Test.10 : I64 = 9i64;
let Test.6 : {I64, I64} = Struct {Test.9, Test.10};
let Test.8 : I64 = 4i64;
let Test.9 : I64 = 9i64;
let Test.6 : {I64, I64} = Struct {Test.8, Test.9};
let Test.5 : I64 = CallByName Test.1 Test.6;
ret Test.5;

12
compiler/test_mono/generated/record_optional_field_let_use_default.txt
View File

@ -1,13 +1,13 @@
procedure Num.22 (#Attr.2, #Attr.3):
let Test.8 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Test.8;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.228 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.228;
procedure Test.1 (Test.2):
let Test.3 : I64 = 10i64;
let Test.7 : I64 = CallByName Num.22 Test.3 Test.2;
let Test.7 : I64 = CallByName Num.19 Test.3 Test.2;
ret Test.7;
procedure Test.0 ():
let Test.9 : I64 = 9i64;
let Test.5 : I64 = CallByName Test.1 Test.9;
let Test.8 : I64 = 9i64;
let Test.5 : I64 = CallByName Test.1 Test.8;
ret Test.5;

101
compiler/test_mono/generated/rigids.txt
View File

@ -1,68 +1,63 @@
procedure List.3 (#Attr.2, #Attr.3):
let Test.44 : U64 = lowlevel ListLen #Attr.2;
let Test.41 : Int1 = lowlevel NumLt #Attr.3 Test.44;
if Test.41 then
let Test.43 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
let Test.42 : [C {}, C I64] = Ok Test.43;
ret Test.42;
procedure List.2 (#Attr.2, #Attr.3):
let List.154 : U64 = lowlevel ListLen #Attr.2;
let List.151 : Int1 = lowlevel NumLt #Attr.3 List.154;
if List.151 then
let List.153 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
let List.152 : [C {}, C I64] = Ok List.153;
ret List.152;
else
let Test.40 : {} = Struct {};
let Test.39 : [C {}, C I64] = Err Test.40;
ret Test.39;
let List.150 : {} = Struct {};
let List.149 : [C {}, C I64] = Err List.150;
ret List.149;
procedure List.4 (#Attr.2, #Attr.3, #Attr.4):
let Test.24 : U64 = lowlevel ListLen #Attr.2;
let Test.17 : Int1 = lowlevel NumLt #Attr.3 Test.24;
if Test.17 then
let Test.19 : {List I64, I64} = CallByName List.58 #Attr.2 #Attr.3 #Attr.4;
let Test.18 : List I64 = StructAtIndex 0 Test.19;
inc Test.18;
dec Test.19;
ret Test.18;
else
ret #Attr.2;
procedure List.3 (List.63, List.64, List.65):
let List.142 : {List I64, I64} = CallByName List.57 List.63 List.64 List.65;
let List.141 : List I64 = StructAtIndex 0 List.142;
inc List.141;
dec List.142;
ret List.141;
procedure List.58 (#Attr.2, #Attr.3, #Attr.4):
let Test.23 : U64 = lowlevel ListLen #Attr.2;
let Test.21 : Int1 = lowlevel NumLt #Attr.3 Test.23;
if Test.21 then
let Test.22 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Test.22;
procedure List.57 (#Attr.2, #Attr.3, #Attr.4):
let List.158 : U64 = lowlevel ListLen #Attr.2;
let List.156 : Int1 = lowlevel NumLt #Attr.3 List.158;
if List.156 then
let List.157 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.157;
else
let Test.20 : {List I64, I64} = Struct {#Attr.2, #Attr.4};
ret Test.20;
let List.155 : {List I64, I64} = Struct {#Attr.2, #Attr.4};
ret List.155;
procedure Test.1 (Test.2, Test.3, Test.4):
let Test.38 : [C {}, C I64] = CallByName List.3 Test.4 Test.3;
let Test.37 : [C {}, C I64] = CallByName List.3 Test.4 Test.2;
let Test.13 : {[C {}, C I64], [C {}, C I64]} = Struct {Test.37, Test.38};
joinpoint Test.34:
let Test.25 : List I64 = Array [];
ret Test.25;
let Test.29 : [C {}, C I64] = CallByName List.2 Test.4 Test.3;
let Test.28 : [C {}, C I64] = CallByName List.2 Test.4 Test.2;
let Test.13 : {[C {}, C I64], [C {}, C I64]} = Struct {Test.28, Test.29};
joinpoint Test.25:
let Test.16 : List I64 = Array [];
ret Test.16;
in
let Test.31 : [C {}, C I64] = StructAtIndex 1 Test.13;
let Test.32 : U8 = 1i64;
let Test.33 : U8 = GetTagId Test.31;
let Test.36 : Int1 = lowlevel Eq Test.32 Test.33;
if Test.36 then
let Test.28 : [C {}, C I64] = StructAtIndex 0 Test.13;
let Test.29 : U8 = 1i64;
let Test.30 : U8 = GetTagId Test.28;
let Test.35 : Int1 = lowlevel Eq Test.29 Test.30;
if Test.35 then
let Test.27 : [C {}, C I64] = StructAtIndex 0 Test.13;
let Test.6 : I64 = UnionAtIndex (Id 1) (Index 0) Test.27;
let Test.26 : [C {}, C I64] = StructAtIndex 1 Test.13;
let Test.7 : I64 = UnionAtIndex (Id 1) (Index 0) Test.26;
let Test.15 : List I64 = CallByName List.4 Test.4 Test.2 Test.7;
let Test.14 : List I64 = CallByName List.4 Test.15 Test.3 Test.6;
let Test.22 : [C {}, C I64] = StructAtIndex 1 Test.13;
let Test.23 : U8 = 1i64;
let Test.24 : U8 = GetTagId Test.22;
let Test.27 : Int1 = lowlevel Eq Test.23 Test.24;
if Test.27 then
let Test.19 : [C {}, C I64] = StructAtIndex 0 Test.13;
let Test.20 : U8 = 1i64;
let Test.21 : U8 = GetTagId Test.19;
let Test.26 : Int1 = lowlevel Eq Test.20 Test.21;
if Test.26 then
let Test.18 : [C {}, C I64] = StructAtIndex 0 Test.13;
let Test.6 : I64 = UnionAtIndex (Id 1) (Index 0) Test.18;
let Test.17 : [C {}, C I64] = StructAtIndex 1 Test.13;
let Test.7 : I64 = UnionAtIndex (Id 1) (Index 0) Test.17;
let Test.15 : List I64 = CallByName List.3 Test.4 Test.2 Test.7;
let Test.14 : List I64 = CallByName List.3 Test.15 Test.3 Test.6;
ret Test.14;
else
dec Test.4;
jump Test.34;
jump Test.25;
else
dec Test.4;
jump Test.34;
jump Test.25;
procedure Test.0 ():
let Test.10 : U64 = 0i64;

32
compiler/test_mono/generated/somehow_drops_definitions.txt
View File

@ -1,27 +1,27 @@
procedure Num.22 (#Attr.2, #Attr.3):
let Test.27 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Test.27;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.229 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.229;
procedure Num.24 (#Attr.2, #Attr.3):
let Test.22 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Test.22;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.228 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.228;
procedure Test.1 ():
let Test.28 : I64 = 1i64;
ret Test.28;
let Test.26 : I64 = 1i64;
ret Test.26;
procedure Test.2 ():
let Test.23 : I64 = 2i64;
ret Test.23;
let Test.22 : I64 = 2i64;
ret Test.22;
procedure Test.3 (Test.6):
let Test.26 : I64 = CallByName Test.1;
let Test.25 : I64 = CallByName Num.22 Test.6 Test.26;
ret Test.25;
let Test.25 : I64 = CallByName Test.1;
let Test.24 : I64 = CallByName Num.19 Test.6 Test.25;
ret Test.24;
procedure Test.4 (Test.7):
let Test.21 : I64 = CallByName Test.2;
let Test.20 : I64 = CallByName Num.24 Test.7 Test.21;
let Test.20 : I64 = CallByName Num.21 Test.7 Test.21;
ret Test.20;
procedure Test.5 (Test.8, Test.9):
@ -44,8 +44,8 @@ procedure Test.0 ():
let Test.11 : I64 = CallByName Test.5 Test.12 Test.13;
ret Test.11;
in
let Test.24 : Int1 = true;
if Test.24 then
let Test.23 : Int1 = true;
if Test.23 then
let Test.3 : Int1 = false;
jump Test.19 Test.3;
else

10
compiler/test_mono/generated/specialize_ability_call.txt
View File

@ -1,7 +1,7 @@
procedure Test.5 (Test.8):
ret Test.8;
procedure Test.5 (Test.7):
ret Test.7;
procedure Test.0 ():
let Test.10 : U64 = 1234i64;
let Test.9 : U64 = CallByName Test.5 Test.10;
ret Test.9;
let Test.9 : U64 = 1234i64;
let Test.8 : U64 = CallByName Test.5 Test.9;
ret Test.8;

24
compiler/test_mono/generated/specialize_closures.txt
View File

@ -1,10 +1,10 @@
procedure Num.22 (#Attr.2, #Attr.3):
let Test.28 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Test.28;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.229 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.229;
procedure Num.24 (#Attr.2, #Attr.3):
let Test.25 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Test.25;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.228 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.228;
procedure Test.1 (Test.2, Test.3):
let Test.17 : U8 = GetTagId Test.2;
@ -23,29 +23,29 @@ procedure Test.1 (Test.2, Test.3):
procedure Test.7 (Test.10, #Attr.12):
let Test.4 : I64 = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Test.27 : I64 = CallByName Num.22 Test.10 Test.4;
ret Test.27;
let Test.26 : I64 = CallByName Num.19 Test.10 Test.4;
ret Test.26;
procedure Test.8 (Test.11, #Attr.12):
let Test.6 : Int1 = UnionAtIndex (Id 1) (Index 1) #Attr.12;
let Test.5 : I64 = UnionAtIndex (Id 1) (Index 0) #Attr.12;
if Test.6 then
let Test.24 : I64 = CallByName Num.24 Test.11 Test.5;
let Test.24 : I64 = CallByName Num.21 Test.11 Test.5;
ret Test.24;
else
ret Test.11;
procedure Test.0 ():
let Test.4 : I64 = 1i64;
let Test.5 : I64 = 2i64;
let Test.6 : Int1 = true;
let Test.4 : I64 = 1i64;
joinpoint Test.22 Test.14:
let Test.15 : I64 = 42i64;
let Test.13 : I64 = CallByName Test.1 Test.14 Test.15;
ret Test.13;
in
let Test.26 : Int1 = true;
if Test.26 then
let Test.25 : Int1 = true;
if Test.25 then
let Test.7 : [C I64, C I64 Int1] = ClosureTag(Test.7) Test.4;
jump Test.22 Test.7;
else

24
compiler/test_mono/generated/specialize_lowlevel.txt
View File

@ -1,24 +1,24 @@
procedure Num.22 (#Attr.2, #Attr.3):
let Test.24 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Test.24;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.229 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.229;
procedure Num.24 (#Attr.2, #Attr.3):
let Test.21 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Test.21;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.228 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.228;
procedure Test.6 (Test.8, #Attr.12):
let Test.4 : I64 = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Test.23 : I64 = CallByName Num.22 Test.8 Test.4;
ret Test.23;
let Test.22 : I64 = CallByName Num.19 Test.8 Test.4;
ret Test.22;
procedure Test.7 (Test.9, #Attr.12):
let Test.5 : I64 = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Test.20 : I64 = CallByName Num.24 Test.9 Test.5;
let Test.20 : I64 = CallByName Num.21 Test.9 Test.5;
ret Test.20;
procedure Test.0 ():
let Test.5 : I64 = 2i64;
let Test.4 : I64 = 1i64;
let Test.5 : I64 = 2i64;
let Test.12 : I64 = 42i64;
joinpoint Test.19 Test.13:
let Test.14 : U8 = GetTagId Test.13;
@ -35,8 +35,8 @@ procedure Test.0 ():
jump Test.15 Test.17;
in
let Test.22 : Int1 = true;
if Test.22 then
let Test.21 : Int1 = true;
if Test.21 then
let Test.6 : [C I64, C I64] = ClosureTag(Test.6) Test.4;
jump Test.19 Test.6;
else

46
compiler/test_mono/generated/when_nested_maybe.txt
View File

@ -1,30 +1,30 @@
procedure Num.22 (#Attr.2, #Attr.3):
let Test.8 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Test.8;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.228 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.228;
procedure Test.0 ():
let Test.20 : I64 = 41i64;
let Test.19 : [C I64, C ] = Just Test.20;
let Test.2 : [C [C I64, C ], C ] = Just Test.19;
joinpoint Test.16:
let Test.9 : I64 = 1i64;
ret Test.9;
let Test.19 : I64 = 41i64;
let Test.18 : [C I64, C ] = Just Test.19;
let Test.2 : [C [C I64, C ], C ] = Just Test.18;
joinpoint Test.15:
let Test.8 : I64 = 1i64;
ret Test.8;
in
let Test.14 : U8 = 0i64;
let Test.15 : U8 = GetTagId Test.2;
let Test.18 : Int1 = lowlevel Eq Test.14 Test.15;
if Test.18 then
let Test.11 : [C I64, C ] = UnionAtIndex (Id 0) (Index 0) Test.2;
let Test.12 : U8 = 0i64;
let Test.13 : U8 = GetTagId Test.11;
let Test.17 : Int1 = lowlevel Eq Test.12 Test.13;
if Test.17 then
let Test.10 : [C I64, C ] = UnionAtIndex (Id 0) (Index 0) Test.2;
let Test.5 : I64 = UnionAtIndex (Id 0) (Index 0) Test.10;
let Test.13 : U8 = 0i64;
let Test.14 : U8 = GetTagId Test.2;
let Test.17 : Int1 = lowlevel Eq Test.13 Test.14;
if Test.17 then
let Test.10 : [C I64, C ] = UnionAtIndex (Id 0) (Index 0) Test.2;
let Test.11 : U8 = 0i64;
let Test.12 : U8 = GetTagId Test.10;
let Test.16 : Int1 = lowlevel Eq Test.11 Test.12;
if Test.16 then
let Test.9 : [C I64, C ] = UnionAtIndex (Id 0) (Index 0) Test.2;
let Test.5 : I64 = UnionAtIndex (Id 0) (Index 0) Test.9;
let Test.7 : I64 = 1i64;
let Test.6 : I64 = CallByName Num.22 Test.5 Test.7;
let Test.6 : I64 = CallByName Num.19 Test.5 Test.7;
ret Test.6;
else
jump Test.16;
jump Test.15;
else
jump Test.16;
jump Test.15;

10
compiler/test_mono/generated/when_on_record.txt
View File

@ -1,9 +1,9 @@
procedure Num.22 (#Attr.2, #Attr.3):
let Test.5 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Test.5;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.228 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.228;
procedure Test.0 ():
let Test.6 : I64 = 2i64;
let Test.5 : I64 = 2i64;
let Test.4 : I64 = 3i64;
let Test.3 : I64 = CallByName Num.22 Test.6 Test.4;
let Test.3 : I64 = CallByName Num.19 Test.5 Test.4;
ret Test.3;

36
compiler/test_mono/generated/when_on_two_values.txt
View File

@ -1,28 +1,28 @@
procedure Num.22 (#Attr.2, #Attr.3):
let Test.7 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Test.7;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.228 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.228;
procedure Test.0 ():
let Test.16 : I64 = 3i64;
let Test.15 : I64 = 2i64;
let Test.4 : {I64, I64} = Struct {Test.15, Test.16};
joinpoint Test.12:
let Test.15 : I64 = 3i64;
let Test.14 : I64 = 2i64;
let Test.4 : {I64, I64} = Struct {Test.14, Test.15};
joinpoint Test.11:
let Test.2 : I64 = StructAtIndex 0 Test.4;
let Test.3 : I64 = StructAtIndex 1 Test.4;
let Test.6 : I64 = CallByName Num.22 Test.2 Test.3;
let Test.6 : I64 = CallByName Num.19 Test.2 Test.3;
ret Test.6;
in
let Test.10 : I64 = StructAtIndex 1 Test.4;
let Test.11 : I64 = 3i64;
let Test.14 : Int1 = lowlevel Eq Test.11 Test.10;
if Test.14 then
let Test.8 : I64 = StructAtIndex 0 Test.4;
let Test.9 : I64 = 4i64;
let Test.13 : Int1 = lowlevel Eq Test.9 Test.8;
if Test.13 then
let Test.9 : I64 = StructAtIndex 1 Test.4;
let Test.10 : I64 = 3i64;
let Test.13 : Int1 = lowlevel Eq Test.10 Test.9;
if Test.13 then
let Test.7 : I64 = StructAtIndex 0 Test.4;
let Test.8 : I64 = 4i64;
let Test.12 : Int1 = lowlevel Eq Test.8 Test.7;
if Test.12 then
let Test.5 : I64 = 9i64;
ret Test.5;
else
jump Test.12;
jump Test.11;
else
jump Test.12;
jump Test.11;