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 Json.165 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 Json.24 Encode.105;
    let Encode.108 : List U8 = CallByName Encode.24 Encode.109 Encode.110 Encode.106;
    ret Encode.108;

procedure Json.1 ():
    let Json.969 : [C , C [], C , C , C , C ] = TagId(2) ;
    ret Json.969;

procedure Json.165 (Json.166, Json.972, Json.164):
    let Json.981 : I64 = 34i64;
    let Json.980 : U8 = CallByName Num.127 Json.981;
    let Json.978 : List U8 = CallByName List.4 Json.166 Json.980;
    let Json.979 : List U8 = CallByName Str.12 Json.164;
    let Json.975 : List U8 = CallByName List.8 Json.978 Json.979;
    let Json.977 : I64 = 34i64;
    let Json.976 : U8 = CallByName Num.127 Json.977;
    let Json.974 : List U8 = CallByName List.4 Json.975 Json.976;
    ret Json.974;

procedure Json.24 (Json.164):
    let Json.970 : Str = CallByName Encode.23 Json.164;
    ret Json.970;

procedure List.4 (List.107, List.108):
    let List.503 : U64 = 1i64;
    let List.502 : List U8 = CallByName List.70 List.107 List.503;
    let List.501 : List U8 = CallByName List.71 List.502 List.108;
    ret List.501;

procedure List.6 (#Attr.2):
    let List.494 : U64 = lowlevel ListLen #Attr.2;
    ret List.494;

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

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

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

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

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

procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
    let Str.307 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
    ret Str.307;

procedure Str.9 (Str.79):
    let Str.305 : U64 = 0i64;
    let Str.306 : U64 = CallByName List.6 Str.79;
    let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.305 Str.306;
    let Str.302 : Int1 = StructAtIndex 2 Str.80;
    if Str.302 then
        let Str.304 : Str = StructAtIndex 1 Str.80;
        inc Str.304;
        dec Str.80;
        let Str.303 : [C {U64, U8}, C Str] = TagId(1) Str.304;
        ret Str.303;
    else
        let Str.300 : U8 = StructAtIndex 3 Str.80;
        let Str.301 : U64 = StructAtIndex 0 Str.80;
        dec Str.80;
        let Str.299 : {U64, U8} = Struct {Str.301, Str.300};
        let Str.298 : [C {U64, U8}, C Str] = TagId(0) Str.299;
        ret Str.298;

procedure Test.0 ():
    let Test.9 : Str = "abc";
    let Test.10 : [C , C [], C , C , C , C ] = CallByName Json.1;
    let Test.8 : List U8 = CallByName Encode.26 Test.9 Test.10;
    let Test.1 : [C {U64, U8}, C Str] = CallByName Str.9 Test.8;
    let Test.5 : U8 = 1i64;
    let Test.6 : U8 = GetTagId Test.1;
    let Test.7 : Int1 = lowlevel Eq Test.5 Test.6;
    if Test.7 then
        let Test.2 : Str = UnionAtIndex (Id 1) (Index 0) Test.1;
        inc Test.2;
        dec Test.1;
        ret Test.2;
    else
        dec Test.1;
        let Test.4 : Str = "<bad>";
        ret Test.4;