roc/crates/compiler/test_mono/generated/issue_4770.txt

procedure Bool.1 ():
    let Bool.23 : Int1 = false;
    ret Bool.23;

procedure Bool.2 ():
    let Bool.22 : Int1 = true;
    ret Bool.22;

procedure List.109 (Bool.30, Bool.31, Bool.32, Bool.33, Bool.34, Bool.35):
    joinpoint List.732 List.303 List.304 List.305 List.306 List.307 List.308:
        let List.734 : Int1 = CallByName Num.22 List.307 List.308;
        if List.734 then
            let List.740 : [<r>C I64, C List *self] = CallByName List.66 List.303 List.307;
            inc List.740;
            let List.741 : [<r>C I64, C List *self] = CallByName List.66 List.304 List.307;
            inc List.741;
            let List.309 : {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName Test.15 List.740 List.741;
            let List.736 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName List.71 List.305 List.309;
            let List.738 : U64 = 1i64;
            let List.737 : U64 = CallByName Num.51 List.307 List.738;
            jump List.732 List.303 List.304 List.736 List.306 List.737 List.308;
        else
            dec List.304;
            dec List.303;
            ret List.305;
    in
    inc Bool.30;
    inc Bool.31;
    jump List.732 Bool.30 Bool.31 Bool.32 Bool.33 Bool.34 Bool.35;

procedure List.119 (List.582, List.583, List.584):
    let List.708 : U64 = 0i64;
    let List.709 : U64 = CallByName List.6 List.582;
    let List.707 : [C {}, C {}] = CallByName List.80 List.582 List.583 List.584 List.708 List.709;
    ret List.707;

procedure List.23 (List.299, List.300, List.301):
    let List.744 : U64 = CallByName List.6 List.299;
    let List.745 : U64 = CallByName List.6 List.300;
    let List.302 : U64 = CallByName Num.148 List.744 List.745;
    let List.730 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName List.68 List.302;
    let List.731 : U64 = 0i64;
    let List.729 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName List.109 List.299 List.300 List.730 List.301 List.731 List.302;
    ret List.729;

procedure List.251 (List.696, List.252, List.250):
    let List.726 : Int1 = CallByName Test.1 List.252;
    if List.726 then
        let List.728 : {} = Struct {};
        let List.727 : [C {}, C {}] = TagId(1) List.728;
        ret List.727;
    else
        let List.725 : {} = Struct {};
        let List.724 : [C {}, C {}] = TagId(0) List.725;
        ret List.724;

procedure List.56 (List.249, List.250):
    let List.705 : {} = Struct {};
    let List.697 : [C {}, C {}] = CallByName List.119 List.249 List.705 List.250;
    let List.702 : U8 = 1i64;
    let List.703 : U8 = GetTagId List.697;
    let List.704 : Int1 = lowlevel Eq List.702 List.703;
    if List.704 then
        let List.698 : Int1 = CallByName Bool.2;
        ret List.698;
    else
        let List.699 : Int1 = CallByName Bool.1;
        ret List.699;

procedure List.6 (#Attr.2):
    let List.695 : U64 = lowlevel ListLenU64 #Attr.2;
    ret List.695;

procedure List.6 (#Attr.2):
    let List.723 : U64 = lowlevel ListLenU64 #Attr.2;
    ret List.723;

procedure List.66 (#Attr.2, #Attr.3):
    let List.722 : {[<r>C I64, C List *self], [<r>C I64, C List *self]} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
    ret List.722;

procedure List.66 (#Attr.2, #Attr.3):
    let List.742 : [<r>C I64, C List *self] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
    ret List.742;

procedure List.68 (#Attr.2):
    let List.743 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = lowlevel ListWithCapacity #Attr.2;
    ret List.743;

procedure List.71 (#Attr.2, #Attr.3):
    let List.739 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
    ret List.739;

procedure List.80 (Bool.25, Bool.26, Bool.27, Bool.28, Bool.29):
    joinpoint List.710 List.585 List.586 List.587 List.588 List.589:
        let List.712 : Int1 = CallByName Num.22 List.588 List.589;
        if List.712 then
            let List.721 : {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName List.66 List.585 List.588;
            inc List.721;
            let List.713 : [C {}, C {}] = CallByName List.251 List.586 List.721 List.587;
            let List.718 : U8 = 1i64;
            let List.719 : U8 = GetTagId List.713;
            let List.720 : Int1 = lowlevel Eq List.718 List.719;
            if List.720 then
                let List.590 : {} = UnionAtIndex (Id 1) (Index 0) List.713;
                let List.716 : U64 = 1i64;
                let List.715 : U64 = CallByName Num.51 List.588 List.716;
                jump List.710 List.585 List.590 List.587 List.715 List.589;
            else
                dec List.585;
                let List.591 : {} = UnionAtIndex (Id 0) (Index 0) List.713;
                let List.717 : [C {}, C {}] = TagId(0) List.591;
                ret List.717;
        else
            dec List.585;
            let List.711 : [C {}, C {}] = TagId(1) List.586;
            ret List.711;
    in
    inc Bool.25;
    jump List.710 Bool.25 Bool.26 Bool.27 Bool.28 Bool.29;

procedure Num.148 (Num.232, Num.233):
    let Num.296 : Int1 = CallByName Num.22 Num.232 Num.233;
    if Num.296 then
        ret Num.232;
    else
        ret Num.233;

procedure Num.22 (#Attr.2, #Attr.3):
    let Num.289 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
    ret Num.289;

procedure Num.22 (#Attr.2, #Attr.3):
    let Num.294 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
    ret Num.294;

procedure Num.51 (#Attr.2, #Attr.3):
    let Num.292 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
    ret Num.292;

procedure Test.1 (Bool.24):
    joinpoint Test.26 Test.6:
        let Test.65 : [<r>C I64, C List *self] = StructAtIndex 1 Test.6;
        let Test.66 : U8 = 0i64;
        let Test.67 : U8 = GetTagId Test.65;
        let Test.68 : Int1 = lowlevel Eq Test.66 Test.67;
        if Test.68 then
            let Test.57 : [<r>C I64, C List *self] = StructAtIndex 0 Test.6;
            let Test.58 : U8 = 0i64;
            let Test.59 : U8 = GetTagId Test.57;
            let Test.60 : Int1 = lowlevel Eq Test.58 Test.59;
            if Test.60 then
                let Test.50 : [<r>C I64, C List *self] = StructAtIndex 0 Test.6;
                let Test.8 : I64 = UnionAtIndex (Id 0) (Index 0) Test.50;
                let Test.49 : [<r>C I64, C List *self] = StructAtIndex 1 Test.6;
                dec Test.50;
                let Test.10 : I64 = UnionAtIndex (Id 0) (Index 0) Test.49;
                joinpoint Bool.36:
                    let Test.27 : Int1 = CallByName Num.22 Test.8 Test.10;
                    ret Test.27;
                in
                let Bool.37 : Int1 = lowlevel RefCountIsUnique Test.49;
                if Bool.37 then
                    free Test.49;
                    jump Bool.36;
                else
                    decref Test.49;
                    jump Bool.36;
            else
                let Test.39 : [<r>C I64, C List *self] = StructAtIndex 0 Test.6;
                let Test.42 : [<r>C I64, C List *self] = StructAtIndex 1 Test.6;
                let Test.41 : List [<r>C I64, C List *self] = Array [Test.42];
                let Test.40 : [<r>C I64, C List *self] = TagId(1) Test.41;
                let Test.38 : {[<r>C I64, C List *self], [<r>C I64, C List *self]} = Struct {Test.39, Test.40};
                jump Test.26 Test.38;
        else
            let Test.61 : [<r>C I64, C List *self] = StructAtIndex 0 Test.6;
            let Test.62 : U8 = 1i64;
            let Test.63 : U8 = GetTagId Test.61;
            let Test.64 : Int1 = lowlevel Eq Test.62 Test.63;
            if Test.64 then
                let Test.52 : [<r>C I64, C List *self] = StructAtIndex 0 Test.6;
                let Test.12 : List [<r>C I64, C List *self] = UnionAtIndex (Id 1) (Index 0) Test.52;
                inc Test.12;
                let Test.51 : [<r>C I64, C List *self] = StructAtIndex 1 Test.6;
                dec Test.52;
                let Test.14 : List [<r>C I64, C List *self] = UnionAtIndex (Id 1) (Index 0) Test.51;
                joinpoint Bool.38:
                    let Test.35 : {} = Struct {};
                    let Test.33 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName List.23 Test.12 Test.14 Test.35;
                    let Test.34 : {} = Struct {};
                    let Test.29 : Int1 = CallByName List.56 Test.33 Test.34;
                    dec Test.33;
                    if Test.29 then
                        let Test.31 : U64 = CallByName List.6 Test.12;
                        dec Test.12;
                        let Test.32 : U64 = CallByName List.6 Test.14;
                        dec Test.14;
                        let Test.30 : Int1 = CallByName Num.22 Test.31 Test.32;
                        ret Test.30;
                    else
                        dec Test.12;
                        dec Test.14;
                        let Test.28 : Int1 = CallByName Bool.1;
                        ret Test.28;
                in
                let Bool.39 : Int1 = lowlevel RefCountIsUnique Test.51;
                if Bool.39 then
                    free Test.51;
                    jump Bool.38;
                else
                    inc Test.14;
                    decref Test.51;
                    jump Bool.38;
            else
                let Test.48 : [<r>C I64, C List *self] = StructAtIndex 0 Test.6;
                let Test.47 : List [<r>C I64, C List *self] = Array [Test.48];
                let Test.45 : [<r>C I64, C List *self] = TagId(1) Test.47;
                let Test.46 : [<r>C I64, C List *self] = StructAtIndex 1 Test.6;
                let Test.44 : {[<r>C I64, C List *self], [<r>C I64, C List *self]} = Struct {Test.45, Test.46};
                jump Test.26 Test.44;
    in
    jump Test.26 Bool.24;

procedure Test.15 (Test.16, Test.17):
    let Test.36 : {[<r>C I64, C List *self], [<r>C I64, C List *self]} = Struct {Test.16, Test.17};
    ret Test.36;

procedure Test.0 ():
    let Test.76 : I64 = 10i64;
    let Test.75 : [<r>C I64, C List *self] = TagId(0) Test.76;
    let Test.74 : List [<r>C I64, C List *self] = Array [Test.75];
    let Test.69 : [<r>C I64, C List *self] = TagId(1) Test.74;
    let Test.73 : I64 = 20i64;
    let Test.72 : [<r>C I64, C List *self] = TagId(0) Test.73;
    let Test.71 : List [<r>C I64, C List *self] = Array [Test.72];
    let Test.70 : [<r>C I64, C List *self] = TagId(1) Test.71;
    let Test.25 : {[<r>C I64, C List *self], [<r>C I64, C List *self]} = Struct {Test.69, Test.70};
    let Test.24 : Int1 = CallByName Test.1 Test.25;
    ret Test.24;