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

procedure Encode.23 (Encode.98):
    ret Encode.98;

procedure Encode.24 (Encode.99, Encode.107, Encode.101):
    let Encode.111 : List U8 = CallByName TotallyNotJson.182 Encode.99 Encode.101 Encode.107;
    ret Encode.111;

procedure Encode.26 (Encode.105, Encode.106):
    let Encode.109 : List U8 = Array [];
    let Encode.110 : Str = CallByName TotallyNotJson.25 Encode.105;
    let Encode.108 : List U8 = CallByName Encode.24 Encode.109 Encode.110 Encode.106;
    ret Encode.108;

procedure List.18 (List.154, List.155, List.156):
    let List.567 : U64 = 0i64;
    let List.568 : U64 = CallByName List.6 List.154;
    let List.566 : List U8 = CallByName List.88 List.154 List.155 List.156 List.567 List.568;
    ret List.566;

procedure List.26 (List.181, List.182, List.183):
    let List.593 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.99 List.181 List.182 List.183;
    let List.596 : U8 = 1i64;
    let List.597 : U8 = GetTagId List.593;
    let List.598 : Int1 = lowlevel Eq List.596 List.597;
    if List.598 then
        let List.184 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.593;
        ret List.184;
    else
        let List.185 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.593;
        ret List.185;

procedure List.49 (List.400, List.401):
    let List.585 : U64 = StructAtIndex 0 List.401;
    let List.586 : U64 = 0i64;
    let List.583 : Int1 = CallByName Bool.11 List.585 List.586;
    if List.583 then
        dec List.400;
        let List.584 : List U8 = Array [];
        ret List.584;
    else
        let List.580 : U64 = StructAtIndex 1 List.401;
        let List.581 : U64 = StructAtIndex 0 List.401;
        let List.579 : List U8 = CallByName List.72 List.400 List.580 List.581;
        ret List.579;

procedure List.52 (List.415, List.416):
    let List.417 : U64 = CallByName List.6 List.415;
    joinpoint List.591 List.418:
        let List.589 : U64 = 0i64;
        let List.588 : {U64, U64} = Struct {List.418, List.589};
        inc List.415;
        let List.419 : List U8 = CallByName List.49 List.415 List.588;
        let List.587 : U64 = CallByName Num.75 List.417 List.418;
        let List.578 : {U64, U64} = Struct {List.587, List.418};
        let List.420 : List U8 = CallByName List.49 List.415 List.578;
        let List.577 : {List U8, List U8} = Struct {List.419, List.420};
        ret List.577;
    in
    let List.592 : Int1 = CallByName Num.24 List.417 List.416;
    if List.592 then
        jump List.591 List.416;
    else
        jump List.591 List.417;

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

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

procedure List.68 (#Attr.2):
    let List.563 : List U8 = lowlevel ListWithCapacity #Attr.2;
    ret List.563;

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

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

procedure List.80 (#Derived_gen.8, #Derived_gen.9, #Derived_gen.10, #Derived_gen.11, #Derived_gen.12):
    joinpoint List.602 List.471 List.472 List.473 List.474 List.475:
        let List.604 : Int1 = CallByName Num.22 List.474 List.475;
        if List.604 then
            let List.613 : U8 = CallByName List.66 List.471 List.474;
            let List.605 : [C {U64, Int1}, C {U64, Int1}] = CallByName TotallyNotJson.189 List.472 List.613;
            let List.610 : U8 = 1i64;
            let List.611 : U8 = GetTagId List.605;
            let List.612 : Int1 = lowlevel Eq List.610 List.611;
            if List.612 then
                let List.476 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.605;
                let List.608 : U64 = 1i64;
                let List.607 : U64 = CallByName Num.51 List.474 List.608;
                jump List.602 List.471 List.476 List.473 List.607 List.475;
            else
                dec List.471;
                let List.477 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.605;
                let List.609 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.477;
                ret List.609;
        else
            dec List.471;
            let List.603 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.472;
            ret List.603;
    in
    jump List.602 #Derived_gen.8 #Derived_gen.9 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12;

procedure List.88 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
    joinpoint List.569 List.157 List.158 List.159 List.160 List.161:
        let List.571 : Int1 = CallByName Num.22 List.160 List.161;
        if List.571 then
            let List.575 : U8 = CallByName List.66 List.157 List.160;
            let List.162 : List U8 = CallByName TotallyNotJson.215 List.158 List.575;
            let List.574 : U64 = 1i64;
            let List.573 : U64 = CallByName Num.51 List.160 List.574;
            jump List.569 List.157 List.162 List.159 List.573 List.161;
        else
            dec List.157;
            ret List.158;
    in
    jump List.569 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;

procedure List.99 (List.468, List.469, List.470):
    let List.600 : U64 = 0i64;
    let List.601 : U64 = CallByName List.6 List.468;
    let List.599 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.468 List.469 List.470 List.600 List.601;
    ret List.599;

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

procedure Num.21 (#Attr.2, #Attr.3):
    let Num.294 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
    ret Num.294;

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

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

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

procedure Num.75 (#Attr.2, #Attr.3):
    let Num.299 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
    ret Num.299;

procedure Num.94 (#Attr.2, #Attr.3):
    let Num.293 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
    ret Num.293;

procedure Str.12 (#Attr.2):
    let Str.302 : List U8 = lowlevel StrToUtf8 #Attr.2;
    ret Str.302;

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.13 : Str = StructAtIndex 1 Str.81;
        dec #Derived_gen.13;
        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 TotallyNotJson.182 (TotallyNotJson.183, TotallyNotJson.1175, TotallyNotJson.181):
    let TotallyNotJson.1178 : List U8 = CallByName TotallyNotJson.26 TotallyNotJson.181;
    let TotallyNotJson.1177 : List U8 = CallByName List.8 TotallyNotJson.183 TotallyNotJson.1178;
    ret TotallyNotJson.1177;

procedure TotallyNotJson.189 (TotallyNotJson.1226, TotallyNotJson.192):
    let TotallyNotJson.190 : U64 = StructAtIndex 0 TotallyNotJson.1226;
    let TotallyNotJson.191 : Int1 = StructAtIndex 1 TotallyNotJson.1226;
    switch TotallyNotJson.192:
        case 34:
            let TotallyNotJson.1229 : Int1 = false;
            let TotallyNotJson.1228 : {U64, Int1} = Struct {TotallyNotJson.190, TotallyNotJson.1229};
            let TotallyNotJson.1227 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) TotallyNotJson.1228;
            ret TotallyNotJson.1227;
    
        case 92:
            let TotallyNotJson.1232 : Int1 = false;
            let TotallyNotJson.1231 : {U64, Int1} = Struct {TotallyNotJson.190, TotallyNotJson.1232};
            let TotallyNotJson.1230 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) TotallyNotJson.1231;
            ret TotallyNotJson.1230;
    
        case 47:
            let TotallyNotJson.1235 : Int1 = false;
            let TotallyNotJson.1234 : {U64, Int1} = Struct {TotallyNotJson.190, TotallyNotJson.1235};
            let TotallyNotJson.1233 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) TotallyNotJson.1234;
            ret TotallyNotJson.1233;
    
        case 8:
            let TotallyNotJson.1238 : Int1 = false;
            let TotallyNotJson.1237 : {U64, Int1} = Struct {TotallyNotJson.190, TotallyNotJson.1238};
            let TotallyNotJson.1236 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) TotallyNotJson.1237;
            ret TotallyNotJson.1236;
    
        case 12:
            let TotallyNotJson.1241 : Int1 = false;
            let TotallyNotJson.1240 : {U64, Int1} = Struct {TotallyNotJson.190, TotallyNotJson.1241};
            let TotallyNotJson.1239 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) TotallyNotJson.1240;
            ret TotallyNotJson.1239;
    
        case 10:
            let TotallyNotJson.1244 : Int1 = false;
            let TotallyNotJson.1243 : {U64, Int1} = Struct {TotallyNotJson.190, TotallyNotJson.1244};
            let TotallyNotJson.1242 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) TotallyNotJson.1243;
            ret TotallyNotJson.1242;
    
        case 13:
            let TotallyNotJson.1247 : Int1 = false;
            let TotallyNotJson.1246 : {U64, Int1} = Struct {TotallyNotJson.190, TotallyNotJson.1247};
            let TotallyNotJson.1245 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) TotallyNotJson.1246;
            ret TotallyNotJson.1245;
    
        case 9:
            let TotallyNotJson.1250 : Int1 = false;
            let TotallyNotJson.1249 : {U64, Int1} = Struct {TotallyNotJson.190, TotallyNotJson.1250};
            let TotallyNotJson.1248 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) TotallyNotJson.1249;
            ret TotallyNotJson.1248;
    
        default:
            let TotallyNotJson.1254 : U64 = 1i64;
            let TotallyNotJson.1253 : U64 = CallByName Num.19 TotallyNotJson.190 TotallyNotJson.1254;
            let TotallyNotJson.1252 : {U64, Int1} = Struct {TotallyNotJson.1253, TotallyNotJson.191};
            let TotallyNotJson.1251 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) TotallyNotJson.1252;
            ret TotallyNotJson.1251;
    

procedure TotallyNotJson.215 (TotallyNotJson.216, TotallyNotJson.217):
    let TotallyNotJson.1197 : List U8 = CallByName TotallyNotJson.27 TotallyNotJson.217;
    let TotallyNotJson.1196 : List U8 = CallByName List.8 TotallyNotJson.216 TotallyNotJson.1197;
    ret TotallyNotJson.1196;

procedure TotallyNotJson.25 (TotallyNotJson.181):
    let TotallyNotJson.1173 : Str = CallByName Encode.23 TotallyNotJson.181;
    ret TotallyNotJson.1173;

procedure TotallyNotJson.26 (TotallyNotJson.184):
    let TotallyNotJson.185 : List U8 = CallByName Str.12 TotallyNotJson.184;
    let TotallyNotJson.1255 : U64 = 0i64;
    let TotallyNotJson.1256 : Int1 = true;
    let TotallyNotJson.186 : {U64, Int1} = Struct {TotallyNotJson.1255, TotallyNotJson.1256};
    let TotallyNotJson.1225 : {} = Struct {};
    inc TotallyNotJson.185;
    let TotallyNotJson.187 : {U64, Int1} = CallByName List.26 TotallyNotJson.185 TotallyNotJson.186 TotallyNotJson.1225;
    let TotallyNotJson.1179 : Int1 = StructAtIndex 1 TotallyNotJson.187;
    let TotallyNotJson.1223 : Int1 = true;
    let TotallyNotJson.1224 : Int1 = lowlevel Eq TotallyNotJson.1223 TotallyNotJson.1179;
    if TotallyNotJson.1224 then
        let TotallyNotJson.1189 : U64 = CallByName List.6 TotallyNotJson.185;
        let TotallyNotJson.1190 : U64 = 2i64;
        let TotallyNotJson.1188 : U64 = CallByName Num.19 TotallyNotJson.1189 TotallyNotJson.1190;
        let TotallyNotJson.1185 : List U8 = CallByName List.68 TotallyNotJson.1188;
        let TotallyNotJson.1187 : U8 = 34i64;
        let TotallyNotJson.1186 : List U8 = Array [TotallyNotJson.1187];
        let TotallyNotJson.1184 : List U8 = CallByName List.8 TotallyNotJson.1185 TotallyNotJson.1186;
        let TotallyNotJson.1181 : List U8 = CallByName List.8 TotallyNotJson.1184 TotallyNotJson.185;
        let TotallyNotJson.1183 : U8 = 34i64;
        let TotallyNotJson.1182 : List U8 = Array [TotallyNotJson.1183];
        let TotallyNotJson.1180 : List U8 = CallByName List.8 TotallyNotJson.1181 TotallyNotJson.1182;
        ret TotallyNotJson.1180;
    else
        inc TotallyNotJson.185;
        let TotallyNotJson.1222 : U64 = StructAtIndex 0 TotallyNotJson.187;
        let TotallyNotJson.1221 : {List U8, List U8} = CallByName List.52 TotallyNotJson.185 TotallyNotJson.1222;
        let TotallyNotJson.211 : List U8 = StructAtIndex 0 TotallyNotJson.1221;
        let TotallyNotJson.213 : List U8 = StructAtIndex 1 TotallyNotJson.1221;
        let TotallyNotJson.1219 : U64 = CallByName List.6 TotallyNotJson.185;
        dec TotallyNotJson.185;
        let TotallyNotJson.1220 : U64 = 120i64;
        let TotallyNotJson.1217 : U64 = CallByName Num.21 TotallyNotJson.1219 TotallyNotJson.1220;
        let TotallyNotJson.1218 : U64 = 100i64;
        let TotallyNotJson.1216 : U64 = CallByName Num.94 TotallyNotJson.1217 TotallyNotJson.1218;
        let TotallyNotJson.1213 : List U8 = CallByName List.68 TotallyNotJson.1216;
        let TotallyNotJson.1215 : U8 = 34i64;
        let TotallyNotJson.1214 : List U8 = Array [TotallyNotJson.1215];
        let TotallyNotJson.1212 : List U8 = CallByName List.8 TotallyNotJson.1213 TotallyNotJson.1214;
        let TotallyNotJson.214 : List U8 = CallByName List.8 TotallyNotJson.1212 TotallyNotJson.211;
        let TotallyNotJson.1195 : {} = Struct {};
        let TotallyNotJson.1192 : List U8 = CallByName List.18 TotallyNotJson.213 TotallyNotJson.214 TotallyNotJson.1195;
        let TotallyNotJson.1194 : U8 = 34i64;
        let TotallyNotJson.1193 : List U8 = Array [TotallyNotJson.1194];
        let TotallyNotJson.1191 : List U8 = CallByName List.8 TotallyNotJson.1192 TotallyNotJson.1193;
        ret TotallyNotJson.1191;

procedure TotallyNotJson.27 (TotallyNotJson.218):
    switch TotallyNotJson.218:
        case 34:
            let TotallyNotJson.1198 : List U8 = Array [92i64, 34i64];
            ret TotallyNotJson.1198;
    
        case 92:
            let TotallyNotJson.1199 : List U8 = Array [92i64, 92i64];
            ret TotallyNotJson.1199;
    
        case 47:
            let TotallyNotJson.1200 : List U8 = Array [92i64, 47i64];
            ret TotallyNotJson.1200;
    
        case 8:
            let TotallyNotJson.1202 : U8 = 98i64;
            let TotallyNotJson.1201 : List U8 = Array [92i64, TotallyNotJson.1202];
            ret TotallyNotJson.1201;
    
        case 12:
            let TotallyNotJson.1204 : U8 = 102i64;
            let TotallyNotJson.1203 : List U8 = Array [92i64, TotallyNotJson.1204];
            ret TotallyNotJson.1203;
    
        case 10:
            let TotallyNotJson.1206 : U8 = 110i64;
            let TotallyNotJson.1205 : List U8 = Array [92i64, TotallyNotJson.1206];
            ret TotallyNotJson.1205;
    
        case 13:
            let TotallyNotJson.1208 : U8 = 114i64;
            let TotallyNotJson.1207 : List U8 = Array [92i64, TotallyNotJson.1208];
            ret TotallyNotJson.1207;
    
        case 9:
            let TotallyNotJson.1210 : U8 = 114i64;
            let TotallyNotJson.1209 : List U8 = Array [92i64, TotallyNotJson.1210];
            ret TotallyNotJson.1209;
    
        default:
            let TotallyNotJson.1211 : List U8 = Array [TotallyNotJson.218];
            ret TotallyNotJson.1211;
    

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

procedure Test.0 ():
    let Test.9 : Str = "abc";
    let Test.10 : [C , C [], C , C , C , C ] = CallByName TotallyNotJson.8;
    let Test.8 : List U8 = CallByName Encode.26 Test.9 Test.10;
    let Test.1 : [C {U64, U8}, C Str] = CallByName Str.9 Test.8;
    let Test.5 : U8 = 1i64;
    let Test.6 : U8 = GetTagId Test.1;
    let Test.7 : Int1 = lowlevel Eq Test.5 Test.6;
    if Test.7 then
        let Test.2 : Str = UnionAtIndex (Id 1) (Index 0) Test.1;
        ret Test.2;
    else
        dec Test.1;
        let Test.4 : Str = "<bad>";
        ret Test.4;