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;
    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.23 (Decode.94):
    ret Decode.94;

procedure Decode.24 (Decode.95, Decode.114, Decode.97):
    let Decode.127 : {List U8, [C {}, C Str]} = CallByName Json.300 Decode.95 Decode.97;
    ret Decode.127;

procedure Decode.25 (Decode.98, Decode.99):
    let Decode.126 : {} = CallByName Json.42;
    let Decode.125 : {List U8, [C {}, C Str]} = CallByName Decode.24 Decode.98 Decode.126 Decode.99;
    ret Decode.125;

procedure Decode.26 (Decode.100, Decode.101):
    let Decode.115 : {List U8, [C {}, C Str]} = CallByName Decode.25 Decode.100 Decode.101;
    let Decode.103 : List U8 = StructAtIndex 0 Decode.115;
    inc Decode.103;
    let Decode.102 : [C {}, C Str] = StructAtIndex 1 Decode.115;
    inc Decode.102;
    dec Decode.115;
    let Decode.118 : Int1 = CallByName List.1 Decode.103;
    if Decode.118 then
        dec Decode.103;
        let Decode.122 : U8 = 1i64;
        let Decode.123 : U8 = GetTagId Decode.102;
        let Decode.124 : Int1 = lowlevel Eq Decode.122 Decode.123;
        if Decode.124 then
            let Decode.104 : Str = UnionAtIndex (Id 1) (Index 0) Decode.102;
            inc Decode.104;
            dec Decode.102;
            let Decode.119 : [C [C List U8, C ], C Str] = TagId(1) Decode.104;
            ret Decode.119;
        else
            dec Decode.102;
            let Decode.121 : [C List U8, C ] = TagId(1) ;
            let Decode.120 : [C [C List U8, C ], C Str] = TagId(0) Decode.121;
            ret Decode.120;
    else
        dec Decode.102;
        let Decode.117 : [C List U8, C ] = TagId(0) Decode.103;
        let Decode.116 : [C [C List U8, C ], C Str] = TagId(0) Decode.117;
        ret Decode.116;

procedure Json.145 (Json.512, Json.513):
    joinpoint Json.450 Json.447 Json.144:
        let Json.147 : List U8 = StructAtIndex 0 Json.447;
        inc Json.147;
        let Json.146 : List U8 = StructAtIndex 1 Json.447;
        inc Json.146;
        dec Json.447;
        joinpoint Json.490:
            let Json.487 : {List U8, List U8} = Struct {Json.147, Json.146};
            ret Json.487;
        in
        let Json.496 : U64 = lowlevel ListLen Json.147;
        let Json.497 : U64 = 2i64;
        let Json.498 : Int1 = lowlevel NumGte Json.496 Json.497;
        if Json.498 then
            let Json.489 : U64 = 0i64;
            let Json.148 : U8 = lowlevel ListGetUnsafe Json.147 Json.489;
            let Json.488 : U64 = 1i64;
            let Json.149 : U8 = lowlevel ListGetUnsafe Json.147 Json.488;
            let Json.458 : Int1 = CallByName Json.22 Json.148 Json.149;
            if Json.458 then
                let Json.465 : U64 = 2i64;
                let Json.462 : List U8 = CallByName List.29 Json.147 Json.465;
                let Json.464 : List U8 = CallByName List.4 Json.146 Json.148;
                let Json.463 : List U8 = CallByName List.4 Json.464 Json.149;
                let Json.460 : {List U8, List U8} = Struct {Json.462, Json.463};
                jump Json.450 Json.460 Json.144;
            else
                let Json.452 : Int1 = CallByName Json.290 Json.148;
                if Json.452 then
                    let Json.456 : List U8 = CallByName List.38 Json.147;
                    let Json.457 : List U8 = CallByName List.4 Json.146 Json.148;
                    let Json.454 : {List U8, List U8} = Struct {Json.456, Json.457};
                    jump Json.450 Json.454 Json.144;
                else
                    let Json.451 : {List U8, List U8} = Struct {Json.147, Json.146};
                    ret Json.451;
        else
            let Json.493 : U64 = lowlevel ListLen Json.147;
            let Json.494 : U64 = 1i64;
            let Json.495 : Int1 = lowlevel NumGte Json.493 Json.494;
            if Json.495 then
                let Json.492 : U64 = 0i64;
                let Json.150 : U8 = lowlevel ListGetUnsafe Json.147 Json.492;
                joinpoint Json.485 Json.491:
                    if Json.491 then
                        let Json.483 : List U8 = CallByName List.38 Json.147;
                        let Json.484 : List U8 = CallByName List.4 Json.146 Json.150;
                        let Json.481 : {List U8, List U8} = Struct {Json.483, Json.484};
                        jump Json.450 Json.481 Json.144;
                    else
                        jump Json.490;
                in
                let Json.486 : Int1 = CallByName Json.290 Json.150;
                jump Json.485 Json.486;
            else
                jump Json.490;
    in
    jump Json.450 Json.512 Json.513;

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

procedure Json.22 (Json.140, Json.141):
    let Json.466 : {U8, U8} = Struct {Json.140, Json.141};
    joinpoint Json.475:
        let Json.474 : Int1 = CallByName Bool.1;
        ret Json.474;
    in
    let Json.477 : U8 = StructAtIndex 0 Json.466;
    let Json.478 : U8 = 92i64;
    let Json.479 : Int1 = lowlevel Eq Json.478 Json.477;
    if Json.479 then
        let Json.476 : U8 = StructAtIndex 1 Json.466;
        switch Json.476:
            case 98:
                let Json.467 : Int1 = CallByName Bool.2;
                ret Json.467;
        
            case 102:
                let Json.468 : Int1 = CallByName Bool.2;
                ret Json.468;
        
            case 110:
                let Json.469 : Int1 = CallByName Bool.2;
                ret Json.469;
        
            case 114:
                let Json.470 : Int1 = CallByName Bool.2;
                ret Json.470;
        
            case 116:
                let Json.471 : Int1 = CallByName Bool.2;
                ret Json.471;
        
            case 34:
                let Json.472 : Int1 = CallByName Bool.2;
                ret Json.472;
        
            case 92:
                let Json.473 : Int1 = CallByName Bool.2;
                ret Json.473;
        
            default:
                jump Json.475;
        
    else
        jump Json.475;

procedure Json.23 (Json.143, Json.144):
    let Json.500 : List U8 = Array [];
    let Json.449 : {List U8, List U8} = Struct {Json.143, Json.500};
    let Json.448 : {List U8, List U8} = CallByName Json.145 Json.449 Json.144;
    ret Json.448;

procedure Json.290 (Json.291):
    let Json.502 : U8 = 34i64;
    let Json.501 : Int1 = CallByName Bool.7 Json.291 Json.502;
    ret Json.501;

procedure Json.300 (Json.301, Json.428):
    let Json.429 : {List U8, [C {}, C Str]} = CallByName Json.41 Json.301;
    ret Json.429;

procedure Json.41 (Json.283):
    let Json.506 : U64 = 1i64;
    inc Json.283;
    let Json.505 : {List U8, List U8} = CallByName List.52 Json.283 Json.506;
    let Json.284 : List U8 = StructAtIndex 0 Json.505;
    inc Json.284;
    let Json.286 : List U8 = StructAtIndex 1 Json.505;
    inc Json.286;
    dec Json.505;
    let Json.504 : U8 = 34i64;
    let Json.503 : List U8 = Array [Json.504];
    let Json.433 : Int1 = CallByName Bool.11 Json.284 Json.503;
    dec Json.503;
    dec Json.284;
    if Json.433 then
        dec Json.283;
        let Json.446 : {} = Struct {};
        let Json.445 : {List U8, List U8} = CallByName Json.23 Json.286 Json.446;
        let Json.289 : List U8 = StructAtIndex 0 Json.445;
        inc Json.289;
        let Json.288 : List U8 = StructAtIndex 1 Json.445;
        inc Json.288;
        dec Json.445;
        let Json.434 : [C {U64, U8}, C Str] = CallByName Str.9 Json.288;
        let Json.442 : U8 = 1i64;
        let Json.443 : U8 = GetTagId Json.434;
        let Json.444 : Int1 = lowlevel Eq Json.442 Json.443;
        if Json.444 then
            let Json.292 : Str = UnionAtIndex (Id 1) (Index 0) Json.434;
            inc Json.292;
            dec Json.434;
            let Json.438 : U64 = 1i64;
            let Json.437 : {List U8, List U8} = CallByName List.52 Json.289 Json.438;
            let Json.294 : List U8 = StructAtIndex 1 Json.437;
            inc Json.294;
            dec Json.437;
            let Json.436 : [C {}, C Str] = TagId(1) Json.292;
            let Json.435 : {List U8, [C {}, C Str]} = Struct {Json.294, Json.436};
            ret Json.435;
        else
            dec Json.434;
            let Json.441 : {} = Struct {};
            let Json.440 : [C {}, C Str] = TagId(0) Json.441;
            let Json.439 : {List U8, [C {}, C Str]} = Struct {Json.289, Json.440};
            ret Json.439;
    else
        dec Json.286;
        let Json.432 : {} = Struct {};
        let Json.431 : [C {}, C Str] = TagId(0) Json.432;
        let Json.430 : {List U8, [C {}, C Str]} = Struct {Json.283, Json.431};
        ret Json.430;

procedure Json.42 ():
    let Json.427 : {} = Struct {};
    let Json.426 : {} = CallByName Decode.23 Json.427;
    ret Json.426;

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

procedure List.29 (List.297, List.298):
    let List.548 : U64 = CallByName List.6 List.297;
    let List.299 : U64 = CallByName Num.77 List.548 List.298;
    let List.543 : List U8 = CallByName List.43 List.297 List.299;
    ret List.543;

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

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

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

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

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

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

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

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

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

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

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.274 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
    ret Str.274;

procedure Str.9 (Str.76):
    let Str.272 : U64 = 0i64;
    let Str.273 : U64 = CallByName List.6 Str.76;
    let Str.77 : {U64, Str, Int1, U8} = CallByName Str.48 Str.76 Str.272 Str.273;
    let Str.269 : Int1 = StructAtIndex 2 Str.77;
    if Str.269 then
        let Str.271 : Str = StructAtIndex 1 Str.77;
        inc Str.271;
        dec Str.77;
        let Str.270 : [C {U64, U8}, C Str] = TagId(1) Str.271;
        ret Str.270;
    else
        let Str.267 : U8 = StructAtIndex 3 Str.77;
        let Str.268 : U64 = StructAtIndex 0 Str.77;
        dec Str.77;
        let Str.266 : {U64, U8} = Struct {Str.268, Str.267};
        let Str.265 : [C {U64, U8}, C Str] = TagId(0) Str.266;
        ret Str.265;

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.26 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;