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

procedure Encode.24 (Encode.101, Encode.109, Encode.103):
    let Encode.113 : List U8 = CallByName Test.57 Encode.101 Encode.103 Encode.109;
    ret Encode.113;

procedure Encode.26 (Encode.107, Encode.108):
    let Encode.111 : List U8 = Array [];
    let Encode.112 : Str = CallByName Test.20 Encode.107;
    let Encode.110 : List U8 = CallByName Encode.24 Encode.111 Encode.112 Encode.108;
    ret Encode.110;

procedure List.4 (List.131, List.132):
    let List.636 : U64 = 1i64;
    let List.635 : List U8 = CallByName List.70 List.131 List.636;
    let List.634 : List U8 = CallByName List.71 List.635 List.132;
    ret List.634;

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

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

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

procedure Num.127 (#Attr.2):
    let Num.282 : U8 = lowlevel NumIntCast #Attr.2;
    ret Num.282;

procedure Num.96 (#Attr.2):
    let Num.281 : Str = lowlevel NumToStr #Attr.2;
    ret Num.281;

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

procedure Str.36 (#Attr.2):
    let Str.256 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
    ret Str.256;

procedure Str.43 (#Attr.2):
    let Str.253 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
    ret Str.253;

procedure Str.9 (Str.73):
    let Str.74 : {U64, Str, Int1, U8} = CallByName Str.43 Str.73;
    let Str.250 : Int1 = StructAtIndex 2 Str.74;
    if Str.250 then
        let Str.252 : Str = StructAtIndex 1 Str.74;
        let Str.251 : [C {U64, U8}, C Str] = TagId(1) Str.252;
        ret Str.251;
    else
        let Str.248 : U8 = StructAtIndex 3 Str.74;
        let Str.249 : U64 = StructAtIndex 0 Str.74;
        let #Derived_gen.3 : Str = StructAtIndex 1 Str.74;
        dec #Derived_gen.3;
        let Str.247 : {U64, U8} = Struct {Str.249, Str.248};
        let Str.246 : [C {U64, U8}, C Str] = TagId(0) Str.247;
        ret Str.246;

procedure Test.20 (Test.56):
    let Test.259 : Str = CallByName Encode.23 Test.56;
    ret Test.259;

procedure Test.3 ():
    let Test.258 : {} = Struct {};
    ret Test.258;

procedure Test.4 (Test.49, Test.50, Test.51):
    let Test.276 : U8 = CallByName Num.127 Test.50;
    let Test.273 : List U8 = CallByName List.4 Test.49 Test.276;
    let Test.275 : Str = CallByName Num.96 Test.51;
    let Test.274 : List U8 = CallByName Str.12 Test.275;
    let Test.271 : List U8 = CallByName List.8 Test.273 Test.274;
    let Test.272 : U8 = 32i64;
    let Test.270 : List U8 = CallByName List.4 Test.271 Test.272;
    ret Test.270;

procedure Test.57 (Test.58, Test.261, Test.56):
    let Test.268 : I64 = 115i64;
    let Test.269 : U64 = CallByName Str.36 Test.56;
    let Test.266 : List U8 = CallByName Test.4 Test.58 Test.268 Test.269;
    let Test.267 : List U8 = CallByName Str.12 Test.56;
    let Test.264 : List U8 = CallByName List.8 Test.266 Test.267;
    let Test.265 : U8 = 32i64;
    let Test.263 : List U8 = CallByName List.4 Test.264 Test.265;
    ret Test.263;

procedure Test.0 ():
    let Test.256 : Str = "abc";
    let Test.257 : {} = CallByName Test.3;
    let Test.255 : List U8 = CallByName Encode.26 Test.256 Test.257;
    let Test.210 : [C {U64, U8}, C Str] = CallByName Str.9 Test.255;
    let Test.252 : U8 = 1i64;
    let Test.253 : U8 = GetTagId Test.210;
    let Test.254 : Int1 = lowlevel Eq Test.252 Test.253;
    if Test.254 then
        let Test.211 : Str = UnionAtIndex (Id 1) (Index 0) Test.210;
        ret Test.211;
    else
        dec Test.210;
        let Test.251 : Str = "<bad>";
        ret Test.251;