diff --git a/crates/compiler/test_mono/generated/compose_recursive_lambda_set_productive_nullable_wrapped.txt b/crates/compiler/test_mono/generated/compose_recursive_lambda_set_productive_nullable_wrapped.txt
index e06264f601..00ce3579c7 100644
--- a/crates/compiler/test_mono/generated/compose_recursive_lambda_set_productive_nullable_wrapped.txt
+++ b/crates/compiler/test_mono/generated/compose_recursive_lambda_set_productive_nullable_wrapped.txt
@@ -41,8 +41,8 @@ procedure Num.51 (#Attr.2, #Attr.3):
     ret Num.283;
 
 procedure Str.3 (#Attr.2, #Attr.3):
-    let Str.248 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
-    ret Str.248;
+    let Str.380 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.380;
 
 procedure Test.1 (Test.5):
     ret Test.5;
diff --git a/crates/compiler/test_mono/generated/dbg_expr.txt b/crates/compiler/test_mono/generated/dbg_expr.txt
index 2d8c0f7480..dc748e9e54 100644
--- a/crates/compiler/test_mono/generated/dbg_expr.txt
+++ b/crates/compiler/test_mono/generated/dbg_expr.txt
@@ -43,8 +43,8 @@ procedure Num.96 (#Attr.2):
     ret Num.284;
 
 procedure Str.3 (#Attr.2, #Attr.3):
-    let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
-    ret Str.246;
+    let Str.378 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.378;
 
 procedure Test.0 ():
     let Test.5 : I64 = 1i64;
diff --git a/crates/compiler/test_mono/generated/dbg_in_expect.txt b/crates/compiler/test_mono/generated/dbg_in_expect.txt
index 4e6bd826f2..8e55d3e565 100644
--- a/crates/compiler/test_mono/generated/dbg_in_expect.txt
+++ b/crates/compiler/test_mono/generated/dbg_in_expect.txt
@@ -104,181 +104,181 @@ procedure Num.77 (#Attr.2, #Attr.3):
     ret Num.293;
 
 procedure Str.20 (#Attr.2):
-    let Str.313 : Str = lowlevel StrWithCapacity #Attr.2;
-    ret Str.313;
+    let Str.445 : Str = lowlevel StrWithCapacity #Attr.2;
+    ret Str.445;
 
 procedure Str.3 (#Attr.2, #Attr.3):
-    let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
-    ret Str.246;
+    let Str.378 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.378;
 
 procedure Str.35 (#Attr.2, #Attr.3):
-    let Str.303 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
-    ret Str.303;
+    let Str.435 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
+    ret Str.435;
 
 procedure Str.36 (#Attr.2):
-    let Str.266 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
-    ret Str.266;
+    let Str.398 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
+    ret Str.398;
 
 procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
-    let Str.264 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
-    ret Str.264;
+    let Str.396 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
+    ret Str.396;
 
-procedure Str.38 (Str.112, Str.113):
-    let Str.260 : [C , C U64] = CallByName Str.57 Str.112 Str.113;
-    let Str.273 : U8 = 1i64;
-    let Str.274 : U8 = GetTagId Str.260;
-    let Str.275 : Int1 = lowlevel Eq Str.273 Str.274;
-    if Str.275 then
-        let Str.114 : U64 = UnionAtIndex (Id 1) (Index 0) Str.260;
-        let Str.269 : U64 = CallByName Str.36 Str.112;
-        let Str.270 : U64 = CallByName Str.36 Str.113;
-        let Str.268 : U64 = CallByName Num.20 Str.269 Str.270;
-        let Str.115 : U64 = CallByName Num.20 Str.268 Str.114;
-        let Str.267 : U64 = 0i64;
-        inc Str.112;
-        let Str.116 : Str = CallByName Str.37 Str.112 Str.267 Str.114;
-        let Str.265 : U64 = CallByName Str.36 Str.113;
-        let Str.263 : U64 = CallByName Num.51 Str.114 Str.265;
-        let Str.117 : Str = CallByName Str.37 Str.112 Str.263 Str.115;
-        let Str.262 : {Str, Str} = Struct {Str.117, Str.116};
-        let Str.261 : [C {}, C {Str, Str}] = TagId(1) Str.262;
-        ret Str.261;
+procedure Str.38 (Str.210, Str.211):
+    let Str.392 : [C , C U64] = CallByName Str.62 Str.210 Str.211;
+    let Str.405 : U8 = 1i64;
+    let Str.406 : U8 = GetTagId Str.392;
+    let Str.407 : Int1 = lowlevel Eq Str.405 Str.406;
+    if Str.407 then
+        let Str.212 : U64 = UnionAtIndex (Id 1) (Index 0) Str.392;
+        let Str.401 : U64 = CallByName Str.36 Str.210;
+        let Str.402 : U64 = CallByName Str.36 Str.211;
+        let Str.400 : U64 = CallByName Num.20 Str.401 Str.402;
+        let Str.213 : U64 = CallByName Num.20 Str.400 Str.212;
+        let Str.399 : U64 = 0i64;
+        inc Str.210;
+        let Str.214 : Str = CallByName Str.37 Str.210 Str.399 Str.212;
+        let Str.397 : U64 = CallByName Str.36 Str.211;
+        let Str.395 : U64 = CallByName Num.51 Str.212 Str.397;
+        let Str.215 : Str = CallByName Str.37 Str.210 Str.395 Str.213;
+        let Str.394 : {Str, Str} = Struct {Str.215, Str.214};
+        let Str.393 : [C {}, C {Str, Str}] = TagId(1) Str.394;
+        ret Str.393;
     else
-        dec Str.112;
-        let Str.272 : {} = Struct {};
-        let Str.271 : [C {}, C {Str, Str}] = TagId(0) Str.272;
-        ret Str.271;
+        dec Str.210;
+        let Str.404 : {} = Struct {};
+        let Str.403 : [C {}, C {Str, Str}] = TagId(0) Str.404;
+        ret Str.403;
 
-procedure Str.45 (Str.91, Str.92, Str.93):
-    inc Str.91;
-    let Str.341 : [C {}, C {Str, Str}] = CallByName Str.38 Str.91 Str.92;
-    let Str.349 : U8 = 1i64;
-    let Str.350 : U8 = GetTagId Str.341;
-    let Str.351 : Int1 = lowlevel Eq Str.349 Str.350;
-    if Str.351 then
-        let Str.348 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.341;
-        let Str.95 : Str = StructAtIndex 0 Str.348;
-        let Str.94 : Str = StructAtIndex 1 Str.348;
-        let Str.346 : U64 = CallByName Str.36 Str.91;
-        dec Str.91;
-        let Str.345 : Str = CallByName Str.20 Str.346;
-        let Str.344 : Str = CallByName Str.3 Str.345 Str.94;
-        dec Str.94;
-        let Str.343 : Str = CallByName Str.3 Str.344 Str.93;
-        let Str.342 : Str = CallByName Str.56 Str.343 Str.95 Str.92 Str.93;
-        ret Str.342;
+procedure Str.45 (Str.189, Str.190, Str.191):
+    inc Str.189;
+    let Str.473 : [C {}, C {Str, Str}] = CallByName Str.38 Str.189 Str.190;
+    let Str.481 : U8 = 1i64;
+    let Str.482 : U8 = GetTagId Str.473;
+    let Str.483 : Int1 = lowlevel Eq Str.481 Str.482;
+    if Str.483 then
+        let Str.480 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.473;
+        let Str.193 : Str = StructAtIndex 0 Str.480;
+        let Str.192 : Str = StructAtIndex 1 Str.480;
+        let Str.478 : U64 = CallByName Str.36 Str.189;
+        dec Str.189;
+        let Str.477 : Str = CallByName Str.20 Str.478;
+        let Str.476 : Str = CallByName Str.3 Str.477 Str.192;
+        dec Str.192;
+        let Str.475 : Str = CallByName Str.3 Str.476 Str.191;
+        let Str.474 : Str = CallByName Str.61 Str.475 Str.193 Str.190 Str.191;
+        ret Str.474;
     else
-        dec Str.341;
-        ret Str.91;
+        dec Str.473;
+        ret Str.189;
 
-procedure Str.56 (#Derived_gen.5, #Derived_gen.6, #Derived_gen.7, #Derived_gen.8):
-    joinpoint Str.250 Str.96 Str.97 Str.98 Str.99:
-        inc Str.97;
-        let Str.251 : [C {}, C {Str, Str}] = CallByName Str.38 Str.97 Str.98;
-        let Str.257 : U8 = 1i64;
-        let Str.258 : U8 = GetTagId Str.251;
-        let Str.259 : Int1 = lowlevel Eq Str.257 Str.258;
-        if Str.259 then
-            dec Str.97;
-            let Str.256 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.251;
-            let Str.101 : Str = StructAtIndex 0 Str.256;
-            let Str.100 : Str = StructAtIndex 1 Str.256;
-            let Str.254 : Str = CallByName Str.3 Str.96 Str.100;
-            dec Str.100;
-            let Str.253 : Str = CallByName Str.3 Str.254 Str.99;
-            jump Str.250 Str.253 Str.101 Str.98 Str.99;
+procedure Str.61 (#Derived_gen.5, #Derived_gen.6, #Derived_gen.7, #Derived_gen.8):
+    joinpoint Str.382 Str.194 Str.195 Str.196 Str.197:
+        inc Str.195;
+        let Str.383 : [C {}, C {Str, Str}] = CallByName Str.38 Str.195 Str.196;
+        let Str.389 : U8 = 1i64;
+        let Str.390 : U8 = GetTagId Str.383;
+        let Str.391 : Int1 = lowlevel Eq Str.389 Str.390;
+        if Str.391 then
+            dec Str.195;
+            let Str.388 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.383;
+            let Str.199 : Str = StructAtIndex 0 Str.388;
+            let Str.198 : Str = StructAtIndex 1 Str.388;
+            let Str.386 : Str = CallByName Str.3 Str.194 Str.198;
+            dec Str.198;
+            let Str.385 : Str = CallByName Str.3 Str.386 Str.197;
+            jump Str.382 Str.385 Str.199 Str.196 Str.197;
         else
-            dec Str.98;
-            dec Str.251;
-            dec Str.99;
-            let Str.255 : Str = CallByName Str.3 Str.96 Str.97;
-            dec Str.97;
-            ret Str.255;
+            dec Str.196;
+            dec Str.383;
+            dec Str.197;
+            let Str.387 : Str = CallByName Str.3 Str.194 Str.195;
+            dec Str.195;
+            ret Str.387;
     in
     inc #Derived_gen.7;
     inc #Derived_gen.8;
-    jump Str.250 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7 #Derived_gen.8;
+    jump Str.382 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7 #Derived_gen.8;
 
-procedure Str.57 (Str.121, Str.122):
-    let Str.123 : U64 = CallByName Str.36 Str.121;
-    let Str.124 : U64 = CallByName Str.36 Str.122;
-    let Str.125 : U64 = CallByName Num.77 Str.123 Str.124;
-    let Str.277 : U64 = 0i64;
-    let Str.276 : [C , C U64] = CallByName Str.58 Str.121 Str.122 Str.277 Str.125;
-    ret Str.276;
+procedure Str.62 (Str.219, Str.220):
+    let Str.221 : U64 = CallByName Str.36 Str.219;
+    let Str.222 : U64 = CallByName Str.36 Str.220;
+    let Str.223 : U64 = CallByName Num.77 Str.221 Str.222;
+    let Str.409 : U64 = 0i64;
+    let Str.408 : [C , C U64] = CallByName Str.63 Str.219 Str.220 Str.409 Str.223;
+    ret Str.408;
 
-procedure Str.58 (#Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
-    joinpoint Str.278 Str.126 Str.127 Str.128 Str.129:
-        let Str.280 : Int1 = CallByName Num.23 Str.128 Str.129;
-        if Str.280 then
-            let Str.284 : Int1 = CallByName Str.62 Str.126 Str.128 Str.127;
-            if Str.284 then
-                dec Str.127;
-                dec Str.126;
-                let Str.285 : [C , C U64] = TagId(1) Str.128;
-                ret Str.285;
+procedure Str.63 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3):
+    joinpoint Str.410 Str.224 Str.225 Str.226 Str.227:
+        let Str.412 : Int1 = CallByName Num.23 Str.226 Str.227;
+        if Str.412 then
+            let Str.416 : Int1 = CallByName Str.67 Str.224 Str.226 Str.225;
+            if Str.416 then
+                dec Str.224;
+                dec Str.225;
+                let Str.417 : [C , C U64] = TagId(1) Str.226;
+                ret Str.417;
             else
-                let Str.283 : U64 = 1i64;
-                let Str.282 : U64 = CallByName Num.51 Str.128 Str.283;
-                jump Str.278 Str.126 Str.127 Str.282 Str.129;
+                let Str.415 : U64 = 1i64;
+                let Str.414 : U64 = CallByName Num.51 Str.226 Str.415;
+                jump Str.410 Str.224 Str.225 Str.414 Str.227;
         else
-            dec Str.127;
-            dec Str.126;
-            let Str.279 : [C , C U64] = TagId(0) ;
-            ret Str.279;
+            dec Str.224;
+            dec Str.225;
+            let Str.411 : [C , C U64] = TagId(0) ;
+            ret Str.411;
     in
+    inc #Derived_gen.0;
     inc #Derived_gen.1;
-    inc #Derived_gen.2;
-    jump Str.278 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
+    jump Str.410 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3;
 
-procedure Str.61 (Str.152, Str.153):
-    let Str.308 : Int1 = CallByName Num.22 Str.152 Str.153;
-    if Str.308 then
-        ret Str.152;
+procedure Str.66 (Str.250, Str.251):
+    let Str.440 : Int1 = CallByName Num.22 Str.250 Str.251;
+    if Str.440 then
+        ret Str.250;
     else
-        ret Str.153;
+        ret Str.251;
 
-procedure Str.62 (Str.154, Str.155, Str.156):
-    let Str.157 : U64 = CallByName Str.36 Str.154;
-    let Str.158 : U64 = CallByName Str.36 Str.156;
-    let Str.306 : U64 = CallByName Num.53 Str.155 Str.158;
-    let Str.159 : U64 = CallByName Str.61 Str.306 Str.157;
-    let Str.305 : U64 = 0i64;
-    inc Str.156;
-    inc Str.154;
-    let Str.287 : {U64, Str, U64, Str, U64, U64} = Struct {Str.159, Str.154, Str.155, Str.156, Str.305, Str.158};
-    let Str.286 : Int1 = CallByName Str.63 Str.287;
-    ret Str.286;
+procedure Str.67 (Str.252, Str.253, Str.254):
+    let Str.255 : U64 = CallByName Str.36 Str.252;
+    let Str.256 : U64 = CallByName Str.36 Str.254;
+    let Str.438 : U64 = CallByName Num.53 Str.253 Str.256;
+    let Str.257 : U64 = CallByName Str.66 Str.438 Str.255;
+    let Str.437 : U64 = 0i64;
+    inc Str.252;
+    inc Str.254;
+    let Str.419 : {U64, Str, U64, Str, U64, U64} = Struct {Str.257, Str.252, Str.253, Str.254, Str.437, Str.256};
+    let Str.418 : Int1 = CallByName Str.68 Str.419;
+    ret Str.418;
 
-procedure Str.63 (Str.160):
-    let Str.166 : U64 = StructAtIndex 0 Str.160;
-    let Str.161 : Str = StructAtIndex 1 Str.160;
-    let Str.162 : U64 = StructAtIndex 2 Str.160;
-    let Str.163 : Str = StructAtIndex 3 Str.160;
-    let Str.164 : U64 = StructAtIndex 4 Str.160;
-    let Str.165 : U64 = StructAtIndex 5 Str.160;
-    let Str.167 : Int1 = CallByName Num.25 Str.162 Str.166;
-    if Str.167 then
-        dec Str.163;
-        dec Str.161;
-        let Str.168 : Int1 = CallByName Bool.11 Str.164 Str.165;
-        ret Str.168;
+procedure Str.68 (Str.258):
+    let Str.264 : U64 = StructAtIndex 0 Str.258;
+    let Str.259 : Str = StructAtIndex 1 Str.258;
+    let Str.260 : U64 = StructAtIndex 2 Str.258;
+    let Str.261 : Str = StructAtIndex 3 Str.258;
+    let Str.262 : U64 = StructAtIndex 4 Str.258;
+    let Str.263 : U64 = StructAtIndex 5 Str.258;
+    let Str.265 : Int1 = CallByName Num.25 Str.260 Str.264;
+    if Str.265 then
+        dec Str.259;
+        dec Str.261;
+        let Str.266 : Int1 = CallByName Bool.11 Str.262 Str.263;
+        ret Str.266;
     else
-        let Str.301 : U8 = CallByName Str.35 Str.161 Str.162;
-        let Str.302 : U8 = CallByName Str.35 Str.163 Str.164;
-        let Str.169 : Int1 = CallByName Bool.11 Str.301 Str.302;
-        let Str.291 : U64 = StructAtIndex 0 Str.160;
-        let Str.292 : Str = StructAtIndex 1 Str.160;
-        let Str.294 : Str = StructAtIndex 3 Str.160;
-        let Str.296 : U64 = StructAtIndex 5 Str.160;
-        let Str.300 : U64 = 1i64;
-        let Str.298 : U64 = CallByName Num.51 Str.164 Str.300;
-        let Str.299 : U64 = 1i64;
-        let Str.297 : U64 = CallByName Num.51 Str.162 Str.299;
-        let Str.290 : {U64, Str, U64, Str, U64, U64} = Struct {Str.291, Str.292, Str.297, Str.294, Str.298, Str.296};
-        let Str.170 : Int1 = CallByName Str.63 Str.290;
-        let Str.289 : Int1 = CallByName Bool.3 Str.169 Str.170;
-        ret Str.289;
+        let Str.433 : U8 = CallByName Str.35 Str.259 Str.260;
+        let Str.434 : U8 = CallByName Str.35 Str.261 Str.262;
+        let Str.267 : Int1 = CallByName Bool.11 Str.433 Str.434;
+        let Str.423 : U64 = StructAtIndex 0 Str.258;
+        let Str.424 : Str = StructAtIndex 1 Str.258;
+        let Str.426 : Str = StructAtIndex 3 Str.258;
+        let Str.428 : U64 = StructAtIndex 5 Str.258;
+        let Str.432 : U64 = 1i64;
+        let Str.430 : U64 = CallByName Num.51 Str.262 Str.432;
+        let Str.431 : U64 = 1i64;
+        let Str.429 : U64 = CallByName Num.51 Str.260 Str.431;
+        let Str.422 : {U64, Str, U64, Str, U64, U64} = Struct {Str.423, Str.424, Str.429, Str.426, Str.430, Str.428};
+        let Str.268 : Int1 = CallByName Str.68 Str.422;
+        let Str.421 : Int1 = CallByName Bool.3 Str.267 Str.268;
+        ret Str.421;
 
 procedure Test.1 ():
     let Test.4 : Str = "";
diff --git a/crates/compiler/test_mono/generated/dbg_inside_string.txt b/crates/compiler/test_mono/generated/dbg_inside_string.txt
index 45395b4bdb..56b1db145f 100644
--- a/crates/compiler/test_mono/generated/dbg_inside_string.txt
+++ b/crates/compiler/test_mono/generated/dbg_inside_string.txt
@@ -100,181 +100,181 @@ procedure Num.77 (#Attr.2, #Attr.3):
     ret Num.293;
 
 procedure Str.20 (#Attr.2):
-    let Str.315 : Str = lowlevel StrWithCapacity #Attr.2;
-    ret Str.315;
+    let Str.447 : Str = lowlevel StrWithCapacity #Attr.2;
+    ret Str.447;
 
 procedure Str.3 (#Attr.2, #Attr.3):
-    let Str.248 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
-    ret Str.248;
+    let Str.380 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.380;
 
 procedure Str.35 (#Attr.2, #Attr.3):
-    let Str.305 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
-    ret Str.305;
+    let Str.437 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
+    ret Str.437;
 
 procedure Str.36 (#Attr.2):
-    let Str.268 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
-    ret Str.268;
+    let Str.400 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
+    ret Str.400;
 
 procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
-    let Str.266 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
-    ret Str.266;
+    let Str.398 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
+    ret Str.398;
 
-procedure Str.38 (Str.112, Str.113):
-    let Str.262 : [C , C U64] = CallByName Str.57 Str.112 Str.113;
-    let Str.275 : U8 = 1i64;
-    let Str.276 : U8 = GetTagId Str.262;
-    let Str.277 : Int1 = lowlevel Eq Str.275 Str.276;
-    if Str.277 then
-        let Str.114 : U64 = UnionAtIndex (Id 1) (Index 0) Str.262;
-        let Str.271 : U64 = CallByName Str.36 Str.112;
-        let Str.272 : U64 = CallByName Str.36 Str.113;
-        let Str.270 : U64 = CallByName Num.20 Str.271 Str.272;
-        let Str.115 : U64 = CallByName Num.20 Str.270 Str.114;
-        let Str.269 : U64 = 0i64;
-        inc Str.112;
-        let Str.116 : Str = CallByName Str.37 Str.112 Str.269 Str.114;
-        let Str.267 : U64 = CallByName Str.36 Str.113;
-        let Str.265 : U64 = CallByName Num.51 Str.114 Str.267;
-        let Str.117 : Str = CallByName Str.37 Str.112 Str.265 Str.115;
-        let Str.264 : {Str, Str} = Struct {Str.117, Str.116};
-        let Str.263 : [C {}, C {Str, Str}] = TagId(1) Str.264;
-        ret Str.263;
+procedure Str.38 (Str.210, Str.211):
+    let Str.394 : [C , C U64] = CallByName Str.62 Str.210 Str.211;
+    let Str.407 : U8 = 1i64;
+    let Str.408 : U8 = GetTagId Str.394;
+    let Str.409 : Int1 = lowlevel Eq Str.407 Str.408;
+    if Str.409 then
+        let Str.212 : U64 = UnionAtIndex (Id 1) (Index 0) Str.394;
+        let Str.403 : U64 = CallByName Str.36 Str.210;
+        let Str.404 : U64 = CallByName Str.36 Str.211;
+        let Str.402 : U64 = CallByName Num.20 Str.403 Str.404;
+        let Str.213 : U64 = CallByName Num.20 Str.402 Str.212;
+        let Str.401 : U64 = 0i64;
+        inc Str.210;
+        let Str.214 : Str = CallByName Str.37 Str.210 Str.401 Str.212;
+        let Str.399 : U64 = CallByName Str.36 Str.211;
+        let Str.397 : U64 = CallByName Num.51 Str.212 Str.399;
+        let Str.215 : Str = CallByName Str.37 Str.210 Str.397 Str.213;
+        let Str.396 : {Str, Str} = Struct {Str.215, Str.214};
+        let Str.395 : [C {}, C {Str, Str}] = TagId(1) Str.396;
+        ret Str.395;
     else
-        dec Str.112;
-        let Str.274 : {} = Struct {};
-        let Str.273 : [C {}, C {Str, Str}] = TagId(0) Str.274;
-        ret Str.273;
+        dec Str.210;
+        let Str.406 : {} = Struct {};
+        let Str.405 : [C {}, C {Str, Str}] = TagId(0) Str.406;
+        ret Str.405;
 
-procedure Str.45 (Str.91, Str.92, Str.93):
-    inc Str.91;
-    let Str.343 : [C {}, C {Str, Str}] = CallByName Str.38 Str.91 Str.92;
-    let Str.351 : U8 = 1i64;
-    let Str.352 : U8 = GetTagId Str.343;
-    let Str.353 : Int1 = lowlevel Eq Str.351 Str.352;
-    if Str.353 then
-        let Str.350 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.343;
-        let Str.95 : Str = StructAtIndex 0 Str.350;
-        let Str.94 : Str = StructAtIndex 1 Str.350;
-        let Str.348 : U64 = CallByName Str.36 Str.91;
-        dec Str.91;
-        let Str.347 : Str = CallByName Str.20 Str.348;
-        let Str.346 : Str = CallByName Str.3 Str.347 Str.94;
-        dec Str.94;
-        let Str.345 : Str = CallByName Str.3 Str.346 Str.93;
-        let Str.344 : Str = CallByName Str.56 Str.345 Str.95 Str.92 Str.93;
-        ret Str.344;
+procedure Str.45 (Str.189, Str.190, Str.191):
+    inc Str.189;
+    let Str.475 : [C {}, C {Str, Str}] = CallByName Str.38 Str.189 Str.190;
+    let Str.483 : U8 = 1i64;
+    let Str.484 : U8 = GetTagId Str.475;
+    let Str.485 : Int1 = lowlevel Eq Str.483 Str.484;
+    if Str.485 then
+        let Str.482 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.475;
+        let Str.193 : Str = StructAtIndex 0 Str.482;
+        let Str.192 : Str = StructAtIndex 1 Str.482;
+        let Str.480 : U64 = CallByName Str.36 Str.189;
+        dec Str.189;
+        let Str.479 : Str = CallByName Str.20 Str.480;
+        let Str.478 : Str = CallByName Str.3 Str.479 Str.192;
+        dec Str.192;
+        let Str.477 : Str = CallByName Str.3 Str.478 Str.191;
+        let Str.476 : Str = CallByName Str.61 Str.477 Str.193 Str.190 Str.191;
+        ret Str.476;
     else
-        dec Str.343;
-        ret Str.91;
+        dec Str.475;
+        ret Str.189;
 
-procedure Str.56 (#Derived_gen.5, #Derived_gen.6, #Derived_gen.7, #Derived_gen.8):
-    joinpoint Str.252 Str.96 Str.97 Str.98 Str.99:
-        inc Str.97;
-        let Str.253 : [C {}, C {Str, Str}] = CallByName Str.38 Str.97 Str.98;
-        let Str.259 : U8 = 1i64;
-        let Str.260 : U8 = GetTagId Str.253;
-        let Str.261 : Int1 = lowlevel Eq Str.259 Str.260;
-        if Str.261 then
-            dec Str.97;
-            let Str.258 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.253;
-            let Str.101 : Str = StructAtIndex 0 Str.258;
-            let Str.100 : Str = StructAtIndex 1 Str.258;
-            let Str.256 : Str = CallByName Str.3 Str.96 Str.100;
-            dec Str.100;
-            let Str.255 : Str = CallByName Str.3 Str.256 Str.99;
-            jump Str.252 Str.255 Str.101 Str.98 Str.99;
+procedure Str.61 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3):
+    joinpoint Str.384 Str.194 Str.195 Str.196 Str.197:
+        inc Str.195;
+        let Str.385 : [C {}, C {Str, Str}] = CallByName Str.38 Str.195 Str.196;
+        let Str.391 : U8 = 1i64;
+        let Str.392 : U8 = GetTagId Str.385;
+        let Str.393 : Int1 = lowlevel Eq Str.391 Str.392;
+        if Str.393 then
+            dec Str.195;
+            let Str.390 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.385;
+            let Str.199 : Str = StructAtIndex 0 Str.390;
+            let Str.198 : Str = StructAtIndex 1 Str.390;
+            let Str.388 : Str = CallByName Str.3 Str.194 Str.198;
+            dec Str.198;
+            let Str.387 : Str = CallByName Str.3 Str.388 Str.197;
+            jump Str.384 Str.387 Str.199 Str.196 Str.197;
         else
-            dec Str.98;
-            dec Str.99;
-            dec Str.253;
-            let Str.257 : Str = CallByName Str.3 Str.96 Str.97;
-            dec Str.97;
-            ret Str.257;
+            dec Str.385;
+            dec Str.196;
+            dec Str.197;
+            let Str.389 : Str = CallByName Str.3 Str.194 Str.195;
+            dec Str.195;
+            ret Str.389;
     in
-    inc #Derived_gen.7;
-    inc #Derived_gen.8;
-    jump Str.252 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7 #Derived_gen.8;
-
-procedure Str.57 (Str.121, Str.122):
-    let Str.123 : U64 = CallByName Str.36 Str.121;
-    let Str.124 : U64 = CallByName Str.36 Str.122;
-    let Str.125 : U64 = CallByName Num.77 Str.123 Str.124;
-    let Str.279 : U64 = 0i64;
-    let Str.278 : [C , C U64] = CallByName Str.58 Str.121 Str.122 Str.279 Str.125;
-    ret Str.278;
-
-procedure Str.58 (#Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
-    joinpoint Str.280 Str.126 Str.127 Str.128 Str.129:
-        let Str.282 : Int1 = CallByName Num.23 Str.128 Str.129;
-        if Str.282 then
-            let Str.286 : Int1 = CallByName Str.62 Str.126 Str.128 Str.127;
-            if Str.286 then
-                dec Str.127;
-                dec Str.126;
-                let Str.287 : [C , C U64] = TagId(1) Str.128;
-                ret Str.287;
-            else
-                let Str.285 : U64 = 1i64;
-                let Str.284 : U64 = CallByName Num.51 Str.128 Str.285;
-                jump Str.280 Str.126 Str.127 Str.284 Str.129;
-        else
-            dec Str.127;
-            dec Str.126;
-            let Str.281 : [C , C U64] = TagId(0) ;
-            ret Str.281;
-    in
-    inc #Derived_gen.1;
+    inc #Derived_gen.3;
     inc #Derived_gen.2;
-    jump Str.280 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
+    jump Str.384 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3;
 
-procedure Str.61 (Str.152, Str.153):
-    let Str.310 : Int1 = CallByName Num.22 Str.152 Str.153;
-    if Str.310 then
-        ret Str.152;
+procedure Str.62 (Str.219, Str.220):
+    let Str.221 : U64 = CallByName Str.36 Str.219;
+    let Str.222 : U64 = CallByName Str.36 Str.220;
+    let Str.223 : U64 = CallByName Num.77 Str.221 Str.222;
+    let Str.411 : U64 = 0i64;
+    let Str.410 : [C , C U64] = CallByName Str.63 Str.219 Str.220 Str.411 Str.223;
+    ret Str.410;
+
+procedure Str.63 (#Derived_gen.4, #Derived_gen.5, #Derived_gen.6, #Derived_gen.7):
+    joinpoint Str.412 Str.224 Str.225 Str.226 Str.227:
+        let Str.414 : Int1 = CallByName Num.23 Str.226 Str.227;
+        if Str.414 then
+            let Str.418 : Int1 = CallByName Str.67 Str.224 Str.226 Str.225;
+            if Str.418 then
+                dec Str.224;
+                dec Str.225;
+                let Str.419 : [C , C U64] = TagId(1) Str.226;
+                ret Str.419;
+            else
+                let Str.417 : U64 = 1i64;
+                let Str.416 : U64 = CallByName Num.51 Str.226 Str.417;
+                jump Str.412 Str.224 Str.225 Str.416 Str.227;
+        else
+            dec Str.224;
+            dec Str.225;
+            let Str.413 : [C , C U64] = TagId(0) ;
+            ret Str.413;
+    in
+    inc #Derived_gen.5;
+    inc #Derived_gen.4;
+    jump Str.412 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7;
+
+procedure Str.66 (Str.250, Str.251):
+    let Str.442 : Int1 = CallByName Num.22 Str.250 Str.251;
+    if Str.442 then
+        ret Str.250;
     else
-        ret Str.153;
+        ret Str.251;
 
-procedure Str.62 (Str.154, Str.155, Str.156):
-    let Str.157 : U64 = CallByName Str.36 Str.154;
-    let Str.158 : U64 = CallByName Str.36 Str.156;
-    let Str.308 : U64 = CallByName Num.53 Str.155 Str.158;
-    let Str.159 : U64 = CallByName Str.61 Str.308 Str.157;
-    let Str.307 : U64 = 0i64;
-    inc Str.156;
-    inc Str.154;
-    let Str.289 : {U64, Str, U64, Str, U64, U64} = Struct {Str.159, Str.154, Str.155, Str.156, Str.307, Str.158};
-    let Str.288 : Int1 = CallByName Str.63 Str.289;
-    ret Str.288;
+procedure Str.67 (Str.252, Str.253, Str.254):
+    let Str.255 : U64 = CallByName Str.36 Str.252;
+    let Str.256 : U64 = CallByName Str.36 Str.254;
+    let Str.440 : U64 = CallByName Num.53 Str.253 Str.256;
+    let Str.257 : U64 = CallByName Str.66 Str.440 Str.255;
+    let Str.439 : U64 = 0i64;
+    inc Str.252;
+    inc Str.254;
+    let Str.421 : {U64, Str, U64, Str, U64, U64} = Struct {Str.257, Str.252, Str.253, Str.254, Str.439, Str.256};
+    let Str.420 : Int1 = CallByName Str.68 Str.421;
+    ret Str.420;
 
-procedure Str.63 (Str.160):
-    let Str.166 : U64 = StructAtIndex 0 Str.160;
-    let Str.161 : Str = StructAtIndex 1 Str.160;
-    let Str.162 : U64 = StructAtIndex 2 Str.160;
-    let Str.163 : Str = StructAtIndex 3 Str.160;
-    let Str.164 : U64 = StructAtIndex 4 Str.160;
-    let Str.165 : U64 = StructAtIndex 5 Str.160;
-    let Str.167 : Int1 = CallByName Num.25 Str.162 Str.166;
-    if Str.167 then
-        dec Str.163;
-        dec Str.161;
-        let Str.168 : Int1 = CallByName Bool.11 Str.164 Str.165;
-        ret Str.168;
+procedure Str.68 (Str.258):
+    let Str.264 : U64 = StructAtIndex 0 Str.258;
+    let Str.259 : Str = StructAtIndex 1 Str.258;
+    let Str.260 : U64 = StructAtIndex 2 Str.258;
+    let Str.261 : Str = StructAtIndex 3 Str.258;
+    let Str.262 : U64 = StructAtIndex 4 Str.258;
+    let Str.263 : U64 = StructAtIndex 5 Str.258;
+    let Str.265 : Int1 = CallByName Num.25 Str.260 Str.264;
+    if Str.265 then
+        dec Str.259;
+        dec Str.261;
+        let Str.266 : Int1 = CallByName Bool.11 Str.262 Str.263;
+        ret Str.266;
     else
-        let Str.303 : U8 = CallByName Str.35 Str.161 Str.162;
-        let Str.304 : U8 = CallByName Str.35 Str.163 Str.164;
-        let Str.169 : Int1 = CallByName Bool.11 Str.303 Str.304;
-        let Str.293 : U64 = StructAtIndex 0 Str.160;
-        let Str.294 : Str = StructAtIndex 1 Str.160;
-        let Str.296 : Str = StructAtIndex 3 Str.160;
-        let Str.298 : U64 = StructAtIndex 5 Str.160;
-        let Str.302 : U64 = 1i64;
-        let Str.300 : U64 = CallByName Num.51 Str.164 Str.302;
-        let Str.301 : U64 = 1i64;
-        let Str.299 : U64 = CallByName Num.51 Str.162 Str.301;
-        let Str.292 : {U64, Str, U64, Str, U64, U64} = Struct {Str.293, Str.294, Str.299, Str.296, Str.300, Str.298};
-        let Str.170 : Int1 = CallByName Str.63 Str.292;
-        let Str.291 : Int1 = CallByName Bool.3 Str.169 Str.170;
-        ret Str.291;
+        let Str.435 : U8 = CallByName Str.35 Str.259 Str.260;
+        let Str.436 : U8 = CallByName Str.35 Str.261 Str.262;
+        let Str.267 : Int1 = CallByName Bool.11 Str.435 Str.436;
+        let Str.425 : U64 = StructAtIndex 0 Str.258;
+        let Str.426 : Str = StructAtIndex 1 Str.258;
+        let Str.428 : Str = StructAtIndex 3 Str.258;
+        let Str.430 : U64 = StructAtIndex 5 Str.258;
+        let Str.434 : U64 = 1i64;
+        let Str.432 : U64 = CallByName Num.51 Str.262 Str.434;
+        let Str.433 : U64 = 1i64;
+        let Str.431 : U64 = CallByName Num.51 Str.260 Str.433;
+        let Str.424 : {U64, Str, U64, Str, U64, U64} = Struct {Str.425, Str.426, Str.431, Str.428, Str.432, Str.430};
+        let Str.268 : Int1 = CallByName Str.68 Str.424;
+        let Str.423 : Int1 = CallByName Bool.3 Str.267 Str.268;
+        ret Str.423;
 
 procedure Test.0 ():
     let Test.5 : Str = "Hello ";
diff --git a/crates/compiler/test_mono/generated/dbg_nested_expr.txt b/crates/compiler/test_mono/generated/dbg_nested_expr.txt
index c3b19c61fc..31b331f42f 100644
--- a/crates/compiler/test_mono/generated/dbg_nested_expr.txt
+++ b/crates/compiler/test_mono/generated/dbg_nested_expr.txt
@@ -39,8 +39,8 @@ procedure Num.96 (#Attr.2):
     ret Num.283;
 
 procedure Str.3 (#Attr.2, #Attr.3):
-    let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
-    ret Str.246;
+    let Str.378 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.378;
 
 procedure Test.0 ():
     let Test.6 : I64 = 1i64;
diff --git a/crates/compiler/test_mono/generated/dbg_str_followed_by_number.txt b/crates/compiler/test_mono/generated/dbg_str_followed_by_number.txt
index 5cc0a2fbe8..2bc764bb12 100644
--- a/crates/compiler/test_mono/generated/dbg_str_followed_by_number.txt
+++ b/crates/compiler/test_mono/generated/dbg_str_followed_by_number.txt
@@ -100,181 +100,181 @@ procedure Num.77 (#Attr.2, #Attr.3):
     ret Num.293;
 
 procedure Str.20 (#Attr.2):
-    let Str.313 : Str = lowlevel StrWithCapacity #Attr.2;
-    ret Str.313;
+    let Str.445 : Str = lowlevel StrWithCapacity #Attr.2;
+    ret Str.445;
 
 procedure Str.3 (#Attr.2, #Attr.3):
-    let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
-    ret Str.246;
+    let Str.378 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.378;
 
 procedure Str.35 (#Attr.2, #Attr.3):
-    let Str.303 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
-    ret Str.303;
+    let Str.435 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
+    ret Str.435;
 
 procedure Str.36 (#Attr.2):
-    let Str.266 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
-    ret Str.266;
+    let Str.398 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
+    ret Str.398;
 
 procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
-    let Str.264 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
-    ret Str.264;
+    let Str.396 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
+    ret Str.396;
 
-procedure Str.38 (Str.112, Str.113):
-    let Str.260 : [C , C U64] = CallByName Str.57 Str.112 Str.113;
-    let Str.273 : U8 = 1i64;
-    let Str.274 : U8 = GetTagId Str.260;
-    let Str.275 : Int1 = lowlevel Eq Str.273 Str.274;
-    if Str.275 then
-        let Str.114 : U64 = UnionAtIndex (Id 1) (Index 0) Str.260;
-        let Str.269 : U64 = CallByName Str.36 Str.112;
-        let Str.270 : U64 = CallByName Str.36 Str.113;
-        let Str.268 : U64 = CallByName Num.20 Str.269 Str.270;
-        let Str.115 : U64 = CallByName Num.20 Str.268 Str.114;
-        let Str.267 : U64 = 0i64;
-        inc Str.112;
-        let Str.116 : Str = CallByName Str.37 Str.112 Str.267 Str.114;
-        let Str.265 : U64 = CallByName Str.36 Str.113;
-        let Str.263 : U64 = CallByName Num.51 Str.114 Str.265;
-        let Str.117 : Str = CallByName Str.37 Str.112 Str.263 Str.115;
-        let Str.262 : {Str, Str} = Struct {Str.117, Str.116};
-        let Str.261 : [C {}, C {Str, Str}] = TagId(1) Str.262;
-        ret Str.261;
+procedure Str.38 (Str.210, Str.211):
+    let Str.392 : [C , C U64] = CallByName Str.62 Str.210 Str.211;
+    let Str.405 : U8 = 1i64;
+    let Str.406 : U8 = GetTagId Str.392;
+    let Str.407 : Int1 = lowlevel Eq Str.405 Str.406;
+    if Str.407 then
+        let Str.212 : U64 = UnionAtIndex (Id 1) (Index 0) Str.392;
+        let Str.401 : U64 = CallByName Str.36 Str.210;
+        let Str.402 : U64 = CallByName Str.36 Str.211;
+        let Str.400 : U64 = CallByName Num.20 Str.401 Str.402;
+        let Str.213 : U64 = CallByName Num.20 Str.400 Str.212;
+        let Str.399 : U64 = 0i64;
+        inc Str.210;
+        let Str.214 : Str = CallByName Str.37 Str.210 Str.399 Str.212;
+        let Str.397 : U64 = CallByName Str.36 Str.211;
+        let Str.395 : U64 = CallByName Num.51 Str.212 Str.397;
+        let Str.215 : Str = CallByName Str.37 Str.210 Str.395 Str.213;
+        let Str.394 : {Str, Str} = Struct {Str.215, Str.214};
+        let Str.393 : [C {}, C {Str, Str}] = TagId(1) Str.394;
+        ret Str.393;
     else
-        dec Str.112;
-        let Str.272 : {} = Struct {};
-        let Str.271 : [C {}, C {Str, Str}] = TagId(0) Str.272;
-        ret Str.271;
+        dec Str.210;
+        let Str.404 : {} = Struct {};
+        let Str.403 : [C {}, C {Str, Str}] = TagId(0) Str.404;
+        ret Str.403;
 
-procedure Str.45 (Str.91, Str.92, Str.93):
-    inc Str.91;
-    let Str.341 : [C {}, C {Str, Str}] = CallByName Str.38 Str.91 Str.92;
-    let Str.349 : U8 = 1i64;
-    let Str.350 : U8 = GetTagId Str.341;
-    let Str.351 : Int1 = lowlevel Eq Str.349 Str.350;
-    if Str.351 then
-        let Str.348 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.341;
-        let Str.95 : Str = StructAtIndex 0 Str.348;
-        let Str.94 : Str = StructAtIndex 1 Str.348;
-        let Str.346 : U64 = CallByName Str.36 Str.91;
-        dec Str.91;
-        let Str.345 : Str = CallByName Str.20 Str.346;
-        let Str.344 : Str = CallByName Str.3 Str.345 Str.94;
-        dec Str.94;
-        let Str.343 : Str = CallByName Str.3 Str.344 Str.93;
-        let Str.342 : Str = CallByName Str.56 Str.343 Str.95 Str.92 Str.93;
-        ret Str.342;
+procedure Str.45 (Str.189, Str.190, Str.191):
+    inc Str.189;
+    let Str.473 : [C {}, C {Str, Str}] = CallByName Str.38 Str.189 Str.190;
+    let Str.481 : U8 = 1i64;
+    let Str.482 : U8 = GetTagId Str.473;
+    let Str.483 : Int1 = lowlevel Eq Str.481 Str.482;
+    if Str.483 then
+        let Str.480 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.473;
+        let Str.193 : Str = StructAtIndex 0 Str.480;
+        let Str.192 : Str = StructAtIndex 1 Str.480;
+        let Str.478 : U64 = CallByName Str.36 Str.189;
+        dec Str.189;
+        let Str.477 : Str = CallByName Str.20 Str.478;
+        let Str.476 : Str = CallByName Str.3 Str.477 Str.192;
+        dec Str.192;
+        let Str.475 : Str = CallByName Str.3 Str.476 Str.191;
+        let Str.474 : Str = CallByName Str.61 Str.475 Str.193 Str.190 Str.191;
+        ret Str.474;
     else
-        dec Str.341;
-        ret Str.91;
+        dec Str.473;
+        ret Str.189;
 
-procedure Str.56 (#Derived_gen.5, #Derived_gen.6, #Derived_gen.7, #Derived_gen.8):
-    joinpoint Str.250 Str.96 Str.97 Str.98 Str.99:
-        inc Str.97;
-        let Str.251 : [C {}, C {Str, Str}] = CallByName Str.38 Str.97 Str.98;
-        let Str.257 : U8 = 1i64;
-        let Str.258 : U8 = GetTagId Str.251;
-        let Str.259 : Int1 = lowlevel Eq Str.257 Str.258;
-        if Str.259 then
-            dec Str.97;
-            let Str.256 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.251;
-            let Str.101 : Str = StructAtIndex 0 Str.256;
-            let Str.100 : Str = StructAtIndex 1 Str.256;
-            let Str.254 : Str = CallByName Str.3 Str.96 Str.100;
-            dec Str.100;
-            let Str.253 : Str = CallByName Str.3 Str.254 Str.99;
-            jump Str.250 Str.253 Str.101 Str.98 Str.99;
+procedure Str.61 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3):
+    joinpoint Str.382 Str.194 Str.195 Str.196 Str.197:
+        inc Str.195;
+        let Str.383 : [C {}, C {Str, Str}] = CallByName Str.38 Str.195 Str.196;
+        let Str.389 : U8 = 1i64;
+        let Str.390 : U8 = GetTagId Str.383;
+        let Str.391 : Int1 = lowlevel Eq Str.389 Str.390;
+        if Str.391 then
+            dec Str.195;
+            let Str.388 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.383;
+            let Str.199 : Str = StructAtIndex 0 Str.388;
+            let Str.198 : Str = StructAtIndex 1 Str.388;
+            let Str.386 : Str = CallByName Str.3 Str.194 Str.198;
+            dec Str.198;
+            let Str.385 : Str = CallByName Str.3 Str.386 Str.197;
+            jump Str.382 Str.385 Str.199 Str.196 Str.197;
         else
-            dec Str.98;
-            dec Str.251;
-            dec Str.99;
-            let Str.255 : Str = CallByName Str.3 Str.96 Str.97;
-            dec Str.97;
-            ret Str.255;
+            dec Str.196;
+            dec Str.383;
+            dec Str.197;
+            let Str.387 : Str = CallByName Str.3 Str.194 Str.195;
+            dec Str.195;
+            ret Str.387;
     in
-    inc #Derived_gen.7;
-    inc #Derived_gen.8;
-    jump Str.250 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7 #Derived_gen.8;
-
-procedure Str.57 (Str.121, Str.122):
-    let Str.123 : U64 = CallByName Str.36 Str.121;
-    let Str.124 : U64 = CallByName Str.36 Str.122;
-    let Str.125 : U64 = CallByName Num.77 Str.123 Str.124;
-    let Str.277 : U64 = 0i64;
-    let Str.276 : [C , C U64] = CallByName Str.58 Str.121 Str.122 Str.277 Str.125;
-    ret Str.276;
-
-procedure Str.58 (#Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
-    joinpoint Str.278 Str.126 Str.127 Str.128 Str.129:
-        let Str.280 : Int1 = CallByName Num.23 Str.128 Str.129;
-        if Str.280 then
-            let Str.284 : Int1 = CallByName Str.62 Str.126 Str.128 Str.127;
-            if Str.284 then
-                dec Str.127;
-                dec Str.126;
-                let Str.285 : [C , C U64] = TagId(1) Str.128;
-                ret Str.285;
-            else
-                let Str.283 : U64 = 1i64;
-                let Str.282 : U64 = CallByName Num.51 Str.128 Str.283;
-                jump Str.278 Str.126 Str.127 Str.282 Str.129;
-        else
-            dec Str.127;
-            dec Str.126;
-            let Str.279 : [C , C U64] = TagId(0) ;
-            ret Str.279;
-    in
-    inc #Derived_gen.1;
+    inc #Derived_gen.3;
     inc #Derived_gen.2;
-    jump Str.278 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
+    jump Str.382 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3;
 
-procedure Str.61 (Str.152, Str.153):
-    let Str.308 : Int1 = CallByName Num.22 Str.152 Str.153;
-    if Str.308 then
-        ret Str.152;
+procedure Str.62 (Str.219, Str.220):
+    let Str.221 : U64 = CallByName Str.36 Str.219;
+    let Str.222 : U64 = CallByName Str.36 Str.220;
+    let Str.223 : U64 = CallByName Num.77 Str.221 Str.222;
+    let Str.409 : U64 = 0i64;
+    let Str.408 : [C , C U64] = CallByName Str.63 Str.219 Str.220 Str.409 Str.223;
+    ret Str.408;
+
+procedure Str.63 (#Derived_gen.4, #Derived_gen.5, #Derived_gen.6, #Derived_gen.7):
+    joinpoint Str.410 Str.224 Str.225 Str.226 Str.227:
+        let Str.412 : Int1 = CallByName Num.23 Str.226 Str.227;
+        if Str.412 then
+            let Str.416 : Int1 = CallByName Str.67 Str.224 Str.226 Str.225;
+            if Str.416 then
+                dec Str.224;
+                dec Str.225;
+                let Str.417 : [C , C U64] = TagId(1) Str.226;
+                ret Str.417;
+            else
+                let Str.415 : U64 = 1i64;
+                let Str.414 : U64 = CallByName Num.51 Str.226 Str.415;
+                jump Str.410 Str.224 Str.225 Str.414 Str.227;
+        else
+            dec Str.224;
+            dec Str.225;
+            let Str.411 : [C , C U64] = TagId(0) ;
+            ret Str.411;
+    in
+    inc #Derived_gen.5;
+    inc #Derived_gen.4;
+    jump Str.410 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7;
+
+procedure Str.66 (Str.250, Str.251):
+    let Str.440 : Int1 = CallByName Num.22 Str.250 Str.251;
+    if Str.440 then
+        ret Str.250;
     else
-        ret Str.153;
+        ret Str.251;
 
-procedure Str.62 (Str.154, Str.155, Str.156):
-    let Str.157 : U64 = CallByName Str.36 Str.154;
-    let Str.158 : U64 = CallByName Str.36 Str.156;
-    let Str.306 : U64 = CallByName Num.53 Str.155 Str.158;
-    let Str.159 : U64 = CallByName Str.61 Str.306 Str.157;
-    let Str.305 : U64 = 0i64;
-    inc Str.156;
-    inc Str.154;
-    let Str.287 : {U64, Str, U64, Str, U64, U64} = Struct {Str.159, Str.154, Str.155, Str.156, Str.305, Str.158};
-    let Str.286 : Int1 = CallByName Str.63 Str.287;
-    ret Str.286;
+procedure Str.67 (Str.252, Str.253, Str.254):
+    let Str.255 : U64 = CallByName Str.36 Str.252;
+    let Str.256 : U64 = CallByName Str.36 Str.254;
+    let Str.438 : U64 = CallByName Num.53 Str.253 Str.256;
+    let Str.257 : U64 = CallByName Str.66 Str.438 Str.255;
+    let Str.437 : U64 = 0i64;
+    inc Str.252;
+    inc Str.254;
+    let Str.419 : {U64, Str, U64, Str, U64, U64} = Struct {Str.257, Str.252, Str.253, Str.254, Str.437, Str.256};
+    let Str.418 : Int1 = CallByName Str.68 Str.419;
+    ret Str.418;
 
-procedure Str.63 (Str.160):
-    let Str.166 : U64 = StructAtIndex 0 Str.160;
-    let Str.161 : Str = StructAtIndex 1 Str.160;
-    let Str.162 : U64 = StructAtIndex 2 Str.160;
-    let Str.163 : Str = StructAtIndex 3 Str.160;
-    let Str.164 : U64 = StructAtIndex 4 Str.160;
-    let Str.165 : U64 = StructAtIndex 5 Str.160;
-    let Str.167 : Int1 = CallByName Num.25 Str.162 Str.166;
-    if Str.167 then
-        dec Str.163;
-        dec Str.161;
-        let Str.168 : Int1 = CallByName Bool.11 Str.164 Str.165;
-        ret Str.168;
+procedure Str.68 (Str.258):
+    let Str.264 : U64 = StructAtIndex 0 Str.258;
+    let Str.259 : Str = StructAtIndex 1 Str.258;
+    let Str.260 : U64 = StructAtIndex 2 Str.258;
+    let Str.261 : Str = StructAtIndex 3 Str.258;
+    let Str.262 : U64 = StructAtIndex 4 Str.258;
+    let Str.263 : U64 = StructAtIndex 5 Str.258;
+    let Str.265 : Int1 = CallByName Num.25 Str.260 Str.264;
+    if Str.265 then
+        dec Str.259;
+        dec Str.261;
+        let Str.266 : Int1 = CallByName Bool.11 Str.262 Str.263;
+        ret Str.266;
     else
-        let Str.301 : U8 = CallByName Str.35 Str.161 Str.162;
-        let Str.302 : U8 = CallByName Str.35 Str.163 Str.164;
-        let Str.169 : Int1 = CallByName Bool.11 Str.301 Str.302;
-        let Str.291 : U64 = StructAtIndex 0 Str.160;
-        let Str.292 : Str = StructAtIndex 1 Str.160;
-        let Str.294 : Str = StructAtIndex 3 Str.160;
-        let Str.296 : U64 = StructAtIndex 5 Str.160;
-        let Str.300 : U64 = 1i64;
-        let Str.298 : U64 = CallByName Num.51 Str.164 Str.300;
-        let Str.299 : U64 = 1i64;
-        let Str.297 : U64 = CallByName Num.51 Str.162 Str.299;
-        let Str.290 : {U64, Str, U64, Str, U64, U64} = Struct {Str.291, Str.292, Str.297, Str.294, Str.298, Str.296};
-        let Str.170 : Int1 = CallByName Str.63 Str.290;
-        let Str.289 : Int1 = CallByName Bool.3 Str.169 Str.170;
-        ret Str.289;
+        let Str.433 : U8 = CallByName Str.35 Str.259 Str.260;
+        let Str.434 : U8 = CallByName Str.35 Str.261 Str.262;
+        let Str.267 : Int1 = CallByName Bool.11 Str.433 Str.434;
+        let Str.423 : U64 = StructAtIndex 0 Str.258;
+        let Str.424 : Str = StructAtIndex 1 Str.258;
+        let Str.426 : Str = StructAtIndex 3 Str.258;
+        let Str.428 : U64 = StructAtIndex 5 Str.258;
+        let Str.432 : U64 = 1i64;
+        let Str.430 : U64 = CallByName Num.51 Str.262 Str.432;
+        let Str.431 : U64 = 1i64;
+        let Str.429 : U64 = CallByName Num.51 Str.260 Str.431;
+        let Str.422 : {U64, Str, U64, Str, U64, U64} = Struct {Str.423, Str.424, Str.429, Str.426, Str.430, Str.428};
+        let Str.268 : Int1 = CallByName Str.68 Str.422;
+        let Str.421 : Int1 = CallByName Bool.3 Str.267 Str.268;
+        ret Str.421;
 
 procedure Test.0 ():
     let Test.3 : Str = "";
diff --git a/crates/compiler/test_mono/generated/dec_refcount_for_usage_after_early_return_in_if.txt b/crates/compiler/test_mono/generated/dec_refcount_for_usage_after_early_return_in_if.txt
index 88f4f16d63..352d22ee26 100644
--- a/crates/compiler/test_mono/generated/dec_refcount_for_usage_after_early_return_in_if.txt
+++ b/crates/compiler/test_mono/generated/dec_refcount_for_usage_after_early_return_in_if.txt
@@ -11,8 +11,8 @@ procedure Num.96 (#Attr.2):
     ret Num.284;
 
 procedure Str.3 (#Attr.2, #Attr.3):
-    let Str.247 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
-    ret Str.247;
+    let Str.379 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.379;
 
 procedure Test.1 (Test.2):
     let Test.3 : Str = CallByName Num.96 Test.2;
diff --git a/crates/compiler/test_mono/generated/encode_derived_nested_record_string.txt b/crates/compiler/test_mono/generated/encode_derived_nested_record_string.txt
index eee404c564..517f1280ab 100644
--- a/crates/compiler/test_mono/generated/encode_derived_nested_record_string.txt
+++ b/crates/compiler/test_mono/generated/encode_derived_nested_record_string.txt
@@ -164,32 +164,32 @@ procedure Num.96 (#Attr.2):
     ret Num.287;
 
 procedure Str.12 (#Attr.2):
-    let Str.259 : List U8 = lowlevel StrToUtf8 #Attr.2;
-    ret Str.259;
+    let Str.391 : List U8 = lowlevel StrToUtf8 #Attr.2;
+    ret Str.391;
 
 procedure Str.36 (#Attr.2):
-    let Str.260 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
-    ret Str.260;
+    let Str.392 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
+    ret Str.392;
 
 procedure Str.43 (#Attr.2):
-    let Str.254 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
-    ret Str.254;
+    let Str.386 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
+    ret Str.386;
 
-procedure Str.9 (Str.73):
-    let Str.74 : {U64, Str, Int1, U8} = CallByName Str.43 Str.73;
-    let Str.251 : Int1 = StructAtIndex 2 Str.74;
-    if Str.251 then
-        let Str.253 : Str = StructAtIndex 1 Str.74;
-        let Str.252 : [C {U64, U8}, C Str] = TagId(1) Str.253;
-        ret Str.252;
+procedure Str.9 (Str.76):
+    let Str.77 : {U64, Str, Int1, U8} = CallByName Str.43 Str.76;
+    let Str.383 : Int1 = StructAtIndex 2 Str.77;
+    if Str.383 then
+        let Str.385 : Str = StructAtIndex 1 Str.77;
+        let Str.384 : [C {U64, U8}, C Str] = TagId(1) Str.385;
+        ret Str.384;
     else
-        let Str.249 : U64 = StructAtIndex 0 Str.74;
-        let Str.250 : U8 = StructAtIndex 3 Str.74;
-        let #Derived_gen.45 : Str = StructAtIndex 1 Str.74;
+        let Str.381 : U64 = StructAtIndex 0 Str.77;
+        let Str.382 : U8 = StructAtIndex 3 Str.77;
+        let #Derived_gen.45 : Str = StructAtIndex 1 Str.77;
         dec #Derived_gen.45;
-        let Str.248 : {U64, U8} = Struct {Str.249, Str.250};
-        let Str.246 : [C {U64, U8}, C Str] = TagId(0) Str.248;
-        ret Str.246;
+        let Str.380 : {U64, U8} = Struct {Str.381, Str.382};
+        let Str.378 : [C {U64, U8}, C Str] = TagId(0) Str.380;
+        ret Str.378;
 
 procedure Test.20 (Test.56):
     let Test.325 : Str = CallByName Encode.23 Test.56;
diff --git a/crates/compiler/test_mono/generated/encode_derived_record_one_field_string.txt b/crates/compiler/test_mono/generated/encode_derived_record_one_field_string.txt
index 89317dea5e..8fd049caf0 100644
--- a/crates/compiler/test_mono/generated/encode_derived_record_one_field_string.txt
+++ b/crates/compiler/test_mono/generated/encode_derived_record_one_field_string.txt
@@ -105,32 +105,32 @@ procedure Num.96 (#Attr.2):
     ret Num.283;
 
 procedure Str.12 (#Attr.2):
-    let Str.256 : List U8 = lowlevel StrToUtf8 #Attr.2;
-    ret Str.256;
+    let Str.388 : List U8 = lowlevel StrToUtf8 #Attr.2;
+    ret Str.388;
 
 procedure Str.36 (#Attr.2):
-    let Str.257 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
-    ret Str.257;
+    let Str.389 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
+    ret Str.389;
 
 procedure Str.43 (#Attr.2):
-    let Str.254 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
-    ret Str.254;
+    let Str.386 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
+    ret Str.386;
 
-procedure Str.9 (Str.73):
-    let Str.74 : {U64, Str, Int1, U8} = CallByName Str.43 Str.73;
-    let Str.251 : Int1 = StructAtIndex 2 Str.74;
-    if Str.251 then
-        let Str.253 : Str = StructAtIndex 1 Str.74;
-        let Str.252 : [C {U64, U8}, C Str] = TagId(1) Str.253;
-        ret Str.252;
+procedure Str.9 (Str.76):
+    let Str.77 : {U64, Str, Int1, U8} = CallByName Str.43 Str.76;
+    let Str.383 : Int1 = StructAtIndex 2 Str.77;
+    if Str.383 then
+        let Str.385 : Str = StructAtIndex 1 Str.77;
+        let Str.384 : [C {U64, U8}, C Str] = TagId(1) Str.385;
+        ret Str.384;
     else
-        let Str.249 : U64 = StructAtIndex 0 Str.74;
-        let Str.250 : U8 = StructAtIndex 3 Str.74;
-        let #Derived_gen.24 : Str = StructAtIndex 1 Str.74;
+        let Str.381 : U64 = StructAtIndex 0 Str.77;
+        let Str.382 : U8 = StructAtIndex 3 Str.77;
+        let #Derived_gen.24 : Str = StructAtIndex 1 Str.77;
         dec #Derived_gen.24;
-        let Str.248 : {U64, U8} = Struct {Str.249, Str.250};
-        let Str.246 : [C {U64, U8}, C Str] = TagId(0) Str.248;
-        ret Str.246;
+        let Str.380 : {U64, U8} = Struct {Str.381, Str.382};
+        let Str.378 : [C {U64, U8}, C Str] = TagId(0) Str.380;
+        ret Str.378;
 
 procedure Test.20 (Test.56):
     let Test.292 : Str = CallByName Encode.23 Test.56;
diff --git a/crates/compiler/test_mono/generated/encode_derived_record_two_field_strings.txt b/crates/compiler/test_mono/generated/encode_derived_record_two_field_strings.txt
index 4934cb386b..abdd34b5dd 100644
--- a/crates/compiler/test_mono/generated/encode_derived_record_two_field_strings.txt
+++ b/crates/compiler/test_mono/generated/encode_derived_record_two_field_strings.txt
@@ -112,32 +112,32 @@ procedure Num.96 (#Attr.2):
     ret Num.283;
 
 procedure Str.12 (#Attr.2):
-    let Str.256 : List U8 = lowlevel StrToUtf8 #Attr.2;
-    ret Str.256;
+    let Str.388 : List U8 = lowlevel StrToUtf8 #Attr.2;
+    ret Str.388;
 
 procedure Str.36 (#Attr.2):
-    let Str.257 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
-    ret Str.257;
+    let Str.389 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
+    ret Str.389;
 
 procedure Str.43 (#Attr.2):
-    let Str.254 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
-    ret Str.254;
+    let Str.386 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
+    ret Str.386;
 
-procedure Str.9 (Str.73):
-    let Str.74 : {U64, Str, Int1, U8} = CallByName Str.43 Str.73;
-    let Str.251 : Int1 = StructAtIndex 2 Str.74;
-    if Str.251 then
-        let Str.253 : Str = StructAtIndex 1 Str.74;
-        let Str.252 : [C {U64, U8}, C Str] = TagId(1) Str.253;
-        ret Str.252;
+procedure Str.9 (Str.76):
+    let Str.77 : {U64, Str, Int1, U8} = CallByName Str.43 Str.76;
+    let Str.383 : Int1 = StructAtIndex 2 Str.77;
+    if Str.383 then
+        let Str.385 : Str = StructAtIndex 1 Str.77;
+        let Str.384 : [C {U64, U8}, C Str] = TagId(1) Str.385;
+        ret Str.384;
     else
-        let Str.249 : U64 = StructAtIndex 0 Str.74;
-        let Str.250 : U8 = StructAtIndex 3 Str.74;
-        let #Derived_gen.28 : Str = StructAtIndex 1 Str.74;
+        let Str.381 : U64 = StructAtIndex 0 Str.77;
+        let Str.382 : U8 = StructAtIndex 3 Str.77;
+        let #Derived_gen.28 : Str = StructAtIndex 1 Str.77;
         dec #Derived_gen.28;
-        let Str.248 : {U64, U8} = Struct {Str.249, Str.250};
-        let Str.246 : [C {U64, U8}, C Str] = TagId(0) Str.248;
-        ret Str.246;
+        let Str.380 : {U64, U8} = Struct {Str.381, Str.382};
+        let Str.378 : [C {U64, U8}, C Str] = TagId(0) Str.380;
+        ret Str.378;
 
 procedure Test.20 (Test.56):
     let Test.296 : Str = CallByName Encode.23 Test.56;
diff --git a/crates/compiler/test_mono/generated/encode_derived_string.txt b/crates/compiler/test_mono/generated/encode_derived_string.txt
index be968f298f..78679a7da8 100644
--- a/crates/compiler/test_mono/generated/encode_derived_string.txt
+++ b/crates/compiler/test_mono/generated/encode_derived_string.txt
@@ -38,32 +38,32 @@ procedure Num.96 (#Attr.2):
     ret Num.283;
 
 procedure Str.12 (#Attr.2):
-    let Str.256 : List U8 = lowlevel StrToUtf8 #Attr.2;
-    ret Str.256;
+    let Str.388 : List U8 = lowlevel StrToUtf8 #Attr.2;
+    ret Str.388;
 
 procedure Str.36 (#Attr.2):
-    let Str.257 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
-    ret Str.257;
+    let Str.389 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
+    ret Str.389;
 
 procedure Str.43 (#Attr.2):
-    let Str.254 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
-    ret Str.254;
+    let Str.386 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
+    ret Str.386;
 
-procedure Str.9 (Str.73):
-    let Str.74 : {U64, Str, Int1, U8} = CallByName Str.43 Str.73;
-    let Str.251 : Int1 = StructAtIndex 2 Str.74;
-    if Str.251 then
-        let Str.253 : Str = StructAtIndex 1 Str.74;
-        let Str.252 : [C {U64, U8}, C Str] = TagId(1) Str.253;
-        ret Str.252;
+procedure Str.9 (Str.76):
+    let Str.77 : {U64, Str, Int1, U8} = CallByName Str.43 Str.76;
+    let Str.383 : Int1 = StructAtIndex 2 Str.77;
+    if Str.383 then
+        let Str.385 : Str = StructAtIndex 1 Str.77;
+        let Str.384 : [C {U64, U8}, C Str] = TagId(1) Str.385;
+        ret Str.384;
     else
-        let Str.249 : U64 = StructAtIndex 0 Str.74;
-        let Str.250 : U8 = StructAtIndex 3 Str.74;
-        let #Derived_gen.3 : Str = StructAtIndex 1 Str.74;
+        let Str.381 : U64 = StructAtIndex 0 Str.77;
+        let Str.382 : U8 = StructAtIndex 3 Str.77;
+        let #Derived_gen.3 : Str = StructAtIndex 1 Str.77;
         dec #Derived_gen.3;
-        let Str.248 : {U64, U8} = Struct {Str.249, Str.250};
-        let Str.246 : [C {U64, U8}, C Str] = TagId(0) Str.248;
-        ret Str.246;
+        let Str.380 : {U64, U8} = Struct {Str.381, Str.382};
+        let Str.378 : [C {U64, U8}, C Str] = TagId(0) Str.380;
+        ret Str.378;
 
 procedure Test.20 (Test.56):
     let Test.259 : Str = CallByName Encode.23 Test.56;
diff --git a/crates/compiler/test_mono/generated/encode_derived_tag_one_field_string.txt b/crates/compiler/test_mono/generated/encode_derived_tag_one_field_string.txt
index 6f14951fea..3ce9c3b83e 100644
--- a/crates/compiler/test_mono/generated/encode_derived_tag_one_field_string.txt
+++ b/crates/compiler/test_mono/generated/encode_derived_tag_one_field_string.txt
@@ -110,32 +110,32 @@ procedure Num.96 (#Attr.2):
     ret Num.283;
 
 procedure Str.12 (#Attr.2):
-    let Str.256 : List U8 = lowlevel StrToUtf8 #Attr.2;
-    ret Str.256;
+    let Str.388 : List U8 = lowlevel StrToUtf8 #Attr.2;
+    ret Str.388;
 
 procedure Str.36 (#Attr.2):
-    let Str.257 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
-    ret Str.257;
+    let Str.389 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
+    ret Str.389;
 
 procedure Str.43 (#Attr.2):
-    let Str.254 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
-    ret Str.254;
+    let Str.386 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
+    ret Str.386;
 
-procedure Str.9 (Str.73):
-    let Str.74 : {U64, Str, Int1, U8} = CallByName Str.43 Str.73;
-    let Str.251 : Int1 = StructAtIndex 2 Str.74;
-    if Str.251 then
-        let Str.253 : Str = StructAtIndex 1 Str.74;
-        let Str.252 : [C {U64, U8}, C Str] = TagId(1) Str.253;
-        ret Str.252;
+procedure Str.9 (Str.76):
+    let Str.77 : {U64, Str, Int1, U8} = CallByName Str.43 Str.76;
+    let Str.383 : Int1 = StructAtIndex 2 Str.77;
+    if Str.383 then
+        let Str.385 : Str = StructAtIndex 1 Str.77;
+        let Str.384 : [C {U64, U8}, C Str] = TagId(1) Str.385;
+        ret Str.384;
     else
-        let Str.249 : U64 = StructAtIndex 0 Str.74;
-        let Str.250 : U8 = StructAtIndex 3 Str.74;
-        let #Derived_gen.27 : Str = StructAtIndex 1 Str.74;
+        let Str.381 : U64 = StructAtIndex 0 Str.77;
+        let Str.382 : U8 = StructAtIndex 3 Str.77;
+        let #Derived_gen.27 : Str = StructAtIndex 1 Str.77;
         dec #Derived_gen.27;
-        let Str.248 : {U64, U8} = Struct {Str.249, Str.250};
-        let Str.246 : [C {U64, U8}, C Str] = TagId(0) Str.248;
-        ret Str.246;
+        let Str.380 : {U64, U8} = Struct {Str.381, Str.382};
+        let Str.378 : [C {U64, U8}, C Str] = TagId(0) Str.380;
+        ret Str.378;
 
 procedure Test.20 (Test.56):
     let Test.297 : Str = CallByName Encode.23 Test.56;
diff --git a/crates/compiler/test_mono/generated/encode_derived_tag_two_payloads_string.txt b/crates/compiler/test_mono/generated/encode_derived_tag_two_payloads_string.txt
index 5e331a1f00..b6cbe9b8bd 100644
--- a/crates/compiler/test_mono/generated/encode_derived_tag_two_payloads_string.txt
+++ b/crates/compiler/test_mono/generated/encode_derived_tag_two_payloads_string.txt
@@ -113,32 +113,32 @@ procedure Num.96 (#Attr.2):
     ret Num.283;
 
 procedure Str.12 (#Attr.2):
-    let Str.256 : List U8 = lowlevel StrToUtf8 #Attr.2;
-    ret Str.256;
+    let Str.388 : List U8 = lowlevel StrToUtf8 #Attr.2;
+    ret Str.388;
 
 procedure Str.36 (#Attr.2):
-    let Str.257 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
-    ret Str.257;
+    let Str.389 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
+    ret Str.389;
 
 procedure Str.43 (#Attr.2):
-    let Str.254 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
-    ret Str.254;
+    let Str.386 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
+    ret Str.386;
 
-procedure Str.9 (Str.73):
-    let Str.74 : {U64, Str, Int1, U8} = CallByName Str.43 Str.73;
-    let Str.251 : Int1 = StructAtIndex 2 Str.74;
-    if Str.251 then
-        let Str.253 : Str = StructAtIndex 1 Str.74;
-        let Str.252 : [C {U64, U8}, C Str] = TagId(1) Str.253;
-        ret Str.252;
+procedure Str.9 (Str.76):
+    let Str.77 : {U64, Str, Int1, U8} = CallByName Str.43 Str.76;
+    let Str.383 : Int1 = StructAtIndex 2 Str.77;
+    if Str.383 then
+        let Str.385 : Str = StructAtIndex 1 Str.77;
+        let Str.384 : [C {U64, U8}, C Str] = TagId(1) Str.385;
+        ret Str.384;
     else
-        let Str.249 : U64 = StructAtIndex 0 Str.74;
-        let Str.250 : U8 = StructAtIndex 3 Str.74;
-        let #Derived_gen.28 : Str = StructAtIndex 1 Str.74;
+        let Str.381 : U64 = StructAtIndex 0 Str.77;
+        let Str.382 : U8 = StructAtIndex 3 Str.77;
+        let #Derived_gen.28 : Str = StructAtIndex 1 Str.77;
         dec #Derived_gen.28;
-        let Str.248 : {U64, U8} = Struct {Str.249, Str.250};
-        let Str.246 : [C {U64, U8}, C Str] = TagId(0) Str.248;
-        ret Str.246;
+        let Str.380 : {U64, U8} = Struct {Str.381, Str.382};
+        let Str.378 : [C {U64, U8}, C Str] = TagId(0) Str.380;
+        ret Str.378;
 
 procedure Test.20 (Test.56):
     let Test.301 : Str = CallByName Encode.23 Test.56;
diff --git a/crates/compiler/test_mono/generated/inspect_derived_dict.txt b/crates/compiler/test_mono/generated/inspect_derived_dict.txt
index 87ba855f30..b8628e9ac9 100644
--- a/crates/compiler/test_mono/generated/inspect_derived_dict.txt
+++ b/crates/compiler/test_mono/generated/inspect_derived_dict.txt
@@ -153,7 +153,7 @@ procedure Dict.43 (Dict.126):
     let Dict.1102 : {List {U32, U32}, List {Str, I64}, U64, Float32, U8} = CallByName Inspect.30 Dict.126;
     ret Dict.1102;
 
-procedure Dict.45 (#Derived_gen.39, #Derived_gen.40, #Derived_gen.41, #Derived_gen.42, #Derived_gen.43, #Derived_gen.44, #Derived_gen.45, #Derived_gen.46, #Derived_gen.47):
+procedure Dict.45 (#Derived_gen.40, #Derived_gen.41, #Derived_gen.42, #Derived_gen.43, #Derived_gen.44, #Derived_gen.45, #Derived_gen.46, #Derived_gen.47, #Derived_gen.48):
     joinpoint Dict.745 Dict.228 Dict.229 Dict.230 Dict.231 Dict.232 Dict.233 Dict.234 Dict.235 Dict.236:
         let Dict.237 : {U32, U32} = CallByName Dict.22 Dict.228 Dict.230;
         let Dict.792 : U32 = StructAtIndex 1 Dict.237;
@@ -196,8 +196,8 @@ procedure Dict.45 (#Derived_gen.39, #Derived_gen.40, #Derived_gen.41, #Derived_g
                 let Dict.246 : U32 = CallByName Dict.55 Dict.231;
                 jump Dict.745 Dict.228 Dict.229 Dict.245 Dict.246 Dict.232 Dict.233 Dict.234 Dict.235 Dict.236;
     in
-    inc #Derived_gen.43;
-    jump Dict.745 #Derived_gen.39 #Derived_gen.40 #Derived_gen.41 #Derived_gen.42 #Derived_gen.43 #Derived_gen.44 #Derived_gen.45 #Derived_gen.46 #Derived_gen.47;
+    inc #Derived_gen.44;
+    jump Dict.745 #Derived_gen.40 #Derived_gen.41 #Derived_gen.42 #Derived_gen.43 #Derived_gen.44 #Derived_gen.45 #Derived_gen.46 #Derived_gen.47 #Derived_gen.48;
 
 procedure Dict.48 ():
     let Dict.869 : U32 = 0i64;
@@ -312,7 +312,7 @@ procedure Dict.72 (Dict.413, Dict.414, Dict.415):
     let Dict.855 : {U64, U32} = CallByName Dict.73 Dict.413 Dict.418 Dict.417;
     ret Dict.855;
 
-procedure Dict.73 (#Derived_gen.15, #Derived_gen.16, #Derived_gen.17):
+procedure Dict.73 (#Derived_gen.19, #Derived_gen.20, #Derived_gen.21):
     joinpoint Dict.856 Dict.419 Dict.420 Dict.421:
         let Dict.422 : {U32, U32} = CallByName Dict.22 Dict.419 Dict.420;
         let Dict.863 : U32 = StructAtIndex 1 Dict.422;
@@ -327,10 +327,10 @@ procedure Dict.73 (#Derived_gen.15, #Derived_gen.16, #Derived_gen.17):
             let Dict.857 : {U64, U32} = Struct {Dict.420, Dict.421};
             ret Dict.857;
     in
-    inc #Derived_gen.15;
-    jump Dict.856 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17;
+    inc #Derived_gen.19;
+    jump Dict.856 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21;
 
-procedure Dict.74 (#Derived_gen.48, #Derived_gen.49, #Derived_gen.50):
+procedure Dict.74 (#Derived_gen.49, #Derived_gen.50, #Derived_gen.51):
     joinpoint Dict.762 Dict.423 Dict.424 Dict.425:
         let Dict.426 : {U32, U32} = CallByName Dict.22 Dict.423 Dict.425;
         let Dict.772 : U32 = StructAtIndex 1 Dict.426;
@@ -349,7 +349,7 @@ procedure Dict.74 (#Derived_gen.48, #Derived_gen.49, #Derived_gen.50):
             let Dict.763 : List {U32, U32} = CallByName List.3 Dict.423 Dict.425 Dict.424;
             ret Dict.763;
     in
-    jump Dict.762 #Derived_gen.48 #Derived_gen.49 #Derived_gen.50;
+    jump Dict.762 #Derived_gen.49 #Derived_gen.50 #Derived_gen.51;
 
 procedure Dict.75 (Dict.428, Dict.429):
     let Dict.758 : U64 = 1i64;
@@ -529,7 +529,7 @@ procedure Dict.89 (Dict.711, Dict.489):
             let Dict.926 : {U64, U64, U64} = CallByName Dict.90 Dict.487 Dict.487 Dict.487 Dict.489 Dict.928 Dict.490;
             jump Dict.927 Dict.926;
 
-procedure Dict.90 (#Derived_gen.4, #Derived_gen.5, #Derived_gen.6, #Derived_gen.7, #Derived_gen.8, #Derived_gen.9):
+procedure Dict.90 (#Derived_gen.8, #Derived_gen.9, #Derived_gen.10, #Derived_gen.11, #Derived_gen.12, #Derived_gen.13):
     joinpoint Dict.929 Dict.495 Dict.496 Dict.497 Dict.498 Dict.499 Dict.500:
         let Dict.1036 : U64 = CallByName Dict.98 Dict.498 Dict.499;
         let Dict.1037 : U64 = CallByName Dict.93;
@@ -591,8 +591,8 @@ procedure Dict.90 (#Derived_gen.4, #Derived_gen.5, #Derived_gen.6, #Derived_gen.
                 let Dict.930 : {U64, U64, U64} = Struct {Dict.931, Dict.932, Dict.507};
                 ret Dict.930;
     in
-    inc #Derived_gen.7;
-    jump Dict.929 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7 #Derived_gen.8 #Derived_gen.9;
+    inc #Derived_gen.11;
+    jump Dict.929 #Derived_gen.8 #Derived_gen.9 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12 #Derived_gen.13;
 
 procedure Dict.91 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3):
     joinpoint Dict.982 Dict.508 Dict.509 Dict.510 Dict.511:
@@ -902,7 +902,7 @@ procedure Inspect.63 (Inspect.295, Inspect.291):
 procedure Inspect.64 (Inspect.297):
     ret Inspect.297;
 
-procedure List.101 (#Derived_gen.10, #Derived_gen.11, #Derived_gen.12, #Derived_gen.13, #Derived_gen.14):
+procedure List.101 (#Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17, #Derived_gen.18):
     joinpoint List.678 List.175 List.176 List.177 List.178 List.179:
         let List.680 : Int1 = CallByName Num.22 List.178 List.179;
         if List.680 then
@@ -916,10 +916,10 @@ procedure List.101 (#Derived_gen.10, #Derived_gen.11, #Derived_gen.12, #Derived_
             dec List.175;
             ret List.176;
     in
-    inc #Derived_gen.10;
-    jump List.678 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14;
+    inc #Derived_gen.14;
+    jump List.678 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18;
 
-procedure List.101 (#Derived_gen.51, #Derived_gen.52, #Derived_gen.53, #Derived_gen.54, #Derived_gen.55):
+procedure List.101 (#Derived_gen.52, #Derived_gen.53, #Derived_gen.54, #Derived_gen.55, #Derived_gen.56):
     joinpoint List.742 List.175 List.176 List.177 List.178 List.179:
         let List.744 : Int1 = CallByName Num.22 List.178 List.179;
         if List.744 then
@@ -933,10 +933,10 @@ procedure List.101 (#Derived_gen.51, #Derived_gen.52, #Derived_gen.53, #Derived_
             dec List.175;
             ret List.176;
     in
-    inc #Derived_gen.51;
-    jump List.742 #Derived_gen.51 #Derived_gen.52 #Derived_gen.53 #Derived_gen.54 #Derived_gen.55;
+    inc #Derived_gen.52;
+    jump List.742 #Derived_gen.52 #Derived_gen.53 #Derived_gen.54 #Derived_gen.55 #Derived_gen.56;
 
-procedure List.102 (#Derived_gen.23, #Derived_gen.24, #Derived_gen.25, #Derived_gen.26, #Derived_gen.27):
+procedure List.102 (#Derived_gen.27, #Derived_gen.28, #Derived_gen.29, #Derived_gen.30, #Derived_gen.31):
     joinpoint List.717 List.184 List.185 List.186 List.187 List.188:
         let List.719 : Int1 = CallByName Num.22 List.187 List.188;
         if List.719 then
@@ -950,8 +950,8 @@ procedure List.102 (#Derived_gen.23, #Derived_gen.24, #Derived_gen.25, #Derived_
             dec List.184;
             ret List.185;
     in
-    inc #Derived_gen.23;
-    jump List.717 #Derived_gen.23 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27;
+    inc #Derived_gen.27;
+    jump List.717 #Derived_gen.27 #Derived_gen.28 #Derived_gen.29 #Derived_gen.30 #Derived_gen.31;
 
 procedure List.11 (List.150, List.151):
     let List.737 : List {U32, U32} = CallByName List.68 List.151;
@@ -1054,7 +1054,7 @@ procedure List.83 (List.181, List.182, List.183):
     let List.714 : List {U32, U32} = CallByName List.102 List.181 List.182 List.183 List.715 List.716;
     ret List.714;
 
-procedure List.99 (#Derived_gen.20, #Derived_gen.21, #Derived_gen.22):
+procedure List.99 (#Derived_gen.24, #Derived_gen.25, #Derived_gen.26):
     joinpoint List.726 List.152 List.153 List.154:
         let List.734 : U64 = 0i64;
         let List.728 : Int1 = CallByName Num.24 List.153 List.734;
@@ -1066,7 +1066,7 @@ procedure List.99 (#Derived_gen.20, #Derived_gen.21, #Derived_gen.22):
         else
             ret List.154;
     in
-    jump List.726 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22;
+    jump List.726 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26;
 
 procedure Num.131 (#Attr.2):
     let Num.291 : U32 = lowlevel NumIntCast #Attr.2;
@@ -1208,185 +1208,185 @@ procedure Num.96 (#Attr.2):
     ret Num.440;
 
 procedure Str.12 (#Attr.2):
-    let Str.248 : List U8 = lowlevel StrToUtf8 #Attr.2;
-    ret Str.248;
+    let Str.380 : List U8 = lowlevel StrToUtf8 #Attr.2;
+    ret Str.380;
 
 procedure Str.20 (#Attr.2):
-    let Str.316 : Str = lowlevel StrWithCapacity #Attr.2;
-    ret Str.316;
+    let Str.448 : Str = lowlevel StrWithCapacity #Attr.2;
+    ret Str.448;
 
 procedure Str.3 (#Attr.2, #Attr.3):
-    let Str.249 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
-    ret Str.249;
+    let Str.381 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.381;
 
 procedure Str.35 (#Attr.2, #Attr.3):
-    let Str.306 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
-    ret Str.306;
+    let Str.438 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
+    ret Str.438;
 
 procedure Str.36 (#Attr.2):
-    let Str.269 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
-    ret Str.269;
+    let Str.401 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
+    ret Str.401;
 
 procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
-    let Str.267 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
-    ret Str.267;
+    let Str.399 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
+    ret Str.399;
 
-procedure Str.38 (Str.112, Str.113):
-    let Str.263 : [C , C U64] = CallByName Str.57 Str.112 Str.113;
-    let Str.276 : U8 = 1i64;
-    let Str.277 : U8 = GetTagId Str.263;
-    let Str.278 : Int1 = lowlevel Eq Str.276 Str.277;
-    if Str.278 then
-        let Str.114 : U64 = UnionAtIndex (Id 1) (Index 0) Str.263;
-        let Str.272 : U64 = CallByName Str.36 Str.112;
-        let Str.273 : U64 = CallByName Str.36 Str.113;
-        let Str.271 : U64 = CallByName Num.20 Str.272 Str.273;
-        let Str.115 : U64 = CallByName Num.20 Str.271 Str.114;
-        let Str.270 : U64 = 0i64;
-        inc Str.112;
-        let Str.116 : Str = CallByName Str.37 Str.112 Str.270 Str.114;
-        let Str.268 : U64 = CallByName Str.36 Str.113;
-        let Str.266 : U64 = CallByName Num.51 Str.114 Str.268;
-        let Str.117 : Str = CallByName Str.37 Str.112 Str.266 Str.115;
-        let Str.265 : {Str, Str} = Struct {Str.117, Str.116};
-        let Str.264 : [C {}, C {Str, Str}] = TagId(1) Str.265;
-        ret Str.264;
+procedure Str.38 (Str.210, Str.211):
+    let Str.395 : [C , C U64] = CallByName Str.62 Str.210 Str.211;
+    let Str.408 : U8 = 1i64;
+    let Str.409 : U8 = GetTagId Str.395;
+    let Str.410 : Int1 = lowlevel Eq Str.408 Str.409;
+    if Str.410 then
+        let Str.212 : U64 = UnionAtIndex (Id 1) (Index 0) Str.395;
+        let Str.404 : U64 = CallByName Str.36 Str.210;
+        let Str.405 : U64 = CallByName Str.36 Str.211;
+        let Str.403 : U64 = CallByName Num.20 Str.404 Str.405;
+        let Str.213 : U64 = CallByName Num.20 Str.403 Str.212;
+        let Str.402 : U64 = 0i64;
+        inc Str.210;
+        let Str.214 : Str = CallByName Str.37 Str.210 Str.402 Str.212;
+        let Str.400 : U64 = CallByName Str.36 Str.211;
+        let Str.398 : U64 = CallByName Num.51 Str.212 Str.400;
+        let Str.215 : Str = CallByName Str.37 Str.210 Str.398 Str.213;
+        let Str.397 : {Str, Str} = Struct {Str.215, Str.214};
+        let Str.396 : [C {}, C {Str, Str}] = TagId(1) Str.397;
+        ret Str.396;
     else
-        dec Str.112;
-        let Str.275 : {} = Struct {};
-        let Str.274 : [C {}, C {Str, Str}] = TagId(0) Str.275;
-        ret Str.274;
+        dec Str.210;
+        let Str.407 : {} = Struct {};
+        let Str.406 : [C {}, C {Str, Str}] = TagId(0) Str.407;
+        ret Str.406;
 
-procedure Str.45 (Str.91, Str.92, Str.93):
-    inc Str.91;
-    let Str.344 : [C {}, C {Str, Str}] = CallByName Str.38 Str.91 Str.92;
-    let Str.352 : U8 = 1i64;
-    let Str.353 : U8 = GetTagId Str.344;
-    let Str.354 : Int1 = lowlevel Eq Str.352 Str.353;
-    if Str.354 then
-        let Str.351 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.344;
-        let Str.95 : Str = StructAtIndex 0 Str.351;
-        let Str.94 : Str = StructAtIndex 1 Str.351;
-        let Str.349 : U64 = CallByName Str.36 Str.91;
-        dec Str.91;
-        let Str.348 : Str = CallByName Str.20 Str.349;
-        let Str.347 : Str = CallByName Str.3 Str.348 Str.94;
-        dec Str.94;
-        let Str.346 : Str = CallByName Str.3 Str.347 Str.93;
-        let Str.345 : Str = CallByName Str.56 Str.346 Str.95 Str.92 Str.93;
-        ret Str.345;
+procedure Str.45 (Str.189, Str.190, Str.191):
+    inc Str.189;
+    let Str.476 : [C {}, C {Str, Str}] = CallByName Str.38 Str.189 Str.190;
+    let Str.484 : U8 = 1i64;
+    let Str.485 : U8 = GetTagId Str.476;
+    let Str.486 : Int1 = lowlevel Eq Str.484 Str.485;
+    if Str.486 then
+        let Str.483 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.476;
+        let Str.193 : Str = StructAtIndex 0 Str.483;
+        let Str.192 : Str = StructAtIndex 1 Str.483;
+        let Str.481 : U64 = CallByName Str.36 Str.189;
+        dec Str.189;
+        let Str.480 : Str = CallByName Str.20 Str.481;
+        let Str.479 : Str = CallByName Str.3 Str.480 Str.192;
+        dec Str.192;
+        let Str.478 : Str = CallByName Str.3 Str.479 Str.191;
+        let Str.477 : Str = CallByName Str.61 Str.478 Str.193 Str.190 Str.191;
+        ret Str.477;
     else
-        dec Str.344;
-        ret Str.91;
+        dec Str.476;
+        ret Str.189;
 
-procedure Str.56 (#Derived_gen.56, #Derived_gen.57, #Derived_gen.58, #Derived_gen.59):
-    joinpoint Str.253 Str.96 Str.97 Str.98 Str.99:
-        inc Str.97;
-        let Str.254 : [C {}, C {Str, Str}] = CallByName Str.38 Str.97 Str.98;
-        let Str.260 : U8 = 1i64;
-        let Str.261 : U8 = GetTagId Str.254;
-        let Str.262 : Int1 = lowlevel Eq Str.260 Str.261;
-        if Str.262 then
-            dec Str.97;
-            let Str.259 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.254;
-            let Str.101 : Str = StructAtIndex 0 Str.259;
-            let Str.100 : Str = StructAtIndex 1 Str.259;
-            let Str.257 : Str = CallByName Str.3 Str.96 Str.100;
-            dec Str.100;
-            let Str.256 : Str = CallByName Str.3 Str.257 Str.99;
-            jump Str.253 Str.256 Str.101 Str.98 Str.99;
+procedure Str.61 (#Derived_gen.61, #Derived_gen.62, #Derived_gen.63, #Derived_gen.64):
+    joinpoint Str.385 Str.194 Str.195 Str.196 Str.197:
+        inc Str.195;
+        let Str.386 : [C {}, C {Str, Str}] = CallByName Str.38 Str.195 Str.196;
+        let Str.392 : U8 = 1i64;
+        let Str.393 : U8 = GetTagId Str.386;
+        let Str.394 : Int1 = lowlevel Eq Str.392 Str.393;
+        if Str.394 then
+            dec Str.195;
+            let Str.391 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.386;
+            let Str.199 : Str = StructAtIndex 0 Str.391;
+            let Str.198 : Str = StructAtIndex 1 Str.391;
+            let Str.389 : Str = CallByName Str.3 Str.194 Str.198;
+            dec Str.198;
+            let Str.388 : Str = CallByName Str.3 Str.389 Str.197;
+            jump Str.385 Str.388 Str.199 Str.196 Str.197;
         else
-            dec Str.98;
-            dec Str.99;
-            dec Str.254;
-            let Str.258 : Str = CallByName Str.3 Str.96 Str.97;
-            dec Str.97;
-            ret Str.258;
+            dec Str.386;
+            dec Str.196;
+            dec Str.197;
+            let Str.390 : Str = CallByName Str.3 Str.194 Str.195;
+            dec Str.195;
+            ret Str.390;
     in
-    inc #Derived_gen.58;
-    inc #Derived_gen.59;
-    jump Str.253 #Derived_gen.56 #Derived_gen.57 #Derived_gen.58 #Derived_gen.59;
+    inc #Derived_gen.63;
+    inc #Derived_gen.64;
+    jump Str.385 #Derived_gen.61 #Derived_gen.62 #Derived_gen.63 #Derived_gen.64;
 
-procedure Str.57 (Str.121, Str.122):
-    let Str.123 : U64 = CallByName Str.36 Str.121;
-    let Str.124 : U64 = CallByName Str.36 Str.122;
-    let Str.125 : U64 = CallByName Num.77 Str.123 Str.124;
-    let Str.280 : U64 = 0i64;
-    let Str.279 : [C , C U64] = CallByName Str.58 Str.121 Str.122 Str.280 Str.125;
-    ret Str.279;
+procedure Str.62 (Str.219, Str.220):
+    let Str.221 : U64 = CallByName Str.36 Str.219;
+    let Str.222 : U64 = CallByName Str.36 Str.220;
+    let Str.223 : U64 = CallByName Num.77 Str.221 Str.222;
+    let Str.412 : U64 = 0i64;
+    let Str.411 : [C , C U64] = CallByName Str.63 Str.219 Str.220 Str.412 Str.223;
+    ret Str.411;
 
-procedure Str.58 (#Derived_gen.33, #Derived_gen.34, #Derived_gen.35, #Derived_gen.36):
-    joinpoint Str.281 Str.126 Str.127 Str.128 Str.129:
-        let Str.283 : Int1 = CallByName Num.23 Str.128 Str.129;
-        if Str.283 then
-            let Str.287 : Int1 = CallByName Str.62 Str.126 Str.128 Str.127;
-            if Str.287 then
-                dec Str.127;
-                dec Str.126;
-                let Str.288 : [C , C U64] = TagId(1) Str.128;
-                ret Str.288;
+procedure Str.63 (#Derived_gen.4, #Derived_gen.5, #Derived_gen.6, #Derived_gen.7):
+    joinpoint Str.413 Str.224 Str.225 Str.226 Str.227:
+        let Str.415 : Int1 = CallByName Num.23 Str.226 Str.227;
+        if Str.415 then
+            let Str.419 : Int1 = CallByName Str.67 Str.224 Str.226 Str.225;
+            if Str.419 then
+                dec Str.224;
+                dec Str.225;
+                let Str.420 : [C , C U64] = TagId(1) Str.226;
+                ret Str.420;
             else
-                let Str.286 : U64 = 1i64;
-                let Str.285 : U64 = CallByName Num.51 Str.128 Str.286;
-                jump Str.281 Str.126 Str.127 Str.285 Str.129;
+                let Str.418 : U64 = 1i64;
+                let Str.417 : U64 = CallByName Num.51 Str.226 Str.418;
+                jump Str.413 Str.224 Str.225 Str.417 Str.227;
         else
-            dec Str.127;
-            dec Str.126;
-            let Str.282 : [C , C U64] = TagId(0) ;
-            ret Str.282;
+            dec Str.224;
+            dec Str.225;
+            let Str.414 : [C , C U64] = TagId(0) ;
+            ret Str.414;
     in
-    inc #Derived_gen.34;
-    inc #Derived_gen.33;
-    jump Str.281 #Derived_gen.33 #Derived_gen.34 #Derived_gen.35 #Derived_gen.36;
+    inc #Derived_gen.5;
+    inc #Derived_gen.4;
+    jump Str.413 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7;
 
-procedure Str.61 (Str.152, Str.153):
-    let Str.311 : Int1 = CallByName Num.22 Str.152 Str.153;
-    if Str.311 then
-        ret Str.152;
+procedure Str.66 (Str.250, Str.251):
+    let Str.443 : Int1 = CallByName Num.22 Str.250 Str.251;
+    if Str.443 then
+        ret Str.250;
     else
-        ret Str.153;
+        ret Str.251;
 
-procedure Str.62 (Str.154, Str.155, Str.156):
-    let Str.157 : U64 = CallByName Str.36 Str.154;
-    let Str.158 : U64 = CallByName Str.36 Str.156;
-    let Str.309 : U64 = CallByName Num.53 Str.155 Str.158;
-    let Str.159 : U64 = CallByName Str.61 Str.309 Str.157;
-    let Str.308 : U64 = 0i64;
-    inc Str.156;
-    inc Str.154;
-    let Str.290 : {U64, Str, U64, Str, U64, U64} = Struct {Str.159, Str.154, Str.155, Str.156, Str.308, Str.158};
-    let Str.289 : Int1 = CallByName Str.63 Str.290;
-    ret Str.289;
+procedure Str.67 (Str.252, Str.253, Str.254):
+    let Str.255 : U64 = CallByName Str.36 Str.252;
+    let Str.256 : U64 = CallByName Str.36 Str.254;
+    let Str.441 : U64 = CallByName Num.53 Str.253 Str.256;
+    let Str.257 : U64 = CallByName Str.66 Str.441 Str.255;
+    let Str.440 : U64 = 0i64;
+    inc Str.252;
+    inc Str.254;
+    let Str.422 : {U64, Str, U64, Str, U64, U64} = Struct {Str.257, Str.252, Str.253, Str.254, Str.440, Str.256};
+    let Str.421 : Int1 = CallByName Str.68 Str.422;
+    ret Str.421;
 
-procedure Str.63 (Str.160):
-    let Str.166 : U64 = StructAtIndex 0 Str.160;
-    let Str.161 : Str = StructAtIndex 1 Str.160;
-    let Str.162 : U64 = StructAtIndex 2 Str.160;
-    let Str.163 : Str = StructAtIndex 3 Str.160;
-    let Str.164 : U64 = StructAtIndex 4 Str.160;
-    let Str.165 : U64 = StructAtIndex 5 Str.160;
-    let Str.167 : Int1 = CallByName Num.25 Str.162 Str.166;
-    if Str.167 then
-        dec Str.163;
-        dec Str.161;
-        let Str.168 : Int1 = CallByName Bool.11 Str.164 Str.165;
-        ret Str.168;
+procedure Str.68 (Str.258):
+    let Str.264 : U64 = StructAtIndex 0 Str.258;
+    let Str.259 : Str = StructAtIndex 1 Str.258;
+    let Str.260 : U64 = StructAtIndex 2 Str.258;
+    let Str.261 : Str = StructAtIndex 3 Str.258;
+    let Str.262 : U64 = StructAtIndex 4 Str.258;
+    let Str.263 : U64 = StructAtIndex 5 Str.258;
+    let Str.265 : Int1 = CallByName Num.25 Str.260 Str.264;
+    if Str.265 then
+        dec Str.259;
+        dec Str.261;
+        let Str.266 : Int1 = CallByName Bool.11 Str.262 Str.263;
+        ret Str.266;
     else
-        let Str.304 : U8 = CallByName Str.35 Str.161 Str.162;
-        let Str.305 : U8 = CallByName Str.35 Str.163 Str.164;
-        let Str.169 : Int1 = CallByName Bool.11 Str.304 Str.305;
-        let Str.294 : U64 = StructAtIndex 0 Str.160;
-        let Str.295 : Str = StructAtIndex 1 Str.160;
-        let Str.297 : Str = StructAtIndex 3 Str.160;
-        let Str.299 : U64 = StructAtIndex 5 Str.160;
-        let Str.303 : U64 = 1i64;
-        let Str.301 : U64 = CallByName Num.51 Str.164 Str.303;
-        let Str.302 : U64 = 1i64;
-        let Str.300 : U64 = CallByName Num.51 Str.162 Str.302;
-        let Str.293 : {U64, Str, U64, Str, U64, U64} = Struct {Str.294, Str.295, Str.300, Str.297, Str.301, Str.299};
-        let Str.170 : Int1 = CallByName Str.63 Str.293;
-        let Str.292 : Int1 = CallByName Bool.3 Str.169 Str.170;
-        ret Str.292;
+        let Str.436 : U8 = CallByName Str.35 Str.259 Str.260;
+        let Str.437 : U8 = CallByName Str.35 Str.261 Str.262;
+        let Str.267 : Int1 = CallByName Bool.11 Str.436 Str.437;
+        let Str.426 : U64 = StructAtIndex 0 Str.258;
+        let Str.427 : Str = StructAtIndex 1 Str.258;
+        let Str.429 : Str = StructAtIndex 3 Str.258;
+        let Str.431 : U64 = StructAtIndex 5 Str.258;
+        let Str.435 : U64 = 1i64;
+        let Str.433 : U64 = CallByName Num.51 Str.262 Str.435;
+        let Str.434 : U64 = 1i64;
+        let Str.432 : U64 = CallByName Num.51 Str.260 Str.434;
+        let Str.425 : {U64, Str, U64, Str, U64, U64} = Struct {Str.426, Str.427, Str.432, Str.429, Str.433, Str.431};
+        let Str.268 : Int1 = CallByName Str.68 Str.425;
+        let Str.424 : Int1 = CallByName Bool.3 Str.267 Str.268;
+        ret Str.424;
 
 procedure Test.0 ():
     let Test.8 : Str = "a";
diff --git a/crates/compiler/test_mono/generated/inspect_derived_list.txt b/crates/compiler/test_mono/generated/inspect_derived_list.txt
index 8fc98930c4..4d5a404741 100644
--- a/crates/compiler/test_mono/generated/inspect_derived_list.txt
+++ b/crates/compiler/test_mono/generated/inspect_derived_list.txt
@@ -163,8 +163,8 @@ procedure Num.96 (#Attr.2):
     ret Num.283;
 
 procedure Str.3 (#Attr.2, #Attr.3):
-    let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
-    ret Str.246;
+    let Str.378 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.378;
 
 procedure Test.0 ():
     let Test.2 : List I64 = Array [1i64, 2i64, 3i64];
diff --git a/crates/compiler/test_mono/generated/inspect_derived_nested_record_string.txt b/crates/compiler/test_mono/generated/inspect_derived_nested_record_string.txt
index 25343efbcc..5da14f45dc 100644
--- a/crates/compiler/test_mono/generated/inspect_derived_nested_record_string.txt
+++ b/crates/compiler/test_mono/generated/inspect_derived_nested_record_string.txt
@@ -252,7 +252,7 @@ procedure List.101 (#Derived_gen.20, #Derived_gen.21, #Derived_gen.22, #Derived_
     inc #Derived_gen.20;
     jump List.678 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23 #Derived_gen.24;
 
-procedure List.101 (#Derived_gen.39, #Derived_gen.40, #Derived_gen.41, #Derived_gen.42, #Derived_gen.43):
+procedure List.101 (#Derived_gen.36, #Derived_gen.37, #Derived_gen.38, #Derived_gen.39, #Derived_gen.40):
     joinpoint List.690 List.175 List.176 List.177 List.178 List.179:
         let List.692 : Int1 = CallByName Num.22 List.178 List.179;
         if List.692 then
@@ -266,8 +266,8 @@ procedure List.101 (#Derived_gen.39, #Derived_gen.40, #Derived_gen.41, #Derived_
             dec List.175;
             ret List.176;
     in
-    inc #Derived_gen.39;
-    jump List.690 #Derived_gen.39 #Derived_gen.40 #Derived_gen.41 #Derived_gen.42 #Derived_gen.43;
+    inc #Derived_gen.36;
+    jump List.690 #Derived_gen.36 #Derived_gen.37 #Derived_gen.38 #Derived_gen.39 #Derived_gen.40;
 
 procedure List.18 (List.172, List.173, List.174):
     let List.676 : U64 = 0i64;
@@ -326,181 +326,181 @@ procedure Num.77 (#Attr.2, #Attr.3):
     ret Num.295;
 
 procedure Str.20 (#Attr.2):
-    let Str.314 : Str = lowlevel StrWithCapacity #Attr.2;
-    ret Str.314;
+    let Str.446 : Str = lowlevel StrWithCapacity #Attr.2;
+    ret Str.446;
 
 procedure Str.3 (#Attr.2, #Attr.3):
-    let Str.247 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
-    ret Str.247;
+    let Str.379 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.379;
 
 procedure Str.35 (#Attr.2, #Attr.3):
-    let Str.304 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
-    ret Str.304;
+    let Str.436 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
+    ret Str.436;
 
 procedure Str.36 (#Attr.2):
-    let Str.267 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
-    ret Str.267;
+    let Str.399 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
+    ret Str.399;
 
 procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
-    let Str.265 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
-    ret Str.265;
+    let Str.397 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
+    ret Str.397;
 
-procedure Str.38 (Str.112, Str.113):
-    let Str.261 : [C , C U64] = CallByName Str.57 Str.112 Str.113;
-    let Str.274 : U8 = 1i64;
-    let Str.275 : U8 = GetTagId Str.261;
-    let Str.276 : Int1 = lowlevel Eq Str.274 Str.275;
-    if Str.276 then
-        let Str.114 : U64 = UnionAtIndex (Id 1) (Index 0) Str.261;
-        let Str.270 : U64 = CallByName Str.36 Str.112;
-        let Str.271 : U64 = CallByName Str.36 Str.113;
-        let Str.269 : U64 = CallByName Num.20 Str.270 Str.271;
-        let Str.115 : U64 = CallByName Num.20 Str.269 Str.114;
-        let Str.268 : U64 = 0i64;
-        inc Str.112;
-        let Str.116 : Str = CallByName Str.37 Str.112 Str.268 Str.114;
-        let Str.266 : U64 = CallByName Str.36 Str.113;
-        let Str.264 : U64 = CallByName Num.51 Str.114 Str.266;
-        let Str.117 : Str = CallByName Str.37 Str.112 Str.264 Str.115;
-        let Str.263 : {Str, Str} = Struct {Str.117, Str.116};
-        let Str.262 : [C {}, C {Str, Str}] = TagId(1) Str.263;
-        ret Str.262;
+procedure Str.38 (Str.210, Str.211):
+    let Str.393 : [C , C U64] = CallByName Str.62 Str.210 Str.211;
+    let Str.406 : U8 = 1i64;
+    let Str.407 : U8 = GetTagId Str.393;
+    let Str.408 : Int1 = lowlevel Eq Str.406 Str.407;
+    if Str.408 then
+        let Str.212 : U64 = UnionAtIndex (Id 1) (Index 0) Str.393;
+        let Str.402 : U64 = CallByName Str.36 Str.210;
+        let Str.403 : U64 = CallByName Str.36 Str.211;
+        let Str.401 : U64 = CallByName Num.20 Str.402 Str.403;
+        let Str.213 : U64 = CallByName Num.20 Str.401 Str.212;
+        let Str.400 : U64 = 0i64;
+        inc Str.210;
+        let Str.214 : Str = CallByName Str.37 Str.210 Str.400 Str.212;
+        let Str.398 : U64 = CallByName Str.36 Str.211;
+        let Str.396 : U64 = CallByName Num.51 Str.212 Str.398;
+        let Str.215 : Str = CallByName Str.37 Str.210 Str.396 Str.213;
+        let Str.395 : {Str, Str} = Struct {Str.215, Str.214};
+        let Str.394 : [C {}, C {Str, Str}] = TagId(1) Str.395;
+        ret Str.394;
     else
-        dec Str.112;
-        let Str.273 : {} = Struct {};
-        let Str.272 : [C {}, C {Str, Str}] = TagId(0) Str.273;
-        ret Str.272;
+        dec Str.210;
+        let Str.405 : {} = Struct {};
+        let Str.404 : [C {}, C {Str, Str}] = TagId(0) Str.405;
+        ret Str.404;
 
-procedure Str.45 (Str.91, Str.92, Str.93):
-    inc Str.91;
-    let Str.342 : [C {}, C {Str, Str}] = CallByName Str.38 Str.91 Str.92;
-    let Str.350 : U8 = 1i64;
-    let Str.351 : U8 = GetTagId Str.342;
-    let Str.352 : Int1 = lowlevel Eq Str.350 Str.351;
-    if Str.352 then
-        let Str.349 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.342;
-        let Str.95 : Str = StructAtIndex 0 Str.349;
-        let Str.94 : Str = StructAtIndex 1 Str.349;
-        let Str.347 : U64 = CallByName Str.36 Str.91;
-        dec Str.91;
-        let Str.346 : Str = CallByName Str.20 Str.347;
-        let Str.345 : Str = CallByName Str.3 Str.346 Str.94;
-        dec Str.94;
-        let Str.344 : Str = CallByName Str.3 Str.345 Str.93;
-        let Str.343 : Str = CallByName Str.56 Str.344 Str.95 Str.92 Str.93;
-        ret Str.343;
+procedure Str.45 (Str.189, Str.190, Str.191):
+    inc Str.189;
+    let Str.474 : [C {}, C {Str, Str}] = CallByName Str.38 Str.189 Str.190;
+    let Str.482 : U8 = 1i64;
+    let Str.483 : U8 = GetTagId Str.474;
+    let Str.484 : Int1 = lowlevel Eq Str.482 Str.483;
+    if Str.484 then
+        let Str.481 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.474;
+        let Str.193 : Str = StructAtIndex 0 Str.481;
+        let Str.192 : Str = StructAtIndex 1 Str.481;
+        let Str.479 : U64 = CallByName Str.36 Str.189;
+        dec Str.189;
+        let Str.478 : Str = CallByName Str.20 Str.479;
+        let Str.477 : Str = CallByName Str.3 Str.478 Str.192;
+        dec Str.192;
+        let Str.476 : Str = CallByName Str.3 Str.477 Str.191;
+        let Str.475 : Str = CallByName Str.61 Str.476 Str.193 Str.190 Str.191;
+        ret Str.475;
     else
-        dec Str.342;
-        ret Str.91;
+        dec Str.474;
+        ret Str.189;
 
-procedure Str.56 (#Derived_gen.27, #Derived_gen.28, #Derived_gen.29, #Derived_gen.30):
-    joinpoint Str.251 Str.96 Str.97 Str.98 Str.99:
-        inc Str.97;
-        let Str.252 : [C {}, C {Str, Str}] = CallByName Str.38 Str.97 Str.98;
-        let Str.258 : U8 = 1i64;
-        let Str.259 : U8 = GetTagId Str.252;
-        let Str.260 : Int1 = lowlevel Eq Str.258 Str.259;
-        if Str.260 then
-            dec Str.97;
-            let Str.257 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.252;
-            let Str.101 : Str = StructAtIndex 0 Str.257;
-            let Str.100 : Str = StructAtIndex 1 Str.257;
-            let Str.255 : Str = CallByName Str.3 Str.96 Str.100;
-            dec Str.100;
-            let Str.254 : Str = CallByName Str.3 Str.255 Str.99;
-            jump Str.251 Str.254 Str.101 Str.98 Str.99;
+procedure Str.61 (#Derived_gen.41, #Derived_gen.42, #Derived_gen.43, #Derived_gen.44):
+    joinpoint Str.383 Str.194 Str.195 Str.196 Str.197:
+        inc Str.195;
+        let Str.384 : [C {}, C {Str, Str}] = CallByName Str.38 Str.195 Str.196;
+        let Str.390 : U8 = 1i64;
+        let Str.391 : U8 = GetTagId Str.384;
+        let Str.392 : Int1 = lowlevel Eq Str.390 Str.391;
+        if Str.392 then
+            dec Str.195;
+            let Str.389 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.384;
+            let Str.199 : Str = StructAtIndex 0 Str.389;
+            let Str.198 : Str = StructAtIndex 1 Str.389;
+            let Str.387 : Str = CallByName Str.3 Str.194 Str.198;
+            dec Str.198;
+            let Str.386 : Str = CallByName Str.3 Str.387 Str.197;
+            jump Str.383 Str.386 Str.199 Str.196 Str.197;
         else
-            dec Str.98;
-            dec Str.252;
-            dec Str.99;
-            let Str.256 : Str = CallByName Str.3 Str.96 Str.97;
-            dec Str.97;
-            ret Str.256;
+            dec Str.384;
+            dec Str.196;
+            dec Str.197;
+            let Str.388 : Str = CallByName Str.3 Str.194 Str.195;
+            dec Str.195;
+            ret Str.388;
     in
-    inc #Derived_gen.29;
-    inc #Derived_gen.30;
-    jump Str.251 #Derived_gen.27 #Derived_gen.28 #Derived_gen.29 #Derived_gen.30;
+    inc #Derived_gen.44;
+    inc #Derived_gen.43;
+    jump Str.383 #Derived_gen.41 #Derived_gen.42 #Derived_gen.43 #Derived_gen.44;
 
-procedure Str.57 (Str.121, Str.122):
-    let Str.123 : U64 = CallByName Str.36 Str.121;
-    let Str.124 : U64 = CallByName Str.36 Str.122;
-    let Str.125 : U64 = CallByName Num.77 Str.123 Str.124;
-    let Str.278 : U64 = 0i64;
-    let Str.277 : [C , C U64] = CallByName Str.58 Str.121 Str.122 Str.278 Str.125;
-    ret Str.277;
+procedure Str.62 (Str.219, Str.220):
+    let Str.221 : U64 = CallByName Str.36 Str.219;
+    let Str.222 : U64 = CallByName Str.36 Str.220;
+    let Str.223 : U64 = CallByName Num.77 Str.221 Str.222;
+    let Str.410 : U64 = 0i64;
+    let Str.409 : [C , C U64] = CallByName Str.63 Str.219 Str.220 Str.410 Str.223;
+    ret Str.409;
 
-procedure Str.58 (#Derived_gen.33, #Derived_gen.34, #Derived_gen.35, #Derived_gen.36):
-    joinpoint Str.279 Str.126 Str.127 Str.128 Str.129:
-        let Str.281 : Int1 = CallByName Num.23 Str.128 Str.129;
-        if Str.281 then
-            let Str.285 : Int1 = CallByName Str.62 Str.126 Str.128 Str.127;
-            if Str.285 then
-                dec Str.127;
-                dec Str.126;
-                let Str.286 : [C , C U64] = TagId(1) Str.128;
-                ret Str.286;
+procedure Str.63 (#Derived_gen.25, #Derived_gen.26, #Derived_gen.27, #Derived_gen.28):
+    joinpoint Str.411 Str.224 Str.225 Str.226 Str.227:
+        let Str.413 : Int1 = CallByName Num.23 Str.226 Str.227;
+        if Str.413 then
+            let Str.417 : Int1 = CallByName Str.67 Str.224 Str.226 Str.225;
+            if Str.417 then
+                dec Str.224;
+                dec Str.225;
+                let Str.418 : [C , C U64] = TagId(1) Str.226;
+                ret Str.418;
             else
-                let Str.284 : U64 = 1i64;
-                let Str.283 : U64 = CallByName Num.51 Str.128 Str.284;
-                jump Str.279 Str.126 Str.127 Str.283 Str.129;
+                let Str.416 : U64 = 1i64;
+                let Str.415 : U64 = CallByName Num.51 Str.226 Str.416;
+                jump Str.411 Str.224 Str.225 Str.415 Str.227;
         else
-            dec Str.127;
-            dec Str.126;
-            let Str.280 : [C , C U64] = TagId(0) ;
-            ret Str.280;
+            dec Str.224;
+            dec Str.225;
+            let Str.412 : [C , C U64] = TagId(0) ;
+            ret Str.412;
     in
-    inc #Derived_gen.34;
-    inc #Derived_gen.33;
-    jump Str.279 #Derived_gen.33 #Derived_gen.34 #Derived_gen.35 #Derived_gen.36;
+    inc #Derived_gen.25;
+    inc #Derived_gen.26;
+    jump Str.411 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28;
 
-procedure Str.61 (Str.152, Str.153):
-    let Str.309 : Int1 = CallByName Num.22 Str.152 Str.153;
-    if Str.309 then
-        ret Str.152;
+procedure Str.66 (Str.250, Str.251):
+    let Str.441 : Int1 = CallByName Num.22 Str.250 Str.251;
+    if Str.441 then
+        ret Str.250;
     else
-        ret Str.153;
+        ret Str.251;
 
-procedure Str.62 (Str.154, Str.155, Str.156):
-    let Str.157 : U64 = CallByName Str.36 Str.154;
-    let Str.158 : U64 = CallByName Str.36 Str.156;
-    let Str.307 : U64 = CallByName Num.53 Str.155 Str.158;
-    let Str.159 : U64 = CallByName Str.61 Str.307 Str.157;
-    let Str.306 : U64 = 0i64;
-    inc Str.156;
-    inc Str.154;
-    let Str.288 : {U64, Str, U64, Str, U64, U64} = Struct {Str.159, Str.154, Str.155, Str.156, Str.306, Str.158};
-    let Str.287 : Int1 = CallByName Str.63 Str.288;
-    ret Str.287;
+procedure Str.67 (Str.252, Str.253, Str.254):
+    let Str.255 : U64 = CallByName Str.36 Str.252;
+    let Str.256 : U64 = CallByName Str.36 Str.254;
+    let Str.439 : U64 = CallByName Num.53 Str.253 Str.256;
+    let Str.257 : U64 = CallByName Str.66 Str.439 Str.255;
+    let Str.438 : U64 = 0i64;
+    inc Str.252;
+    inc Str.254;
+    let Str.420 : {U64, Str, U64, Str, U64, U64} = Struct {Str.257, Str.252, Str.253, Str.254, Str.438, Str.256};
+    let Str.419 : Int1 = CallByName Str.68 Str.420;
+    ret Str.419;
 
-procedure Str.63 (Str.160):
-    let Str.166 : U64 = StructAtIndex 0 Str.160;
-    let Str.161 : Str = StructAtIndex 1 Str.160;
-    let Str.162 : U64 = StructAtIndex 2 Str.160;
-    let Str.163 : Str = StructAtIndex 3 Str.160;
-    let Str.164 : U64 = StructAtIndex 4 Str.160;
-    let Str.165 : U64 = StructAtIndex 5 Str.160;
-    let Str.167 : Int1 = CallByName Num.25 Str.162 Str.166;
-    if Str.167 then
-        dec Str.163;
-        dec Str.161;
-        let Str.168 : Int1 = CallByName Bool.11 Str.164 Str.165;
-        ret Str.168;
+procedure Str.68 (Str.258):
+    let Str.264 : U64 = StructAtIndex 0 Str.258;
+    let Str.259 : Str = StructAtIndex 1 Str.258;
+    let Str.260 : U64 = StructAtIndex 2 Str.258;
+    let Str.261 : Str = StructAtIndex 3 Str.258;
+    let Str.262 : U64 = StructAtIndex 4 Str.258;
+    let Str.263 : U64 = StructAtIndex 5 Str.258;
+    let Str.265 : Int1 = CallByName Num.25 Str.260 Str.264;
+    if Str.265 then
+        dec Str.259;
+        dec Str.261;
+        let Str.266 : Int1 = CallByName Bool.11 Str.262 Str.263;
+        ret Str.266;
     else
-        let Str.302 : U8 = CallByName Str.35 Str.161 Str.162;
-        let Str.303 : U8 = CallByName Str.35 Str.163 Str.164;
-        let Str.169 : Int1 = CallByName Bool.11 Str.302 Str.303;
-        let Str.292 : U64 = StructAtIndex 0 Str.160;
-        let Str.293 : Str = StructAtIndex 1 Str.160;
-        let Str.295 : Str = StructAtIndex 3 Str.160;
-        let Str.297 : U64 = StructAtIndex 5 Str.160;
-        let Str.301 : U64 = 1i64;
-        let Str.299 : U64 = CallByName Num.51 Str.164 Str.301;
-        let Str.300 : U64 = 1i64;
-        let Str.298 : U64 = CallByName Num.51 Str.162 Str.300;
-        let Str.291 : {U64, Str, U64, Str, U64, U64} = Struct {Str.292, Str.293, Str.298, Str.295, Str.299, Str.297};
-        let Str.170 : Int1 = CallByName Str.63 Str.291;
-        let Str.290 : Int1 = CallByName Bool.3 Str.169 Str.170;
-        ret Str.290;
+        let Str.434 : U8 = CallByName Str.35 Str.259 Str.260;
+        let Str.435 : U8 = CallByName Str.35 Str.261 Str.262;
+        let Str.267 : Int1 = CallByName Bool.11 Str.434 Str.435;
+        let Str.424 : U64 = StructAtIndex 0 Str.258;
+        let Str.425 : Str = StructAtIndex 1 Str.258;
+        let Str.427 : Str = StructAtIndex 3 Str.258;
+        let Str.429 : U64 = StructAtIndex 5 Str.258;
+        let Str.433 : U64 = 1i64;
+        let Str.431 : U64 = CallByName Num.51 Str.262 Str.433;
+        let Str.432 : U64 = 1i64;
+        let Str.430 : U64 = CallByName Num.51 Str.260 Str.432;
+        let Str.423 : {U64, Str, U64, Str, U64, U64} = Struct {Str.424, Str.425, Str.430, Str.427, Str.431, Str.429};
+        let Str.268 : Int1 = CallByName Str.68 Str.423;
+        let Str.422 : Int1 = CallByName Bool.3 Str.267 Str.268;
+        ret Str.422;
 
 procedure Test.0 ():
     let Test.4 : Str = "bar";
diff --git a/crates/compiler/test_mono/generated/inspect_derived_record.txt b/crates/compiler/test_mono/generated/inspect_derived_record.txt
index 0c7d6db97f..6d706e620a 100644
--- a/crates/compiler/test_mono/generated/inspect_derived_record.txt
+++ b/crates/compiler/test_mono/generated/inspect_derived_record.txt
@@ -198,8 +198,8 @@ procedure Num.96 (#Attr.2):
     ret Num.284;
 
 procedure Str.3 (#Attr.2, #Attr.3):
-    let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
-    ret Str.246;
+    let Str.378 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.378;
 
 procedure Test.0 ():
     let Test.3 : Decimal = 3dec;
diff --git a/crates/compiler/test_mono/generated/inspect_derived_record_one_field_string.txt b/crates/compiler/test_mono/generated/inspect_derived_record_one_field_string.txt
index 8fa307c5a9..eb6447f7b5 100644
--- a/crates/compiler/test_mono/generated/inspect_derived_record_one_field_string.txt
+++ b/crates/compiler/test_mono/generated/inspect_derived_record_one_field_string.txt
@@ -220,181 +220,181 @@ procedure Num.77 (#Attr.2, #Attr.3):
     ret Num.293;
 
 procedure Str.20 (#Attr.2):
-    let Str.313 : Str = lowlevel StrWithCapacity #Attr.2;
-    ret Str.313;
+    let Str.445 : Str = lowlevel StrWithCapacity #Attr.2;
+    ret Str.445;
 
 procedure Str.3 (#Attr.2, #Attr.3):
-    let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
-    ret Str.246;
+    let Str.378 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.378;
 
 procedure Str.35 (#Attr.2, #Attr.3):
-    let Str.303 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
-    ret Str.303;
+    let Str.435 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
+    ret Str.435;
 
 procedure Str.36 (#Attr.2):
-    let Str.266 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
-    ret Str.266;
+    let Str.398 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
+    ret Str.398;
 
 procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
-    let Str.264 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
-    ret Str.264;
+    let Str.396 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
+    ret Str.396;
 
-procedure Str.38 (Str.112, Str.113):
-    let Str.260 : [C , C U64] = CallByName Str.57 Str.112 Str.113;
-    let Str.273 : U8 = 1i64;
-    let Str.274 : U8 = GetTagId Str.260;
-    let Str.275 : Int1 = lowlevel Eq Str.273 Str.274;
-    if Str.275 then
-        let Str.114 : U64 = UnionAtIndex (Id 1) (Index 0) Str.260;
-        let Str.269 : U64 = CallByName Str.36 Str.112;
-        let Str.270 : U64 = CallByName Str.36 Str.113;
-        let Str.268 : U64 = CallByName Num.20 Str.269 Str.270;
-        let Str.115 : U64 = CallByName Num.20 Str.268 Str.114;
-        let Str.267 : U64 = 0i64;
-        inc Str.112;
-        let Str.116 : Str = CallByName Str.37 Str.112 Str.267 Str.114;
-        let Str.265 : U64 = CallByName Str.36 Str.113;
-        let Str.263 : U64 = CallByName Num.51 Str.114 Str.265;
-        let Str.117 : Str = CallByName Str.37 Str.112 Str.263 Str.115;
-        let Str.262 : {Str, Str} = Struct {Str.117, Str.116};
-        let Str.261 : [C {}, C {Str, Str}] = TagId(1) Str.262;
-        ret Str.261;
+procedure Str.38 (Str.210, Str.211):
+    let Str.392 : [C , C U64] = CallByName Str.62 Str.210 Str.211;
+    let Str.405 : U8 = 1i64;
+    let Str.406 : U8 = GetTagId Str.392;
+    let Str.407 : Int1 = lowlevel Eq Str.405 Str.406;
+    if Str.407 then
+        let Str.212 : U64 = UnionAtIndex (Id 1) (Index 0) Str.392;
+        let Str.401 : U64 = CallByName Str.36 Str.210;
+        let Str.402 : U64 = CallByName Str.36 Str.211;
+        let Str.400 : U64 = CallByName Num.20 Str.401 Str.402;
+        let Str.213 : U64 = CallByName Num.20 Str.400 Str.212;
+        let Str.399 : U64 = 0i64;
+        inc Str.210;
+        let Str.214 : Str = CallByName Str.37 Str.210 Str.399 Str.212;
+        let Str.397 : U64 = CallByName Str.36 Str.211;
+        let Str.395 : U64 = CallByName Num.51 Str.212 Str.397;
+        let Str.215 : Str = CallByName Str.37 Str.210 Str.395 Str.213;
+        let Str.394 : {Str, Str} = Struct {Str.215, Str.214};
+        let Str.393 : [C {}, C {Str, Str}] = TagId(1) Str.394;
+        ret Str.393;
     else
-        dec Str.112;
-        let Str.272 : {} = Struct {};
-        let Str.271 : [C {}, C {Str, Str}] = TagId(0) Str.272;
-        ret Str.271;
+        dec Str.210;
+        let Str.404 : {} = Struct {};
+        let Str.403 : [C {}, C {Str, Str}] = TagId(0) Str.404;
+        ret Str.403;
 
-procedure Str.45 (Str.91, Str.92, Str.93):
-    inc Str.91;
-    let Str.341 : [C {}, C {Str, Str}] = CallByName Str.38 Str.91 Str.92;
-    let Str.349 : U8 = 1i64;
-    let Str.350 : U8 = GetTagId Str.341;
-    let Str.351 : Int1 = lowlevel Eq Str.349 Str.350;
-    if Str.351 then
-        let Str.348 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.341;
-        let Str.95 : Str = StructAtIndex 0 Str.348;
-        let Str.94 : Str = StructAtIndex 1 Str.348;
-        let Str.346 : U64 = CallByName Str.36 Str.91;
-        dec Str.91;
-        let Str.345 : Str = CallByName Str.20 Str.346;
-        let Str.344 : Str = CallByName Str.3 Str.345 Str.94;
-        dec Str.94;
-        let Str.343 : Str = CallByName Str.3 Str.344 Str.93;
-        let Str.342 : Str = CallByName Str.56 Str.343 Str.95 Str.92 Str.93;
-        ret Str.342;
+procedure Str.45 (Str.189, Str.190, Str.191):
+    inc Str.189;
+    let Str.473 : [C {}, C {Str, Str}] = CallByName Str.38 Str.189 Str.190;
+    let Str.481 : U8 = 1i64;
+    let Str.482 : U8 = GetTagId Str.473;
+    let Str.483 : Int1 = lowlevel Eq Str.481 Str.482;
+    if Str.483 then
+        let Str.480 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.473;
+        let Str.193 : Str = StructAtIndex 0 Str.480;
+        let Str.192 : Str = StructAtIndex 1 Str.480;
+        let Str.478 : U64 = CallByName Str.36 Str.189;
+        dec Str.189;
+        let Str.477 : Str = CallByName Str.20 Str.478;
+        let Str.476 : Str = CallByName Str.3 Str.477 Str.192;
+        dec Str.192;
+        let Str.475 : Str = CallByName Str.3 Str.476 Str.191;
+        let Str.474 : Str = CallByName Str.61 Str.475 Str.193 Str.190 Str.191;
+        ret Str.474;
     else
-        dec Str.341;
-        ret Str.91;
+        dec Str.473;
+        ret Str.189;
 
-procedure Str.56 (#Derived_gen.24, #Derived_gen.25, #Derived_gen.26, #Derived_gen.27):
-    joinpoint Str.250 Str.96 Str.97 Str.98 Str.99:
-        inc Str.97;
-        let Str.251 : [C {}, C {Str, Str}] = CallByName Str.38 Str.97 Str.98;
-        let Str.257 : U8 = 1i64;
-        let Str.258 : U8 = GetTagId Str.251;
-        let Str.259 : Int1 = lowlevel Eq Str.257 Str.258;
-        if Str.259 then
-            dec Str.97;
-            let Str.256 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.251;
-            let Str.101 : Str = StructAtIndex 0 Str.256;
-            let Str.100 : Str = StructAtIndex 1 Str.256;
-            let Str.254 : Str = CallByName Str.3 Str.96 Str.100;
-            dec Str.100;
-            let Str.253 : Str = CallByName Str.3 Str.254 Str.99;
-            jump Str.250 Str.253 Str.101 Str.98 Str.99;
+procedure Str.61 (#Derived_gen.23, #Derived_gen.24, #Derived_gen.25, #Derived_gen.26):
+    joinpoint Str.382 Str.194 Str.195 Str.196 Str.197:
+        inc Str.195;
+        let Str.383 : [C {}, C {Str, Str}] = CallByName Str.38 Str.195 Str.196;
+        let Str.389 : U8 = 1i64;
+        let Str.390 : U8 = GetTagId Str.383;
+        let Str.391 : Int1 = lowlevel Eq Str.389 Str.390;
+        if Str.391 then
+            dec Str.195;
+            let Str.388 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.383;
+            let Str.199 : Str = StructAtIndex 0 Str.388;
+            let Str.198 : Str = StructAtIndex 1 Str.388;
+            let Str.386 : Str = CallByName Str.3 Str.194 Str.198;
+            dec Str.198;
+            let Str.385 : Str = CallByName Str.3 Str.386 Str.197;
+            jump Str.382 Str.385 Str.199 Str.196 Str.197;
         else
-            dec Str.98;
-            dec Str.251;
-            dec Str.99;
-            let Str.255 : Str = CallByName Str.3 Str.96 Str.97;
-            dec Str.97;
-            ret Str.255;
+            dec Str.196;
+            dec Str.383;
+            dec Str.197;
+            let Str.387 : Str = CallByName Str.3 Str.194 Str.195;
+            dec Str.195;
+            ret Str.387;
     in
-    inc #Derived_gen.27;
+    inc #Derived_gen.25;
     inc #Derived_gen.26;
-    jump Str.250 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27;
+    jump Str.382 #Derived_gen.23 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26;
 
-procedure Str.57 (Str.121, Str.122):
-    let Str.123 : U64 = CallByName Str.36 Str.121;
-    let Str.124 : U64 = CallByName Str.36 Str.122;
-    let Str.125 : U64 = CallByName Num.77 Str.123 Str.124;
-    let Str.277 : U64 = 0i64;
-    let Str.276 : [C , C U64] = CallByName Str.58 Str.121 Str.122 Str.277 Str.125;
-    ret Str.276;
+procedure Str.62 (Str.219, Str.220):
+    let Str.221 : U64 = CallByName Str.36 Str.219;
+    let Str.222 : U64 = CallByName Str.36 Str.220;
+    let Str.223 : U64 = CallByName Num.77 Str.221 Str.222;
+    let Str.409 : U64 = 0i64;
+    let Str.408 : [C , C U64] = CallByName Str.63 Str.219 Str.220 Str.409 Str.223;
+    ret Str.408;
 
-procedure Str.58 (#Derived_gen.20, #Derived_gen.21, #Derived_gen.22, #Derived_gen.23):
-    joinpoint Str.278 Str.126 Str.127 Str.128 Str.129:
-        let Str.280 : Int1 = CallByName Num.23 Str.128 Str.129;
-        if Str.280 then
-            let Str.284 : Int1 = CallByName Str.62 Str.126 Str.128 Str.127;
-            if Str.284 then
-                dec Str.127;
-                dec Str.126;
-                let Str.285 : [C , C U64] = TagId(1) Str.128;
-                ret Str.285;
+procedure Str.63 (#Derived_gen.19, #Derived_gen.20, #Derived_gen.21, #Derived_gen.22):
+    joinpoint Str.410 Str.224 Str.225 Str.226 Str.227:
+        let Str.412 : Int1 = CallByName Num.23 Str.226 Str.227;
+        if Str.412 then
+            let Str.416 : Int1 = CallByName Str.67 Str.224 Str.226 Str.225;
+            if Str.416 then
+                dec Str.224;
+                dec Str.225;
+                let Str.417 : [C , C U64] = TagId(1) Str.226;
+                ret Str.417;
             else
-                let Str.283 : U64 = 1i64;
-                let Str.282 : U64 = CallByName Num.51 Str.128 Str.283;
-                jump Str.278 Str.126 Str.127 Str.282 Str.129;
+                let Str.415 : U64 = 1i64;
+                let Str.414 : U64 = CallByName Num.51 Str.226 Str.415;
+                jump Str.410 Str.224 Str.225 Str.414 Str.227;
         else
-            dec Str.127;
-            dec Str.126;
-            let Str.279 : [C , C U64] = TagId(0) ;
-            ret Str.279;
+            dec Str.224;
+            dec Str.225;
+            let Str.411 : [C , C U64] = TagId(0) ;
+            ret Str.411;
     in
     inc #Derived_gen.20;
-    inc #Derived_gen.21;
-    jump Str.278 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23;
+    inc #Derived_gen.19;
+    jump Str.410 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22;
 
-procedure Str.61 (Str.152, Str.153):
-    let Str.308 : Int1 = CallByName Num.22 Str.152 Str.153;
-    if Str.308 then
-        ret Str.152;
+procedure Str.66 (Str.250, Str.251):
+    let Str.440 : Int1 = CallByName Num.22 Str.250 Str.251;
+    if Str.440 then
+        ret Str.250;
     else
-        ret Str.153;
+        ret Str.251;
 
-procedure Str.62 (Str.154, Str.155, Str.156):
-    let Str.157 : U64 = CallByName Str.36 Str.154;
-    let Str.158 : U64 = CallByName Str.36 Str.156;
-    let Str.306 : U64 = CallByName Num.53 Str.155 Str.158;
-    let Str.159 : U64 = CallByName Str.61 Str.306 Str.157;
-    let Str.305 : U64 = 0i64;
-    inc Str.156;
-    inc Str.154;
-    let Str.287 : {U64, Str, U64, Str, U64, U64} = Struct {Str.159, Str.154, Str.155, Str.156, Str.305, Str.158};
-    let Str.286 : Int1 = CallByName Str.63 Str.287;
-    ret Str.286;
+procedure Str.67 (Str.252, Str.253, Str.254):
+    let Str.255 : U64 = CallByName Str.36 Str.252;
+    let Str.256 : U64 = CallByName Str.36 Str.254;
+    let Str.438 : U64 = CallByName Num.53 Str.253 Str.256;
+    let Str.257 : U64 = CallByName Str.66 Str.438 Str.255;
+    let Str.437 : U64 = 0i64;
+    inc Str.252;
+    inc Str.254;
+    let Str.419 : {U64, Str, U64, Str, U64, U64} = Struct {Str.257, Str.252, Str.253, Str.254, Str.437, Str.256};
+    let Str.418 : Int1 = CallByName Str.68 Str.419;
+    ret Str.418;
 
-procedure Str.63 (Str.160):
-    let Str.166 : U64 = StructAtIndex 0 Str.160;
-    let Str.161 : Str = StructAtIndex 1 Str.160;
-    let Str.162 : U64 = StructAtIndex 2 Str.160;
-    let Str.163 : Str = StructAtIndex 3 Str.160;
-    let Str.164 : U64 = StructAtIndex 4 Str.160;
-    let Str.165 : U64 = StructAtIndex 5 Str.160;
-    let Str.167 : Int1 = CallByName Num.25 Str.162 Str.166;
-    if Str.167 then
-        dec Str.163;
-        dec Str.161;
-        let Str.168 : Int1 = CallByName Bool.11 Str.164 Str.165;
-        ret Str.168;
+procedure Str.68 (Str.258):
+    let Str.264 : U64 = StructAtIndex 0 Str.258;
+    let Str.259 : Str = StructAtIndex 1 Str.258;
+    let Str.260 : U64 = StructAtIndex 2 Str.258;
+    let Str.261 : Str = StructAtIndex 3 Str.258;
+    let Str.262 : U64 = StructAtIndex 4 Str.258;
+    let Str.263 : U64 = StructAtIndex 5 Str.258;
+    let Str.265 : Int1 = CallByName Num.25 Str.260 Str.264;
+    if Str.265 then
+        dec Str.259;
+        dec Str.261;
+        let Str.266 : Int1 = CallByName Bool.11 Str.262 Str.263;
+        ret Str.266;
     else
-        let Str.301 : U8 = CallByName Str.35 Str.161 Str.162;
-        let Str.302 : U8 = CallByName Str.35 Str.163 Str.164;
-        let Str.169 : Int1 = CallByName Bool.11 Str.301 Str.302;
-        let Str.291 : U64 = StructAtIndex 0 Str.160;
-        let Str.292 : Str = StructAtIndex 1 Str.160;
-        let Str.294 : Str = StructAtIndex 3 Str.160;
-        let Str.296 : U64 = StructAtIndex 5 Str.160;
-        let Str.300 : U64 = 1i64;
-        let Str.298 : U64 = CallByName Num.51 Str.164 Str.300;
-        let Str.299 : U64 = 1i64;
-        let Str.297 : U64 = CallByName Num.51 Str.162 Str.299;
-        let Str.290 : {U64, Str, U64, Str, U64, U64} = Struct {Str.291, Str.292, Str.297, Str.294, Str.298, Str.296};
-        let Str.170 : Int1 = CallByName Str.63 Str.290;
-        let Str.289 : Int1 = CallByName Bool.3 Str.169 Str.170;
-        ret Str.289;
+        let Str.433 : U8 = CallByName Str.35 Str.259 Str.260;
+        let Str.434 : U8 = CallByName Str.35 Str.261 Str.262;
+        let Str.267 : Int1 = CallByName Bool.11 Str.433 Str.434;
+        let Str.423 : U64 = StructAtIndex 0 Str.258;
+        let Str.424 : Str = StructAtIndex 1 Str.258;
+        let Str.426 : Str = StructAtIndex 3 Str.258;
+        let Str.428 : U64 = StructAtIndex 5 Str.258;
+        let Str.432 : U64 = 1i64;
+        let Str.430 : U64 = CallByName Num.51 Str.262 Str.432;
+        let Str.431 : U64 = 1i64;
+        let Str.429 : U64 = CallByName Num.51 Str.260 Str.431;
+        let Str.422 : {U64, Str, U64, Str, U64, U64} = Struct {Str.423, Str.424, Str.429, Str.426, Str.430, Str.428};
+        let Str.268 : Int1 = CallByName Str.68 Str.422;
+        let Str.421 : Int1 = CallByName Bool.3 Str.267 Str.268;
+        ret Str.421;
 
 procedure Test.0 ():
     let Test.3 : Str = "foo";
diff --git a/crates/compiler/test_mono/generated/inspect_derived_record_two_field_strings.txt b/crates/compiler/test_mono/generated/inspect_derived_record_two_field_strings.txt
index a872fbd68a..ae69c73b6d 100644
--- a/crates/compiler/test_mono/generated/inspect_derived_record_two_field_strings.txt
+++ b/crates/compiler/test_mono/generated/inspect_derived_record_two_field_strings.txt
@@ -227,181 +227,181 @@ procedure Num.77 (#Attr.2, #Attr.3):
     ret Num.293;
 
 procedure Str.20 (#Attr.2):
-    let Str.313 : Str = lowlevel StrWithCapacity #Attr.2;
-    ret Str.313;
+    let Str.445 : Str = lowlevel StrWithCapacity #Attr.2;
+    ret Str.445;
 
 procedure Str.3 (#Attr.2, #Attr.3):
-    let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
-    ret Str.246;
+    let Str.378 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.378;
 
 procedure Str.35 (#Attr.2, #Attr.3):
-    let Str.303 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
-    ret Str.303;
+    let Str.435 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
+    ret Str.435;
 
 procedure Str.36 (#Attr.2):
-    let Str.266 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
-    ret Str.266;
+    let Str.398 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
+    ret Str.398;
 
 procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
-    let Str.264 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
-    ret Str.264;
+    let Str.396 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
+    ret Str.396;
 
-procedure Str.38 (Str.112, Str.113):
-    let Str.260 : [C , C U64] = CallByName Str.57 Str.112 Str.113;
-    let Str.273 : U8 = 1i64;
-    let Str.274 : U8 = GetTagId Str.260;
-    let Str.275 : Int1 = lowlevel Eq Str.273 Str.274;
-    if Str.275 then
-        let Str.114 : U64 = UnionAtIndex (Id 1) (Index 0) Str.260;
-        let Str.269 : U64 = CallByName Str.36 Str.112;
-        let Str.270 : U64 = CallByName Str.36 Str.113;
-        let Str.268 : U64 = CallByName Num.20 Str.269 Str.270;
-        let Str.115 : U64 = CallByName Num.20 Str.268 Str.114;
-        let Str.267 : U64 = 0i64;
-        inc Str.112;
-        let Str.116 : Str = CallByName Str.37 Str.112 Str.267 Str.114;
-        let Str.265 : U64 = CallByName Str.36 Str.113;
-        let Str.263 : U64 = CallByName Num.51 Str.114 Str.265;
-        let Str.117 : Str = CallByName Str.37 Str.112 Str.263 Str.115;
-        let Str.262 : {Str, Str} = Struct {Str.117, Str.116};
-        let Str.261 : [C {}, C {Str, Str}] = TagId(1) Str.262;
-        ret Str.261;
+procedure Str.38 (Str.210, Str.211):
+    let Str.392 : [C , C U64] = CallByName Str.62 Str.210 Str.211;
+    let Str.405 : U8 = 1i64;
+    let Str.406 : U8 = GetTagId Str.392;
+    let Str.407 : Int1 = lowlevel Eq Str.405 Str.406;
+    if Str.407 then
+        let Str.212 : U64 = UnionAtIndex (Id 1) (Index 0) Str.392;
+        let Str.401 : U64 = CallByName Str.36 Str.210;
+        let Str.402 : U64 = CallByName Str.36 Str.211;
+        let Str.400 : U64 = CallByName Num.20 Str.401 Str.402;
+        let Str.213 : U64 = CallByName Num.20 Str.400 Str.212;
+        let Str.399 : U64 = 0i64;
+        inc Str.210;
+        let Str.214 : Str = CallByName Str.37 Str.210 Str.399 Str.212;
+        let Str.397 : U64 = CallByName Str.36 Str.211;
+        let Str.395 : U64 = CallByName Num.51 Str.212 Str.397;
+        let Str.215 : Str = CallByName Str.37 Str.210 Str.395 Str.213;
+        let Str.394 : {Str, Str} = Struct {Str.215, Str.214};
+        let Str.393 : [C {}, C {Str, Str}] = TagId(1) Str.394;
+        ret Str.393;
     else
-        dec Str.112;
-        let Str.272 : {} = Struct {};
-        let Str.271 : [C {}, C {Str, Str}] = TagId(0) Str.272;
-        ret Str.271;
+        dec Str.210;
+        let Str.404 : {} = Struct {};
+        let Str.403 : [C {}, C {Str, Str}] = TagId(0) Str.404;
+        ret Str.403;
 
-procedure Str.45 (Str.91, Str.92, Str.93):
-    inc Str.91;
-    let Str.385 : [C {}, C {Str, Str}] = CallByName Str.38 Str.91 Str.92;
-    let Str.393 : U8 = 1i64;
-    let Str.394 : U8 = GetTagId Str.385;
-    let Str.395 : Int1 = lowlevel Eq Str.393 Str.394;
-    if Str.395 then
-        let Str.392 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.385;
-        let Str.95 : Str = StructAtIndex 0 Str.392;
-        let Str.94 : Str = StructAtIndex 1 Str.392;
-        let Str.390 : U64 = CallByName Str.36 Str.91;
-        dec Str.91;
-        let Str.389 : Str = CallByName Str.20 Str.390;
-        let Str.388 : Str = CallByName Str.3 Str.389 Str.94;
-        dec Str.94;
-        let Str.387 : Str = CallByName Str.3 Str.388 Str.93;
-        let Str.386 : Str = CallByName Str.56 Str.387 Str.95 Str.92 Str.93;
-        ret Str.386;
+procedure Str.45 (Str.189, Str.190, Str.191):
+    inc Str.189;
+    let Str.517 : [C {}, C {Str, Str}] = CallByName Str.38 Str.189 Str.190;
+    let Str.525 : U8 = 1i64;
+    let Str.526 : U8 = GetTagId Str.517;
+    let Str.527 : Int1 = lowlevel Eq Str.525 Str.526;
+    if Str.527 then
+        let Str.524 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.517;
+        let Str.193 : Str = StructAtIndex 0 Str.524;
+        let Str.192 : Str = StructAtIndex 1 Str.524;
+        let Str.522 : U64 = CallByName Str.36 Str.189;
+        dec Str.189;
+        let Str.521 : Str = CallByName Str.20 Str.522;
+        let Str.520 : Str = CallByName Str.3 Str.521 Str.192;
+        dec Str.192;
+        let Str.519 : Str = CallByName Str.3 Str.520 Str.191;
+        let Str.518 : Str = CallByName Str.61 Str.519 Str.193 Str.190 Str.191;
+        ret Str.518;
     else
-        dec Str.385;
-        ret Str.91;
+        dec Str.517;
+        ret Str.189;
 
-procedure Str.56 (#Derived_gen.28, #Derived_gen.29, #Derived_gen.30, #Derived_gen.31):
-    joinpoint Str.250 Str.96 Str.97 Str.98 Str.99:
-        inc Str.97;
-        let Str.251 : [C {}, C {Str, Str}] = CallByName Str.38 Str.97 Str.98;
-        let Str.257 : U8 = 1i64;
-        let Str.258 : U8 = GetTagId Str.251;
-        let Str.259 : Int1 = lowlevel Eq Str.257 Str.258;
-        if Str.259 then
-            dec Str.97;
-            let Str.256 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.251;
-            let Str.101 : Str = StructAtIndex 0 Str.256;
-            let Str.100 : Str = StructAtIndex 1 Str.256;
-            let Str.254 : Str = CallByName Str.3 Str.96 Str.100;
-            dec Str.100;
-            let Str.253 : Str = CallByName Str.3 Str.254 Str.99;
-            jump Str.250 Str.253 Str.101 Str.98 Str.99;
+procedure Str.61 (#Derived_gen.27, #Derived_gen.28, #Derived_gen.29, #Derived_gen.30):
+    joinpoint Str.382 Str.194 Str.195 Str.196 Str.197:
+        inc Str.195;
+        let Str.383 : [C {}, C {Str, Str}] = CallByName Str.38 Str.195 Str.196;
+        let Str.389 : U8 = 1i64;
+        let Str.390 : U8 = GetTagId Str.383;
+        let Str.391 : Int1 = lowlevel Eq Str.389 Str.390;
+        if Str.391 then
+            dec Str.195;
+            let Str.388 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.383;
+            let Str.199 : Str = StructAtIndex 0 Str.388;
+            let Str.198 : Str = StructAtIndex 1 Str.388;
+            let Str.386 : Str = CallByName Str.3 Str.194 Str.198;
+            dec Str.198;
+            let Str.385 : Str = CallByName Str.3 Str.386 Str.197;
+            jump Str.382 Str.385 Str.199 Str.196 Str.197;
         else
-            dec Str.98;
-            dec Str.251;
-            dec Str.99;
-            let Str.255 : Str = CallByName Str.3 Str.96 Str.97;
-            dec Str.97;
-            ret Str.255;
+            dec Str.196;
+            dec Str.383;
+            dec Str.197;
+            let Str.387 : Str = CallByName Str.3 Str.194 Str.195;
+            dec Str.195;
+            ret Str.387;
     in
+    inc #Derived_gen.29;
     inc #Derived_gen.30;
-    inc #Derived_gen.31;
-    jump Str.250 #Derived_gen.28 #Derived_gen.29 #Derived_gen.30 #Derived_gen.31;
+    jump Str.382 #Derived_gen.27 #Derived_gen.28 #Derived_gen.29 #Derived_gen.30;
 
-procedure Str.57 (Str.121, Str.122):
-    let Str.123 : U64 = CallByName Str.36 Str.121;
-    let Str.124 : U64 = CallByName Str.36 Str.122;
-    let Str.125 : U64 = CallByName Num.77 Str.123 Str.124;
-    let Str.277 : U64 = 0i64;
-    let Str.276 : [C , C U64] = CallByName Str.58 Str.121 Str.122 Str.277 Str.125;
-    ret Str.276;
+procedure Str.62 (Str.219, Str.220):
+    let Str.221 : U64 = CallByName Str.36 Str.219;
+    let Str.222 : U64 = CallByName Str.36 Str.220;
+    let Str.223 : U64 = CallByName Num.77 Str.221 Str.222;
+    let Str.409 : U64 = 0i64;
+    let Str.408 : [C , C U64] = CallByName Str.63 Str.219 Str.220 Str.409 Str.223;
+    ret Str.408;
 
-procedure Str.58 (#Derived_gen.24, #Derived_gen.25, #Derived_gen.26, #Derived_gen.27):
-    joinpoint Str.278 Str.126 Str.127 Str.128 Str.129:
-        let Str.280 : Int1 = CallByName Num.23 Str.128 Str.129;
-        if Str.280 then
-            let Str.284 : Int1 = CallByName Str.62 Str.126 Str.128 Str.127;
-            if Str.284 then
-                dec Str.127;
-                dec Str.126;
-                let Str.285 : [C , C U64] = TagId(1) Str.128;
-                ret Str.285;
+procedure Str.63 (#Derived_gen.23, #Derived_gen.24, #Derived_gen.25, #Derived_gen.26):
+    joinpoint Str.410 Str.224 Str.225 Str.226 Str.227:
+        let Str.412 : Int1 = CallByName Num.23 Str.226 Str.227;
+        if Str.412 then
+            let Str.416 : Int1 = CallByName Str.67 Str.224 Str.226 Str.225;
+            if Str.416 then
+                dec Str.224;
+                dec Str.225;
+                let Str.417 : [C , C U64] = TagId(1) Str.226;
+                ret Str.417;
             else
-                let Str.283 : U64 = 1i64;
-                let Str.282 : U64 = CallByName Num.51 Str.128 Str.283;
-                jump Str.278 Str.126 Str.127 Str.282 Str.129;
+                let Str.415 : U64 = 1i64;
+                let Str.414 : U64 = CallByName Num.51 Str.226 Str.415;
+                jump Str.410 Str.224 Str.225 Str.414 Str.227;
         else
-            dec Str.127;
-            dec Str.126;
-            let Str.279 : [C , C U64] = TagId(0) ;
-            ret Str.279;
+            dec Str.224;
+            dec Str.225;
+            let Str.411 : [C , C U64] = TagId(0) ;
+            ret Str.411;
     in
     inc #Derived_gen.24;
-    inc #Derived_gen.25;
-    jump Str.278 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27;
+    inc #Derived_gen.23;
+    jump Str.410 #Derived_gen.23 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26;
 
-procedure Str.61 (Str.152, Str.153):
-    let Str.308 : Int1 = CallByName Num.22 Str.152 Str.153;
-    if Str.308 then
-        ret Str.152;
+procedure Str.66 (Str.250, Str.251):
+    let Str.440 : Int1 = CallByName Num.22 Str.250 Str.251;
+    if Str.440 then
+        ret Str.250;
     else
-        ret Str.153;
+        ret Str.251;
 
-procedure Str.62 (Str.154, Str.155, Str.156):
-    let Str.157 : U64 = CallByName Str.36 Str.154;
-    let Str.158 : U64 = CallByName Str.36 Str.156;
-    let Str.306 : U64 = CallByName Num.53 Str.155 Str.158;
-    let Str.159 : U64 = CallByName Str.61 Str.306 Str.157;
-    let Str.305 : U64 = 0i64;
-    inc Str.156;
-    inc Str.154;
-    let Str.287 : {U64, Str, U64, Str, U64, U64} = Struct {Str.159, Str.154, Str.155, Str.156, Str.305, Str.158};
-    let Str.286 : Int1 = CallByName Str.63 Str.287;
-    ret Str.286;
+procedure Str.67 (Str.252, Str.253, Str.254):
+    let Str.255 : U64 = CallByName Str.36 Str.252;
+    let Str.256 : U64 = CallByName Str.36 Str.254;
+    let Str.438 : U64 = CallByName Num.53 Str.253 Str.256;
+    let Str.257 : U64 = CallByName Str.66 Str.438 Str.255;
+    let Str.437 : U64 = 0i64;
+    inc Str.252;
+    inc Str.254;
+    let Str.419 : {U64, Str, U64, Str, U64, U64} = Struct {Str.257, Str.252, Str.253, Str.254, Str.437, Str.256};
+    let Str.418 : Int1 = CallByName Str.68 Str.419;
+    ret Str.418;
 
-procedure Str.63 (Str.160):
-    let Str.166 : U64 = StructAtIndex 0 Str.160;
-    let Str.161 : Str = StructAtIndex 1 Str.160;
-    let Str.162 : U64 = StructAtIndex 2 Str.160;
-    let Str.163 : Str = StructAtIndex 3 Str.160;
-    let Str.164 : U64 = StructAtIndex 4 Str.160;
-    let Str.165 : U64 = StructAtIndex 5 Str.160;
-    let Str.167 : Int1 = CallByName Num.25 Str.162 Str.166;
-    if Str.167 then
-        dec Str.163;
-        dec Str.161;
-        let Str.168 : Int1 = CallByName Bool.11 Str.164 Str.165;
-        ret Str.168;
+procedure Str.68 (Str.258):
+    let Str.264 : U64 = StructAtIndex 0 Str.258;
+    let Str.259 : Str = StructAtIndex 1 Str.258;
+    let Str.260 : U64 = StructAtIndex 2 Str.258;
+    let Str.261 : Str = StructAtIndex 3 Str.258;
+    let Str.262 : U64 = StructAtIndex 4 Str.258;
+    let Str.263 : U64 = StructAtIndex 5 Str.258;
+    let Str.265 : Int1 = CallByName Num.25 Str.260 Str.264;
+    if Str.265 then
+        dec Str.259;
+        dec Str.261;
+        let Str.266 : Int1 = CallByName Bool.11 Str.262 Str.263;
+        ret Str.266;
     else
-        let Str.301 : U8 = CallByName Str.35 Str.161 Str.162;
-        let Str.302 : U8 = CallByName Str.35 Str.163 Str.164;
-        let Str.169 : Int1 = CallByName Bool.11 Str.301 Str.302;
-        let Str.291 : U64 = StructAtIndex 0 Str.160;
-        let Str.292 : Str = StructAtIndex 1 Str.160;
-        let Str.294 : Str = StructAtIndex 3 Str.160;
-        let Str.296 : U64 = StructAtIndex 5 Str.160;
-        let Str.300 : U64 = 1i64;
-        let Str.298 : U64 = CallByName Num.51 Str.164 Str.300;
-        let Str.299 : U64 = 1i64;
-        let Str.297 : U64 = CallByName Num.51 Str.162 Str.299;
-        let Str.290 : {U64, Str, U64, Str, U64, U64} = Struct {Str.291, Str.292, Str.297, Str.294, Str.298, Str.296};
-        let Str.170 : Int1 = CallByName Str.63 Str.290;
-        let Str.289 : Int1 = CallByName Bool.3 Str.169 Str.170;
-        ret Str.289;
+        let Str.433 : U8 = CallByName Str.35 Str.259 Str.260;
+        let Str.434 : U8 = CallByName Str.35 Str.261 Str.262;
+        let Str.267 : Int1 = CallByName Bool.11 Str.433 Str.434;
+        let Str.423 : U64 = StructAtIndex 0 Str.258;
+        let Str.424 : Str = StructAtIndex 1 Str.258;
+        let Str.426 : Str = StructAtIndex 3 Str.258;
+        let Str.428 : U64 = StructAtIndex 5 Str.258;
+        let Str.432 : U64 = 1i64;
+        let Str.430 : U64 = CallByName Num.51 Str.262 Str.432;
+        let Str.431 : U64 = 1i64;
+        let Str.429 : U64 = CallByName Num.51 Str.260 Str.431;
+        let Str.422 : {U64, Str, U64, Str, U64, U64} = Struct {Str.423, Str.424, Str.429, Str.426, Str.430, Str.428};
+        let Str.268 : Int1 = CallByName Str.68 Str.422;
+        let Str.421 : Int1 = CallByName Bool.3 Str.267 Str.268;
+        ret Str.421;
 
 procedure Test.0 ():
     let Test.3 : Str = "foo";
diff --git a/crates/compiler/test_mono/generated/inspect_derived_string.txt b/crates/compiler/test_mono/generated/inspect_derived_string.txt
index d51bf51684..8844d39ebc 100644
--- a/crates/compiler/test_mono/generated/inspect_derived_string.txt
+++ b/crates/compiler/test_mono/generated/inspect_derived_string.txt
@@ -100,181 +100,181 @@ procedure Num.77 (#Attr.2, #Attr.3):
     ret Num.293;
 
 procedure Str.20 (#Attr.2):
-    let Str.313 : Str = lowlevel StrWithCapacity #Attr.2;
-    ret Str.313;
+    let Str.445 : Str = lowlevel StrWithCapacity #Attr.2;
+    ret Str.445;
 
 procedure Str.3 (#Attr.2, #Attr.3):
-    let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
-    ret Str.246;
+    let Str.378 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.378;
 
 procedure Str.35 (#Attr.2, #Attr.3):
-    let Str.303 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
-    ret Str.303;
+    let Str.435 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
+    ret Str.435;
 
 procedure Str.36 (#Attr.2):
-    let Str.266 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
-    ret Str.266;
+    let Str.398 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
+    ret Str.398;
 
 procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
-    let Str.264 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
-    ret Str.264;
+    let Str.396 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
+    ret Str.396;
 
-procedure Str.38 (Str.112, Str.113):
-    let Str.260 : [C , C U64] = CallByName Str.57 Str.112 Str.113;
-    let Str.273 : U8 = 1i64;
-    let Str.274 : U8 = GetTagId Str.260;
-    let Str.275 : Int1 = lowlevel Eq Str.273 Str.274;
-    if Str.275 then
-        let Str.114 : U64 = UnionAtIndex (Id 1) (Index 0) Str.260;
-        let Str.269 : U64 = CallByName Str.36 Str.112;
-        let Str.270 : U64 = CallByName Str.36 Str.113;
-        let Str.268 : U64 = CallByName Num.20 Str.269 Str.270;
-        let Str.115 : U64 = CallByName Num.20 Str.268 Str.114;
-        let Str.267 : U64 = 0i64;
-        inc Str.112;
-        let Str.116 : Str = CallByName Str.37 Str.112 Str.267 Str.114;
-        let Str.265 : U64 = CallByName Str.36 Str.113;
-        let Str.263 : U64 = CallByName Num.51 Str.114 Str.265;
-        let Str.117 : Str = CallByName Str.37 Str.112 Str.263 Str.115;
-        let Str.262 : {Str, Str} = Struct {Str.117, Str.116};
-        let Str.261 : [C {}, C {Str, Str}] = TagId(1) Str.262;
-        ret Str.261;
+procedure Str.38 (Str.210, Str.211):
+    let Str.392 : [C , C U64] = CallByName Str.62 Str.210 Str.211;
+    let Str.405 : U8 = 1i64;
+    let Str.406 : U8 = GetTagId Str.392;
+    let Str.407 : Int1 = lowlevel Eq Str.405 Str.406;
+    if Str.407 then
+        let Str.212 : U64 = UnionAtIndex (Id 1) (Index 0) Str.392;
+        let Str.401 : U64 = CallByName Str.36 Str.210;
+        let Str.402 : U64 = CallByName Str.36 Str.211;
+        let Str.400 : U64 = CallByName Num.20 Str.401 Str.402;
+        let Str.213 : U64 = CallByName Num.20 Str.400 Str.212;
+        let Str.399 : U64 = 0i64;
+        inc Str.210;
+        let Str.214 : Str = CallByName Str.37 Str.210 Str.399 Str.212;
+        let Str.397 : U64 = CallByName Str.36 Str.211;
+        let Str.395 : U64 = CallByName Num.51 Str.212 Str.397;
+        let Str.215 : Str = CallByName Str.37 Str.210 Str.395 Str.213;
+        let Str.394 : {Str, Str} = Struct {Str.215, Str.214};
+        let Str.393 : [C {}, C {Str, Str}] = TagId(1) Str.394;
+        ret Str.393;
     else
-        dec Str.112;
-        let Str.272 : {} = Struct {};
-        let Str.271 : [C {}, C {Str, Str}] = TagId(0) Str.272;
-        ret Str.271;
+        dec Str.210;
+        let Str.404 : {} = Struct {};
+        let Str.403 : [C {}, C {Str, Str}] = TagId(0) Str.404;
+        ret Str.403;
 
-procedure Str.45 (Str.91, Str.92, Str.93):
-    inc Str.91;
-    let Str.341 : [C {}, C {Str, Str}] = CallByName Str.38 Str.91 Str.92;
-    let Str.349 : U8 = 1i64;
-    let Str.350 : U8 = GetTagId Str.341;
-    let Str.351 : Int1 = lowlevel Eq Str.349 Str.350;
-    if Str.351 then
-        let Str.348 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.341;
-        let Str.95 : Str = StructAtIndex 0 Str.348;
-        let Str.94 : Str = StructAtIndex 1 Str.348;
-        let Str.346 : U64 = CallByName Str.36 Str.91;
-        dec Str.91;
-        let Str.345 : Str = CallByName Str.20 Str.346;
-        let Str.344 : Str = CallByName Str.3 Str.345 Str.94;
-        dec Str.94;
-        let Str.343 : Str = CallByName Str.3 Str.344 Str.93;
-        let Str.342 : Str = CallByName Str.56 Str.343 Str.95 Str.92 Str.93;
-        ret Str.342;
+procedure Str.45 (Str.189, Str.190, Str.191):
+    inc Str.189;
+    let Str.473 : [C {}, C {Str, Str}] = CallByName Str.38 Str.189 Str.190;
+    let Str.481 : U8 = 1i64;
+    let Str.482 : U8 = GetTagId Str.473;
+    let Str.483 : Int1 = lowlevel Eq Str.481 Str.482;
+    if Str.483 then
+        let Str.480 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.473;
+        let Str.193 : Str = StructAtIndex 0 Str.480;
+        let Str.192 : Str = StructAtIndex 1 Str.480;
+        let Str.478 : U64 = CallByName Str.36 Str.189;
+        dec Str.189;
+        let Str.477 : Str = CallByName Str.20 Str.478;
+        let Str.476 : Str = CallByName Str.3 Str.477 Str.192;
+        dec Str.192;
+        let Str.475 : Str = CallByName Str.3 Str.476 Str.191;
+        let Str.474 : Str = CallByName Str.61 Str.475 Str.193 Str.190 Str.191;
+        ret Str.474;
     else
-        dec Str.341;
-        ret Str.91;
+        dec Str.473;
+        ret Str.189;
 
-procedure Str.56 (#Derived_gen.5, #Derived_gen.6, #Derived_gen.7, #Derived_gen.8):
-    joinpoint Str.250 Str.96 Str.97 Str.98 Str.99:
-        inc Str.97;
-        let Str.251 : [C {}, C {Str, Str}] = CallByName Str.38 Str.97 Str.98;
-        let Str.257 : U8 = 1i64;
-        let Str.258 : U8 = GetTagId Str.251;
-        let Str.259 : Int1 = lowlevel Eq Str.257 Str.258;
-        if Str.259 then
-            dec Str.97;
-            let Str.256 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.251;
-            let Str.101 : Str = StructAtIndex 0 Str.256;
-            let Str.100 : Str = StructAtIndex 1 Str.256;
-            let Str.254 : Str = CallByName Str.3 Str.96 Str.100;
-            dec Str.100;
-            let Str.253 : Str = CallByName Str.3 Str.254 Str.99;
-            jump Str.250 Str.253 Str.101 Str.98 Str.99;
+procedure Str.61 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3):
+    joinpoint Str.382 Str.194 Str.195 Str.196 Str.197:
+        inc Str.195;
+        let Str.383 : [C {}, C {Str, Str}] = CallByName Str.38 Str.195 Str.196;
+        let Str.389 : U8 = 1i64;
+        let Str.390 : U8 = GetTagId Str.383;
+        let Str.391 : Int1 = lowlevel Eq Str.389 Str.390;
+        if Str.391 then
+            dec Str.195;
+            let Str.388 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.383;
+            let Str.199 : Str = StructAtIndex 0 Str.388;
+            let Str.198 : Str = StructAtIndex 1 Str.388;
+            let Str.386 : Str = CallByName Str.3 Str.194 Str.198;
+            dec Str.198;
+            let Str.385 : Str = CallByName Str.3 Str.386 Str.197;
+            jump Str.382 Str.385 Str.199 Str.196 Str.197;
         else
-            dec Str.98;
-            dec Str.251;
-            dec Str.99;
-            let Str.255 : Str = CallByName Str.3 Str.96 Str.97;
-            dec Str.97;
-            ret Str.255;
+            dec Str.196;
+            dec Str.383;
+            dec Str.197;
+            let Str.387 : Str = CallByName Str.3 Str.194 Str.195;
+            dec Str.195;
+            ret Str.387;
     in
-    inc #Derived_gen.7;
-    inc #Derived_gen.8;
-    jump Str.250 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7 #Derived_gen.8;
-
-procedure Str.57 (Str.121, Str.122):
-    let Str.123 : U64 = CallByName Str.36 Str.121;
-    let Str.124 : U64 = CallByName Str.36 Str.122;
-    let Str.125 : U64 = CallByName Num.77 Str.123 Str.124;
-    let Str.277 : U64 = 0i64;
-    let Str.276 : [C , C U64] = CallByName Str.58 Str.121 Str.122 Str.277 Str.125;
-    ret Str.276;
-
-procedure Str.58 (#Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
-    joinpoint Str.278 Str.126 Str.127 Str.128 Str.129:
-        let Str.280 : Int1 = CallByName Num.23 Str.128 Str.129;
-        if Str.280 then
-            let Str.284 : Int1 = CallByName Str.62 Str.126 Str.128 Str.127;
-            if Str.284 then
-                dec Str.127;
-                dec Str.126;
-                let Str.285 : [C , C U64] = TagId(1) Str.128;
-                ret Str.285;
-            else
-                let Str.283 : U64 = 1i64;
-                let Str.282 : U64 = CallByName Num.51 Str.128 Str.283;
-                jump Str.278 Str.126 Str.127 Str.282 Str.129;
-        else
-            dec Str.127;
-            dec Str.126;
-            let Str.279 : [C , C U64] = TagId(0) ;
-            ret Str.279;
-    in
-    inc #Derived_gen.1;
+    inc #Derived_gen.3;
     inc #Derived_gen.2;
-    jump Str.278 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
+    jump Str.382 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3;
 
-procedure Str.61 (Str.152, Str.153):
-    let Str.308 : Int1 = CallByName Num.22 Str.152 Str.153;
-    if Str.308 then
-        ret Str.152;
+procedure Str.62 (Str.219, Str.220):
+    let Str.221 : U64 = CallByName Str.36 Str.219;
+    let Str.222 : U64 = CallByName Str.36 Str.220;
+    let Str.223 : U64 = CallByName Num.77 Str.221 Str.222;
+    let Str.409 : U64 = 0i64;
+    let Str.408 : [C , C U64] = CallByName Str.63 Str.219 Str.220 Str.409 Str.223;
+    ret Str.408;
+
+procedure Str.63 (#Derived_gen.4, #Derived_gen.5, #Derived_gen.6, #Derived_gen.7):
+    joinpoint Str.410 Str.224 Str.225 Str.226 Str.227:
+        let Str.412 : Int1 = CallByName Num.23 Str.226 Str.227;
+        if Str.412 then
+            let Str.416 : Int1 = CallByName Str.67 Str.224 Str.226 Str.225;
+            if Str.416 then
+                dec Str.224;
+                dec Str.225;
+                let Str.417 : [C , C U64] = TagId(1) Str.226;
+                ret Str.417;
+            else
+                let Str.415 : U64 = 1i64;
+                let Str.414 : U64 = CallByName Num.51 Str.226 Str.415;
+                jump Str.410 Str.224 Str.225 Str.414 Str.227;
+        else
+            dec Str.224;
+            dec Str.225;
+            let Str.411 : [C , C U64] = TagId(0) ;
+            ret Str.411;
+    in
+    inc #Derived_gen.5;
+    inc #Derived_gen.4;
+    jump Str.410 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7;
+
+procedure Str.66 (Str.250, Str.251):
+    let Str.440 : Int1 = CallByName Num.22 Str.250 Str.251;
+    if Str.440 then
+        ret Str.250;
     else
-        ret Str.153;
+        ret Str.251;
 
-procedure Str.62 (Str.154, Str.155, Str.156):
-    let Str.157 : U64 = CallByName Str.36 Str.154;
-    let Str.158 : U64 = CallByName Str.36 Str.156;
-    let Str.306 : U64 = CallByName Num.53 Str.155 Str.158;
-    let Str.159 : U64 = CallByName Str.61 Str.306 Str.157;
-    let Str.305 : U64 = 0i64;
-    inc Str.156;
-    inc Str.154;
-    let Str.287 : {U64, Str, U64, Str, U64, U64} = Struct {Str.159, Str.154, Str.155, Str.156, Str.305, Str.158};
-    let Str.286 : Int1 = CallByName Str.63 Str.287;
-    ret Str.286;
+procedure Str.67 (Str.252, Str.253, Str.254):
+    let Str.255 : U64 = CallByName Str.36 Str.252;
+    let Str.256 : U64 = CallByName Str.36 Str.254;
+    let Str.438 : U64 = CallByName Num.53 Str.253 Str.256;
+    let Str.257 : U64 = CallByName Str.66 Str.438 Str.255;
+    let Str.437 : U64 = 0i64;
+    inc Str.252;
+    inc Str.254;
+    let Str.419 : {U64, Str, U64, Str, U64, U64} = Struct {Str.257, Str.252, Str.253, Str.254, Str.437, Str.256};
+    let Str.418 : Int1 = CallByName Str.68 Str.419;
+    ret Str.418;
 
-procedure Str.63 (Str.160):
-    let Str.166 : U64 = StructAtIndex 0 Str.160;
-    let Str.161 : Str = StructAtIndex 1 Str.160;
-    let Str.162 : U64 = StructAtIndex 2 Str.160;
-    let Str.163 : Str = StructAtIndex 3 Str.160;
-    let Str.164 : U64 = StructAtIndex 4 Str.160;
-    let Str.165 : U64 = StructAtIndex 5 Str.160;
-    let Str.167 : Int1 = CallByName Num.25 Str.162 Str.166;
-    if Str.167 then
-        dec Str.163;
-        dec Str.161;
-        let Str.168 : Int1 = CallByName Bool.11 Str.164 Str.165;
-        ret Str.168;
+procedure Str.68 (Str.258):
+    let Str.264 : U64 = StructAtIndex 0 Str.258;
+    let Str.259 : Str = StructAtIndex 1 Str.258;
+    let Str.260 : U64 = StructAtIndex 2 Str.258;
+    let Str.261 : Str = StructAtIndex 3 Str.258;
+    let Str.262 : U64 = StructAtIndex 4 Str.258;
+    let Str.263 : U64 = StructAtIndex 5 Str.258;
+    let Str.265 : Int1 = CallByName Num.25 Str.260 Str.264;
+    if Str.265 then
+        dec Str.259;
+        dec Str.261;
+        let Str.266 : Int1 = CallByName Bool.11 Str.262 Str.263;
+        ret Str.266;
     else
-        let Str.301 : U8 = CallByName Str.35 Str.161 Str.162;
-        let Str.302 : U8 = CallByName Str.35 Str.163 Str.164;
-        let Str.169 : Int1 = CallByName Bool.11 Str.301 Str.302;
-        let Str.291 : U64 = StructAtIndex 0 Str.160;
-        let Str.292 : Str = StructAtIndex 1 Str.160;
-        let Str.294 : Str = StructAtIndex 3 Str.160;
-        let Str.296 : U64 = StructAtIndex 5 Str.160;
-        let Str.300 : U64 = 1i64;
-        let Str.298 : U64 = CallByName Num.51 Str.164 Str.300;
-        let Str.299 : U64 = 1i64;
-        let Str.297 : U64 = CallByName Num.51 Str.162 Str.299;
-        let Str.290 : {U64, Str, U64, Str, U64, U64} = Struct {Str.291, Str.292, Str.297, Str.294, Str.298, Str.296};
-        let Str.170 : Int1 = CallByName Str.63 Str.290;
-        let Str.289 : Int1 = CallByName Bool.3 Str.169 Str.170;
-        ret Str.289;
+        let Str.433 : U8 = CallByName Str.35 Str.259 Str.260;
+        let Str.434 : U8 = CallByName Str.35 Str.261 Str.262;
+        let Str.267 : Int1 = CallByName Bool.11 Str.433 Str.434;
+        let Str.423 : U64 = StructAtIndex 0 Str.258;
+        let Str.424 : Str = StructAtIndex 1 Str.258;
+        let Str.426 : Str = StructAtIndex 3 Str.258;
+        let Str.428 : U64 = StructAtIndex 5 Str.258;
+        let Str.432 : U64 = 1i64;
+        let Str.430 : U64 = CallByName Num.51 Str.262 Str.432;
+        let Str.431 : U64 = 1i64;
+        let Str.429 : U64 = CallByName Num.51 Str.260 Str.431;
+        let Str.422 : {U64, Str, U64, Str, U64, U64} = Struct {Str.423, Str.424, Str.429, Str.426, Str.430, Str.428};
+        let Str.268 : Int1 = CallByName Str.68 Str.422;
+        let Str.421 : Int1 = CallByName Bool.3 Str.267 Str.268;
+        ret Str.421;
 
 procedure Test.0 ():
     let Test.2 : Str = "abc";
diff --git a/crates/compiler/test_mono/generated/inspect_derived_tag_one_field_string.txt b/crates/compiler/test_mono/generated/inspect_derived_tag_one_field_string.txt
index 8cb8571757..a5fe454646 100644
--- a/crates/compiler/test_mono/generated/inspect_derived_tag_one_field_string.txt
+++ b/crates/compiler/test_mono/generated/inspect_derived_tag_one_field_string.txt
@@ -162,7 +162,7 @@ procedure List.1 (List.119):
     let List.687 : Int1 = CallByName Bool.11 List.688 List.689;
     ret List.687;
 
-procedure List.101 (#Derived_gen.11, #Derived_gen.12, #Derived_gen.13, #Derived_gen.14, #Derived_gen.15):
+procedure List.101 (#Derived_gen.10, #Derived_gen.11, #Derived_gen.12, #Derived_gen.13, #Derived_gen.14):
     joinpoint List.678 List.175 List.176 List.177 List.178 List.179:
         let List.680 : Int1 = CallByName Num.22 List.178 List.179;
         if List.680 then
@@ -177,8 +177,8 @@ procedure List.101 (#Derived_gen.11, #Derived_gen.12, #Derived_gen.13, #Derived_
             dec List.175;
             ret List.176;
     in
-    inc #Derived_gen.11;
-    jump List.678 #Derived_gen.11 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15;
+    inc #Derived_gen.10;
+    jump List.678 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14;
 
 procedure List.18 (List.172, List.173, List.174):
     let List.676 : U64 = 0i64;
@@ -223,181 +223,181 @@ procedure Num.77 (#Attr.2, #Attr.3):
     ret Num.293;
 
 procedure Str.20 (#Attr.2):
-    let Str.313 : Str = lowlevel StrWithCapacity #Attr.2;
-    ret Str.313;
+    let Str.445 : Str = lowlevel StrWithCapacity #Attr.2;
+    ret Str.445;
 
 procedure Str.3 (#Attr.2, #Attr.3):
-    let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
-    ret Str.246;
+    let Str.378 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.378;
 
 procedure Str.35 (#Attr.2, #Attr.3):
-    let Str.303 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
-    ret Str.303;
+    let Str.435 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
+    ret Str.435;
 
 procedure Str.36 (#Attr.2):
-    let Str.266 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
-    ret Str.266;
+    let Str.398 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
+    ret Str.398;
 
 procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
-    let Str.264 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
-    ret Str.264;
+    let Str.396 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
+    ret Str.396;
 
-procedure Str.38 (Str.112, Str.113):
-    let Str.260 : [C , C U64] = CallByName Str.57 Str.112 Str.113;
-    let Str.273 : U8 = 1i64;
-    let Str.274 : U8 = GetTagId Str.260;
-    let Str.275 : Int1 = lowlevel Eq Str.273 Str.274;
-    if Str.275 then
-        let Str.114 : U64 = UnionAtIndex (Id 1) (Index 0) Str.260;
-        let Str.269 : U64 = CallByName Str.36 Str.112;
-        let Str.270 : U64 = CallByName Str.36 Str.113;
-        let Str.268 : U64 = CallByName Num.20 Str.269 Str.270;
-        let Str.115 : U64 = CallByName Num.20 Str.268 Str.114;
-        let Str.267 : U64 = 0i64;
-        inc Str.112;
-        let Str.116 : Str = CallByName Str.37 Str.112 Str.267 Str.114;
-        let Str.265 : U64 = CallByName Str.36 Str.113;
-        let Str.263 : U64 = CallByName Num.51 Str.114 Str.265;
-        let Str.117 : Str = CallByName Str.37 Str.112 Str.263 Str.115;
-        let Str.262 : {Str, Str} = Struct {Str.117, Str.116};
-        let Str.261 : [C {}, C {Str, Str}] = TagId(1) Str.262;
-        ret Str.261;
+procedure Str.38 (Str.210, Str.211):
+    let Str.392 : [C , C U64] = CallByName Str.62 Str.210 Str.211;
+    let Str.405 : U8 = 1i64;
+    let Str.406 : U8 = GetTagId Str.392;
+    let Str.407 : Int1 = lowlevel Eq Str.405 Str.406;
+    if Str.407 then
+        let Str.212 : U64 = UnionAtIndex (Id 1) (Index 0) Str.392;
+        let Str.401 : U64 = CallByName Str.36 Str.210;
+        let Str.402 : U64 = CallByName Str.36 Str.211;
+        let Str.400 : U64 = CallByName Num.20 Str.401 Str.402;
+        let Str.213 : U64 = CallByName Num.20 Str.400 Str.212;
+        let Str.399 : U64 = 0i64;
+        inc Str.210;
+        let Str.214 : Str = CallByName Str.37 Str.210 Str.399 Str.212;
+        let Str.397 : U64 = CallByName Str.36 Str.211;
+        let Str.395 : U64 = CallByName Num.51 Str.212 Str.397;
+        let Str.215 : Str = CallByName Str.37 Str.210 Str.395 Str.213;
+        let Str.394 : {Str, Str} = Struct {Str.215, Str.214};
+        let Str.393 : [C {}, C {Str, Str}] = TagId(1) Str.394;
+        ret Str.393;
     else
-        dec Str.112;
-        let Str.272 : {} = Struct {};
-        let Str.271 : [C {}, C {Str, Str}] = TagId(0) Str.272;
-        ret Str.271;
+        dec Str.210;
+        let Str.404 : {} = Struct {};
+        let Str.403 : [C {}, C {Str, Str}] = TagId(0) Str.404;
+        ret Str.403;
 
-procedure Str.45 (Str.91, Str.92, Str.93):
-    inc Str.91;
-    let Str.341 : [C {}, C {Str, Str}] = CallByName Str.38 Str.91 Str.92;
-    let Str.349 : U8 = 1i64;
-    let Str.350 : U8 = GetTagId Str.341;
-    let Str.351 : Int1 = lowlevel Eq Str.349 Str.350;
-    if Str.351 then
-        let Str.348 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.341;
-        let Str.95 : Str = StructAtIndex 0 Str.348;
-        let Str.94 : Str = StructAtIndex 1 Str.348;
-        let Str.346 : U64 = CallByName Str.36 Str.91;
-        dec Str.91;
-        let Str.345 : Str = CallByName Str.20 Str.346;
-        let Str.344 : Str = CallByName Str.3 Str.345 Str.94;
-        dec Str.94;
-        let Str.343 : Str = CallByName Str.3 Str.344 Str.93;
-        let Str.342 : Str = CallByName Str.56 Str.343 Str.95 Str.92 Str.93;
-        ret Str.342;
+procedure Str.45 (Str.189, Str.190, Str.191):
+    inc Str.189;
+    let Str.473 : [C {}, C {Str, Str}] = CallByName Str.38 Str.189 Str.190;
+    let Str.481 : U8 = 1i64;
+    let Str.482 : U8 = GetTagId Str.473;
+    let Str.483 : Int1 = lowlevel Eq Str.481 Str.482;
+    if Str.483 then
+        let Str.480 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.473;
+        let Str.193 : Str = StructAtIndex 0 Str.480;
+        let Str.192 : Str = StructAtIndex 1 Str.480;
+        let Str.478 : U64 = CallByName Str.36 Str.189;
+        dec Str.189;
+        let Str.477 : Str = CallByName Str.20 Str.478;
+        let Str.476 : Str = CallByName Str.3 Str.477 Str.192;
+        dec Str.192;
+        let Str.475 : Str = CallByName Str.3 Str.476 Str.191;
+        let Str.474 : Str = CallByName Str.61 Str.475 Str.193 Str.190 Str.191;
+        ret Str.474;
     else
-        dec Str.341;
-        ret Str.91;
+        dec Str.473;
+        ret Str.189;
 
-procedure Str.56 (#Derived_gen.24, #Derived_gen.25, #Derived_gen.26, #Derived_gen.27):
-    joinpoint Str.250 Str.96 Str.97 Str.98 Str.99:
-        inc Str.97;
-        let Str.251 : [C {}, C {Str, Str}] = CallByName Str.38 Str.97 Str.98;
-        let Str.257 : U8 = 1i64;
-        let Str.258 : U8 = GetTagId Str.251;
-        let Str.259 : Int1 = lowlevel Eq Str.257 Str.258;
-        if Str.259 then
-            dec Str.97;
-            let Str.256 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.251;
-            let Str.101 : Str = StructAtIndex 0 Str.256;
-            let Str.100 : Str = StructAtIndex 1 Str.256;
-            let Str.254 : Str = CallByName Str.3 Str.96 Str.100;
-            dec Str.100;
-            let Str.253 : Str = CallByName Str.3 Str.254 Str.99;
-            jump Str.250 Str.253 Str.101 Str.98 Str.99;
+procedure Str.61 (#Derived_gen.21, #Derived_gen.22, #Derived_gen.23, #Derived_gen.24):
+    joinpoint Str.382 Str.194 Str.195 Str.196 Str.197:
+        inc Str.195;
+        let Str.383 : [C {}, C {Str, Str}] = CallByName Str.38 Str.195 Str.196;
+        let Str.389 : U8 = 1i64;
+        let Str.390 : U8 = GetTagId Str.383;
+        let Str.391 : Int1 = lowlevel Eq Str.389 Str.390;
+        if Str.391 then
+            dec Str.195;
+            let Str.388 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.383;
+            let Str.199 : Str = StructAtIndex 0 Str.388;
+            let Str.198 : Str = StructAtIndex 1 Str.388;
+            let Str.386 : Str = CallByName Str.3 Str.194 Str.198;
+            dec Str.198;
+            let Str.385 : Str = CallByName Str.3 Str.386 Str.197;
+            jump Str.382 Str.385 Str.199 Str.196 Str.197;
         else
-            dec Str.98;
-            dec Str.251;
-            dec Str.99;
-            let Str.255 : Str = CallByName Str.3 Str.96 Str.97;
-            dec Str.97;
-            ret Str.255;
+            dec Str.196;
+            dec Str.383;
+            dec Str.197;
+            let Str.387 : Str = CallByName Str.3 Str.194 Str.195;
+            dec Str.195;
+            ret Str.387;
     in
-    inc #Derived_gen.27;
-    inc #Derived_gen.26;
-    jump Str.250 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27;
+    inc #Derived_gen.23;
+    inc #Derived_gen.24;
+    jump Str.382 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23 #Derived_gen.24;
 
-procedure Str.57 (Str.121, Str.122):
-    let Str.123 : U64 = CallByName Str.36 Str.121;
-    let Str.124 : U64 = CallByName Str.36 Str.122;
-    let Str.125 : U64 = CallByName Num.77 Str.123 Str.124;
-    let Str.277 : U64 = 0i64;
-    let Str.276 : [C , C U64] = CallByName Str.58 Str.121 Str.122 Str.277 Str.125;
-    ret Str.276;
+procedure Str.62 (Str.219, Str.220):
+    let Str.221 : U64 = CallByName Str.36 Str.219;
+    let Str.222 : U64 = CallByName Str.36 Str.220;
+    let Str.223 : U64 = CallByName Num.77 Str.221 Str.222;
+    let Str.409 : U64 = 0i64;
+    let Str.408 : [C , C U64] = CallByName Str.63 Str.219 Str.220 Str.409 Str.223;
+    ret Str.408;
 
-procedure Str.58 (#Derived_gen.18, #Derived_gen.19, #Derived_gen.20, #Derived_gen.21):
-    joinpoint Str.278 Str.126 Str.127 Str.128 Str.129:
-        let Str.280 : Int1 = CallByName Num.23 Str.128 Str.129;
-        if Str.280 then
-            let Str.284 : Int1 = CallByName Str.62 Str.126 Str.128 Str.127;
-            if Str.284 then
-                dec Str.127;
-                dec Str.126;
-                let Str.285 : [C , C U64] = TagId(1) Str.128;
-                ret Str.285;
+procedure Str.63 (#Derived_gen.17, #Derived_gen.18, #Derived_gen.19, #Derived_gen.20):
+    joinpoint Str.410 Str.224 Str.225 Str.226 Str.227:
+        let Str.412 : Int1 = CallByName Num.23 Str.226 Str.227;
+        if Str.412 then
+            let Str.416 : Int1 = CallByName Str.67 Str.224 Str.226 Str.225;
+            if Str.416 then
+                dec Str.224;
+                dec Str.225;
+                let Str.417 : [C , C U64] = TagId(1) Str.226;
+                ret Str.417;
             else
-                let Str.283 : U64 = 1i64;
-                let Str.282 : U64 = CallByName Num.51 Str.128 Str.283;
-                jump Str.278 Str.126 Str.127 Str.282 Str.129;
+                let Str.415 : U64 = 1i64;
+                let Str.414 : U64 = CallByName Num.51 Str.226 Str.415;
+                jump Str.410 Str.224 Str.225 Str.414 Str.227;
         else
-            dec Str.127;
-            dec Str.126;
-            let Str.279 : [C , C U64] = TagId(0) ;
-            ret Str.279;
+            dec Str.224;
+            dec Str.225;
+            let Str.411 : [C , C U64] = TagId(0) ;
+            ret Str.411;
     in
+    inc #Derived_gen.17;
     inc #Derived_gen.18;
-    inc #Derived_gen.19;
-    jump Str.278 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21;
+    jump Str.410 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20;
 
-procedure Str.61 (Str.152, Str.153):
-    let Str.308 : Int1 = CallByName Num.22 Str.152 Str.153;
-    if Str.308 then
-        ret Str.152;
+procedure Str.66 (Str.250, Str.251):
+    let Str.440 : Int1 = CallByName Num.22 Str.250 Str.251;
+    if Str.440 then
+        ret Str.250;
     else
-        ret Str.153;
+        ret Str.251;
 
-procedure Str.62 (Str.154, Str.155, Str.156):
-    let Str.157 : U64 = CallByName Str.36 Str.154;
-    let Str.158 : U64 = CallByName Str.36 Str.156;
-    let Str.306 : U64 = CallByName Num.53 Str.155 Str.158;
-    let Str.159 : U64 = CallByName Str.61 Str.306 Str.157;
-    let Str.305 : U64 = 0i64;
-    inc Str.156;
-    inc Str.154;
-    let Str.287 : {U64, Str, U64, Str, U64, U64} = Struct {Str.159, Str.154, Str.155, Str.156, Str.305, Str.158};
-    let Str.286 : Int1 = CallByName Str.63 Str.287;
-    ret Str.286;
+procedure Str.67 (Str.252, Str.253, Str.254):
+    let Str.255 : U64 = CallByName Str.36 Str.252;
+    let Str.256 : U64 = CallByName Str.36 Str.254;
+    let Str.438 : U64 = CallByName Num.53 Str.253 Str.256;
+    let Str.257 : U64 = CallByName Str.66 Str.438 Str.255;
+    let Str.437 : U64 = 0i64;
+    inc Str.252;
+    inc Str.254;
+    let Str.419 : {U64, Str, U64, Str, U64, U64} = Struct {Str.257, Str.252, Str.253, Str.254, Str.437, Str.256};
+    let Str.418 : Int1 = CallByName Str.68 Str.419;
+    ret Str.418;
 
-procedure Str.63 (Str.160):
-    let Str.166 : U64 = StructAtIndex 0 Str.160;
-    let Str.161 : Str = StructAtIndex 1 Str.160;
-    let Str.162 : U64 = StructAtIndex 2 Str.160;
-    let Str.163 : Str = StructAtIndex 3 Str.160;
-    let Str.164 : U64 = StructAtIndex 4 Str.160;
-    let Str.165 : U64 = StructAtIndex 5 Str.160;
-    let Str.167 : Int1 = CallByName Num.25 Str.162 Str.166;
-    if Str.167 then
-        dec Str.163;
-        dec Str.161;
-        let Str.168 : Int1 = CallByName Bool.11 Str.164 Str.165;
-        ret Str.168;
+procedure Str.68 (Str.258):
+    let Str.264 : U64 = StructAtIndex 0 Str.258;
+    let Str.259 : Str = StructAtIndex 1 Str.258;
+    let Str.260 : U64 = StructAtIndex 2 Str.258;
+    let Str.261 : Str = StructAtIndex 3 Str.258;
+    let Str.262 : U64 = StructAtIndex 4 Str.258;
+    let Str.263 : U64 = StructAtIndex 5 Str.258;
+    let Str.265 : Int1 = CallByName Num.25 Str.260 Str.264;
+    if Str.265 then
+        dec Str.259;
+        dec Str.261;
+        let Str.266 : Int1 = CallByName Bool.11 Str.262 Str.263;
+        ret Str.266;
     else
-        let Str.301 : U8 = CallByName Str.35 Str.161 Str.162;
-        let Str.302 : U8 = CallByName Str.35 Str.163 Str.164;
-        let Str.169 : Int1 = CallByName Bool.11 Str.301 Str.302;
-        let Str.291 : U64 = StructAtIndex 0 Str.160;
-        let Str.292 : Str = StructAtIndex 1 Str.160;
-        let Str.294 : Str = StructAtIndex 3 Str.160;
-        let Str.296 : U64 = StructAtIndex 5 Str.160;
-        let Str.300 : U64 = 1i64;
-        let Str.298 : U64 = CallByName Num.51 Str.164 Str.300;
-        let Str.299 : U64 = 1i64;
-        let Str.297 : U64 = CallByName Num.51 Str.162 Str.299;
-        let Str.290 : {U64, Str, U64, Str, U64, U64} = Struct {Str.291, Str.292, Str.297, Str.294, Str.298, Str.296};
-        let Str.170 : Int1 = CallByName Str.63 Str.290;
-        let Str.289 : Int1 = CallByName Bool.3 Str.169 Str.170;
-        ret Str.289;
+        let Str.433 : U8 = CallByName Str.35 Str.259 Str.260;
+        let Str.434 : U8 = CallByName Str.35 Str.261 Str.262;
+        let Str.267 : Int1 = CallByName Bool.11 Str.433 Str.434;
+        let Str.423 : U64 = StructAtIndex 0 Str.258;
+        let Str.424 : Str = StructAtIndex 1 Str.258;
+        let Str.426 : Str = StructAtIndex 3 Str.258;
+        let Str.428 : U64 = StructAtIndex 5 Str.258;
+        let Str.432 : U64 = 1i64;
+        let Str.430 : U64 = CallByName Num.51 Str.262 Str.432;
+        let Str.431 : U64 = 1i64;
+        let Str.429 : U64 = CallByName Num.51 Str.260 Str.431;
+        let Str.422 : {U64, Str, U64, Str, U64, U64} = Struct {Str.423, Str.424, Str.429, Str.426, Str.430, Str.428};
+        let Str.268 : Int1 = CallByName Str.68 Str.422;
+        let Str.421 : Int1 = CallByName Bool.3 Str.267 Str.268;
+        ret Str.421;
 
 procedure Test.0 ():
     let Test.4 : Str = "foo";
diff --git a/crates/compiler/test_mono/generated/inspect_derived_tag_two_payloads_string.txt b/crates/compiler/test_mono/generated/inspect_derived_tag_two_payloads_string.txt
index b5d821a158..03d0c9226c 100644
--- a/crates/compiler/test_mono/generated/inspect_derived_tag_two_payloads_string.txt
+++ b/crates/compiler/test_mono/generated/inspect_derived_tag_two_payloads_string.txt
@@ -226,181 +226,181 @@ procedure Num.77 (#Attr.2, #Attr.3):
     ret Num.293;
 
 procedure Str.20 (#Attr.2):
-    let Str.313 : Str = lowlevel StrWithCapacity #Attr.2;
-    ret Str.313;
+    let Str.445 : Str = lowlevel StrWithCapacity #Attr.2;
+    ret Str.445;
 
 procedure Str.3 (#Attr.2, #Attr.3):
-    let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
-    ret Str.246;
+    let Str.378 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.378;
 
 procedure Str.35 (#Attr.2, #Attr.3):
-    let Str.303 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
-    ret Str.303;
+    let Str.435 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
+    ret Str.435;
 
 procedure Str.36 (#Attr.2):
-    let Str.266 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
-    ret Str.266;
+    let Str.398 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
+    ret Str.398;
 
 procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
-    let Str.264 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
-    ret Str.264;
+    let Str.396 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
+    ret Str.396;
 
-procedure Str.38 (Str.112, Str.113):
-    let Str.260 : [C , C U64] = CallByName Str.57 Str.112 Str.113;
-    let Str.273 : U8 = 1i64;
-    let Str.274 : U8 = GetTagId Str.260;
-    let Str.275 : Int1 = lowlevel Eq Str.273 Str.274;
-    if Str.275 then
-        let Str.114 : U64 = UnionAtIndex (Id 1) (Index 0) Str.260;
-        let Str.269 : U64 = CallByName Str.36 Str.112;
-        let Str.270 : U64 = CallByName Str.36 Str.113;
-        let Str.268 : U64 = CallByName Num.20 Str.269 Str.270;
-        let Str.115 : U64 = CallByName Num.20 Str.268 Str.114;
-        let Str.267 : U64 = 0i64;
-        inc Str.112;
-        let Str.116 : Str = CallByName Str.37 Str.112 Str.267 Str.114;
-        let Str.265 : U64 = CallByName Str.36 Str.113;
-        let Str.263 : U64 = CallByName Num.51 Str.114 Str.265;
-        let Str.117 : Str = CallByName Str.37 Str.112 Str.263 Str.115;
-        let Str.262 : {Str, Str} = Struct {Str.117, Str.116};
-        let Str.261 : [C {}, C {Str, Str}] = TagId(1) Str.262;
-        ret Str.261;
+procedure Str.38 (Str.210, Str.211):
+    let Str.392 : [C , C U64] = CallByName Str.62 Str.210 Str.211;
+    let Str.405 : U8 = 1i64;
+    let Str.406 : U8 = GetTagId Str.392;
+    let Str.407 : Int1 = lowlevel Eq Str.405 Str.406;
+    if Str.407 then
+        let Str.212 : U64 = UnionAtIndex (Id 1) (Index 0) Str.392;
+        let Str.401 : U64 = CallByName Str.36 Str.210;
+        let Str.402 : U64 = CallByName Str.36 Str.211;
+        let Str.400 : U64 = CallByName Num.20 Str.401 Str.402;
+        let Str.213 : U64 = CallByName Num.20 Str.400 Str.212;
+        let Str.399 : U64 = 0i64;
+        inc Str.210;
+        let Str.214 : Str = CallByName Str.37 Str.210 Str.399 Str.212;
+        let Str.397 : U64 = CallByName Str.36 Str.211;
+        let Str.395 : U64 = CallByName Num.51 Str.212 Str.397;
+        let Str.215 : Str = CallByName Str.37 Str.210 Str.395 Str.213;
+        let Str.394 : {Str, Str} = Struct {Str.215, Str.214};
+        let Str.393 : [C {}, C {Str, Str}] = TagId(1) Str.394;
+        ret Str.393;
     else
-        dec Str.112;
-        let Str.272 : {} = Struct {};
-        let Str.271 : [C {}, C {Str, Str}] = TagId(0) Str.272;
-        ret Str.271;
+        dec Str.210;
+        let Str.404 : {} = Struct {};
+        let Str.403 : [C {}, C {Str, Str}] = TagId(0) Str.404;
+        ret Str.403;
 
-procedure Str.45 (Str.91, Str.92, Str.93):
-    inc Str.91;
-    let Str.385 : [C {}, C {Str, Str}] = CallByName Str.38 Str.91 Str.92;
-    let Str.393 : U8 = 1i64;
-    let Str.394 : U8 = GetTagId Str.385;
-    let Str.395 : Int1 = lowlevel Eq Str.393 Str.394;
-    if Str.395 then
-        let Str.392 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.385;
-        let Str.95 : Str = StructAtIndex 0 Str.392;
-        let Str.94 : Str = StructAtIndex 1 Str.392;
-        let Str.390 : U64 = CallByName Str.36 Str.91;
-        dec Str.91;
-        let Str.389 : Str = CallByName Str.20 Str.390;
-        let Str.388 : Str = CallByName Str.3 Str.389 Str.94;
-        dec Str.94;
-        let Str.387 : Str = CallByName Str.3 Str.388 Str.93;
-        let Str.386 : Str = CallByName Str.56 Str.387 Str.95 Str.92 Str.93;
-        ret Str.386;
+procedure Str.45 (Str.189, Str.190, Str.191):
+    inc Str.189;
+    let Str.517 : [C {}, C {Str, Str}] = CallByName Str.38 Str.189 Str.190;
+    let Str.525 : U8 = 1i64;
+    let Str.526 : U8 = GetTagId Str.517;
+    let Str.527 : Int1 = lowlevel Eq Str.525 Str.526;
+    if Str.527 then
+        let Str.524 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.517;
+        let Str.193 : Str = StructAtIndex 0 Str.524;
+        let Str.192 : Str = StructAtIndex 1 Str.524;
+        let Str.522 : U64 = CallByName Str.36 Str.189;
+        dec Str.189;
+        let Str.521 : Str = CallByName Str.20 Str.522;
+        let Str.520 : Str = CallByName Str.3 Str.521 Str.192;
+        dec Str.192;
+        let Str.519 : Str = CallByName Str.3 Str.520 Str.191;
+        let Str.518 : Str = CallByName Str.61 Str.519 Str.193 Str.190 Str.191;
+        ret Str.518;
     else
-        dec Str.385;
-        ret Str.91;
+        dec Str.517;
+        ret Str.189;
 
-procedure Str.56 (#Derived_gen.20, #Derived_gen.21, #Derived_gen.22, #Derived_gen.23):
-    joinpoint Str.250 Str.96 Str.97 Str.98 Str.99:
-        inc Str.97;
-        let Str.251 : [C {}, C {Str, Str}] = CallByName Str.38 Str.97 Str.98;
-        let Str.257 : U8 = 1i64;
-        let Str.258 : U8 = GetTagId Str.251;
-        let Str.259 : Int1 = lowlevel Eq Str.257 Str.258;
-        if Str.259 then
-            dec Str.97;
-            let Str.256 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.251;
-            let Str.101 : Str = StructAtIndex 0 Str.256;
-            let Str.100 : Str = StructAtIndex 1 Str.256;
-            let Str.254 : Str = CallByName Str.3 Str.96 Str.100;
-            dec Str.100;
-            let Str.253 : Str = CallByName Str.3 Str.254 Str.99;
-            jump Str.250 Str.253 Str.101 Str.98 Str.99;
+procedure Str.61 (#Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17):
+    joinpoint Str.382 Str.194 Str.195 Str.196 Str.197:
+        inc Str.195;
+        let Str.383 : [C {}, C {Str, Str}] = CallByName Str.38 Str.195 Str.196;
+        let Str.389 : U8 = 1i64;
+        let Str.390 : U8 = GetTagId Str.383;
+        let Str.391 : Int1 = lowlevel Eq Str.389 Str.390;
+        if Str.391 then
+            dec Str.195;
+            let Str.388 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.383;
+            let Str.199 : Str = StructAtIndex 0 Str.388;
+            let Str.198 : Str = StructAtIndex 1 Str.388;
+            let Str.386 : Str = CallByName Str.3 Str.194 Str.198;
+            dec Str.198;
+            let Str.385 : Str = CallByName Str.3 Str.386 Str.197;
+            jump Str.382 Str.385 Str.199 Str.196 Str.197;
         else
-            dec Str.98;
-            dec Str.251;
-            dec Str.99;
-            let Str.255 : Str = CallByName Str.3 Str.96 Str.97;
-            dec Str.97;
-            ret Str.255;
+            dec Str.196;
+            dec Str.383;
+            dec Str.197;
+            let Str.387 : Str = CallByName Str.3 Str.194 Str.195;
+            dec Str.195;
+            ret Str.387;
     in
-    inc #Derived_gen.23;
-    inc #Derived_gen.22;
-    jump Str.250 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23;
+    inc #Derived_gen.16;
+    inc #Derived_gen.17;
+    jump Str.382 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17;
 
-procedure Str.57 (Str.121, Str.122):
-    let Str.123 : U64 = CallByName Str.36 Str.121;
-    let Str.124 : U64 = CallByName Str.36 Str.122;
-    let Str.125 : U64 = CallByName Num.77 Str.123 Str.124;
-    let Str.277 : U64 = 0i64;
-    let Str.276 : [C , C U64] = CallByName Str.58 Str.121 Str.122 Str.277 Str.125;
-    ret Str.276;
+procedure Str.62 (Str.219, Str.220):
+    let Str.221 : U64 = CallByName Str.36 Str.219;
+    let Str.222 : U64 = CallByName Str.36 Str.220;
+    let Str.223 : U64 = CallByName Num.77 Str.221 Str.222;
+    let Str.409 : U64 = 0i64;
+    let Str.408 : [C , C U64] = CallByName Str.63 Str.219 Str.220 Str.409 Str.223;
+    ret Str.408;
 
-procedure Str.58 (#Derived_gen.13, #Derived_gen.14, #Derived_gen.15, #Derived_gen.16):
-    joinpoint Str.278 Str.126 Str.127 Str.128 Str.129:
-        let Str.280 : Int1 = CallByName Num.23 Str.128 Str.129;
-        if Str.280 then
-            let Str.284 : Int1 = CallByName Str.62 Str.126 Str.128 Str.127;
-            if Str.284 then
-                dec Str.127;
-                dec Str.126;
-                let Str.285 : [C , C U64] = TagId(1) Str.128;
-                ret Str.285;
+procedure Str.63 (#Derived_gen.20, #Derived_gen.21, #Derived_gen.22, #Derived_gen.23):
+    joinpoint Str.410 Str.224 Str.225 Str.226 Str.227:
+        let Str.412 : Int1 = CallByName Num.23 Str.226 Str.227;
+        if Str.412 then
+            let Str.416 : Int1 = CallByName Str.67 Str.224 Str.226 Str.225;
+            if Str.416 then
+                dec Str.224;
+                dec Str.225;
+                let Str.417 : [C , C U64] = TagId(1) Str.226;
+                ret Str.417;
             else
-                let Str.283 : U64 = 1i64;
-                let Str.282 : U64 = CallByName Num.51 Str.128 Str.283;
-                jump Str.278 Str.126 Str.127 Str.282 Str.129;
+                let Str.415 : U64 = 1i64;
+                let Str.414 : U64 = CallByName Num.51 Str.226 Str.415;
+                jump Str.410 Str.224 Str.225 Str.414 Str.227;
         else
-            dec Str.127;
-            dec Str.126;
-            let Str.279 : [C , C U64] = TagId(0) ;
-            ret Str.279;
+            dec Str.224;
+            dec Str.225;
+            let Str.411 : [C , C U64] = TagId(0) ;
+            ret Str.411;
     in
-    inc #Derived_gen.14;
-    inc #Derived_gen.13;
-    jump Str.278 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16;
+    inc #Derived_gen.20;
+    inc #Derived_gen.21;
+    jump Str.410 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23;
 
-procedure Str.61 (Str.152, Str.153):
-    let Str.308 : Int1 = CallByName Num.22 Str.152 Str.153;
-    if Str.308 then
-        ret Str.152;
+procedure Str.66 (Str.250, Str.251):
+    let Str.440 : Int1 = CallByName Num.22 Str.250 Str.251;
+    if Str.440 then
+        ret Str.250;
     else
-        ret Str.153;
+        ret Str.251;
 
-procedure Str.62 (Str.154, Str.155, Str.156):
-    let Str.157 : U64 = CallByName Str.36 Str.154;
-    let Str.158 : U64 = CallByName Str.36 Str.156;
-    let Str.306 : U64 = CallByName Num.53 Str.155 Str.158;
-    let Str.159 : U64 = CallByName Str.61 Str.306 Str.157;
-    let Str.305 : U64 = 0i64;
-    inc Str.156;
-    inc Str.154;
-    let Str.287 : {U64, Str, U64, Str, U64, U64} = Struct {Str.159, Str.154, Str.155, Str.156, Str.305, Str.158};
-    let Str.286 : Int1 = CallByName Str.63 Str.287;
-    ret Str.286;
+procedure Str.67 (Str.252, Str.253, Str.254):
+    let Str.255 : U64 = CallByName Str.36 Str.252;
+    let Str.256 : U64 = CallByName Str.36 Str.254;
+    let Str.438 : U64 = CallByName Num.53 Str.253 Str.256;
+    let Str.257 : U64 = CallByName Str.66 Str.438 Str.255;
+    let Str.437 : U64 = 0i64;
+    inc Str.252;
+    inc Str.254;
+    let Str.419 : {U64, Str, U64, Str, U64, U64} = Struct {Str.257, Str.252, Str.253, Str.254, Str.437, Str.256};
+    let Str.418 : Int1 = CallByName Str.68 Str.419;
+    ret Str.418;
 
-procedure Str.63 (Str.160):
-    let Str.166 : U64 = StructAtIndex 0 Str.160;
-    let Str.161 : Str = StructAtIndex 1 Str.160;
-    let Str.162 : U64 = StructAtIndex 2 Str.160;
-    let Str.163 : Str = StructAtIndex 3 Str.160;
-    let Str.164 : U64 = StructAtIndex 4 Str.160;
-    let Str.165 : U64 = StructAtIndex 5 Str.160;
-    let Str.167 : Int1 = CallByName Num.25 Str.162 Str.166;
-    if Str.167 then
-        dec Str.163;
-        dec Str.161;
-        let Str.168 : Int1 = CallByName Bool.11 Str.164 Str.165;
-        ret Str.168;
+procedure Str.68 (Str.258):
+    let Str.264 : U64 = StructAtIndex 0 Str.258;
+    let Str.259 : Str = StructAtIndex 1 Str.258;
+    let Str.260 : U64 = StructAtIndex 2 Str.258;
+    let Str.261 : Str = StructAtIndex 3 Str.258;
+    let Str.262 : U64 = StructAtIndex 4 Str.258;
+    let Str.263 : U64 = StructAtIndex 5 Str.258;
+    let Str.265 : Int1 = CallByName Num.25 Str.260 Str.264;
+    if Str.265 then
+        dec Str.259;
+        dec Str.261;
+        let Str.266 : Int1 = CallByName Bool.11 Str.262 Str.263;
+        ret Str.266;
     else
-        let Str.301 : U8 = CallByName Str.35 Str.161 Str.162;
-        let Str.302 : U8 = CallByName Str.35 Str.163 Str.164;
-        let Str.169 : Int1 = CallByName Bool.11 Str.301 Str.302;
-        let Str.291 : U64 = StructAtIndex 0 Str.160;
-        let Str.292 : Str = StructAtIndex 1 Str.160;
-        let Str.294 : Str = StructAtIndex 3 Str.160;
-        let Str.296 : U64 = StructAtIndex 5 Str.160;
-        let Str.300 : U64 = 1i64;
-        let Str.298 : U64 = CallByName Num.51 Str.164 Str.300;
-        let Str.299 : U64 = 1i64;
-        let Str.297 : U64 = CallByName Num.51 Str.162 Str.299;
-        let Str.290 : {U64, Str, U64, Str, U64, U64} = Struct {Str.291, Str.292, Str.297, Str.294, Str.298, Str.296};
-        let Str.170 : Int1 = CallByName Str.63 Str.290;
-        let Str.289 : Int1 = CallByName Bool.3 Str.169 Str.170;
-        ret Str.289;
+        let Str.433 : U8 = CallByName Str.35 Str.259 Str.260;
+        let Str.434 : U8 = CallByName Str.35 Str.261 Str.262;
+        let Str.267 : Int1 = CallByName Bool.11 Str.433 Str.434;
+        let Str.423 : U64 = StructAtIndex 0 Str.258;
+        let Str.424 : Str = StructAtIndex 1 Str.258;
+        let Str.426 : Str = StructAtIndex 3 Str.258;
+        let Str.428 : U64 = StructAtIndex 5 Str.258;
+        let Str.432 : U64 = 1i64;
+        let Str.430 : U64 = CallByName Num.51 Str.262 Str.432;
+        let Str.431 : U64 = 1i64;
+        let Str.429 : U64 = CallByName Num.51 Str.260 Str.431;
+        let Str.422 : {U64, Str, U64, Str, U64, U64} = Struct {Str.423, Str.424, Str.429, Str.426, Str.430, Str.428};
+        let Str.268 : Int1 = CallByName Str.68 Str.422;
+        let Str.421 : Int1 = CallByName Bool.3 Str.267 Str.268;
+        ret Str.421;
 
 procedure Test.0 ():
     let Test.5 : Str = "foo";
diff --git a/crates/compiler/test_mono/generated/issue_2583_specialize_errors_behind_unified_branches.txt b/crates/compiler/test_mono/generated/issue_2583_specialize_errors_behind_unified_branches.txt
index d987197ab8..282e796302 100644
--- a/crates/compiler/test_mono/generated/issue_2583_specialize_errors_behind_unified_branches.txt
+++ b/crates/compiler/test_mono/generated/issue_2583_specialize_errors_behind_unified_branches.txt
@@ -45,27 +45,27 @@ procedure Num.22 (#Attr.2, #Attr.3):
     let Num.283 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
     ret Num.283;
 
-procedure Str.27 (Str.84):
-    let Str.246 : [C Int1, C I64] = CallByName Str.66 Str.84;
-    ret Str.246;
+procedure Str.27 (Str.182):
+    let Str.378 : [C Int1, C I64] = CallByName Str.71 Str.182;
+    ret Str.378;
 
 procedure Str.42 (#Attr.2):
-    let Str.254 : {I64, U8} = lowlevel StrToNum #Attr.2;
-    ret Str.254;
+    let Str.386 : {I64, U8} = lowlevel StrToNum #Attr.2;
+    ret Str.386;
 
-procedure Str.66 (Str.191):
-    let Str.192 : {I64, U8} = CallByName Str.42 Str.191;
-    let Str.252 : U8 = StructAtIndex 1 Str.192;
-    let Str.253 : U8 = 0i64;
-    let Str.249 : Int1 = CallByName Bool.11 Str.252 Str.253;
-    if Str.249 then
-        let Str.251 : I64 = StructAtIndex 0 Str.192;
-        let Str.250 : [C Int1, C I64] = TagId(1) Str.251;
-        ret Str.250;
+procedure Str.71 (Str.289):
+    let Str.290 : {I64, U8} = CallByName Str.42 Str.289;
+    let Str.384 : U8 = StructAtIndex 1 Str.290;
+    let Str.385 : U8 = 0i64;
+    let Str.381 : Int1 = CallByName Bool.11 Str.384 Str.385;
+    if Str.381 then
+        let Str.383 : I64 = StructAtIndex 0 Str.290;
+        let Str.382 : [C Int1, C I64] = TagId(1) Str.383;
+        ret Str.382;
     else
-        let Str.248 : Int1 = false;
-        let Str.247 : [C Int1, C I64] = TagId(0) Str.248;
-        ret Str.247;
+        let Str.380 : Int1 = false;
+        let Str.379 : [C Int1, C I64] = TagId(0) Str.380;
+        ret Str.379;
 
 procedure Test.0 ():
     let Test.3 : Int1 = CallByName Bool.2;
diff --git a/crates/compiler/test_mono/generated/issue_4772_weakened_monomorphic_destructure.txt b/crates/compiler/test_mono/generated/issue_4772_weakened_monomorphic_destructure.txt
index 68b16ce580..7175c95747 100644
--- a/crates/compiler/test_mono/generated/issue_4772_weakened_monomorphic_destructure.txt
+++ b/crates/compiler/test_mono/generated/issue_4772_weakened_monomorphic_destructure.txt
@@ -19,30 +19,30 @@ procedure Decode.26 (Decode.109, Decode.110):
     ret Decode.126;
 
 procedure Str.12 (#Attr.2):
-    let Str.255 : List U8 = lowlevel StrToUtf8 #Attr.2;
-    ret Str.255;
+    let Str.387 : List U8 = lowlevel StrToUtf8 #Attr.2;
+    ret Str.387;
 
-procedure Str.27 (Str.84):
-    let Str.246 : [C {}, C I64] = CallByName Str.66 Str.84;
-    ret Str.246;
+procedure Str.27 (Str.182):
+    let Str.378 : [C {}, C I64] = CallByName Str.71 Str.182;
+    ret Str.378;
 
 procedure Str.42 (#Attr.2):
-    let Str.254 : {I64, U8} = lowlevel StrToNum #Attr.2;
-    ret Str.254;
+    let Str.386 : {I64, U8} = lowlevel StrToNum #Attr.2;
+    ret Str.386;
 
-procedure Str.66 (Str.191):
-    let Str.192 : {I64, U8} = CallByName Str.42 Str.191;
-    let Str.252 : U8 = StructAtIndex 1 Str.192;
-    let Str.253 : U8 = 0i64;
-    let Str.249 : Int1 = CallByName Bool.11 Str.252 Str.253;
-    if Str.249 then
-        let Str.251 : I64 = StructAtIndex 0 Str.192;
-        let Str.250 : [C {}, C I64] = TagId(1) Str.251;
-        ret Str.250;
+procedure Str.71 (Str.289):
+    let Str.290 : {I64, U8} = CallByName Str.42 Str.289;
+    let Str.384 : U8 = StructAtIndex 1 Str.290;
+    let Str.385 : U8 = 0i64;
+    let Str.381 : Int1 = CallByName Bool.11 Str.384 Str.385;
+    if Str.381 then
+        let Str.383 : I64 = StructAtIndex 0 Str.290;
+        let Str.382 : [C {}, C I64] = TagId(1) Str.383;
+        ret Str.382;
     else
-        let Str.248 : {} = Struct {};
-        let Str.247 : [C {}, C I64] = TagId(0) Str.248;
-        ret Str.247;
+        let Str.380 : {} = Struct {};
+        let Str.379 : [C {}, C I64] = TagId(0) Str.380;
+        ret Str.379;
 
 procedure Test.103 ():
     let Test.101 : [C Str, C {List U8, I64}] = CallByName Test.19;
diff --git a/crates/compiler/test_mono/generated/lambda_capture_niches_with_other_lambda_capture.txt b/crates/compiler/test_mono/generated/lambda_capture_niches_with_other_lambda_capture.txt
index 6868bfe122..782cea983a 100644
--- a/crates/compiler/test_mono/generated/lambda_capture_niches_with_other_lambda_capture.txt
+++ b/crates/compiler/test_mono/generated/lambda_capture_niches_with_other_lambda_capture.txt
@@ -1,6 +1,6 @@
 procedure Str.3 (#Attr.2, #Attr.3):
-    let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
-    ret Str.246;
+    let Str.378 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.378;
 
 procedure Test.1 (Test.5):
     let Test.16 : [C {}, C U64, C Str] = TagId(0) Test.5;
diff --git a/crates/compiler/test_mono/generated/list_map_closure_borrows.txt b/crates/compiler/test_mono/generated/list_map_closure_borrows.txt
index 223650051b..810427b620 100644
--- a/crates/compiler/test_mono/generated/list_map_closure_borrows.txt
+++ b/crates/compiler/test_mono/generated/list_map_closure_borrows.txt
@@ -71,12 +71,12 @@ procedure Num.51 (#Attr.2, #Attr.3):
     ret Num.285;
 
 procedure Str.16 (#Attr.2, #Attr.3):
-    let Str.246 : Str = lowlevel StrRepeat #Attr.2 #Attr.3;
-    ret Str.246;
+    let Str.378 : Str = lowlevel StrRepeat #Attr.2 #Attr.3;
+    ret Str.378;
 
 procedure Str.3 (#Attr.2, #Attr.3):
-    let Str.247 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
-    ret Str.247;
+    let Str.379 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.379;
 
 procedure Test.1 ():
     let Test.21 : Str = "lllllllllllllllllllllooooooooooong";
diff --git a/crates/compiler/test_mono/generated/list_map_closure_owns.txt b/crates/compiler/test_mono/generated/list_map_closure_owns.txt
index ce02924c29..f0a9973fb3 100644
--- a/crates/compiler/test_mono/generated/list_map_closure_owns.txt
+++ b/crates/compiler/test_mono/generated/list_map_closure_owns.txt
@@ -70,8 +70,8 @@ procedure Num.51 (#Attr.2, #Attr.3):
     ret Num.285;
 
 procedure Str.3 (#Attr.2, #Attr.3):
-    let Str.247 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
-    ret Str.247;
+    let Str.379 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.379;
 
 procedure Test.1 ():
     let Test.21 : Str = "lllllllllllllllllllllooooooooooong";
diff --git a/crates/compiler/test_mono/generated/pizza_dbg.txt b/crates/compiler/test_mono/generated/pizza_dbg.txt
index 3c8c119314..3443cbcfff 100644
--- a/crates/compiler/test_mono/generated/pizza_dbg.txt
+++ b/crates/compiler/test_mono/generated/pizza_dbg.txt
@@ -43,8 +43,8 @@ procedure Num.96 (#Attr.2):
     ret Num.284;
 
 procedure Str.3 (#Attr.2, #Attr.3):
-    let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
-    ret Str.246;
+    let Str.378 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.378;
 
 procedure Test.0 ():
     let Test.4 : I64 = 1i64;
diff --git a/crates/compiler/test_mono/generated/polymorphic_expression_unification.txt b/crates/compiler/test_mono/generated/polymorphic_expression_unification.txt
index 9a8ece2189..9371f12070 100644
--- a/crates/compiler/test_mono/generated/polymorphic_expression_unification.txt
+++ b/crates/compiler/test_mono/generated/polymorphic_expression_unification.txt
@@ -3,8 +3,8 @@ procedure Bool.11 (#Attr.2, #Attr.3):
     ret Bool.23;
 
 procedure Str.3 (#Attr.2, #Attr.3):
-    let Str.247 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
-    ret Str.247;
+    let Str.379 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.379;
 
 procedure Test.2 (Test.7):
     let Test.24 : Str = ".trace(\"";
diff --git a/crates/compiler/test_mono/generated/recursively_build_effect.txt b/crates/compiler/test_mono/generated/recursively_build_effect.txt
index f43506bad3..b529f6d671 100644
--- a/crates/compiler/test_mono/generated/recursively_build_effect.txt
+++ b/crates/compiler/test_mono/generated/recursively_build_effect.txt
@@ -3,8 +3,8 @@ procedure Num.20 (#Attr.2, #Attr.3):
     ret Num.283;
 
 procedure Str.3 (#Attr.2, #Attr.3):
-    let Str.248 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
-    ret Str.248;
+    let Str.380 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.380;
 
 procedure Test.11 (Test.29, #Attr.12):
     let Test.32 : {} = UnionAtIndex (Id 0) (Index 0) #Attr.12;
diff --git a/crates/compiler/test_mono/generated/return_annotated.txt b/crates/compiler/test_mono/generated/return_annotated.txt
index b384d1aafd..9f8c2f7adc 100644
--- a/crates/compiler/test_mono/generated/return_annotated.txt
+++ b/crates/compiler/test_mono/generated/return_annotated.txt
@@ -2,27 +2,27 @@ procedure Bool.11 (#Attr.2, #Attr.3):
     let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
     ret Bool.23;
 
-procedure Str.26 (Str.83):
-    let Str.246 : [C {}, C U64] = CallByName Str.66 Str.83;
-    ret Str.246;
+procedure Str.26 (Str.181):
+    let Str.378 : [C {}, C U64] = CallByName Str.71 Str.181;
+    ret Str.378;
 
 procedure Str.42 (#Attr.2):
-    let Str.254 : {U64, U8} = lowlevel StrToNum #Attr.2;
-    ret Str.254;
+    let Str.386 : {U64, U8} = lowlevel StrToNum #Attr.2;
+    ret Str.386;
 
-procedure Str.66 (Str.191):
-    let Str.192 : {U64, U8} = CallByName Str.42 Str.191;
-    let Str.252 : U8 = StructAtIndex 1 Str.192;
-    let Str.253 : U8 = 0i64;
-    let Str.249 : Int1 = CallByName Bool.11 Str.252 Str.253;
-    if Str.249 then
-        let Str.251 : U64 = StructAtIndex 0 Str.192;
-        let Str.250 : [C {}, C U64] = TagId(1) Str.251;
-        ret Str.250;
+procedure Str.71 (Str.289):
+    let Str.290 : {U64, U8} = CallByName Str.42 Str.289;
+    let Str.384 : U8 = StructAtIndex 1 Str.290;
+    let Str.385 : U8 = 0i64;
+    let Str.381 : Int1 = CallByName Bool.11 Str.384 Str.385;
+    if Str.381 then
+        let Str.383 : U64 = StructAtIndex 0 Str.290;
+        let Str.382 : [C {}, C U64] = TagId(1) Str.383;
+        ret Str.382;
     else
-        let Str.248 : {} = Struct {};
-        let Str.247 : [C {}, C U64] = TagId(0) Str.248;
-        ret Str.247;
+        let Str.380 : {} = Struct {};
+        let Str.379 : [C {}, C U64] = TagId(0) Str.380;
+        ret Str.379;
 
 procedure Test.1 (Test.2):
     joinpoint Test.11 Test.3:
diff --git a/crates/compiler/test_mono/generated/unspecialized_lambda_set_unification_does_not_duplicate_identical_concrete_types.txt b/crates/compiler/test_mono/generated/unspecialized_lambda_set_unification_does_not_duplicate_identical_concrete_types.txt
index 0d803f15bd..2fdef052ba 100644
--- a/crates/compiler/test_mono/generated/unspecialized_lambda_set_unification_does_not_duplicate_identical_concrete_types.txt
+++ b/crates/compiler/test_mono/generated/unspecialized_lambda_set_unification_does_not_duplicate_identical_concrete_types.txt
@@ -99,12 +99,12 @@ procedure Num.96 (#Attr.2):
     ret Num.283;
 
 procedure Str.12 (#Attr.2):
-    let Str.247 : List U8 = lowlevel StrToUtf8 #Attr.2;
-    ret Str.247;
+    let Str.379 : List U8 = lowlevel StrToUtf8 #Attr.2;
+    ret Str.379;
 
 procedure Str.36 (#Attr.2):
-    let Str.248 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
-    ret Str.248;
+    let Str.380 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
+    ret Str.380;
 
 procedure Test.20 (Test.58):
     let Test.295 : Str = CallByName Encode.23 Test.58;
diff --git a/crates/compiler/test_mono/generated/unspecialized_lambda_set_unification_keeps_all_concrete_types_without_unification_of_unifiable.txt b/crates/compiler/test_mono/generated/unspecialized_lambda_set_unification_keeps_all_concrete_types_without_unification_of_unifiable.txt
index 6744f9ca1b..2b1f48515e 100644
--- a/crates/compiler/test_mono/generated/unspecialized_lambda_set_unification_keeps_all_concrete_types_without_unification_of_unifiable.txt
+++ b/crates/compiler/test_mono/generated/unspecialized_lambda_set_unification_keeps_all_concrete_types_without_unification_of_unifiable.txt
@@ -192,12 +192,12 @@ procedure Num.96 (#Attr.2):
     ret Num.287;
 
 procedure Str.12 (#Attr.2):
-    let Str.250 : List U8 = lowlevel StrToUtf8 #Attr.2;
-    ret Str.250;
+    let Str.382 : List U8 = lowlevel StrToUtf8 #Attr.2;
+    ret Str.382;
 
 procedure Str.36 (#Attr.2):
-    let Str.251 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
-    ret Str.251;
+    let Str.383 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
+    ret Str.383;
 
 procedure Test.20 (Test.58):
     inc Test.58;
diff --git a/crates/compiler/uitest/tests/ability/specialize/inspect/opaque_automatic.txt b/crates/compiler/uitest/tests/ability/specialize/inspect/opaque_automatic.txt
index f793852b73..3fdd74e12a 100644
--- a/crates/compiler/uitest/tests/ability/specialize/inspect/opaque_automatic.txt
+++ b/crates/compiler/uitest/tests/ability/specialize/inspect/opaque_automatic.txt
@@ -46,8 +46,8 @@ procedure Inspect.64 (Inspect.297):
     ret Inspect.297;
 
 procedure Str.3 (#Attr.2, #Attr.3):
-    let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
-    ret Str.246;
+    let Str.378 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.378;
 
 procedure Test.0 ():
     let Test.4 : {} = Struct {};
diff --git a/crates/compiler/uitest/tests/ability/specialize/inspect/opaque_automatic_late.txt b/crates/compiler/uitest/tests/ability/specialize/inspect/opaque_automatic_late.txt
index 9a9e0ffd7f..113f55594f 100644
--- a/crates/compiler/uitest/tests/ability/specialize/inspect/opaque_automatic_late.txt
+++ b/crates/compiler/uitest/tests/ability/specialize/inspect/opaque_automatic_late.txt
@@ -49,8 +49,8 @@ procedure Inspect.64 (Inspect.297):
     ret Inspect.297;
 
 procedure Str.3 (#Attr.2, #Attr.3):
-    let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
-    ret Str.246;
+    let Str.378 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.378;
 
 procedure Test.2 (Test.3):
     let Test.4 : Str = CallByName Inspect.33 Test.3;