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 Json.181 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 Json.24 Encode.105;
    let Encode.108 : List U8 = CallByName Encode.24 Encode.109 Encode.110 Encode.106;
    ret Encode.108;

procedure Json.1 ():
    let Json.1171 : [C , C [], C , C , C , C ] = TagId(2) ;
    ret Json.1171;

procedure Json.181 (Json.182, Json.1174, Json.180):
    let Json.1177 : List U8 = CallByName Json.25 Json.180;
    let Json.1176 : List U8 = CallByName List.8 Json.182 Json.1177;
    ret Json.1176;

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

procedure Json.214 (Json.215, Json.216):
    let Json.1196 : List U8 = CallByName Json.26 Json.216;
    let Json.1195 : List U8 = CallByName List.8 Json.215 Json.1196;
    ret Json.1195;

procedure Json.24 (Json.180):
    let Json.1172 : Str = CallByName Encode.23 Json.180;
    ret Json.1172;

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

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

procedure List.139 (List.140, List.141, List.138):
    let List.526 : List U8 = CallByName Json.214 List.140 List.141;
    ret List.526;

procedure List.18 (List.136, List.137, List.138):
    let List.508 : List U8 = CallByName List.92 List.136 List.137 List.138;
    ret List.508;

procedure List.26 (List.153, List.154, List.155):
    let List.543 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.92 List.153 List.154 List.155;
    let List.546 : U8 = 1i64;
    let List.547 : U8 = GetTagId List.543;
    let List.548 : Int1 = lowlevel Eq List.546 List.547;
    if List.548 then
        let List.156 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.543;
        ret List.156;
    else
        let List.157 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.543;
        ret List.157;

procedure List.49 (List.370, List.371):
    let List.535 : U64 = StructAtIndex 0 List.371;
    let List.536 : U64 = 0i64;
    let List.533 : Int1 = CallByName Bool.11 List.535 List.536;
    if List.533 then
        dec List.370;
        let List.534 : List U8 = Array [];
        ret List.534;
    else
        let List.530 : U64 = StructAtIndex 1 List.371;
        let List.531 : U64 = StructAtIndex 0 List.371;
        let List.529 : List U8 = CallByName List.72 List.370 List.530 List.531;
        ret List.529;

procedure List.52 (List.385, List.386):
    let List.387 : U64 = CallByName List.6 List.385;
    joinpoint List.541 List.388:
        let List.539 : U64 = 0i64;
        let List.538 : {U64, U64} = Struct {List.388, List.539};
        inc List.385;
        let List.389 : List U8 = CallByName List.49 List.385 List.538;
        let List.537 : U64 = CallByName Num.20 List.387 List.388;
        let List.528 : {U64, U64} = Struct {List.537, List.388};
        let List.390 : List U8 = CallByName List.49 List.385 List.528;
        let List.527 : {List U8, List U8} = Struct {List.389, List.390};
        ret List.527;
    in
    let List.542 : Int1 = CallByName Num.24 List.387 List.386;
    if List.542 then
        jump List.541 List.386;
    else
        jump List.541 List.387;

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

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

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

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

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

procedure List.80 (List.571, List.572, List.573, List.574, List.575):
    joinpoint List.514 List.433 List.434 List.435 List.436 List.437:
        let List.516 : Int1 = CallByName Num.22 List.436 List.437;
        if List.516 then
            let List.523 : U8 = CallByName List.66 List.433 List.436;
            let List.517 : List U8 = CallByName List.139 List.434 List.523 List.435;
            let List.520 : U64 = 1i64;
            let List.519 : U64 = CallByName Num.19 List.436 List.520;
            jump List.514 List.433 List.517 List.435 List.519 List.437;
        else
            dec List.433;
            ret List.434;
    in
    jump List.514 List.571 List.572 List.573 List.574 List.575;

procedure List.80 (List.594, List.595, List.596, List.597, List.598):
    joinpoint List.552 List.433 List.434 List.435 List.436 List.437:
        let List.554 : Int1 = CallByName Num.22 List.436 List.437;
        if List.554 then
            let List.563 : U8 = CallByName List.66 List.433 List.436;
            let List.555 : [C {U64, Int1}, C {U64, Int1}] = CallByName Json.188 List.434 List.563;
            let List.560 : U8 = 1i64;
            let List.561 : U8 = GetTagId List.555;
            let List.562 : Int1 = lowlevel Eq List.560 List.561;
            if List.562 then
                let List.438 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.555;
                let List.558 : U64 = 1i64;
                let List.557 : U64 = CallByName Num.19 List.436 List.558;
                jump List.552 List.433 List.438 List.435 List.557 List.437;
            else
                dec List.433;
                let List.439 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.555;
                let List.559 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.439;
                ret List.559;
        else
            dec List.433;
            let List.553 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.434;
            ret List.553;
    in
    jump List.552 List.594 List.595 List.596 List.597 List.598;

procedure List.92 (List.430, List.431, List.432):
    let List.512 : U64 = 0i64;
    let List.513 : U64 = CallByName List.6 List.430;
    let List.511 : List U8 = CallByName List.80 List.430 List.431 List.432 List.512 List.513;
    ret List.511;

procedure List.92 (List.430, List.431, List.432):
    let List.550 : U64 = 0i64;
    let List.551 : U64 = CallByName List.6 List.430;
    let List.549 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.430 List.431 List.432 List.550 List.551;
    ret List.549;

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

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

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

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

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

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

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

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;
    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;
        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;
        let #Derived_gen.0 : Str = StructAtIndex 1 Str.80;
        dec #Derived_gen.0;
        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.0 ():
    let Test.9 : Str = "abc";
    let Test.10 : [C , C [], C , C , C , C ] = CallByName Json.1;
    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;