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

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

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

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

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

procedure Bool.3 (#Attr.2, #Attr.3):
    let Bool.33 : Int1 = lowlevel And #Attr.2 #Attr.3;
    ret Bool.33;

procedure Bool.4 (#Attr.2, #Attr.3):
    let Bool.53 : Int1 = lowlevel Or #Attr.2 #Attr.3;
    ret Bool.53;

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 TotallyNotJson.525 Decode.102 Decode.104;
    ret Decode.134;

procedure Decode.26 (Decode.105, Decode.106):
    let Decode.133 : {} = CallByName TotallyNotJson.60;
    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;
    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;
            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 List.1 (List.102):
    let List.607 : U64 = CallByName List.6 List.102;
    dec List.102;
    let List.608 : U64 = 0i64;
    let List.606 : Int1 = CallByName Bool.11 List.607 List.608;
    ret List.606;

procedure List.2 (List.103, List.104):
    let List.598 : U64 = CallByName List.6 List.103;
    let List.595 : Int1 = CallByName Num.22 List.104 List.598;
    if List.595 then
        let List.597 : U8 = CallByName List.66 List.103 List.104;
        dec List.103;
        let List.596 : [C {}, C U8] = TagId(1) List.597;
        ret List.596;
    else
        dec List.103;
        let List.594 : {} = Struct {};
        let List.593 : [C {}, C U8] = TagId(0) List.594;
        ret List.593;

procedure List.26 (List.181, List.182, List.183):
    let List.609 : [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]] = CallByName List.99 List.181 List.182 List.183;
    let List.612 : U8 = 1i64;
    let List.613 : U8 = GetTagId List.609;
    let List.614 : Int1 = lowlevel Eq List.612 List.613;
    if List.614 then
        let List.184 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 1) (Index 0) List.609;
        ret List.184;
    else
        let List.185 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 0) (Index 0) List.609;
        ret List.185;

procedure List.38 (List.324, List.325):
    let List.575 : U64 = CallByName List.6 List.324;
    let List.326 : U64 = CallByName Num.77 List.575 List.325;
    let List.574 : List U8 = CallByName List.43 List.324 List.326;
    ret List.574;

procedure List.4 (List.119, List.120):
    let List.585 : U64 = 1i64;
    let List.584 : List U8 = CallByName List.70 List.119 List.585;
    let List.583 : List U8 = CallByName List.71 List.584 List.120;
    ret List.583;

procedure List.43 (List.322, List.323):
    let List.565 : U64 = CallByName List.6 List.322;
    let List.564 : U64 = CallByName Num.77 List.565 List.323;
    let List.559 : {U64, U64} = Struct {List.323, List.564};
    let List.558 : List U8 = CallByName List.49 List.322 List.559;
    ret List.558;

procedure List.49 (List.400, List.401):
    let List.603 : U64 = StructAtIndex 1 List.401;
    let List.604 : U64 = StructAtIndex 0 List.401;
    let List.602 : List U8 = CallByName List.72 List.400 List.603 List.604;
    ret List.602;

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

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

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

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

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

procedure List.8 (#Attr.2, #Attr.3):
    let List.577 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
    ret List.577;

procedure List.80 (#Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4, #Derived_gen.5):
    joinpoint List.618 List.471 List.472 List.473 List.474 List.475:
        let List.620 : Int1 = CallByName Num.22 List.474 List.475;
        if List.620 then
            let List.629 : U8 = CallByName List.66 List.471 List.474;
            let List.621 : [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]] = CallByName TotallyNotJson.62 List.472 List.629;
            let List.626 : U8 = 1i64;
            let List.627 : U8 = GetTagId List.621;
            let List.628 : Int1 = lowlevel Eq List.626 List.627;
            if List.628 then
                let List.476 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 1) (Index 0) List.621;
                let List.624 : U64 = 1i64;
                let List.623 : U64 = CallByName Num.51 List.474 List.624;
                jump List.618 List.471 List.476 List.473 List.623 List.475;
            else
                dec List.471;
                let List.477 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 0) (Index 0) List.621;
                let List.625 : [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.477;
                ret List.625;
        else
            dec List.471;
            let List.619 : [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.472;
            ret List.619;
    in
    jump List.618 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5;

procedure List.99 (List.468, List.469, List.470):
    let List.616 : U64 = 0i64;
    let List.617 : U64 = CallByName List.6 List.468;
    let List.615 : [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]] = CallByName List.80 List.468 List.469 List.470 List.616 List.617;
    ret List.615;

procedure Num.19 (#Attr.2, #Attr.3):
    let Num.294 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
    ret Num.294;

procedure Num.19 (#Attr.2, #Attr.3):
    let Num.303 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
    ret Num.303;

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

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

procedure Num.23 (#Attr.2, #Attr.3):
    let Num.312 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
    ret Num.312;

procedure Num.25 (#Attr.2, #Attr.3):
    let Num.318 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
    ret Num.318;

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

procedure Num.71 (#Attr.2, #Attr.3):
    let Num.291 : U8 = lowlevel NumBitwiseOr #Attr.2 #Attr.3;
    ret Num.291;

procedure Num.72 (#Attr.2, #Attr.3):
    let Num.292 : U8 = lowlevel NumShiftLeftBy #Attr.2 #Attr.3;
    ret Num.292;

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

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

procedure Str.9 (Str.80):
    let Str.299 : U64 = 0i64;
    let Str.300 : U64 = CallByName List.6 Str.80;
    let Str.81 : {U64, Str, Int1, U8} = CallByName Str.48 Str.80 Str.299 Str.300;
    let Str.296 : Int1 = StructAtIndex 2 Str.81;
    if Str.296 then
        let Str.298 : Str = StructAtIndex 1 Str.81;
        let Str.297 : [C {U64, U8}, C Str] = TagId(1) Str.298;
        ret Str.297;
    else
        let Str.294 : U8 = StructAtIndex 3 Str.81;
        let Str.295 : U64 = StructAtIndex 0 Str.81;
        let #Derived_gen.7 : Str = StructAtIndex 1 Str.81;
        dec #Derived_gen.7;
        let Str.293 : {U64, U8} = Struct {Str.295, Str.294};
        let Str.292 : [C {U64, U8}, C Str] = TagId(0) Str.293;
        ret Str.292;

procedure Test.3 ():
    let Test.0 : List U8 = Array [82i64, 111i64, 99i64];
    let Test.8 : [C , C [], C , C , C , C ] = CallByName TotallyNotJson.8;
    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;
    let Test.5 : Int1 = CallByName Bool.11 Test.1 Test.6;
    dec Test.7;
    expect Test.5;
    dec Test.1;
    dec Test.0;
    let Test.4 : {} = Struct {};
    ret Test.4;

procedure TotallyNotJson.525 (TotallyNotJson.526, TotallyNotJson.1175):
    joinpoint TotallyNotJson.1459:
        inc TotallyNotJson.526;
        let TotallyNotJson.1328 : {List U8, List U8} = CallByName TotallyNotJson.61 TotallyNotJson.526;
        let TotallyNotJson.530 : List U8 = StructAtIndex 0 TotallyNotJson.1328;
        let TotallyNotJson.529 : List U8 = StructAtIndex 1 TotallyNotJson.1328;
        inc TotallyNotJson.529;
        let TotallyNotJson.1324 : Int1 = CallByName List.1 TotallyNotJson.529;
        if TotallyNotJson.1324 then
            dec TotallyNotJson.530;
            dec TotallyNotJson.529;
            let TotallyNotJson.1327 : {} = Struct {};
            let TotallyNotJson.1326 : [C {}, C Str] = TagId(0) TotallyNotJson.1327;
            let TotallyNotJson.1325 : {List U8, [C {}, C Str]} = Struct {TotallyNotJson.526, TotallyNotJson.1326};
            ret TotallyNotJson.1325;
        else
            let TotallyNotJson.1322 : U64 = CallByName List.6 TotallyNotJson.529;
            let TotallyNotJson.1323 : U64 = 2i64;
            let TotallyNotJson.1320 : U64 = CallByName Num.77 TotallyNotJson.1322 TotallyNotJson.1323;
            let TotallyNotJson.1321 : U64 = 1i64;
            let TotallyNotJson.1319 : {U64, U64} = Struct {TotallyNotJson.1320, TotallyNotJson.1321};
            let TotallyNotJson.1194 : List U8 = CallByName List.49 TotallyNotJson.529 TotallyNotJson.1319;
            let TotallyNotJson.1195 : {} = Struct {};
            let TotallyNotJson.1190 : {List U8, List U8} = CallByName TotallyNotJson.534 TotallyNotJson.1194;
            let TotallyNotJson.1191 : {} = Struct {};
            let TotallyNotJson.1189 : List U8 = CallByName TotallyNotJson.536 TotallyNotJson.1190;
            let TotallyNotJson.533 : [C {U64, U8}, C Str] = CallByName Str.9 TotallyNotJson.1189;
            let TotallyNotJson.1186 : U8 = 1i64;
            let TotallyNotJson.1187 : U8 = GetTagId TotallyNotJson.533;
            let TotallyNotJson.1188 : Int1 = lowlevel Eq TotallyNotJson.1186 TotallyNotJson.1187;
            if TotallyNotJson.1188 then
                dec TotallyNotJson.526;
                let TotallyNotJson.537 : Str = UnionAtIndex (Id 1) (Index 0) TotallyNotJson.533;
                let TotallyNotJson.1182 : [C {}, C Str] = TagId(1) TotallyNotJson.537;
                let TotallyNotJson.1181 : {List U8, [C {}, C Str]} = Struct {TotallyNotJson.530, TotallyNotJson.1182};
                ret TotallyNotJson.1181;
            else
                dec TotallyNotJson.530;
                dec TotallyNotJson.533;
                let TotallyNotJson.1185 : {} = Struct {};
                let TotallyNotJson.1184 : [C {}, C Str] = TagId(0) TotallyNotJson.1185;
                let TotallyNotJson.1183 : {List U8, [C {}, C Str]} = Struct {TotallyNotJson.526, TotallyNotJson.1184};
                ret TotallyNotJson.1183;
    in
    let TotallyNotJson.1457 : U64 = lowlevel ListLen TotallyNotJson.526;
    let TotallyNotJson.1458 : U64 = 4i64;
    let TotallyNotJson.1464 : Int1 = lowlevel NumGte TotallyNotJson.1457 TotallyNotJson.1458;
    if TotallyNotJson.1464 then
        let TotallyNotJson.1454 : U64 = 3i64;
        let TotallyNotJson.1455 : U8 = lowlevel ListGetUnsafe TotallyNotJson.526 TotallyNotJson.1454;
        let TotallyNotJson.1456 : U8 = 108i64;
        let TotallyNotJson.1463 : Int1 = lowlevel Eq TotallyNotJson.1456 TotallyNotJson.1455;
        if TotallyNotJson.1463 then
            let TotallyNotJson.1451 : U64 = 2i64;
            let TotallyNotJson.1452 : U8 = lowlevel ListGetUnsafe TotallyNotJson.526 TotallyNotJson.1451;
            let TotallyNotJson.1453 : U8 = 108i64;
            let TotallyNotJson.1462 : Int1 = lowlevel Eq TotallyNotJson.1453 TotallyNotJson.1452;
            if TotallyNotJson.1462 then
                let TotallyNotJson.1448 : U64 = 1i64;
                let TotallyNotJson.1449 : U8 = lowlevel ListGetUnsafe TotallyNotJson.526 TotallyNotJson.1448;
                let TotallyNotJson.1450 : U8 = 117i64;
                let TotallyNotJson.1461 : Int1 = lowlevel Eq TotallyNotJson.1450 TotallyNotJson.1449;
                if TotallyNotJson.1461 then
                    let TotallyNotJson.1445 : U64 = 0i64;
                    let TotallyNotJson.1446 : U8 = lowlevel ListGetUnsafe TotallyNotJson.526 TotallyNotJson.1445;
                    let TotallyNotJson.1447 : U8 = 110i64;
                    let TotallyNotJson.1460 : Int1 = lowlevel Eq TotallyNotJson.1447 TotallyNotJson.1446;
                    if TotallyNotJson.1460 then
                        let TotallyNotJson.1180 : U64 = 4i64;
                        let TotallyNotJson.1177 : List U8 = CallByName List.38 TotallyNotJson.526 TotallyNotJson.1180;
                        let TotallyNotJson.1179 : Str = "null";
                        let TotallyNotJson.1178 : [C {}, C Str] = TagId(1) TotallyNotJson.1179;
                        let TotallyNotJson.1176 : {List U8, [C {}, C Str]} = Struct {TotallyNotJson.1177, TotallyNotJson.1178};
                        ret TotallyNotJson.1176;
                    else
                        jump TotallyNotJson.1459;
                else
                    jump TotallyNotJson.1459;
            else
                jump TotallyNotJson.1459;
        else
            jump TotallyNotJson.1459;
    else
        jump TotallyNotJson.1459;

procedure TotallyNotJson.534 (TotallyNotJson.535):
    let TotallyNotJson.1318 : List U8 = Array [];
    let TotallyNotJson.1197 : {List U8, List U8} = Struct {TotallyNotJson.535, TotallyNotJson.1318};
    let TotallyNotJson.1196 : {List U8, List U8} = CallByName TotallyNotJson.70 TotallyNotJson.1197;
    ret TotallyNotJson.1196;

procedure TotallyNotJson.536 (TotallyNotJson.1192):
    let TotallyNotJson.1193 : List U8 = StructAtIndex 1 TotallyNotJson.1192;
    let #Derived_gen.6 : List U8 = StructAtIndex 0 TotallyNotJson.1192;
    dec #Derived_gen.6;
    ret TotallyNotJson.1193;

procedure TotallyNotJson.60 ():
    let TotallyNotJson.1174 : {} = Struct {};
    let TotallyNotJson.1173 : {} = CallByName Decode.24 TotallyNotJson.1174;
    ret TotallyNotJson.1173;

procedure TotallyNotJson.61 (TotallyNotJson.541):
    let TotallyNotJson.1340 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = TagId(4) ;
    let TotallyNotJson.1341 : {} = Struct {};
    inc TotallyNotJson.541;
    let TotallyNotJson.1329 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = CallByName List.26 TotallyNotJson.541 TotallyNotJson.1340 TotallyNotJson.1341;
    let TotallyNotJson.1337 : U8 = 2i64;
    let TotallyNotJson.1338 : U8 = GetTagId TotallyNotJson.1329;
    let TotallyNotJson.1339 : Int1 = lowlevel Eq TotallyNotJson.1337 TotallyNotJson.1338;
    if TotallyNotJson.1339 then
        inc TotallyNotJson.541;
        let TotallyNotJson.543 : U64 = UnionAtIndex (Id 2) (Index 0) TotallyNotJson.1329;
        let TotallyNotJson.1331 : List U8 = CallByName List.38 TotallyNotJson.541 TotallyNotJson.543;
        let TotallyNotJson.1334 : U64 = 0i64;
        let TotallyNotJson.1333 : {U64, U64} = Struct {TotallyNotJson.543, TotallyNotJson.1334};
        let TotallyNotJson.1332 : List U8 = CallByName List.49 TotallyNotJson.541 TotallyNotJson.1333;
        let TotallyNotJson.1330 : {List U8, List U8} = Struct {TotallyNotJson.1331, TotallyNotJson.1332};
        ret TotallyNotJson.1330;
    else
        let TotallyNotJson.1336 : List U8 = Array [];
        let TotallyNotJson.1335 : {List U8, List U8} = Struct {TotallyNotJson.541, TotallyNotJson.1336};
        ret TotallyNotJson.1335;

procedure TotallyNotJson.62 (TotallyNotJson.544, TotallyNotJson.545):
    let TotallyNotJson.1342 : {[C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], U8} = Struct {TotallyNotJson.544, TotallyNotJson.545};
    joinpoint TotallyNotJson.1385:
        let TotallyNotJson.1383 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = TagId(3) ;
        let TotallyNotJson.1382 : [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) TotallyNotJson.1383;
        ret TotallyNotJson.1382;
    in
    let TotallyNotJson.1386 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = StructAtIndex 0 TotallyNotJson.1342;
    let TotallyNotJson.1444 : U8 = GetTagId TotallyNotJson.1386;
    switch TotallyNotJson.1444:
        case 4:
            let TotallyNotJson.546 : U8 = StructAtIndex 1 TotallyNotJson.1342;
            joinpoint TotallyNotJson.1388 TotallyNotJson.1387:
                if TotallyNotJson.1387 then
                    let TotallyNotJson.1345 : U64 = 1i64;
                    let TotallyNotJson.1344 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = TagId(0) TotallyNotJson.1345;
                    let TotallyNotJson.1343 : [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) TotallyNotJson.1344;
                    ret TotallyNotJson.1343;
                else
                    jump TotallyNotJson.1385;
            in
            let TotallyNotJson.1390 : U8 = 34i64;
            let TotallyNotJson.1389 : Int1 = CallByName Bool.11 TotallyNotJson.546 TotallyNotJson.1390;
            jump TotallyNotJson.1388 TotallyNotJson.1389;
    
        case 0:
            let TotallyNotJson.1401 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = StructAtIndex 0 TotallyNotJson.1342;
            let TotallyNotJson.549 : U64 = UnionAtIndex (Id 0) (Index 0) TotallyNotJson.1401;
            let TotallyNotJson.550 : U8 = StructAtIndex 1 TotallyNotJson.1342;
            joinpoint TotallyNotJson.1398 TotallyNotJson.1392:
                if TotallyNotJson.1392 then
                    let TotallyNotJson.1349 : U64 = 1i64;
                    let TotallyNotJson.1348 : U64 = CallByName Num.19 TotallyNotJson.549 TotallyNotJson.1349;
                    let TotallyNotJson.1347 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = TagId(2) TotallyNotJson.1348;
                    let TotallyNotJson.1346 : [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) TotallyNotJson.1347;
                    ret TotallyNotJson.1346;
                else
                    let TotallyNotJson.1397 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = StructAtIndex 0 TotallyNotJson.1342;
                    let TotallyNotJson.553 : U64 = UnionAtIndex (Id 0) (Index 0) TotallyNotJson.1397;
                    let TotallyNotJson.554 : U8 = StructAtIndex 1 TotallyNotJson.1342;
                    joinpoint TotallyNotJson.1394 TotallyNotJson.1393:
                        if TotallyNotJson.1393 then
                            let TotallyNotJson.1353 : U64 = 1i64;
                            let TotallyNotJson.1352 : U64 = CallByName Num.19 TotallyNotJson.553 TotallyNotJson.1353;
                            let TotallyNotJson.1351 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = TagId(1) TotallyNotJson.1352;
                            let TotallyNotJson.1350 : [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) TotallyNotJson.1351;
                            ret TotallyNotJson.1350;
                        else
                            let TotallyNotJson.1384 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = StructAtIndex 0 TotallyNotJson.1342;
                            let TotallyNotJson.557 : U64 = UnionAtIndex (Id 0) (Index 0) TotallyNotJson.1384;
                            let TotallyNotJson.1357 : U64 = 1i64;
                            let TotallyNotJson.1356 : U64 = CallByName Num.19 TotallyNotJson.557 TotallyNotJson.1357;
                            let TotallyNotJson.1355 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = TagId(0) TotallyNotJson.1356;
                            let TotallyNotJson.1354 : [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) TotallyNotJson.1355;
                            ret TotallyNotJson.1354;
                    in
                    let TotallyNotJson.1396 : U8 = 92i64;
                    let TotallyNotJson.1395 : Int1 = CallByName Bool.11 TotallyNotJson.554 TotallyNotJson.1396;
                    jump TotallyNotJson.1394 TotallyNotJson.1395;
            in
            let TotallyNotJson.1400 : U8 = 34i64;
            let TotallyNotJson.1399 : Int1 = CallByName Bool.11 TotallyNotJson.550 TotallyNotJson.1400;
            jump TotallyNotJson.1398 TotallyNotJson.1399;
    
        case 1:
            let TotallyNotJson.1410 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = StructAtIndex 0 TotallyNotJson.1342;
            let TotallyNotJson.560 : U64 = UnionAtIndex (Id 1) (Index 0) TotallyNotJson.1410;
            let TotallyNotJson.561 : U8 = StructAtIndex 1 TotallyNotJson.1342;
            joinpoint TotallyNotJson.1408 TotallyNotJson.1402:
                if TotallyNotJson.1402 then
                    let TotallyNotJson.1361 : U64 = 1i64;
                    let TotallyNotJson.1360 : U64 = CallByName Num.19 TotallyNotJson.560 TotallyNotJson.1361;
                    let TotallyNotJson.1359 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = TagId(0) TotallyNotJson.1360;
                    let TotallyNotJson.1358 : [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) TotallyNotJson.1359;
                    ret TotallyNotJson.1358;
                else
                    let TotallyNotJson.1407 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = StructAtIndex 0 TotallyNotJson.1342;
                    let TotallyNotJson.564 : U64 = UnionAtIndex (Id 1) (Index 0) TotallyNotJson.1407;
                    let TotallyNotJson.565 : U8 = StructAtIndex 1 TotallyNotJson.1342;
                    joinpoint TotallyNotJson.1404 TotallyNotJson.1403:
                        if TotallyNotJson.1403 then
                            let TotallyNotJson.1365 : U64 = 1i64;
                            let TotallyNotJson.1364 : U64 = CallByName Num.19 TotallyNotJson.564 TotallyNotJson.1365;
                            let TotallyNotJson.1363 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = TagId(5) TotallyNotJson.1364;
                            let TotallyNotJson.1362 : [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) TotallyNotJson.1363;
                            ret TotallyNotJson.1362;
                        else
                            jump TotallyNotJson.1385;
                    in
                    let TotallyNotJson.1406 : U8 = 117i64;
                    let TotallyNotJson.1405 : Int1 = CallByName Bool.11 TotallyNotJson.565 TotallyNotJson.1406;
                    jump TotallyNotJson.1404 TotallyNotJson.1405;
            in
            let TotallyNotJson.1409 : Int1 = CallByName TotallyNotJson.63 TotallyNotJson.561;
            jump TotallyNotJson.1408 TotallyNotJson.1409;
    
        case 5:
            let TotallyNotJson.1431 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = StructAtIndex 0 TotallyNotJson.1342;
            let TotallyNotJson.568 : U64 = UnionAtIndex (Id 5) (Index 0) TotallyNotJson.1431;
            let TotallyNotJson.569 : U8 = StructAtIndex 1 TotallyNotJson.1342;
            joinpoint TotallyNotJson.1412 TotallyNotJson.1411:
                if TotallyNotJson.1411 then
                    let TotallyNotJson.1369 : U64 = 1i64;
                    let TotallyNotJson.1368 : U64 = CallByName Num.19 TotallyNotJson.568 TotallyNotJson.1369;
                    let TotallyNotJson.1367 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = TagId(6) TotallyNotJson.1368;
                    let TotallyNotJson.1366 : [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) TotallyNotJson.1367;
                    ret TotallyNotJson.1366;
                else
                    jump TotallyNotJson.1385;
            in
            let TotallyNotJson.1413 : Int1 = CallByName TotallyNotJson.65 TotallyNotJson.569;
            jump TotallyNotJson.1412 TotallyNotJson.1413;
    
        case 6:
            let TotallyNotJson.1435 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = StructAtIndex 0 TotallyNotJson.1342;
            let TotallyNotJson.572 : U64 = UnionAtIndex (Id 6) (Index 0) TotallyNotJson.1435;
            let TotallyNotJson.573 : U8 = StructAtIndex 1 TotallyNotJson.1342;
            joinpoint TotallyNotJson.1433 TotallyNotJson.1432:
                if TotallyNotJson.1432 then
                    let TotallyNotJson.1373 : U64 = 1i64;
                    let TotallyNotJson.1372 : U64 = CallByName Num.19 TotallyNotJson.572 TotallyNotJson.1373;
                    let TotallyNotJson.1371 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = TagId(7) TotallyNotJson.1372;
                    let TotallyNotJson.1370 : [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) TotallyNotJson.1371;
                    ret TotallyNotJson.1370;
                else
                    jump TotallyNotJson.1385;
            in
            let TotallyNotJson.1434 : Int1 = CallByName TotallyNotJson.65 TotallyNotJson.573;
            jump TotallyNotJson.1433 TotallyNotJson.1434;
    
        case 7:
            let TotallyNotJson.1439 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = StructAtIndex 0 TotallyNotJson.1342;
            let TotallyNotJson.576 : U64 = UnionAtIndex (Id 7) (Index 0) TotallyNotJson.1439;
            let TotallyNotJson.577 : U8 = StructAtIndex 1 TotallyNotJson.1342;
            joinpoint TotallyNotJson.1437 TotallyNotJson.1436:
                if TotallyNotJson.1436 then
                    let TotallyNotJson.1377 : U64 = 1i64;
                    let TotallyNotJson.1376 : U64 = CallByName Num.19 TotallyNotJson.576 TotallyNotJson.1377;
                    let TotallyNotJson.1375 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = TagId(8) TotallyNotJson.1376;
                    let TotallyNotJson.1374 : [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) TotallyNotJson.1375;
                    ret TotallyNotJson.1374;
                else
                    jump TotallyNotJson.1385;
            in
            let TotallyNotJson.1438 : Int1 = CallByName TotallyNotJson.65 TotallyNotJson.577;
            jump TotallyNotJson.1437 TotallyNotJson.1438;
    
        case 8:
            let TotallyNotJson.1443 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = StructAtIndex 0 TotallyNotJson.1342;
            let TotallyNotJson.580 : U64 = UnionAtIndex (Id 8) (Index 0) TotallyNotJson.1443;
            let TotallyNotJson.581 : U8 = StructAtIndex 1 TotallyNotJson.1342;
            joinpoint TotallyNotJson.1441 TotallyNotJson.1440:
                if TotallyNotJson.1440 then
                    let TotallyNotJson.1381 : U64 = 1i64;
                    let TotallyNotJson.1380 : U64 = CallByName Num.19 TotallyNotJson.580 TotallyNotJson.1381;
                    let TotallyNotJson.1379 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = TagId(0) TotallyNotJson.1380;
                    let TotallyNotJson.1378 : [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) TotallyNotJson.1379;
                    ret TotallyNotJson.1378;
                else
                    jump TotallyNotJson.1385;
            in
            let TotallyNotJson.1442 : Int1 = CallByName TotallyNotJson.65 TotallyNotJson.581;
            jump TotallyNotJson.1441 TotallyNotJson.1442;
    
        default:
            jump TotallyNotJson.1385;
    

procedure TotallyNotJson.63 (TotallyNotJson.586):
    switch TotallyNotJson.586:
        case 34:
            let TotallyNotJson.1286 : Int1 = CallByName Bool.2;
            ret TotallyNotJson.1286;
    
        case 92:
            let TotallyNotJson.1287 : Int1 = CallByName Bool.2;
            ret TotallyNotJson.1287;
    
        case 47:
            let TotallyNotJson.1288 : Int1 = CallByName Bool.2;
            ret TotallyNotJson.1288;
    
        case 98:
            let TotallyNotJson.1289 : Int1 = CallByName Bool.2;
            ret TotallyNotJson.1289;
    
        case 102:
            let TotallyNotJson.1290 : Int1 = CallByName Bool.2;
            ret TotallyNotJson.1290;
    
        case 110:
            let TotallyNotJson.1291 : Int1 = CallByName Bool.2;
            ret TotallyNotJson.1291;
    
        case 114:
            let TotallyNotJson.1292 : Int1 = CallByName Bool.2;
            ret TotallyNotJson.1292;
    
        case 116:
            let TotallyNotJson.1293 : Int1 = CallByName Bool.2;
            ret TotallyNotJson.1293;
    
        default:
            let TotallyNotJson.1294 : Int1 = CallByName Bool.1;
            ret TotallyNotJson.1294;
    

procedure TotallyNotJson.64 (TotallyNotJson.587):
    switch TotallyNotJson.587:
        case 34:
            let TotallyNotJson.1263 : U8 = 34i64;
            ret TotallyNotJson.1263;
    
        case 92:
            let TotallyNotJson.1264 : U8 = 92i64;
            ret TotallyNotJson.1264;
    
        case 47:
            let TotallyNotJson.1265 : U8 = 47i64;
            ret TotallyNotJson.1265;
    
        case 98:
            let TotallyNotJson.1266 : U8 = 8i64;
            ret TotallyNotJson.1266;
    
        case 102:
            let TotallyNotJson.1267 : U8 = 12i64;
            ret TotallyNotJson.1267;
    
        case 110:
            let TotallyNotJson.1268 : U8 = 10i64;
            ret TotallyNotJson.1268;
    
        case 114:
            let TotallyNotJson.1269 : U8 = 13i64;
            ret TotallyNotJson.1269;
    
        case 116:
            let TotallyNotJson.1270 : U8 = 9i64;
            ret TotallyNotJson.1270;
    
        default:
            ret TotallyNotJson.587;
    

procedure TotallyNotJson.65 (TotallyNotJson.588):
    let TotallyNotJson.1430 : U8 = 48i64;
    let TotallyNotJson.1427 : Int1 = CallByName Num.25 TotallyNotJson.588 TotallyNotJson.1430;
    let TotallyNotJson.1429 : U8 = 57i64;
    let TotallyNotJson.1428 : Int1 = CallByName Num.23 TotallyNotJson.588 TotallyNotJson.1429;
    let TotallyNotJson.1415 : Int1 = CallByName Bool.3 TotallyNotJson.1427 TotallyNotJson.1428;
    let TotallyNotJson.1426 : U8 = 97i64;
    let TotallyNotJson.1423 : Int1 = CallByName Num.25 TotallyNotJson.588 TotallyNotJson.1426;
    let TotallyNotJson.1425 : U8 = 102i64;
    let TotallyNotJson.1424 : Int1 = CallByName Num.23 TotallyNotJson.588 TotallyNotJson.1425;
    let TotallyNotJson.1417 : Int1 = CallByName Bool.3 TotallyNotJson.1423 TotallyNotJson.1424;
    let TotallyNotJson.1422 : U8 = 65i64;
    let TotallyNotJson.1419 : Int1 = CallByName Num.25 TotallyNotJson.588 TotallyNotJson.1422;
    let TotallyNotJson.1421 : U8 = 70i64;
    let TotallyNotJson.1420 : Int1 = CallByName Num.23 TotallyNotJson.588 TotallyNotJson.1421;
    let TotallyNotJson.1418 : Int1 = CallByName Bool.3 TotallyNotJson.1419 TotallyNotJson.1420;
    let TotallyNotJson.1416 : Int1 = CallByName Bool.4 TotallyNotJson.1417 TotallyNotJson.1418;
    let TotallyNotJson.1414 : Int1 = CallByName Bool.4 TotallyNotJson.1415 TotallyNotJson.1416;
    ret TotallyNotJson.1414;

procedure TotallyNotJson.66 (TotallyNotJson.589):
    let TotallyNotJson.1242 : U8 = 48i64;
    let TotallyNotJson.1239 : Int1 = CallByName Num.25 TotallyNotJson.589 TotallyNotJson.1242;
    let TotallyNotJson.1241 : U8 = 57i64;
    let TotallyNotJson.1240 : Int1 = CallByName Num.23 TotallyNotJson.589 TotallyNotJson.1241;
    let TotallyNotJson.1236 : Int1 = CallByName Bool.3 TotallyNotJson.1239 TotallyNotJson.1240;
    if TotallyNotJson.1236 then
        let TotallyNotJson.1238 : U8 = 48i64;
        let TotallyNotJson.1237 : U8 = CallByName Num.20 TotallyNotJson.589 TotallyNotJson.1238;
        ret TotallyNotJson.1237;
    else
        let TotallyNotJson.1235 : U8 = 97i64;
        let TotallyNotJson.1232 : Int1 = CallByName Num.25 TotallyNotJson.589 TotallyNotJson.1235;
        let TotallyNotJson.1234 : U8 = 102i64;
        let TotallyNotJson.1233 : Int1 = CallByName Num.23 TotallyNotJson.589 TotallyNotJson.1234;
        let TotallyNotJson.1227 : Int1 = CallByName Bool.3 TotallyNotJson.1232 TotallyNotJson.1233;
        if TotallyNotJson.1227 then
            let TotallyNotJson.1231 : U8 = 97i64;
            let TotallyNotJson.1229 : U8 = CallByName Num.20 TotallyNotJson.589 TotallyNotJson.1231;
            let TotallyNotJson.1230 : U8 = 10i64;
            let TotallyNotJson.1228 : U8 = CallByName Num.19 TotallyNotJson.1229 TotallyNotJson.1230;
            ret TotallyNotJson.1228;
        else
            let TotallyNotJson.1226 : U8 = 65i64;
            let TotallyNotJson.1223 : Int1 = CallByName Num.25 TotallyNotJson.589 TotallyNotJson.1226;
            let TotallyNotJson.1225 : U8 = 70i64;
            let TotallyNotJson.1224 : Int1 = CallByName Num.23 TotallyNotJson.589 TotallyNotJson.1225;
            let TotallyNotJson.1218 : Int1 = CallByName Bool.3 TotallyNotJson.1223 TotallyNotJson.1224;
            if TotallyNotJson.1218 then
                let TotallyNotJson.1222 : U8 = 65i64;
                let TotallyNotJson.1220 : U8 = CallByName Num.20 TotallyNotJson.589 TotallyNotJson.1222;
                let TotallyNotJson.1221 : U8 = 10i64;
                let TotallyNotJson.1219 : U8 = CallByName Num.19 TotallyNotJson.1220 TotallyNotJson.1221;
                ret TotallyNotJson.1219;
            else
                let TotallyNotJson.1217 : Str = "got an invalid hex char";
                Crash TotallyNotJson.1217

procedure TotallyNotJson.67 (TotallyNotJson.590, TotallyNotJson.591):
    let TotallyNotJson.1208 : U8 = 4i64;
    let TotallyNotJson.1207 : U8 = CallByName Num.72 TotallyNotJson.590 TotallyNotJson.1208;
    let TotallyNotJson.1206 : U8 = CallByName Num.71 TotallyNotJson.1207 TotallyNotJson.591;
    ret TotallyNotJson.1206;

procedure TotallyNotJson.68 (TotallyNotJson.592, TotallyNotJson.593, TotallyNotJson.594, TotallyNotJson.595):
    let TotallyNotJson.596 : U8 = CallByName TotallyNotJson.66 TotallyNotJson.592;
    let TotallyNotJson.597 : U8 = CallByName TotallyNotJson.66 TotallyNotJson.593;
    let TotallyNotJson.598 : U8 = CallByName TotallyNotJson.66 TotallyNotJson.594;
    let TotallyNotJson.599 : U8 = CallByName TotallyNotJson.66 TotallyNotJson.595;
    let TotallyNotJson.1215 : U8 = 0i64;
    let TotallyNotJson.1212 : Int1 = CallByName Bool.11 TotallyNotJson.596 TotallyNotJson.1215;
    let TotallyNotJson.1214 : U8 = 0i64;
    let TotallyNotJson.1213 : Int1 = CallByName Bool.11 TotallyNotJson.597 TotallyNotJson.1214;
    let TotallyNotJson.1209 : Int1 = CallByName Bool.3 TotallyNotJson.1212 TotallyNotJson.1213;
    if TotallyNotJson.1209 then
        let TotallyNotJson.1211 : U8 = CallByName TotallyNotJson.67 TotallyNotJson.598 TotallyNotJson.599;
        let TotallyNotJson.1210 : List U8 = Array [TotallyNotJson.1211];
        ret TotallyNotJson.1210;
    else
        let TotallyNotJson.1204 : U8 = CallByName TotallyNotJson.67 TotallyNotJson.596 TotallyNotJson.597;
        let TotallyNotJson.1205 : U8 = CallByName TotallyNotJson.67 TotallyNotJson.598 TotallyNotJson.599;
        let TotallyNotJson.1203 : List U8 = Array [TotallyNotJson.1204, TotallyNotJson.1205];
        ret TotallyNotJson.1203;

procedure TotallyNotJson.69 ():
    let TotallyNotJson.1248 : U8 = 102i64;
    let TotallyNotJson.1249 : U8 = 102i64;
    let TotallyNotJson.1250 : U8 = 100i64;
    let TotallyNotJson.1251 : U8 = 100i64;
    let TotallyNotJson.1247 : List U8 = CallByName TotallyNotJson.68 TotallyNotJson.1248 TotallyNotJson.1249 TotallyNotJson.1250 TotallyNotJson.1251;
    ret TotallyNotJson.1247;

procedure TotallyNotJson.70 (#Derived_gen.0):
    joinpoint TotallyNotJson.1198 TotallyNotJson.1166:
        let TotallyNotJson.600 : List U8 = StructAtIndex 0 TotallyNotJson.1166;
        inc 4 TotallyNotJson.600;
        let TotallyNotJson.601 : List U8 = StructAtIndex 1 TotallyNotJson.1166;
        let TotallyNotJson.1317 : U64 = 0i64;
        let TotallyNotJson.602 : [C {}, C U8] = CallByName List.2 TotallyNotJson.600 TotallyNotJson.1317;
        let TotallyNotJson.1316 : U64 = 1i64;
        let TotallyNotJson.603 : [C {}, C U8] = CallByName List.2 TotallyNotJson.600 TotallyNotJson.1316;
        let TotallyNotJson.1315 : U64 = 2i64;
        let TotallyNotJson.604 : List U8 = CallByName List.38 TotallyNotJson.600 TotallyNotJson.1315;
        let TotallyNotJson.1314 : U64 = 6i64;
        let TotallyNotJson.605 : List U8 = CallByName List.38 TotallyNotJson.600 TotallyNotJson.1314;
        let TotallyNotJson.1199 : {[C {}, C U8], [C {}, C U8]} = Struct {TotallyNotJson.602, TotallyNotJson.603};
        joinpoint TotallyNotJson.1279:
            let TotallyNotJson.1278 : [C {}, C U8] = StructAtIndex 0 TotallyNotJson.1199;
            let TotallyNotJson.616 : U8 = UnionAtIndex (Id 1) (Index 0) TotallyNotJson.1278;
            let TotallyNotJson.1276 : U64 = 1i64;
            let TotallyNotJson.1274 : List U8 = CallByName List.38 TotallyNotJson.600 TotallyNotJson.1276;
            let TotallyNotJson.1275 : List U8 = CallByName List.4 TotallyNotJson.601 TotallyNotJson.616;
            let TotallyNotJson.1273 : {List U8, List U8} = Struct {TotallyNotJson.1274, TotallyNotJson.1275};
            jump TotallyNotJson.1198 TotallyNotJson.1273;
        in
        let TotallyNotJson.1310 : [C {}, C U8] = StructAtIndex 0 TotallyNotJson.1199;
        let TotallyNotJson.1311 : U8 = 1i64;
        let TotallyNotJson.1312 : U8 = GetTagId TotallyNotJson.1310;
        let TotallyNotJson.1313 : Int1 = lowlevel Eq TotallyNotJson.1311 TotallyNotJson.1312;
        if TotallyNotJson.1313 then
            let TotallyNotJson.1306 : [C {}, C U8] = StructAtIndex 1 TotallyNotJson.1199;
            let TotallyNotJson.1307 : U8 = 1i64;
            let TotallyNotJson.1308 : U8 = GetTagId TotallyNotJson.1306;
            let TotallyNotJson.1309 : Int1 = lowlevel Eq TotallyNotJson.1307 TotallyNotJson.1308;
            if TotallyNotJson.1309 then
                let TotallyNotJson.1305 : [C {}, C U8] = StructAtIndex 0 TotallyNotJson.1199;
                let TotallyNotJson.607 : U8 = UnionAtIndex (Id 1) (Index 0) TotallyNotJson.1305;
                let TotallyNotJson.1304 : [C {}, C U8] = StructAtIndex 1 TotallyNotJson.1199;
                let TotallyNotJson.608 : U8 = UnionAtIndex (Id 1) (Index 0) TotallyNotJson.1304;
                joinpoint TotallyNotJson.1298 TotallyNotJson.1280:
                    if TotallyNotJson.1280 then
                        dec TotallyNotJson.600;
                        let TotallyNotJson.1256 : U64 = lowlevel ListLen TotallyNotJson.604;
                        let TotallyNotJson.1257 : U64 = 4i64;
                        let TotallyNotJson.1258 : Int1 = lowlevel NumGte TotallyNotJson.1256 TotallyNotJson.1257;
                        if TotallyNotJson.1258 then
                            let TotallyNotJson.1255 : U64 = 0i64;
                            let TotallyNotJson.609 : U8 = lowlevel ListGetUnsafe TotallyNotJson.604 TotallyNotJson.1255;
                            let TotallyNotJson.1254 : U64 = 1i64;
                            let TotallyNotJson.610 : U8 = lowlevel ListGetUnsafe TotallyNotJson.604 TotallyNotJson.1254;
                            let TotallyNotJson.1253 : U64 = 2i64;
                            let TotallyNotJson.611 : U8 = lowlevel ListGetUnsafe TotallyNotJson.604 TotallyNotJson.1253;
                            let TotallyNotJson.1252 : U64 = 3i64;
                            let TotallyNotJson.612 : U8 = lowlevel ListGetUnsafe TotallyNotJson.604 TotallyNotJson.1252;
                            dec TotallyNotJson.604;
                            let TotallyNotJson.613 : List U8 = CallByName TotallyNotJson.68 TotallyNotJson.609 TotallyNotJson.610 TotallyNotJson.611 TotallyNotJson.612;
                            let TotallyNotJson.1202 : List U8 = CallByName List.8 TotallyNotJson.601 TotallyNotJson.613;
                            let TotallyNotJson.1201 : {List U8, List U8} = Struct {TotallyNotJson.605, TotallyNotJson.1202};
                            jump TotallyNotJson.1198 TotallyNotJson.1201;
                        else
                            dec TotallyNotJson.605;
                            let TotallyNotJson.1246 : List U8 = CallByName TotallyNotJson.69;
                            let TotallyNotJson.1245 : List U8 = CallByName List.8 TotallyNotJson.601 TotallyNotJson.1246;
                            let TotallyNotJson.1244 : {List U8, List U8} = Struct {TotallyNotJson.604, TotallyNotJson.1245};
                            jump TotallyNotJson.1198 TotallyNotJson.1244;
                    else
                        dec TotallyNotJson.605;
                        let TotallyNotJson.1297 : [C {}, C U8] = StructAtIndex 0 TotallyNotJson.1199;
                        let TotallyNotJson.614 : U8 = UnionAtIndex (Id 1) (Index 0) TotallyNotJson.1297;
                        let TotallyNotJson.1296 : [C {}, C U8] = StructAtIndex 1 TotallyNotJson.1199;
                        let TotallyNotJson.615 : U8 = UnionAtIndex (Id 1) (Index 0) TotallyNotJson.1296;
                        joinpoint TotallyNotJson.1282 TotallyNotJson.1281:
                            if TotallyNotJson.1281 then
                                dec TotallyNotJson.600;
                                let TotallyNotJson.1262 : U8 = CallByName TotallyNotJson.64 TotallyNotJson.615;
                                let TotallyNotJson.1261 : List U8 = CallByName List.4 TotallyNotJson.601 TotallyNotJson.1262;
                                let TotallyNotJson.1260 : {List U8, List U8} = Struct {TotallyNotJson.604, TotallyNotJson.1261};
                                jump TotallyNotJson.1198 TotallyNotJson.1260;
                            else
                                dec TotallyNotJson.604;
                                jump TotallyNotJson.1279;
                        in
                        let TotallyNotJson.1295 : U8 = 92i64;
                        let TotallyNotJson.1284 : Int1 = CallByName Bool.11 TotallyNotJson.614 TotallyNotJson.1295;
                        let TotallyNotJson.1285 : Int1 = CallByName TotallyNotJson.63 TotallyNotJson.615;
                        let TotallyNotJson.1283 : Int1 = CallByName Bool.3 TotallyNotJson.1284 TotallyNotJson.1285;
                        jump TotallyNotJson.1282 TotallyNotJson.1283;
                in
                let TotallyNotJson.1303 : U8 = 92i64;
                let TotallyNotJson.1300 : Int1 = CallByName Bool.11 TotallyNotJson.607 TotallyNotJson.1303;
                let TotallyNotJson.1302 : U8 = 117i64;
                let TotallyNotJson.1301 : Int1 = CallByName Bool.11 TotallyNotJson.608 TotallyNotJson.1302;
                let TotallyNotJson.1299 : Int1 = CallByName Bool.3 TotallyNotJson.1300 TotallyNotJson.1301;
                jump TotallyNotJson.1298 TotallyNotJson.1299;
            else
                dec TotallyNotJson.605;
                dec TotallyNotJson.604;
                jump TotallyNotJson.1279;
        else
            dec TotallyNotJson.605;
            dec TotallyNotJson.604;
            let TotallyNotJson.1277 : {List U8, List U8} = Struct {TotallyNotJson.600, TotallyNotJson.601};
            ret TotallyNotJson.1277;
    in
    jump TotallyNotJson.1198 #Derived_gen.0;

procedure TotallyNotJson.8 ():
    let TotallyNotJson.1172 : [C , C [], C , C , C , C ] = TagId(2) ;
    ret TotallyNotJson.1172;