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

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

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

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

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.293 Decode.95 Decode.97;
    ret Decode.127;

procedure Decode.25 (Decode.98, Decode.99):
    let Decode.126 : {} = CallByName Json.41;
    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.139 (Json.452, Json.453):
    joinpoint Json.421 Json.418 Json.138:
        let Json.141 : List U8 = StructAtIndex 0 Json.418;
        inc Json.141;
        let Json.140 : List U8 = StructAtIndex 1 Json.418;
        inc Json.140;
        dec Json.418;
        let Json.422 : [C {}, C U8] = CallByName List.9 Json.141;
        let Json.436 : U8 = 1i64;
        let Json.437 : U8 = GetTagId Json.422;
        let Json.438 : Int1 = lowlevel Eq Json.436 Json.437;
        if Json.438 then
            let Json.142 : U8 = UnionAtIndex (Id 1) (Index 0) Json.422;
            let Json.424 : Int1 = CallByName Json.283 Json.142;
            if Json.424 then
                let Json.434 : U64 = 1i64;
                let Json.430 : {List U8, List U8} = CallByName List.52 Json.141 Json.434;
                let Json.431 : {} = Struct {};
                let Json.428 : List U8 = CallByName Json.143 Json.430;
                let Json.429 : List U8 = CallByName List.4 Json.140 Json.142;
                let Json.426 : {List U8, List U8} = Struct {Json.428, Json.429};
                jump Json.421 Json.426 Json.138;
            else
                let Json.423 : {List U8, List U8} = Struct {Json.141, Json.140};
                ret Json.423;
        else
            let Json.435 : {List U8, List U8} = Struct {Json.141, Json.140};
            ret Json.435;
    in
    jump Json.421 Json.452 Json.453;

procedure Json.143 (Json.432):
    let Json.433 : List U8 = StructAtIndex 1 Json.432;
    inc Json.433;
    dec Json.432;
    ret Json.433;

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

procedure Json.22 (Json.137, Json.138):
    let Json.440 : List U8 = Array [];
    let Json.420 : {List U8, List U8} = Struct {Json.137, Json.440};
    let Json.419 : {List U8, List U8} = CallByName Json.139 Json.420 Json.138;
    ret Json.419;

procedure Json.283 (Json.284):
    let Json.442 : U8 = 34i64;
    let Json.441 : Int1 = CallByName Bool.7 Json.284 Json.442;
    ret Json.441;

procedure Json.293 (Json.294, Json.399):
    let Json.400 : {List U8, [C {}, C Str]} = CallByName Json.40 Json.294;
    ret Json.400;

procedure Json.40 (Json.276):
    let Json.446 : U64 = 1i64;
    inc Json.276;
    let Json.445 : {List U8, List U8} = CallByName List.52 Json.276 Json.446;
    let Json.277 : List U8 = StructAtIndex 0 Json.445;
    inc Json.277;
    let Json.279 : List U8 = StructAtIndex 1 Json.445;
    inc Json.279;
    dec Json.445;
    let Json.444 : U8 = 34i64;
    let Json.443 : List U8 = Array [Json.444];
    let Json.404 : Int1 = CallByName Bool.11 Json.277 Json.443;
    dec Json.443;
    dec Json.277;
    if Json.404 then
        dec Json.276;
        let Json.417 : {} = Struct {};
        let Json.416 : {List U8, List U8} = CallByName Json.22 Json.279 Json.417;
        let Json.282 : List U8 = StructAtIndex 0 Json.416;
        inc Json.282;
        let Json.281 : List U8 = StructAtIndex 1 Json.416;
        inc Json.281;
        dec Json.416;
        let Json.405 : [C {U64, U8}, C Str] = CallByName Str.9 Json.281;
        let Json.413 : U8 = 1i64;
        let Json.414 : U8 = GetTagId Json.405;
        let Json.415 : Int1 = lowlevel Eq Json.413 Json.414;
        if Json.415 then
            let Json.285 : Str = UnionAtIndex (Id 1) (Index 0) Json.405;
            inc Json.285;
            dec Json.405;
            let Json.409 : U64 = 1i64;
            let Json.408 : {List U8, List U8} = CallByName List.52 Json.282 Json.409;
            let Json.287 : List U8 = StructAtIndex 1 Json.408;
            inc Json.287;
            dec Json.408;
            let Json.407 : [C {}, C Str] = TagId(1) Json.285;
            let Json.406 : {List U8, [C {}, C Str]} = Struct {Json.287, Json.407};
            ret Json.406;
        else
            dec Json.405;
            let Json.412 : {} = Struct {};
            let Json.411 : [C {}, C Str] = TagId(0) Json.412;
            let Json.410 : {List U8, [C {}, C Str]} = Struct {Json.282, Json.411};
            ret Json.410;
    else
        dec Json.279;
        let Json.403 : {} = Struct {};
        let Json.402 : [C {}, C Str] = TagId(0) Json.403;
        let Json.401 : {List U8, [C {}, C Str]} = Struct {Json.276, Json.402};
        ret Json.401;

procedure Json.41 ():
    let Json.398 : {} = Struct {};
    let Json.397 : {} = CallByName Decode.23 Json.398;
    ret Json.397;

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.2 (List.95, List.96):
    let List.551 : U64 = CallByName List.6 List.95;
    let List.547 : Int1 = CallByName Num.22 List.96 List.551;
    if List.547 then
        let List.549 : U8 = CallByName List.66 List.95 List.96;
        let List.548 : [C {}, C U8] = TagId(1) List.549;
        ret List.548;
    else
        let List.546 : {} = Struct {};
        let List.545 : [C {}, C U8] = TagId(0) List.546;
        ret List.545;

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

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.530 List.387:
        let List.528 : U64 = 0i64;
        let List.527 : {U64, U64} = Struct {List.387, List.528};
        inc List.384;
        let List.388 : List U8 = CallByName List.49 List.384 List.527;
        let List.526 : U64 = CallByName Num.20 List.386 List.387;
        let List.525 : {U64, U64} = Struct {List.526, List.387};
        let List.389 : List U8 = CallByName List.49 List.384 List.525;
        let List.524 : {List U8, List U8} = Struct {List.388, List.389};
        ret List.524;
    in
    let List.531 : Int1 = CallByName Num.24 List.386 List.385;
    if List.531 then
        jump List.530 List.385;
    else
        jump List.530 List.386;

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

procedure List.66 (#Attr.2, #Attr.3):
    let List.550 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
    ret List.550;

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

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

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 List.9 (List.286):
    let List.544 : U64 = 0i64;
    let List.537 : [C {}, C U8] = CallByName List.2 List.286 List.544;
    let List.541 : U8 = 1i64;
    let List.542 : U8 = GetTagId List.537;
    let List.543 : Int1 = lowlevel Eq List.541 List.542;
    if List.543 then
        let List.287 : U8 = UnionAtIndex (Id 1) (Index 0) List.537;
        let List.538 : [C {}, C U8] = TagId(1) List.287;
        ret List.538;
    else
        let List.540 : {} = Struct {};
        let List.539 : [C {}, C U8] = TagId(0) List.540;
        ret List.539;

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

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

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

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;