roc/crates/compiler/test_mono/generated/encode_derived_string.txt

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.139, List.140):
    let List.704 : U64 = 1i64;
    let List.703 : List U8 = CallByName List.70 List.139 List.704;
    let List.702 : List U8 = CallByName List.71 List.703 List.140;
    ret List.702;

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

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

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

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

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

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

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

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

procedure Str.9 (Str.81):
    let Str.82 : {U64, Str, Int1, U8} = CallByName Str.43 Str.81;
    let Str.393 : Int1 = StructAtIndex 2 Str.82;
    if Str.393 then
        let Str.395 : Str = StructAtIndex 1 Str.82;
        let Str.394 : [C {U64, U8}, C Str] = TagId(1) Str.395;
        ret Str.394;
    else
        let Str.391 : U64 = StructAtIndex 0 Str.82;
        let Str.392 : U8 = StructAtIndex 3 Str.82;
        let #Derived_gen.3 : Str = StructAtIndex 1 Str.82;
        dec #Derived_gen.3;
        let Str.390 : {U64, U8} = Struct {Str.391, Str.392};
        let Str.388 : [C {U64, U8}, C Str] = TagId(0) Str.390;
        ret Str.388;

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;