mirror of
https://github.com/roc-lang/roc.git
synced 2025-08-04 04:08:19 +00:00
merge remote/main and update mono
This commit is contained in:
commit
ab4ac1c494
96 changed files with 4746 additions and 3422 deletions
|
@ -68,10 +68,12 @@ procedure List.80 (List.544, List.545, List.546, List.547, List.548):
|
|||
let List.523 : U64 = CallByName Num.19 List.436 List.524;
|
||||
jump List.518 List.433 List.438 List.435 List.523 List.437;
|
||||
else
|
||||
dec List.433;
|
||||
let List.439 : U64 = UnionAtIndex (Id 0) (Index 0) List.521;
|
||||
let List.525 : [C U64, C U64] = TagId(0) List.439;
|
||||
ret List.525;
|
||||
else
|
||||
dec List.433;
|
||||
let List.519 : [C U64, C U64] = TagId(1) List.434;
|
||||
ret List.519;
|
||||
in
|
||||
|
@ -98,6 +100,7 @@ procedure Num.77 (#Attr.2, #Attr.3):
|
|||
procedure Test.1 (Test.2):
|
||||
let Test.13 : U64 = 0i64;
|
||||
let Test.14 : {} = Struct {};
|
||||
inc Test.2;
|
||||
let Test.3 : U64 = CallByName List.26 Test.2 Test.13 Test.14;
|
||||
let Test.12 : U64 = 0i64;
|
||||
let Test.10 : Int1 = CallByName Bool.11 Test.3 Test.12;
|
||||
|
|
|
@ -7,15 +7,18 @@ procedure List.2 (List.96, List.97):
|
|||
let List.504 : Int1 = CallByName Num.22 List.97 List.508;
|
||||
if List.504 then
|
||||
let List.506 : Str = CallByName List.66 List.96 List.97;
|
||||
dec List.96;
|
||||
let List.505 : [C {}, C Str] = TagId(1) List.506;
|
||||
ret List.505;
|
||||
else
|
||||
dec List.96;
|
||||
let List.503 : {} = Struct {};
|
||||
let List.502 : [C {}, C Str] = TagId(0) List.503;
|
||||
ret List.502;
|
||||
|
||||
procedure List.5 (#Attr.2, #Attr.3):
|
||||
let List.510 : List Str = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.10 #Attr.3;
|
||||
decref #Attr.2;
|
||||
ret List.510;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
|
@ -53,13 +56,13 @@ procedure Result.5 (Result.12, Result.13):
|
|||
let Result.40 : U8 = GetTagId Result.12;
|
||||
let Result.41 : Int1 = lowlevel Eq Result.39 Result.40;
|
||||
if Result.41 then
|
||||
dec Result.13;
|
||||
let Result.14 : Str = UnionAtIndex (Id 1) (Index 0) Result.12;
|
||||
inc Result.14;
|
||||
dec Result.12;
|
||||
ret Result.14;
|
||||
else
|
||||
dec Result.12;
|
||||
inc Result.13;
|
||||
ret Result.13;
|
||||
|
||||
procedure Test.10 (Test.11):
|
||||
|
@ -78,6 +81,8 @@ procedure Test.2 (Test.6):
|
|||
let Test.31 : Int1 = lowlevel Eq Test.29 Test.30;
|
||||
if Test.31 then
|
||||
let Test.7 : [<r>C List *self, C *self] = UnionAtIndex (Id 1) (Index 0) Test.6;
|
||||
inc Test.7;
|
||||
dec Test.6;
|
||||
let Test.8 : Str = CallByName Test.2 Test.7;
|
||||
let Test.18 : Int1 = CallByName Bool.1;
|
||||
if Test.18 then
|
||||
|
@ -88,18 +93,17 @@ procedure Test.2 (Test.6):
|
|||
ret Test.17;
|
||||
else
|
||||
let Test.9 : List [<r>C List *self, C *self] = UnionAtIndex (Id 0) (Index 0) Test.6;
|
||||
inc Test.9;
|
||||
dec Test.6;
|
||||
let Test.24 : {} = Struct {};
|
||||
let Test.23 : List Str = CallByName List.5 Test.9 Test.24;
|
||||
let Test.21 : [C {}, C Str] = CallByName List.9 Test.23;
|
||||
dec Test.23;
|
||||
let Test.22 : Str = "foo";
|
||||
let Test.20 : Str = CallByName Result.5 Test.21 Test.22;
|
||||
dec Test.22;
|
||||
ret Test.20;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.32 : List [<r>C List *self, C *self] = Array [];
|
||||
let Test.15 : [<r>C List *self, C *self] = TagId(0) Test.32;
|
||||
let Test.14 : Str = CallByName Test.2 Test.15;
|
||||
dec Test.15;
|
||||
ret Test.14;
|
||||
|
|
|
@ -28,6 +28,7 @@ procedure List.80 (List.517, List.518, List.519, List.520, List.521):
|
|||
let List.505 : U64 = CallByName Num.19 List.436 List.506;
|
||||
jump List.500 List.433 List.503 List.435 List.505 List.437;
|
||||
else
|
||||
dec List.433;
|
||||
ret List.434;
|
||||
in
|
||||
jump List.500 List.517 List.518 List.519 List.520 List.521;
|
||||
|
@ -65,7 +66,6 @@ procedure Test.11 (Test.53, Test.54):
|
|||
case 0:
|
||||
dec Test.7;
|
||||
let Test.28 : Str = CallByName Test.2 Test.29;
|
||||
dec Test.29;
|
||||
ret Test.28;
|
||||
|
||||
case 1:
|
||||
|
@ -89,7 +89,6 @@ procedure Test.11 (Test.53, Test.54):
|
|||
jump Test.27 Test.53 Test.54;
|
||||
|
||||
procedure Test.2 (Test.13):
|
||||
inc Test.13;
|
||||
ret Test.13;
|
||||
|
||||
procedure Test.3 (Test.14):
|
||||
|
@ -136,7 +135,6 @@ procedure Test.9 (Test.10, #Attr.12):
|
|||
case 0:
|
||||
dec Test.7;
|
||||
let Test.39 : Str = CallByName Test.2 Test.10;
|
||||
dec Test.10;
|
||||
jump Test.38 Test.39;
|
||||
|
||||
case 1:
|
||||
|
@ -156,14 +154,12 @@ procedure Test.0 ():
|
|||
let Test.23 : Int1 = CallByName Bool.2;
|
||||
let Test.22 : Int1 = CallByName Test.1 Test.23;
|
||||
let Test.16 : [<rnw><null>, C *self Int1, C *self Int1] = CallByName List.18 Test.20 Test.21 Test.22;
|
||||
dec Test.20;
|
||||
let Test.18 : Str = "hello";
|
||||
let Test.19 : U8 = GetTagId Test.16;
|
||||
switch Test.19:
|
||||
case 0:
|
||||
dec Test.16;
|
||||
let Test.17 : Str = CallByName Test.2 Test.18;
|
||||
dec Test.18;
|
||||
ret Test.17;
|
||||
|
||||
case 1:
|
||||
|
|
|
@ -7,9 +7,11 @@ procedure List.2 (List.96, List.97):
|
|||
let List.496 : Int1 = CallByName Num.22 List.97 List.500;
|
||||
if List.496 then
|
||||
let List.498 : {} = CallByName List.66 List.96 List.97;
|
||||
dec List.96;
|
||||
let List.497 : [C {}, C {}] = TagId(1) List.498;
|
||||
ret List.497;
|
||||
else
|
||||
dec List.96;
|
||||
let List.495 : {} = Struct {};
|
||||
let List.494 : [C {}, C {}] = TagId(0) List.495;
|
||||
ret List.494;
|
||||
|
@ -27,6 +29,7 @@ procedure Num.22 (#Attr.2, #Attr.3):
|
|||
ret Num.275;
|
||||
|
||||
procedure Test.2 (Test.5):
|
||||
dec Test.5;
|
||||
let Test.17 : Str = "bar";
|
||||
ret Test.17;
|
||||
|
||||
|
@ -35,7 +38,6 @@ procedure Test.0 ():
|
|||
joinpoint Test.15 Test.3:
|
||||
let Test.13 : U64 = 0i64;
|
||||
let Test.6 : [C {}, C {}] = CallByName List.2 Test.3 Test.13;
|
||||
dec Test.3;
|
||||
let Test.10 : U8 = 1i64;
|
||||
let Test.11 : U8 = GetTagId Test.6;
|
||||
let Test.12 : Int1 = lowlevel Eq Test.10 Test.11;
|
||||
|
@ -43,7 +45,6 @@ procedure Test.0 ():
|
|||
let Test.4 : {} = UnionAtIndex (Id 1) (Index 0) Test.6;
|
||||
let Test.8 : Str = "foo";
|
||||
let Test.7 : Str = CallByName Test.2 Test.8;
|
||||
dec Test.8;
|
||||
ret Test.7;
|
||||
else
|
||||
let Test.9 : Str = "bad!";
|
||||
|
|
|
@ -88,7 +88,6 @@ procedure Json.162 (Json.163, Json.904, Json.161):
|
|||
let Json.912 : {List U8, U64} = Struct {Json.165, Json.935};
|
||||
let Json.913 : {} = Struct {};
|
||||
let Json.911 : {List U8, U64} = CallByName List.18 Json.161 Json.912 Json.913;
|
||||
dec Json.161;
|
||||
let Json.167 : List U8 = StructAtIndex 0 Json.911;
|
||||
inc Json.167;
|
||||
dec Json.911;
|
||||
|
@ -105,7 +104,6 @@ procedure Json.162 (Json.163, Json.904, Json.161):
|
|||
let Json.952 : {List U8, U64} = Struct {Json.165, Json.975};
|
||||
let Json.953 : {} = Struct {};
|
||||
let Json.951 : {List U8, U64} = CallByName List.18 Json.161 Json.952 Json.953;
|
||||
dec Json.161;
|
||||
let Json.167 : List U8 = StructAtIndex 0 Json.951;
|
||||
inc Json.167;
|
||||
dec Json.951;
|
||||
|
@ -268,6 +266,7 @@ procedure List.80 (List.547, List.548, List.549, List.550, List.551):
|
|||
let List.527 : U64 = CallByName Num.19 List.436 List.528;
|
||||
jump List.522 List.433 List.525 List.435 List.527 List.437;
|
||||
else
|
||||
dec List.433;
|
||||
ret List.434;
|
||||
in
|
||||
jump List.522 List.547 List.548 List.549 List.550 List.551;
|
||||
|
@ -282,6 +281,7 @@ procedure List.80 (List.621, List.622, List.623, List.624, List.625):
|
|||
let List.600 : U64 = CallByName Num.19 List.436 List.601;
|
||||
jump List.595 List.433 List.598 List.435 List.600 List.437;
|
||||
else
|
||||
dec List.433;
|
||||
ret List.434;
|
||||
in
|
||||
jump List.595 List.621 List.622 List.623 List.624 List.625;
|
||||
|
|
|
@ -61,7 +61,6 @@ procedure Json.162 (Json.163, Json.904, Json.161):
|
|||
let Json.912 : {List U8, U64} = Struct {Json.165, Json.935};
|
||||
let Json.913 : {} = Struct {};
|
||||
let Json.911 : {List U8, U64} = CallByName List.18 Json.161 Json.912 Json.913;
|
||||
dec Json.161;
|
||||
let Json.167 : List U8 = StructAtIndex 0 Json.911;
|
||||
inc Json.167;
|
||||
dec Json.911;
|
||||
|
@ -165,6 +164,7 @@ procedure List.80 (List.554, List.555, List.556, List.557, List.558):
|
|||
let List.533 : U64 = CallByName Num.19 List.436 List.534;
|
||||
jump List.528 List.433 List.531 List.435 List.533 List.437;
|
||||
else
|
||||
dec List.433;
|
||||
ret List.434;
|
||||
in
|
||||
jump List.528 List.554 List.555 List.556 List.557 List.558;
|
||||
|
|
|
@ -69,7 +69,6 @@ procedure Json.162 (Json.163, Json.904, Json.161):
|
|||
let Json.912 : {List U8, U64} = Struct {Json.165, Json.935};
|
||||
let Json.913 : {} = Struct {};
|
||||
let Json.911 : {List U8, U64} = CallByName List.18 Json.161 Json.912 Json.913;
|
||||
dec Json.161;
|
||||
let Json.167 : List U8 = StructAtIndex 0 Json.911;
|
||||
inc Json.167;
|
||||
dec Json.911;
|
||||
|
@ -173,6 +172,7 @@ procedure List.80 (List.554, List.555, List.556, List.557, List.558):
|
|||
let List.533 : U64 = CallByName Num.19 List.436 List.534;
|
||||
jump List.528 List.433 List.531 List.435 List.533 List.437;
|
||||
else
|
||||
dec List.433;
|
||||
ret List.434;
|
||||
in
|
||||
jump List.528 List.554 List.555 List.556 List.557 List.558;
|
||||
|
|
|
@ -82,7 +82,6 @@ procedure Json.188 (Json.189, Json.904, #Attr.12):
|
|||
let Json.914 : {List U8, U64} = Struct {Json.191, Json.926};
|
||||
let Json.915 : {} = Struct {};
|
||||
let Json.913 : {List U8, U64} = CallByName List.18 Json.187 Json.914 Json.915;
|
||||
dec Json.187;
|
||||
let Json.193 : List U8 = StructAtIndex 0 Json.913;
|
||||
inc Json.193;
|
||||
dec Json.913;
|
||||
|
@ -174,6 +173,7 @@ procedure List.80 (List.560, List.561, List.562, List.563, List.564):
|
|||
let List.539 : U64 = CallByName Num.19 List.436 List.540;
|
||||
jump List.534 List.433 List.537 List.435 List.539 List.437;
|
||||
else
|
||||
dec List.433;
|
||||
ret List.434;
|
||||
in
|
||||
jump List.534 List.560 List.561 List.562 List.563 List.564;
|
||||
|
|
|
@ -88,7 +88,6 @@ procedure Json.188 (Json.189, Json.904, #Attr.12):
|
|||
let Json.914 : {List U8, U64} = Struct {Json.191, Json.926};
|
||||
let Json.915 : {} = Struct {};
|
||||
let Json.913 : {List U8, U64} = CallByName List.18 Json.187 Json.914 Json.915;
|
||||
dec Json.187;
|
||||
let Json.193 : List U8 = StructAtIndex 0 Json.913;
|
||||
inc Json.193;
|
||||
dec Json.913;
|
||||
|
@ -180,6 +179,7 @@ procedure List.80 (List.560, List.561, List.562, List.563, List.564):
|
|||
let List.539 : U64 = CallByName Num.19 List.436 List.540;
|
||||
jump List.534 List.433 List.537 List.435 List.539 List.437;
|
||||
else
|
||||
dec List.433;
|
||||
ret List.434;
|
||||
in
|
||||
jump List.534 List.560 List.561 List.562 List.563 List.564;
|
||||
|
|
|
@ -1,11 +1,9 @@
|
|||
procedure Test.1 (Test.2, Test.3):
|
||||
inc Test.2;
|
||||
dec Test.3;
|
||||
ret Test.2;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.5 : List I64 = Array [1i64, 2i64, 3i64];
|
||||
let Test.6 : List I64 = Array [3i64, 2i64, 1i64];
|
||||
let Test.4 : List I64 = CallByName Test.1 Test.5 Test.6;
|
||||
dec Test.6;
|
||||
dec Test.5;
|
||||
ret Test.4;
|
||||
|
|
|
@ -9,6 +9,7 @@ procedure Bool.2 ():
|
|||
procedure Test.2 (Test.4):
|
||||
let Test.11 : U8 = 1i64;
|
||||
let Test.12 : U8 = GetTagId Test.4;
|
||||
dec Test.4;
|
||||
let Test.13 : Int1 = lowlevel Eq Test.11 Test.12;
|
||||
if Test.13 then
|
||||
let Test.9 : Int1 = CallByName Bool.2;
|
||||
|
@ -22,5 +23,4 @@ procedure Test.0 ():
|
|||
let Test.15 : [<rnu><null>, C I64 *self] = TagId(1) ;
|
||||
let Test.8 : [<rnu><null>, C I64 *self] = TagId(0) Test.14 Test.15;
|
||||
let Test.7 : Int1 = CallByName Test.2 Test.8;
|
||||
dec Test.8;
|
||||
ret Test.7;
|
||||
|
|
|
@ -11,9 +11,11 @@ procedure List.2 (List.96, List.97):
|
|||
let List.504 : Int1 = CallByName Num.22 List.97 List.508;
|
||||
if List.504 then
|
||||
let List.506 : I64 = CallByName List.66 List.96 List.97;
|
||||
dec List.96;
|
||||
let List.505 : [C {}, C I64] = TagId(1) List.506;
|
||||
ret List.505;
|
||||
else
|
||||
dec List.96;
|
||||
let List.503 : {} = Struct {};
|
||||
let List.502 : [C {}, C I64] = TagId(0) List.503;
|
||||
ret List.502;
|
||||
|
@ -55,6 +57,7 @@ procedure Str.47 (#Attr.2):
|
|||
|
||||
procedure Str.72 (Str.244):
|
||||
let Str.245 : {I64, U8} = CallByName Str.47 Str.244;
|
||||
dec Str.244;
|
||||
let Str.304 : U8 = StructAtIndex 1 Str.245;
|
||||
let Str.305 : U8 = 0i64;
|
||||
let Str.301 : Int1 = CallByName Bool.11 Str.304 Str.305;
|
||||
|
@ -72,10 +75,8 @@ procedure Test.0 ():
|
|||
if Test.3 then
|
||||
let Test.5 : List I64 = Array [];
|
||||
let Test.4 : [C Int1, C I64] = CallByName List.9 Test.5;
|
||||
dec Test.5;
|
||||
ret Test.4;
|
||||
else
|
||||
let Test.2 : Str = "";
|
||||
let Test.1 : [C Int1, C I64] = CallByName Str.27 Test.2;
|
||||
dec Test.2;
|
||||
ret Test.1;
|
||||
|
|
|
@ -8,10 +8,13 @@ procedure Test.2 (Test.19):
|
|||
let Test.17 : U8 = GetTagId Test.7;
|
||||
let Test.18 : Int1 = lowlevel Eq Test.16 Test.17;
|
||||
if Test.18 then
|
||||
dec Test.7;
|
||||
let Test.14 : {} = Struct {};
|
||||
ret Test.14;
|
||||
else
|
||||
let Test.5 : [<rnu><null>, C *self] = UnionAtIndex (Id 0) (Index 0) Test.7;
|
||||
inc Test.5;
|
||||
dec Test.7;
|
||||
jump Test.13 Test.5;
|
||||
in
|
||||
jump Test.13 Test.19;
|
||||
|
@ -19,7 +22,6 @@ procedure Test.2 (Test.19):
|
|||
procedure Test.0 ():
|
||||
let Test.12 : [<rnu><null>, C *self] = TagId(1) ;
|
||||
let Test.10 : {} = CallByName Test.2 Test.12;
|
||||
dec Test.12;
|
||||
let Test.11 : {} = Struct {};
|
||||
let Test.8 : Int1 = CallByName Bool.11 Test.10 Test.11;
|
||||
let Test.9 : Str = "";
|
||||
|
|
|
@ -16,8 +16,8 @@ procedure Test.1 (Test.2, Test.3):
|
|||
let Test.23 : {} = Struct {};
|
||||
joinpoint Test.24 Test.22:
|
||||
let Test.20 : Int1 = CallByName Bool.11 Test.21 Test.22;
|
||||
dec Test.22;
|
||||
dec Test.21;
|
||||
dec Test.22;
|
||||
let Test.18 : Int1 = CallByName Bool.4 Test.19 Test.20;
|
||||
ret Test.18;
|
||||
in
|
||||
|
|
|
@ -4,8 +4,6 @@ procedure Bool.1 ():
|
|||
|
||||
procedure Bool.11 (#Attr.2, #Attr.3):
|
||||
let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
|
||||
dec #Attr.3;
|
||||
dec #Attr.2;
|
||||
ret Bool.23;
|
||||
|
||||
procedure Bool.11 (#Attr.2, #Attr.3):
|
||||
|
@ -47,6 +45,7 @@ procedure Decode.27 (Decode.107, Decode.108):
|
|||
let Decode.109 : [C {}, C Str] = StructAtIndex 1 Decode.122;
|
||||
inc Decode.109;
|
||||
dec Decode.122;
|
||||
inc Decode.110;
|
||||
let Decode.125 : Int1 = CallByName List.1 Decode.110;
|
||||
if Decode.125 then
|
||||
dec Decode.110;
|
||||
|
@ -82,10 +81,11 @@ procedure Json.448 (Json.449, Json.904):
|
|||
let Json.451 : List U8 = StructAtIndex 1 Json.1041;
|
||||
inc Json.451;
|
||||
dec Json.1041;
|
||||
inc Json.451;
|
||||
let Json.1037 : Int1 = CallByName List.1 Json.451;
|
||||
if Json.1037 then
|
||||
dec Json.452;
|
||||
dec Json.451;
|
||||
dec Json.452;
|
||||
let Json.1040 : {} = Struct {};
|
||||
let Json.1039 : [C {}, C Str] = TagId(0) Json.1040;
|
||||
let Json.1038 : {List U8, [C {}, C Str]} = Struct {Json.449, Json.1039};
|
||||
|
@ -112,8 +112,8 @@ procedure Json.448 (Json.449, Json.904):
|
|||
let Json.905 : {List U8, [C {}, C Str]} = Struct {Json.452, Json.906};
|
||||
ret Json.905;
|
||||
else
|
||||
dec Json.457;
|
||||
dec Json.452;
|
||||
dec Json.457;
|
||||
let Json.909 : {} = Struct {};
|
||||
let Json.908 : [C {}, C Str] = TagId(0) Json.909;
|
||||
let Json.907 : {List U8, [C {}, C Str]} = Struct {Json.449, Json.908};
|
||||
|
@ -127,6 +127,7 @@ procedure Json.55 ():
|
|||
procedure Json.56 (Json.462):
|
||||
let Json.1053 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = TagId(4) ;
|
||||
let Json.1054 : {} = Struct {};
|
||||
inc Json.462;
|
||||
let Json.1042 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = CallByName List.26 Json.462 Json.1053 Json.1054;
|
||||
let Json.1050 : U8 = 2i64;
|
||||
let Json.1051 : U8 = GetTagId Json.1042;
|
||||
|
@ -490,8 +491,10 @@ procedure Json.65 (Json.1160):
|
|||
inc Json.522;
|
||||
dec Json.899;
|
||||
let Json.1035 : U64 = 0i64;
|
||||
inc Json.521;
|
||||
let Json.523 : [C {}, C U8] = CallByName List.2 Json.521 Json.1035;
|
||||
let Json.1034 : U64 = 1i64;
|
||||
inc Json.521;
|
||||
let Json.524 : [C {}, C U8] = CallByName List.2 Json.521 Json.1034;
|
||||
let Json.1033 : U64 = 2i64;
|
||||
inc Json.521;
|
||||
|
@ -591,6 +594,7 @@ procedure Json.65 (Json.1160):
|
|||
|
||||
procedure List.1 (List.95):
|
||||
let List.552 : U64 = CallByName List.6 List.95;
|
||||
dec List.95;
|
||||
let List.553 : U64 = 0i64;
|
||||
let List.551 : Int1 = CallByName Bool.11 List.552 List.553;
|
||||
ret List.551;
|
||||
|
@ -600,9 +604,11 @@ procedure List.2 (List.96, List.97):
|
|||
let List.547 : Int1 = CallByName Num.22 List.97 List.550;
|
||||
if List.547 then
|
||||
let List.549 : U8 = CallByName List.66 List.96 List.97;
|
||||
dec List.96;
|
||||
let List.548 : [C {}, C U8] = TagId(1) List.549;
|
||||
ret List.548;
|
||||
else
|
||||
dec List.96;
|
||||
let List.546 : {} = Struct {};
|
||||
let List.545 : [C {}, C U8] = TagId(0) List.546;
|
||||
ret List.545;
|
||||
|
@ -707,10 +713,12 @@ procedure List.80 (List.612, List.613, List.614, List.615, List.616):
|
|||
let List.575 : U64 = CallByName Num.19 List.436 List.576;
|
||||
jump List.570 List.433 List.438 List.435 List.575 List.437;
|
||||
else
|
||||
dec List.433;
|
||||
let List.439 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 0) (Index 0) List.573;
|
||||
let List.577 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = TagId(0) List.439;
|
||||
ret List.577;
|
||||
else
|
||||
dec List.433;
|
||||
let List.571 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = TagId(1) List.434;
|
||||
ret List.571;
|
||||
in
|
||||
|
@ -788,8 +796,8 @@ procedure Test.3 ():
|
|||
let Test.1 : [C [C List U8, C ], C Str] = CallByName Decode.27 Test.0 Test.8;
|
||||
let Test.7 : Str = "Roc";
|
||||
let Test.6 : [C [C List U8, C ], C Str] = TagId(1) Test.7;
|
||||
inc Test.1;
|
||||
let Test.5 : Int1 = CallByName Bool.11 Test.1 Test.6;
|
||||
dec Test.6;
|
||||
expect Test.5;
|
||||
let Test.4 : {} = Struct {};
|
||||
ret Test.4;
|
||||
|
|
|
@ -4,8 +4,6 @@ procedure Bool.1 ():
|
|||
|
||||
procedure Bool.11 (#Attr.2, #Attr.3):
|
||||
let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
|
||||
dec #Attr.3;
|
||||
dec #Attr.2;
|
||||
ret Bool.23;
|
||||
|
||||
procedure Bool.11 (#Attr.2, #Attr.3):
|
||||
|
@ -52,10 +50,11 @@ procedure Json.448 (Json.449, Json.904):
|
|||
let Json.451 : List U8 = StructAtIndex 1 Json.1041;
|
||||
inc Json.451;
|
||||
dec Json.1041;
|
||||
inc Json.451;
|
||||
let Json.1037 : Int1 = CallByName List.1 Json.451;
|
||||
if Json.1037 then
|
||||
dec Json.452;
|
||||
dec Json.451;
|
||||
dec Json.452;
|
||||
let Json.1040 : {} = Struct {};
|
||||
let Json.1039 : [C {}, C Str] = TagId(0) Json.1040;
|
||||
let Json.1038 : {List U8, [C {}, C Str]} = Struct {Json.449, Json.1039};
|
||||
|
@ -82,8 +81,8 @@ procedure Json.448 (Json.449, Json.904):
|
|||
let Json.905 : {List U8, [C {}, C Str]} = Struct {Json.452, Json.906};
|
||||
ret Json.905;
|
||||
else
|
||||
dec Json.457;
|
||||
dec Json.452;
|
||||
dec Json.457;
|
||||
let Json.909 : {} = Struct {};
|
||||
let Json.908 : [C {}, C Str] = TagId(0) Json.909;
|
||||
let Json.907 : {List U8, [C {}, C Str]} = Struct {Json.449, Json.908};
|
||||
|
@ -97,6 +96,7 @@ procedure Json.55 ():
|
|||
procedure Json.56 (Json.462):
|
||||
let Json.1053 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = TagId(4) ;
|
||||
let Json.1054 : {} = Struct {};
|
||||
inc Json.462;
|
||||
let Json.1042 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = CallByName List.26 Json.462 Json.1053 Json.1054;
|
||||
let Json.1050 : U8 = 2i64;
|
||||
let Json.1051 : U8 = GetTagId Json.1042;
|
||||
|
@ -460,8 +460,10 @@ procedure Json.65 (Json.1160):
|
|||
inc Json.522;
|
||||
dec Json.899;
|
||||
let Json.1035 : U64 = 0i64;
|
||||
inc Json.521;
|
||||
let Json.523 : [C {}, C U8] = CallByName List.2 Json.521 Json.1035;
|
||||
let Json.1034 : U64 = 1i64;
|
||||
inc Json.521;
|
||||
let Json.524 : [C {}, C U8] = CallByName List.2 Json.521 Json.1034;
|
||||
let Json.1033 : U64 = 2i64;
|
||||
inc Json.521;
|
||||
|
@ -561,6 +563,7 @@ procedure Json.65 (Json.1160):
|
|||
|
||||
procedure List.1 (List.95):
|
||||
let List.546 : U64 = CallByName List.6 List.95;
|
||||
dec List.95;
|
||||
let List.547 : U64 = 0i64;
|
||||
let List.545 : Int1 = CallByName Bool.11 List.546 List.547;
|
||||
ret List.545;
|
||||
|
@ -570,9 +573,11 @@ procedure List.2 (List.96, List.97):
|
|||
let List.541 : Int1 = CallByName Num.22 List.97 List.544;
|
||||
if List.541 then
|
||||
let List.543 : U8 = CallByName List.66 List.96 List.97;
|
||||
dec List.96;
|
||||
let List.542 : [C {}, C U8] = TagId(1) List.543;
|
||||
ret List.542;
|
||||
else
|
||||
dec List.96;
|
||||
let List.540 : {} = Struct {};
|
||||
let List.539 : [C {}, C U8] = TagId(0) List.540;
|
||||
ret List.539;
|
||||
|
@ -677,10 +682,12 @@ procedure List.80 (List.606, List.607, List.608, List.609, List.610):
|
|||
let List.569 : U64 = CallByName Num.19 List.436 List.570;
|
||||
jump List.564 List.433 List.438 List.435 List.569 List.437;
|
||||
else
|
||||
dec List.433;
|
||||
let List.439 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 0) (Index 0) List.567;
|
||||
let List.571 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = TagId(0) List.439;
|
||||
ret List.571;
|
||||
else
|
||||
dec List.433;
|
||||
let List.565 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = TagId(1) List.434;
|
||||
ret List.565;
|
||||
in
|
||||
|
@ -746,6 +753,7 @@ procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
|
|||
|
||||
procedure Str.72 (Str.244):
|
||||
let Str.245 : {I64, U8} = CallByName Str.47 Str.244;
|
||||
dec Str.244;
|
||||
let Str.304 : U8 = StructAtIndex 1 Str.245;
|
||||
let Str.305 : U8 = 0i64;
|
||||
let Str.301 : Int1 = CallByName Bool.11 Str.304 Str.305;
|
||||
|
@ -795,7 +803,6 @@ procedure Test.0 ():
|
|||
inc Test.3;
|
||||
dec Test.1;
|
||||
let Test.19 : [C {}, C I64] = CallByName Str.27 Test.3;
|
||||
dec Test.3;
|
||||
let Test.25 : U8 = 1i64;
|
||||
let Test.26 : U8 = GetTagId Test.19;
|
||||
let Test.27 : Int1 = lowlevel Eq Test.25 Test.26;
|
||||
|
@ -822,8 +829,8 @@ procedure Test.12 ():
|
|||
let Test.18 : I64 = -1234i64;
|
||||
let Test.16 : {List U8, I64} = Struct {Test.17, Test.18};
|
||||
let Test.15 : [C Str, C {List U8, I64}] = TagId(1) Test.16;
|
||||
inc Test.10;
|
||||
let Test.14 : Int1 = CallByName Bool.11 Test.10 Test.15;
|
||||
dec Test.15;
|
||||
expect Test.14;
|
||||
let Test.13 : {} = Struct {};
|
||||
ret Test.13;
|
||||
|
|
|
@ -22,11 +22,11 @@ procedure Test.2 (Test.7, Test.8):
|
|||
ret Test.41;
|
||||
|
||||
procedure Test.3 (Test.17):
|
||||
dec Test.17;
|
||||
let Test.33 : {} = Struct {};
|
||||
ret Test.33;
|
||||
|
||||
procedure Test.4 (Test.18):
|
||||
inc Test.18;
|
||||
ret Test.18;
|
||||
|
||||
procedure Test.9 (Test.26, #Attr.12):
|
||||
|
@ -35,7 +35,6 @@ procedure Test.9 (Test.26, #Attr.12):
|
|||
let Test.46 : {} = Struct {};
|
||||
let Test.45 : Str = CallByName Test.16 Test.46;
|
||||
let Test.42 : Str = CallByName Test.4 Test.45;
|
||||
dec Test.45;
|
||||
let Test.44 : {} = Struct {};
|
||||
let Test.43 : Str = CallByName Test.13 Test.44 Test.42;
|
||||
ret Test.43;
|
||||
|
@ -46,7 +45,6 @@ procedure Test.9 (Test.26, #Attr.12):
|
|||
let Test.32 : {} = Struct {};
|
||||
let Test.31 : Str = CallByName Test.15 Test.32;
|
||||
let Test.28 : {} = CallByName Test.3 Test.31;
|
||||
dec Test.31;
|
||||
let Test.30 : {} = Struct {};
|
||||
let Test.29 : Str = CallByName Test.11 Test.30;
|
||||
ret Test.29;
|
||||
|
|
|
@ -1,5 +1,4 @@
|
|||
procedure Test.1 (Test.4):
|
||||
inc Test.4;
|
||||
ret Test.4;
|
||||
|
||||
procedure Test.21 (Test.23, #Attr.12):
|
||||
|
@ -21,10 +20,8 @@ procedure Test.0 ():
|
|||
if Test.20 then
|
||||
let Test.15 : Str = "";
|
||||
let Test.10 : Str = CallByName Test.1 Test.15;
|
||||
dec Test.15;
|
||||
jump Test.9 Test.10;
|
||||
else
|
||||
let Test.18 : Str = "";
|
||||
let Test.16 : Str = CallByName Test.1 Test.18;
|
||||
dec Test.18;
|
||||
jump Test.9 Test.16;
|
||||
|
|
|
@ -24,6 +24,7 @@ procedure List.80 (List.517, List.518, List.519, List.520, List.521):
|
|||
let List.505 : U64 = CallByName Num.19 List.436 List.506;
|
||||
jump List.500 List.433 List.503 List.435 List.505 List.437;
|
||||
else
|
||||
dec List.433;
|
||||
ret List.434;
|
||||
in
|
||||
jump List.500 List.517 List.518 List.519 List.520 List.521;
|
||||
|
@ -52,5 +53,4 @@ procedure Test.0 ():
|
|||
let Test.8 : List [<rnu>C *self, <null>] = Array [];
|
||||
let Test.15 : {} = Struct {};
|
||||
let Test.9 : [<rnu><null>, C {[<rnu>C *self, <null>], *self}] = CallByName List.18 Test.8 Test.6 Test.15;
|
||||
dec Test.8;
|
||||
ret Test.9;
|
||||
|
|
|
@ -3,9 +3,11 @@ procedure List.2 (List.96, List.97):
|
|||
let List.496 : Int1 = CallByName Num.22 List.97 List.500;
|
||||
if List.496 then
|
||||
let List.498 : I64 = CallByName List.66 List.96 List.97;
|
||||
dec List.96;
|
||||
let List.497 : [C {}, C I64] = TagId(1) List.498;
|
||||
ret List.497;
|
||||
else
|
||||
dec List.96;
|
||||
let List.495 : {} = Struct {};
|
||||
let List.494 : [C {}, C I64] = TagId(0) List.495;
|
||||
ret List.494;
|
||||
|
@ -26,7 +28,6 @@ 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.2 Test.6 Test.7;
|
||||
dec Test.6;
|
||||
ret Test.5;
|
||||
|
||||
procedure Test.0 ():
|
||||
|
|
|
@ -3,15 +3,18 @@ procedure List.2 (List.96, List.97):
|
|||
let List.496 : Int1 = CallByName Num.22 List.97 List.500;
|
||||
if List.496 then
|
||||
let List.498 : Str = CallByName List.66 List.96 List.97;
|
||||
dec List.96;
|
||||
let List.497 : [C {}, C Str] = TagId(1) List.498;
|
||||
ret List.497;
|
||||
else
|
||||
dec List.96;
|
||||
let List.495 : {} = Struct {};
|
||||
let List.494 : [C {}, C Str] = TagId(0) List.495;
|
||||
ret List.494;
|
||||
|
||||
procedure List.5 (#Attr.2, #Attr.3):
|
||||
let List.502 : List Str = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.3 #Attr.3;
|
||||
decref #Attr.2;
|
||||
ret List.502;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
|
@ -46,19 +49,18 @@ procedure Test.2 ():
|
|||
let Test.15 : List Str = CallByName Test.1;
|
||||
let Test.16 : {} = Struct {};
|
||||
let Test.14 : List Str = CallByName List.5 Test.15 Test.16;
|
||||
dec Test.15;
|
||||
ret Test.14;
|
||||
|
||||
procedure Test.3 (Test.4):
|
||||
let Test.18 : U64 = 2i64;
|
||||
let Test.17 : Str = CallByName Str.16 Test.4 Test.18;
|
||||
dec Test.4;
|
||||
ret Test.17;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.12 : List Str = CallByName Test.2;
|
||||
let Test.13 : U64 = 0i64;
|
||||
let Test.6 : [C {}, C Str] = CallByName List.2 Test.12 Test.13;
|
||||
dec Test.12;
|
||||
let Test.9 : U8 = 1i64;
|
||||
let Test.10 : U8 = GetTagId Test.6;
|
||||
let Test.11 : Int1 = lowlevel Eq Test.9 Test.10;
|
||||
|
|
|
@ -3,9 +3,11 @@ procedure List.2 (List.96, List.97):
|
|||
let List.496 : Int1 = CallByName Num.22 List.97 List.500;
|
||||
if List.496 then
|
||||
let List.498 : Str = CallByName List.66 List.96 List.97;
|
||||
dec List.96;
|
||||
let List.497 : [C {}, C Str] = TagId(1) List.498;
|
||||
ret List.497;
|
||||
else
|
||||
dec List.96;
|
||||
let List.495 : {} = Struct {};
|
||||
let List.494 : [C {}, C Str] = TagId(0) List.495;
|
||||
ret List.494;
|
||||
|
@ -55,7 +57,6 @@ procedure Test.0 ():
|
|||
let Test.12 : List Str = CallByName Test.2;
|
||||
let Test.13 : U64 = 0i64;
|
||||
let Test.6 : [C {}, C Str] = CallByName List.2 Test.12 Test.13;
|
||||
dec Test.12;
|
||||
let Test.9 : U8 = 1i64;
|
||||
let Test.10 : U8 = GetTagId Test.6;
|
||||
let Test.11 : Int1 = lowlevel Eq Test.9 Test.10;
|
||||
|
|
|
@ -1,7 +1,6 @@
|
|||
procedure List.5 (#Attr.2, #Attr.3):
|
||||
let List.495 : U8 = GetTagId #Attr.3;
|
||||
joinpoint List.496 List.494:
|
||||
inc List.494;
|
||||
ret List.494;
|
||||
in
|
||||
switch List.495:
|
||||
|
@ -58,8 +57,8 @@ procedure Test.0 ():
|
|||
else
|
||||
let Test.20 : Str = "B";
|
||||
let Test.21 : Int1 = lowlevel Eq Test.20 Test.12;
|
||||
dec Test.12;
|
||||
dec Test.20;
|
||||
dec Test.12;
|
||||
if Test.21 then
|
||||
let Test.16 : [C U8, C U8, C ] = TagId(1) Test.2;
|
||||
jump Test.13 Test.16;
|
||||
|
|
|
@ -1,11 +1,6 @@
|
|||
procedure List.28 (#Attr.2, #Attr.3):
|
||||
let List.496 : List I64 = lowlevel ListSortWith { xs: `#Attr.#arg1` } #Attr.2 Num.46 #Attr.3;
|
||||
let #Derived_gen.0 : Int1 = lowlevel ListIsUnique #Attr.2;
|
||||
if #Derived_gen.0 then
|
||||
ret List.496;
|
||||
else
|
||||
decref #Attr.2;
|
||||
ret List.496;
|
||||
ret List.496;
|
||||
|
||||
procedure List.59 (List.282):
|
||||
let List.495 : {} = Struct {};
|
||||
|
|
|
@ -7,6 +7,8 @@ procedure Test.1 (Test.3):
|
|||
ret Test.13;
|
||||
|
||||
procedure Test.2 (Test.4, Test.5):
|
||||
dec Test.5;
|
||||
dec Test.4;
|
||||
let Test.9 : U64 = 18i64;
|
||||
ret Test.9;
|
||||
|
||||
|
@ -16,6 +18,4 @@ procedure Test.0 ():
|
|||
let Test.10 : {} = Struct {};
|
||||
let Test.8 : List U16 = CallByName Test.1 Test.10;
|
||||
let Test.6 : U64 = CallByName Test.2 Test.7 Test.8;
|
||||
dec Test.8;
|
||||
dec Test.7;
|
||||
ret Test.6;
|
||||
|
|
|
@ -4,6 +4,7 @@ procedure Str.3 (#Attr.2, #Attr.3):
|
|||
|
||||
procedure Test.2 (Test.4):
|
||||
let Test.16 : U8 = GetTagId Test.4;
|
||||
dec Test.4;
|
||||
switch Test.16:
|
||||
case 0:
|
||||
let Test.13 : Str = "A";
|
||||
|
@ -22,15 +23,12 @@ procedure Test.0 ():
|
|||
let Test.21 : [<rnw>C *self, <null>, C ] = TagId(1) ;
|
||||
let Test.20 : [<rnw>C *self, <null>, C ] = TagId(0) Test.21;
|
||||
let Test.17 : Str = CallByName Test.2 Test.20;
|
||||
dec Test.20;
|
||||
let Test.19 : [<rnw>C *self, <null>, C ] = TagId(1) ;
|
||||
let Test.18 : Str = CallByName Test.2 Test.19;
|
||||
dec Test.19;
|
||||
let Test.10 : Str = CallByName Str.3 Test.17 Test.18;
|
||||
dec Test.18;
|
||||
let Test.12 : [<rnw>C *self, <null>, C ] = TagId(2) ;
|
||||
let Test.11 : Str = CallByName Test.2 Test.12;
|
||||
dec Test.12;
|
||||
let Test.9 : Str = CallByName Str.3 Test.10 Test.11;
|
||||
dec Test.11;
|
||||
ret Test.9;
|
||||
|
|
|
@ -4,6 +4,7 @@ procedure Bool.11 (#Attr.2, #Attr.3):
|
|||
|
||||
procedure Test.2 (Test.5):
|
||||
let Test.14 : U8 = GetTagId Test.5;
|
||||
dec Test.5;
|
||||
switch Test.14:
|
||||
case 2:
|
||||
let Test.11 : Str = "a";
|
||||
|
@ -21,9 +22,8 @@ procedure Test.2 (Test.5):
|
|||
procedure Test.0 ():
|
||||
let Test.10 : [<rnw><null>, C Str, C *self] = TagId(0) ;
|
||||
let Test.8 : Str = CallByName Test.2 Test.10;
|
||||
dec Test.10;
|
||||
let Test.9 : Str = "c";
|
||||
let Test.7 : Int1 = CallByName Bool.11 Test.8 Test.9;
|
||||
dec Test.9;
|
||||
dec Test.8;
|
||||
dec Test.9;
|
||||
ret Test.7;
|
||||
|
|
|
@ -4,8 +4,6 @@ procedure Bool.1 ():
|
|||
|
||||
procedure Bool.11 (#Attr.2, #Attr.3):
|
||||
let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
|
||||
dec #Attr.3;
|
||||
dec #Attr.2;
|
||||
ret Bool.23;
|
||||
|
||||
procedure Test.1 ():
|
||||
|
@ -30,6 +28,8 @@ procedure Test.0 ():
|
|||
dec Test.5;
|
||||
let Test.7 : {I64, Str} = CallByName Test.1;
|
||||
let Test.6 : Int1 = CallByName Bool.11 Test.7 Test.13;
|
||||
dec Test.13;
|
||||
dec Test.7;
|
||||
ret Test.6;
|
||||
else
|
||||
dec Test.5;
|
||||
|
|
|
@ -4,8 +4,6 @@ procedure Bool.1 ():
|
|||
|
||||
procedure Bool.11 (#Attr.2, #Attr.3):
|
||||
let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
|
||||
dec #Attr.3;
|
||||
dec #Attr.2;
|
||||
ret Bool.23;
|
||||
|
||||
procedure Test.1 ():
|
||||
|
@ -22,6 +20,8 @@ procedure Test.0 ():
|
|||
if Test.13 then
|
||||
let Test.6 : {I64, Str} = CallByName Test.1;
|
||||
let Test.5 : Int1 = CallByName Bool.11 Test.6 Test.4;
|
||||
dec Test.6;
|
||||
dec Test.4;
|
||||
ret Test.5;
|
||||
else
|
||||
dec Test.4;
|
||||
|
|
|
@ -3,9 +3,11 @@ procedure List.2 (List.96, List.97):
|
|||
let List.513 : Int1 = CallByName Num.22 List.97 List.516;
|
||||
if List.513 then
|
||||
let List.515 : I64 = CallByName List.66 List.96 List.97;
|
||||
dec List.96;
|
||||
let List.514 : [C {}, C I64] = TagId(1) List.515;
|
||||
ret List.514;
|
||||
else
|
||||
dec List.96;
|
||||
let List.512 : {} = Struct {};
|
||||
let List.511 : [C {}, C I64] = TagId(0) List.512;
|
||||
ret List.511;
|
||||
|
@ -45,8 +47,10 @@ procedure Num.22 (#Attr.2, #Attr.3):
|
|||
|
||||
procedure Test.1 (Test.2):
|
||||
let Test.28 : U64 = 0i64;
|
||||
inc Test.2;
|
||||
let Test.26 : [C {}, C I64] = CallByName List.2 Test.2 Test.28;
|
||||
let Test.27 : U64 = 0i64;
|
||||
inc Test.2;
|
||||
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:
|
||||
|
|
|
@ -1,18 +1,21 @@
|
|||
procedure List.5 (#Attr.2, #Attr.3):
|
||||
let List.494 : List [<rnnu>C List *self] = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.2 #Attr.3;
|
||||
decref #Attr.2;
|
||||
ret List.494;
|
||||
|
||||
procedure Test.2 (Test.5):
|
||||
let Test.6 : List [<rnnu>C List *self] = UnionAtIndex (Id 0) (Index 0) Test.5;
|
||||
inc Test.6;
|
||||
let #Derived_gen.1 : [<rnnu>C List *self] = Reset { symbol: Test.5, id: UpdateModeId { id: 1 } };
|
||||
let Test.15 : {} = Struct {};
|
||||
let Test.7 : List [<rnnu>C List *self] = CallByName List.5 Test.6 Test.15;
|
||||
let Test.14 : [<rnnu>C List *self] = TagId(0) Test.7;
|
||||
let Test.14 : [<rnnu>C List *self] = Reuse #Derived_gen.1 UpdateModeId { id: 1 } TagId(0) Test.7;
|
||||
ret Test.14;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.16 : List [<rnnu>C List *self] = Array [];
|
||||
let Test.12 : [<rnnu>C List *self] = TagId(0) Test.16;
|
||||
let Test.10 : [<rnnu>C List *self] = CallByName Test.2 Test.12;
|
||||
dec Test.12;
|
||||
dec Test.10;
|
||||
let Test.11 : Str = "";
|
||||
ret Test.11;
|
||||
|
|
|
@ -81,5 +81,6 @@ procedure Test.9 (Test.44, Test.8):
|
|||
procedure Test.0 ():
|
||||
let Test.24 : I64 = 4i64;
|
||||
let Test.17 : [<r>C {}, C I64 {}] = CallByName Test.3 Test.24;
|
||||
dec Test.17;
|
||||
let Test.18 : Str = CallByName Test.2;
|
||||
ret Test.18;
|
||||
|
|
|
@ -3,9 +3,11 @@ procedure List.2 (List.96, List.97):
|
|||
let List.513 : Int1 = CallByName Num.22 List.97 List.516;
|
||||
if List.513 then
|
||||
let List.515 : I64 = CallByName List.66 List.96 List.97;
|
||||
dec List.96;
|
||||
let List.514 : [C {}, C I64] = TagId(1) List.515;
|
||||
ret List.514;
|
||||
else
|
||||
dec List.96;
|
||||
let List.512 : {} = Struct {};
|
||||
let List.511 : [C {}, C I64] = TagId(0) List.512;
|
||||
ret List.511;
|
||||
|
@ -44,7 +46,9 @@ procedure Num.22 (#Attr.2, #Attr.3):
|
|||
ret Num.277;
|
||||
|
||||
procedure Test.1 (Test.2, Test.3, Test.4):
|
||||
inc Test.4;
|
||||
let Test.29 : [C {}, C I64] = CallByName List.2 Test.4 Test.3;
|
||||
inc Test.4;
|
||||
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:
|
||||
|
|
|
@ -1,4 +1,5 @@
|
|||
procedure Test.1 (Test.2):
|
||||
dec Test.2;
|
||||
let Test.11 : Int1 = false;
|
||||
ret Test.11;
|
||||
|
||||
|
@ -13,7 +14,6 @@ procedure Test.4 (Test.13):
|
|||
procedure Test.0 ():
|
||||
let Test.16 : Str = "abc";
|
||||
let Test.6 : Int1 = CallByName Test.1 Test.16;
|
||||
dec Test.16;
|
||||
let Test.9 : {} = Struct {};
|
||||
switch Test.6:
|
||||
case 0:
|
||||
|
|
|
@ -71,7 +71,6 @@ procedure Json.188 (Json.189, Json.904, #Attr.12):
|
|||
let Json.914 : {List U8, U64} = Struct {Json.191, Json.926};
|
||||
let Json.915 : {} = Struct {};
|
||||
let Json.913 : {List U8, U64} = CallByName List.18 Json.187 Json.914 Json.915;
|
||||
dec Json.187;
|
||||
let Json.193 : List U8 = StructAtIndex 0 Json.913;
|
||||
inc Json.193;
|
||||
dec Json.913;
|
||||
|
@ -159,6 +158,7 @@ procedure List.80 (List.558, List.559, List.560, List.561, List.562):
|
|||
let List.537 : U64 = CallByName Num.19 List.436 List.538;
|
||||
jump List.532 List.433 List.535 List.435 List.537 List.437;
|
||||
else
|
||||
dec List.433;
|
||||
ret List.434;
|
||||
in
|
||||
jump List.532 List.558 List.559 List.560 List.561 List.562;
|
||||
|
|
|
@ -19,6 +19,7 @@ procedure Test.15 (Test.49):
|
|||
ret Test.70;
|
||||
|
||||
procedure Test.16 (Test.48):
|
||||
dec Test.48;
|
||||
let Test.79 : {} = Struct {};
|
||||
let Test.78 : Int1 = CallByName Test.13 Test.79;
|
||||
ret Test.78;
|
||||
|
@ -27,11 +28,9 @@ procedure Test.17 (Test.47):
|
|||
ret Test.47;
|
||||
|
||||
procedure Test.35 (Test.36, Test.73):
|
||||
inc Test.36;
|
||||
ret Test.36;
|
||||
|
||||
procedure Test.37 (Test.38, Test.81):
|
||||
inc Test.38;
|
||||
ret Test.38;
|
||||
|
||||
procedure Test.40 (Test.41, Test.65, Test.39):
|
||||
|
@ -50,7 +49,6 @@ procedure Test.43 (Test.44, Test.42):
|
|||
joinpoint Test.62 Test.60:
|
||||
let Test.59 : List U8 = Array [];
|
||||
let Test.58 : List U8 = CallByName Test.40 Test.59 Test.44 Test.60;
|
||||
dec Test.59;
|
||||
ret Test.58;
|
||||
in
|
||||
let Test.75 : Int1 = CallByName Bool.2;
|
||||
|
@ -59,7 +57,6 @@ procedure Test.43 (Test.44, Test.42):
|
|||
inc Test.77;
|
||||
dec Test.42;
|
||||
let Test.76 : Int1 = CallByName Test.16 Test.77;
|
||||
dec Test.77;
|
||||
let Test.61 : Int1 = CallByName Test.14 Test.76;
|
||||
jump Test.62 Test.61;
|
||||
else
|
||||
|
|
|
@ -46,6 +46,11 @@ procedure Encode.23 (Encode.98):
|
|||
procedure Encode.23 (Encode.98):
|
||||
ret Encode.98;
|
||||
|
||||
procedure Encode.24 (Encode.99, Encode.107, Encode.101):
|
||||
dec Encode.99;
|
||||
let Encode.138 : Str = "a Lambda Set is empty. Most likely there is a type error in your program.";
|
||||
Crash Encode.138
|
||||
|
||||
procedure Encode.24 (Encode.99, Encode.107, Encode.101):
|
||||
let Encode.111 : List U8 = CallByName Test.5 Encode.99 Encode.101 Encode.107;
|
||||
ret Encode.111;
|
||||
|
@ -70,10 +75,6 @@ procedure Encode.24 (Encode.99, Encode.107, Encode.101):
|
|||
let Encode.134 : List U8 = CallByName Json.188 Encode.99 Encode.101 Encode.107;
|
||||
ret Encode.134;
|
||||
|
||||
procedure Encode.24 (Encode.99, Encode.107, Encode.101):
|
||||
let Encode.138 : Str = "a Lambda Set is empty. Most likely there is a type error in your program.";
|
||||
Crash Encode.138
|
||||
|
||||
procedure Encode.26 (Encode.105, Encode.106):
|
||||
let Encode.109 : List U8 = Array [];
|
||||
let Encode.110 : {{}, {}} = CallByName Test.2 Encode.105;
|
||||
|
@ -111,7 +112,6 @@ procedure Json.188 (Json.189, Json.904, #Attr.12):
|
|||
let Json.914 : {List U8, U64} = Struct {Json.191, Json.926};
|
||||
let Json.915 : {} = Struct {};
|
||||
let Json.913 : {List U8, U64} = CallByName List.18 Json.187 Json.914 Json.915;
|
||||
dec Json.187;
|
||||
let Json.193 : List U8 = StructAtIndex 0 Json.913;
|
||||
inc Json.193;
|
||||
dec Json.913;
|
||||
|
@ -150,7 +150,6 @@ procedure Json.188 (Json.189, Json.904, #Attr.12):
|
|||
let Json.964 : {List U8, U64} = Struct {Json.191, Json.976};
|
||||
let Json.965 : {} = Struct {};
|
||||
let Json.963 : {List U8, U64} = CallByName List.18 Json.187 Json.964 Json.965;
|
||||
dec Json.187;
|
||||
let Json.193 : List U8 = StructAtIndex 0 Json.963;
|
||||
inc Json.193;
|
||||
dec Json.963;
|
||||
|
@ -192,7 +191,6 @@ procedure Json.190 (Json.906, Json.196):
|
|||
dec Json.906;
|
||||
let Json.975 : {} = Struct {};
|
||||
let Json.197 : List U8 = CallByName Encode.24 Json.194 Json.196 Json.975;
|
||||
dec Json.194;
|
||||
joinpoint Json.970 Json.198:
|
||||
let Json.968 : U64 = 1i64;
|
||||
let Json.967 : U64 = CallByName Num.20 Json.195 Json.968;
|
||||
|
@ -279,6 +277,7 @@ procedure List.80 (List.551, List.552, List.553, List.554, List.555):
|
|||
let List.531 : U64 = CallByName Num.19 List.436 List.532;
|
||||
jump List.526 List.433 List.529 List.435 List.531 List.437;
|
||||
else
|
||||
dec List.433;
|
||||
ret List.434;
|
||||
in
|
||||
jump List.526 List.551 List.552 List.553 List.554 List.555;
|
||||
|
@ -293,6 +292,7 @@ procedure List.80 (List.624, List.625, List.626, List.627, List.628):
|
|||
let List.604 : U64 = CallByName Num.19 List.436 List.605;
|
||||
jump List.599 List.433 List.602 List.435 List.604 List.437;
|
||||
else
|
||||
dec List.433;
|
||||
ret List.434;
|
||||
in
|
||||
jump List.599 List.624 List.625 List.626 List.627 List.628;
|
||||
|
|
|
@ -68,10 +68,12 @@ procedure List.80 (List.544, List.545, List.546, List.547, List.548):
|
|||
let List.523 : U64 = CallByName Num.19 List.436 List.524;
|
||||
jump List.518 List.433 List.438 List.435 List.523 List.437;
|
||||
else
|
||||
dec List.433;
|
||||
let List.439 : U64 = UnionAtIndex (Id 0) (Index 0) List.521;
|
||||
let List.525 : [C U64, C U64] = TagId(0) List.439;
|
||||
ret List.525;
|
||||
else
|
||||
dec List.433;
|
||||
let List.519 : [C U64, C U64] = TagId(1) List.434;
|
||||
ret List.519;
|
||||
in
|
||||
|
@ -102,6 +104,7 @@ procedure Test.3 (Test.4, Test.12):
|
|||
procedure Test.0 (Test.1):
|
||||
let Test.10 : U64 = 0i64;
|
||||
let Test.11 : {} = Struct {};
|
||||
inc Test.1;
|
||||
let Test.2 : U64 = CallByName List.26 Test.1 Test.10 Test.11;
|
||||
let Test.9 : U64 = 0i64;
|
||||
let Test.7 : Int1 = CallByName Bool.11 Test.2 Test.9;
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue