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.130, List.131):
    let List.635 : U64 = 1i64;
    let List.634 : List U8 = CallByName List.70 List.130 List.635;
    let List.633 : List U8 = CallByName List.71 List.634 List.131;
    ret List.633;

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

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

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

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.245 : List U8 = lowlevel StrToUtf8 #Attr.2;
    ret Str.245;

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

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

procedure Str.9 (Str.71):
    let Str.72 : {U64, Str, Int1, U8} = CallByName Str.43 Str.71;
    let Str.240 : Int1 = StructAtIndex 2 Str.72;
    if Str.240 then
        let Str.242 : Str = StructAtIndex 1 Str.72;
        let Str.241 : [C {U64, U8}, C Str] = TagId(1) Str.242;
        ret Str.241;
    else
        let Str.238 : U8 = StructAtIndex 3 Str.72;
        let Str.239 : U64 = StructAtIndex 0 Str.72;
        let #Derived_gen.3 : Str = StructAtIndex 1 Str.72;
        dec #Derived_gen.3;
        let Str.237 : {U64, U8} = Struct {Str.239, Str.238};
        let Str.236 : [C {U64, U8}, C Str] = TagId(0) Str.237;
        ret Str.236;

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;