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

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

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):
    let Bool.39 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
    dec #Attr.3;
    dec #Attr.2;
    ret Bool.39;

procedure Bool.11 (#Attr.2, #Attr.3):
    let Bool.46 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
    ret Bool.46;

procedure Bool.12 (#Attr.2, #Attr.3):
    let Bool.38 : Int1 = lowlevel NotEq #Attr.2 #Attr.3;
    ret Bool.38;

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

procedure Bool.7 (Bool.19, Bool.20):
    let Bool.37 : Int1 = CallByName Bool.12 Bool.19 Bool.20;
    ret Bool.37;

procedure Decode.24 (Decode.101):
    ret Decode.101;

procedure Decode.25 (Decode.102, Decode.121, Decode.104):
    let Decode.134 : {List U8, [C {}, C Str]} = CallByName Json.315 Decode.102 Decode.104;
    ret Decode.134;

procedure Decode.26 (Decode.105, Decode.106):
    let Decode.133 : {} = CallByName Json.43;
    let Decode.132 : {List U8, [C {}, C Str]} = CallByName Decode.25 Decode.105 Decode.133 Decode.106;
    ret Decode.132;

procedure Decode.27 (Decode.107, Decode.108):
    let Decode.122 : {List U8, [C {}, C Str]} = CallByName Decode.26 Decode.107 Decode.108;
    let Decode.110 : List U8 = StructAtIndex 0 Decode.122;
    inc Decode.110;
    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;
        let Decode.129 : U8 = 1i64;
        let Decode.130 : U8 = GetTagId Decode.109;
        let Decode.131 : Int1 = lowlevel Eq Decode.129 Decode.130;
        if Decode.131 then
            let Decode.111 : Str = UnionAtIndex (Id 1) (Index 0) Decode.109;
            inc Decode.111;
            dec Decode.109;
            let Decode.126 : [C [C List U8, C ], C Str] = TagId(1) Decode.111;
            ret Decode.126;
        else
            dec Decode.109;
            let Decode.128 : [C List U8, C ] = TagId(1) ;
            let Decode.127 : [C [C List U8, C ], C Str] = TagId(0) Decode.128;
            ret Decode.127;
    else
        dec Decode.109;
        let Decode.124 : [C List U8, C ] = TagId(0) Decode.110;
        let Decode.123 : [C [C List U8, C ], C Str] = TagId(0) Decode.124;
        ret Decode.123;

procedure Json.160 (Json.570, Json.571):
    joinpoint Json.508 Json.505 Json.159:
        let Json.162 : List U8 = StructAtIndex 0 Json.505;
        inc Json.162;
        let Json.161 : List U8 = StructAtIndex 1 Json.505;
        inc Json.161;
        dec Json.505;
        joinpoint Json.546:
            let Json.543 : {List U8, List U8} = Struct {Json.162, Json.161};
            ret Json.543;
        in
        let Json.554 : U64 = lowlevel ListLen Json.162;
        let Json.555 : U64 = 2i64;
        let Json.556 : Int1 = lowlevel NumGte Json.554 Json.555;
        if Json.556 then
            let Json.545 : U64 = 0i64;
            let Json.163 : U8 = lowlevel ListGetUnsafe Json.162 Json.545;
            let Json.544 : U64 = 1i64;
            let Json.164 : U8 = lowlevel ListGetUnsafe Json.162 Json.544;
            let Json.516 : Int1 = CallByName Json.23 Json.163 Json.164;
            if Json.516 then
                let Json.523 : U64 = 2i64;
                let Json.520 : List U8 = CallByName List.29 Json.162 Json.523;
                let Json.522 : List U8 = CallByName List.4 Json.161 Json.163;
                let Json.521 : List U8 = CallByName List.4 Json.522 Json.164;
                let Json.518 : {List U8, List U8} = Struct {Json.520, Json.521};
                jump Json.508 Json.518 Json.159;
            else
                let Json.510 : Int1 = CallByName Json.305 Json.163;
                if Json.510 then
                    let Json.514 : List U8 = CallByName List.38 Json.162;
                    let Json.515 : List U8 = CallByName List.4 Json.161 Json.163;
                    let Json.512 : {List U8, List U8} = Struct {Json.514, Json.515};
                    jump Json.508 Json.512 Json.159;
                else
                    let Json.509 : {List U8, List U8} = Struct {Json.162, Json.161};
                    ret Json.509;
        else
            let Json.551 : U64 = lowlevel ListLen Json.162;
            let Json.552 : U64 = 1i64;
            let Json.553 : Int1 = lowlevel NumGte Json.551 Json.552;
            if Json.553 then
                let Json.550 : U64 = 0i64;
                let Json.165 : U8 = lowlevel ListGetUnsafe Json.162 Json.550;
                joinpoint Json.548 Json.547:
                    if Json.547 then
                        let Json.541 : List U8 = CallByName List.38 Json.162;
                        let Json.542 : List U8 = CallByName List.4 Json.161 Json.165;
                        let Json.539 : {List U8, List U8} = Struct {Json.541, Json.542};
                        jump Json.508 Json.539 Json.159;
                    else
                        jump Json.546;
                in
                let Json.549 : Int1 = CallByName Json.305 Json.165;
                jump Json.548 Json.549;
            else
                jump Json.546;
    in
    jump Json.508 Json.570 Json.571;

procedure Json.2 ():
    let Json.483 : {} = Struct {};
    ret Json.483;

procedure Json.23 (Json.155, Json.156):
    let Json.524 : {U8, U8} = Struct {Json.155, Json.156};
    joinpoint Json.533:
        let Json.532 : Int1 = CallByName Bool.1;
        ret Json.532;
    in
    let Json.535 : U8 = StructAtIndex 0 Json.524;
    let Json.536 : U8 = 92i64;
    let Json.537 : Int1 = lowlevel Eq Json.536 Json.535;
    if Json.537 then
        let Json.534 : U8 = StructAtIndex 1 Json.524;
        switch Json.534:
            case 98:
                let Json.525 : Int1 = CallByName Bool.2;
                ret Json.525;
        
            case 102:
                let Json.526 : Int1 = CallByName Bool.2;
                ret Json.526;
        
            case 110:
                let Json.527 : Int1 = CallByName Bool.2;
                ret Json.527;
        
            case 114:
                let Json.528 : Int1 = CallByName Bool.2;
                ret Json.528;
        
            case 116:
                let Json.529 : Int1 = CallByName Bool.2;
                ret Json.529;
        
            case 34:
                let Json.530 : Int1 = CallByName Bool.2;
                ret Json.530;
        
            case 92:
                let Json.531 : Int1 = CallByName Bool.2;
                ret Json.531;
        
            default:
                jump Json.533;
        
    else
        jump Json.533;

procedure Json.24 (Json.158, Json.159):
    let Json.558 : List U8 = Array [];
    let Json.507 : {List U8, List U8} = Struct {Json.158, Json.558};
    let Json.506 : {List U8, List U8} = CallByName Json.160 Json.507 Json.159;
    ret Json.506;

procedure Json.305 (Json.306):
    let Json.560 : U8 = 34i64;
    let Json.559 : Int1 = CallByName Bool.7 Json.306 Json.560;
    ret Json.559;

procedure Json.315 (Json.316, Json.486):
    let Json.487 : {List U8, [C {}, C Str]} = CallByName Json.42 Json.316;
    ret Json.487;

procedure Json.42 (Json.298):
    let Json.564 : U64 = 1i64;
    inc Json.298;
    let Json.563 : {List U8, List U8} = CallByName List.52 Json.298 Json.564;
    let Json.299 : List U8 = StructAtIndex 0 Json.563;
    inc Json.299;
    let Json.301 : List U8 = StructAtIndex 1 Json.563;
    inc Json.301;
    dec Json.563;
    let Json.562 : U8 = 34i64;
    let Json.561 : List U8 = Array [Json.562];
    let Json.491 : Int1 = CallByName Bool.11 Json.299 Json.561;
    if Json.491 then
        dec Json.298;
        let Json.504 : {} = Struct {};
        let Json.503 : {List U8, List U8} = CallByName Json.24 Json.301 Json.504;
        let Json.304 : List U8 = StructAtIndex 0 Json.503;
        inc Json.304;
        let Json.303 : List U8 = StructAtIndex 1 Json.503;
        inc Json.303;
        dec Json.503;
        let Json.492 : [C {U64, U8}, C Str] = CallByName Str.9 Json.303;
        let Json.500 : U8 = 1i64;
        let Json.501 : U8 = GetTagId Json.492;
        let Json.502 : Int1 = lowlevel Eq Json.500 Json.501;
        if Json.502 then
            let Json.307 : Str = UnionAtIndex (Id 1) (Index 0) Json.492;
            inc Json.307;
            dec Json.492;
            let Json.496 : U64 = 1i64;
            let Json.495 : {List U8, List U8} = CallByName List.52 Json.304 Json.496;
            let Json.309 : List U8 = StructAtIndex 1 Json.495;
            inc Json.309;
            dec Json.495;
            let Json.494 : [C {}, C Str] = TagId(1) Json.307;
            let Json.493 : {List U8, [C {}, C Str]} = Struct {Json.309, Json.494};
            ret Json.493;
        else
            dec Json.492;
            let Json.499 : {} = Struct {};
            let Json.498 : [C {}, C Str] = TagId(0) Json.499;
            let Json.497 : {List U8, [C {}, C Str]} = Struct {Json.304, Json.498};
            ret Json.497;
    else
        dec Json.301;
        let Json.490 : {} = Struct {};
        let Json.489 : [C {}, C Str] = TagId(0) Json.490;
        let Json.488 : {List U8, [C {}, C Str]} = Struct {Json.298, Json.489};
        ret Json.488;

procedure Json.43 ():
    let Json.485 : {} = Struct {};
    let Json.484 : {} = CallByName Decode.24 Json.485;
    ret Json.484;

procedure List.1 (List.95):
    let List.495 : U64 = CallByName List.6 List.95;
    let List.496 : U64 = 0i64;
    let List.494 : Int1 = CallByName Bool.11 List.495 List.496;
    ret List.494;

procedure List.29 (List.298, List.299):
    inc List.298;
    let List.549 : U64 = CallByName List.6 List.298;
    let List.300 : U64 = CallByName Num.77 List.549 List.299;
    let List.544 : List U8 = CallByName List.43 List.298 List.300;
    ret List.544;

procedure List.31 (#Attr.2, #Attr.3):
    let List.541 : List U8 = lowlevel ListDropAt #Attr.2 #Attr.3;
    ret List.541;

procedure List.38 (List.292):
    let List.543 : U64 = 0i64;
    let List.542 : List U8 = CallByName List.31 List.292 List.543;
    ret List.542;

procedure List.4 (List.107, List.108):
    let List.538 : U64 = 1i64;
    let List.537 : List U8 = CallByName List.70 List.107 List.538;
    let List.536 : List U8 = CallByName List.71 List.537 List.108;
    ret List.536;

procedure List.43 (List.296, List.297):
    inc List.296;
    let List.548 : U64 = CallByName List.6 List.296;
    let List.547 : U64 = CallByName Num.77 List.548 List.297;
    let List.546 : {U64, U64} = Struct {List.297, List.547};
    let List.545 : List U8 = CallByName List.49 List.296 List.546;
    ret List.545;

procedure List.49 (List.370, List.371):
    let List.508 : U64 = StructAtIndex 0 List.371;
    let List.509 : U64 = 0i64;
    let List.506 : Int1 = CallByName Bool.11 List.508 List.509;
    if List.506 then
        dec List.370;
        let List.507 : List U8 = Array [];
        ret List.507;
    else
        let List.503 : U64 = StructAtIndex 1 List.371;
        let List.504 : U64 = StructAtIndex 0 List.371;
        let List.502 : List U8 = CallByName List.72 List.370 List.503 List.504;
        ret List.502;

procedure List.52 (List.385, List.386):
    inc List.385;
    let List.387 : U64 = CallByName List.6 List.385;
    joinpoint List.523 List.388:
        let List.521 : U64 = 0i64;
        let List.520 : {U64, U64} = Struct {List.388, List.521};
        inc List.385;
        let List.389 : List U8 = CallByName List.49 List.385 List.520;
        let List.519 : U64 = CallByName Num.20 List.387 List.388;
        let List.518 : {U64, U64} = Struct {List.519, List.388};
        let List.390 : List U8 = CallByName List.49 List.385 List.518;
        let List.517 : {List U8, List U8} = Struct {List.389, List.390};
        ret List.517;
    in
    let List.524 : Int1 = CallByName Num.24 List.387 List.386;
    if List.524 then
        jump List.523 List.386;
    else
        jump List.523 List.387;

procedure List.6 (#Attr.2):
    let List.571 : U64 = lowlevel ListLen #Attr.2;
    dec #Attr.2;
    ret List.571;

procedure List.70 (#Attr.2, #Attr.3):
    let List.529 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
    ret List.529;

procedure List.71 (#Attr.2, #Attr.3):
    let List.527 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
    ret List.527;

procedure List.72 (#Attr.2, #Attr.3, #Attr.4):
    let List.505 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
    ret List.505;

procedure Num.20 (#Attr.2, #Attr.3):
    let Num.276 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
    ret Num.276;

procedure Num.24 (#Attr.2, #Attr.3):
    let Num.278 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
    ret Num.278;

procedure Num.77 (#Attr.2, #Attr.3):
    let Num.280 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
    ret Num.280;

procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
    let Str.307 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
    ret Str.307;

procedure Str.9 (Str.79):
    let Str.305 : U64 = 0i64;
    inc Str.79;
    let Str.306 : U64 = CallByName List.6 Str.79;
    let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.305 Str.306;
    let Str.302 : Int1 = StructAtIndex 2 Str.80;
    if Str.302 then
        let Str.304 : Str = StructAtIndex 1 Str.80;
        inc Str.304;
        dec Str.80;
        let Str.303 : [C {U64, U8}, C Str] = TagId(1) Str.304;
        ret Str.303;
    else
        let Str.300 : U8 = StructAtIndex 3 Str.80;
        let Str.301 : U64 = StructAtIndex 0 Str.80;
        dec Str.80;
        let Str.299 : {U64, U8} = Struct {Str.301, Str.300};
        let Str.298 : [C {U64, U8}, C Str] = TagId(0) Str.299;
        ret Str.298;

procedure Test.3 ():
    let Test.0 : List U8 = Array [82i64, 111i64, 99i64];
    let Test.8 : {} = CallByName Json.2;
    inc Test.0;
    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;
    expect Test.5;
    let Test.4 : {} = Struct {};
    ret Test.4;