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

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

procedure Encode.24 (Encode.99, Encode.107, Encode.101):
    let Encode.111 : List U8 = CallByName Test.56 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 Test.19 Encode.105;
    let Encode.108 : List U8 = CallByName Encode.24 Encode.109 Encode.110 Encode.106;
    ret Encode.108;

procedure List.4 (List.124, List.125):
    let List.584 : U64 = 1i64;
    let List.583 : List U8 = CallByName List.70 List.124 List.584;
    let List.582 : List U8 = CallByName List.71 List.583 List.125;
    ret List.582;

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

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

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

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

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

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

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

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

procedure Str.9 (Str.67):
    let Str.68 : {U64, Str, Int1, U8} = CallByName Str.43 Str.67;
    let Str.236 : Int1 = StructAtIndex 2 Str.68;
    if Str.236 then
        let Str.238 : Str = StructAtIndex 1 Str.68;
        let Str.237 : [C {U64, U8}, C Str] = TagId(1) Str.238;
        ret Str.237;
    else
        let Str.234 : U8 = StructAtIndex 3 Str.68;
        let Str.235 : U64 = StructAtIndex 0 Str.68;
        let #Derived_gen.3 : Str = StructAtIndex 1 Str.68;
        dec #Derived_gen.3;
        let Str.233 : {U64, U8} = Struct {Str.235, Str.234};
        let Str.232 : [C {U64, U8}, C Str] = TagId(0) Str.233;
        ret Str.232;

procedure Test.19 (Test.55):
    let Test.258 : Str = CallByName Encode.23 Test.55;
    ret Test.258;

procedure Test.2 ():
    let Test.257 : {} = Struct {};
    ret Test.257;

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

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

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