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.136, List.137):
    let List.685 : U64 = 1i64;
    let List.684 : List U8 = CallByName List.70 List.136 List.685;
    let List.683 : List U8 = CallByName List.71 List.684 List.137;
    ret List.683;

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

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

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

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

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

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

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

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

procedure Str.9 (Str.79):
    let Str.80 : {U64, Str, Int1, U8} = CallByName Str.43 Str.79;
    let Str.390 : Int1 = StructAtIndex 2 Str.80;
    if Str.390 then
        let Str.392 : Str = StructAtIndex 1 Str.80;
        let Str.391 : [C {U64, U8}, C Str] = TagId(1) Str.392;
        ret Str.391;
    else
        let Str.388 : U64 = StructAtIndex 0 Str.80;
        let Str.389 : U8 = StructAtIndex 3 Str.80;
        let #Derived_gen.3 : Str = StructAtIndex 1 Str.80;
        dec #Derived_gen.3;
        let Str.387 : {U64, U8} = Struct {Str.388, Str.389};
        let Str.385 : [C {U64, U8}, C Str] = TagId(0) Str.387;
        ret Str.385;

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;